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


package computing

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

type validateOpAssociateAddress struct {
}

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

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

type validateOpAssociateMultiIpAddressGroup struct {
}

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

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

type validateOpAssociateRouteTable struct {
}

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

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

type validateOpAssociateUsers struct {
}

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

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

type validateOpAttachIsoImage struct {
}

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

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

type validateOpAttachNetworkInterface struct {
}

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

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

type validateOpAttachVolume struct {
}

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

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

type validateOpAuthorizeSecurityGroupIngress struct {
}

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

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

type validateOpCancelCopyInstances struct {
}

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

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

type validateOpCancelUpload struct {
}

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

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

type validateOpClearLoadBalancerSession struct {
}

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

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

type validateOpConfigureHealthCheck struct {
}

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

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

type validateOpCopyFromBackupInstance struct {
}

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

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

type validateOpCopyInstances struct {
}

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

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

type validateOpCreateBackupInstances struct {
}

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

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

type validateOpCreateCustomerGateway struct {
}

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

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

type validateOpCreateDhcpOptions struct {
}

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

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

type validateOpCreateImageOperation struct {
}

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

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

type validateOpCreateInstanceBackupRule struct {
}

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

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

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

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

type validateOpCreateNetworkInterface struct {
}

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

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

type validateOpCreateRemoteAccessVpnGateway struct {
}

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

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

type validateOpCreateRemoteAccessVpnGatewayUsers struct {
}

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

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

type validateOpCreateRoute struct {
}

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

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

type validateOpCreateSecurityGroup struct {
}

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

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

type validateOpCreateVolume struct {
}

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

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

type validateOpCreateVpnConnection struct {
}

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

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

type validateOpDeleteDhcpOptions struct {
}

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

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

type validateOpDeleteImage struct {
}

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

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

type validateOpDeleteInstanceBackupRule struct {
}

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

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

type validateOpDeleteIsoImage struct {
}

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

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

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

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

type validateOpDeleteNetworkInterface struct {
}

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

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

type validateOpDeleteRemoteAccessVpnGatewayConnections struct {
}

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

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

type validateOpDeleteRemoteAccessVpnGateway struct {
}

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

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

type validateOpDeleteRemoteAccessVpnGatewayUsers struct {
}

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

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

type validateOpDeleteRoute struct {
}

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

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

type validateOpDeleteRouteTable struct {
}

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

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

type validateOpDeleteSecurityGroup struct {
}

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

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

type validateOpDeleteSslCertificate struct {
}

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

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

type validateOpDeleteVolume struct {
}

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

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

type validateOpDeleteVpnConnection struct {
}

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

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

type validateOpDeregisterInstancesFromLoadBalancer struct {
}

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

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

type validateOpDeregisterInstancesFromSecurityGroup struct {
}

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

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

type validateOpDescribeAssociatedUsers struct {
}

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

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

type validateOpDescribeInstanceAttribute struct {
}

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

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

type validateOpDescribeInstanceBackupRuleActivities struct {
}

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

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

type validateOpDescribeInstanceHealth struct {
}

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

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

type validateOpDescribeRemoteAccessVpnGatewayActivities struct {
}

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

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

type validateOpDescribeRemoteAccessVpnGatewayClientConfig struct {
}

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

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

type validateOpDescribeRemoteAccessVpnGatewayConnections struct {
}

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

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

type validateOpDescribeSecurityActivities struct {
}

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

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

type validateOpDescribeSslCertificateAttribute struct {
}

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

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

type validateOpDetachIsoImage struct {
}

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

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

type validateOpDetachNetworkInterface struct {
}

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

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

type validateOpDetachVolume struct {
}

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

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

type validateOpDisassociateMultiIpAddressGroup struct {
}

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

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

type validateOpDisassociateRouteTable struct {
}

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

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

type validateOpDissociateUsers struct {
}

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

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

type validateOpDownloadSslCertificate struct {
}

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

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

type validateOpExtendVolumeSize struct {
}

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

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

type validateOpImportInstanceOperation struct {
}

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

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

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

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

type validateOpModifyImageAttribute struct {
}

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

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

type validateOpModifyInstanceAttribute struct {
}

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

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

type validateOpModifyInstanceBackupRuleAttribute struct {
}

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

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

type validateOpModifyMultiIpAddressGroupAttribute struct {
}

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

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

type validateOpModifyNetworkInterfaceAttribute struct {
}

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

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

type validateOpModifyRemoteAccessVpnGatewayAttribute struct {
}

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

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

type validateOpModifyRemoteAccessVpnGatewayUserAttribute struct {
}

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

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

type validateOpModifySslCertificateAttribute struct {
}

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

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

type validateOpModifyVolumeAttribute struct {
}

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

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

type validateOpNiftyAssociateImage struct {
}

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

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

type validateOpNiftyAssociateNatTable struct {
}

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

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

type validateOpNiftyAssociateRouteTableWithElasticLoadBalancer struct {
}

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

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

type validateOpNiftyAssociateRouteTableWithVpnGateway struct {
}

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

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

type validateOpNiftyConfigureElasticLoadBalancerHealthCheck struct {
}

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

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

type validateOpNiftyCreateAlarm struct {
}

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

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

type validateOpNiftyCreateAutoScalingGroup struct {
}

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

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

type validateOpNiftyCreateDhcpIpAddressPool struct {
}

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

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

type validateOpNiftyCreateDhcpStaticMapping struct {
}

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

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

type validateOpNiftyCreateElasticLoadBalancer struct {
}

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

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

type validateOpNiftyCreateInstanceSnapshot struct {
}

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

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

type validateOpNiftyCreateNatRule struct {
}

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

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

type validateOpNiftyCreatePrivateLan struct {
}

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

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

type validateOpNiftyCreateSeparateInstanceRule struct {
}

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

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

type validateOpNiftyCreateWebProxy struct {
}

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

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

type validateOpNiftyDeleteAlarm struct {
}

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

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

type validateOpNiftyDeleteAutoScalingGroup struct {
}

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

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

type validateOpNiftyDeleteDhcpConfig struct {
}

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

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

type validateOpNiftyDeleteDhcpIpAddressPool struct {
}

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

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

type validateOpNiftyDeleteDhcpStaticMapping struct {
}

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

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

type validateOpNiftyDeleteElasticLoadBalancer struct {
}

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

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

type validateOpNiftyDeleteNatRule struct {
}

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

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

type validateOpNiftyDeleteNatTable struct {
}

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

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

type validateOpNiftyDeleteSeparateInstanceRule struct {
}

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

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

type validateOpNiftyDeregisterInstancesFromElasticLoadBalancer struct {
}

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

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

type validateOpNiftyDeregisterInstancesFromSeparateInstanceRule struct {
}

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

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

type validateOpNiftyDeregisterRoutersFromSecurityGroup struct {
}

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

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

type validateOpNiftyDeregisterVpnGatewaysFromSecurityGroup struct {
}

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

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

type validateOpNiftyDescribeInstanceElasticLoadBalancerHealth struct {
}

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

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

type validateOpNiftyDescribeLoadBalancerSSLPolicies struct {
}

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

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

type validateOpNiftyDescribePerformanceChart struct {
}

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

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

type validateOpNiftyDescribeScalingActivities struct {
}

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

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

type validateOpNiftyDisassociateNatTable struct {
}

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

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

type validateOpNiftyDisassociateRouteTableFromElasticLoadBalancer struct {
}

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

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

type validateOpNiftyDisassociateRouteTableFromVpnGateway struct {
}

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

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

type validateOpNiftyModifyAddressAttribute struct {
}

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

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

type validateOpNiftyModifyCustomerGatewayAttribute struct {
}

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

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

type validateOpNiftyModifyElasticLoadBalancerAttributes struct {
}

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

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

type validateOpNiftyModifyInstanceSnapshotAttribute struct {
}

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

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

type validateOpNiftyModifyKeyPairAttribute struct {
}

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

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

type validateOpNiftyModifyPrivateLanAttribute struct {
}

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

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

type validateOpNiftyModifyRouterAttribute struct {
}

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

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

type validateOpNiftyModifyVpnGatewayAttribute struct {
}

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

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

type validateOpNiftyModifyWebProxyAttribute struct {
}

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

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

type validateOpNiftyRegisterInstancesWithElasticLoadBalancer struct {
}

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

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

type validateOpNiftyRegisterInstancesWithSeparateInstanceRule struct {
}

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

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

type validateOpNiftyRegisterPortWithElasticLoadBalancer struct {
}

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

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

type validateOpNiftyRegisterRoutersWithSecurityGroup struct {
}

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

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

type validateOpNiftyRegisterVpnGatewaysWithSecurityGroup struct {
}

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

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

type validateOpNiftyReplaceDhcpConfig struct {
}

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

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

type validateOpNiftyReplaceDhcpOption struct {
}

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

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

type validateOpNiftyReplaceElasticLoadBalancerListenerSSLCertificate struct {
}

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

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

type validateOpNiftyReplaceNatRule struct {
}

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

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

type validateOpNiftyReplaceNatTableAssociation struct {
}

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

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

type validateOpNiftyReplaceRouteTableAssociationWithElasticLoadBalancer struct {
}

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

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

type validateOpNiftyReplaceRouteTableAssociationWithVpnGateway struct {
}

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

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

type validateOpNiftySetLoadBalancerSSLPoliciesOfListener struct {
}

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

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

type validateOpNiftyUnsetLoadBalancerSSLPoliciesOfListener struct {
}

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

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

type validateOpNiftyUpdateAlarm struct {
}

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

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

type validateOpNiftyUpdateAutoScalingGroup struct {
}

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

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

type validateOpNiftyUpdateInstanceNetworkInterfaces struct {
}

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

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

type validateOpNiftyUpdateSeparateInstanceRule struct {
}

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

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

type validateOpRebootInstances struct {
}

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

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

type validateOpRebootRemoteAccessVpnGateway struct {
}

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

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

type validateOpRefreshInstanceBackupRule struct {
}

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

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

type validateOpRegisterCorporateInfoForCertificate struct {
}

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

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

type validateOpRegisterInstancesWithLoadBalancer struct {
}

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

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

type validateOpRegisterInstancesWithSecurityGroup struct {
}

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

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

type validateOpRegisterPortWithLoadBalancer struct {
}

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

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

type validateOpReleaseMultiIpAddresses struct {
}

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

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

type validateOpReplaceRemoteAccessVpnGatewayLatestVersion struct {
}

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

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

type validateOpReplaceRoute struct {
}

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

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

type validateOpReplaceRouteTableAssociation struct {
}

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

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

type validateOpRevokeSecurityGroupIngress struct {
}

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

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

type validateOpRunInstances struct {
}

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

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

type validateOpSetFilterForLoadBalancer struct {
}

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

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

type validateOpSetLoadBalancerListenerSSLCertificate struct {
}

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

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

type validateOpSetRemoteAccessVpnGatewayCACertificate struct {
}

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

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

type validateOpSetRemoteAccessVpnGatewaySSLCertificate struct {
}

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

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

type validateOpStartInstances struct {
}

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

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

type validateOpStopInstances struct {
}

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

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

type validateOpTerminateInstances struct {
}

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

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

type validateOpUnsetLoadBalancerListenerSSLCertificate struct {
}

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

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

type validateOpUnsetRemoteAccessVpnGatewayCACertificate struct {
}

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

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

type validateOpUnsetRemoteAccessVpnGatewaySSLCertificate struct {
}

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

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

type validateOpUpdateLoadBalancer struct {
}

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

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

type validateOpUpdateLoadBalancerOption struct {
}

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

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

type validateOpUpdateSecurityGroup struct {
}

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

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

type validateOpUploadIsoImage struct {
}

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

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

type validateOpUploadSslCertificate struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpCreateInstanceBackupRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateInstanceBackupRule{}, 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 addOpCreateMultiIpAddressGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateMultiIpAddressGroup{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateListOfRequestInstances(v *types.ListOfRequestInstances) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListOfRequestInstances"}
	if v.Member != nil {
		if err := validateListOfRequestInstancesMember(v.Member); err != nil {
			invalidParams.AddNested("Member", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateListOfRequestListenersOfNiftyCreateElasticLoadBalancer(v *types.ListOfRequestListenersOfNiftyCreateElasticLoadBalancer) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListOfRequestListenersOfNiftyCreateElasticLoadBalancer"}
	if v.Member != nil {
		if err := validateListOfRequestListenersOfNiftyCreateElasticLoadBalancerMember(v.Member); err != nil {
			invalidParams.AddNested("Member", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateListOfRequestListenersOfNiftyRegisterPortWithElasticLoadBalancer(v *types.ListOfRequestListenersOfNiftyRegisterPortWithElasticLoadBalancer) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListOfRequestListenersOfNiftyRegisterPortWithElasticLoadBalancer"}
	if v.Member != nil {
		if err := validateListOfRequestListenersOfNiftyRegisterPortWithElasticLoadBalancerMember(v.Member); err != nil {
			invalidParams.AddNested("Member", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

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

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

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

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

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

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

func validateListOfRequestUsers(v *types.ListOfRequestUsers) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListOfRequestUsers"}
	if v.Member != nil {
		if err := validateListOfRequestUsersMember(v.Member); err != nil {
			invalidParams.AddNested("Member", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

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

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

func validateRequestHealthCheck(v *types.RequestHealthCheck) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RequestHealthCheck"}
	if v.Interval == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Interval"))
	}
	if v.Target == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Target"))
	}
	if v.UnhealthyThreshold == nil {
	invalidParams.Add(smithy.NewErrParamRequired("UnhealthyThreshold"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateRequestHealthCheckOfNiftyConfigureElasticLoadBalancerHealthCheck(v *types.RequestHealthCheckOfNiftyConfigureElasticLoadBalancerHealthCheck) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RequestHealthCheckOfNiftyConfigureElasticLoadBalancerHealthCheck"}
	if v.Interval == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Interval"))
	}
	if v.Target == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Target"))
	}
	if v.UnhealthyThreshold == nil {
	invalidParams.Add(smithy.NewErrParamRequired("UnhealthyThreshold"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

func validateRequestListenersOfNiftyRegisterPortWithElasticLoadBalancer(v *types.RequestListenersOfNiftyRegisterPortWithElasticLoadBalancer) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RequestListenersOfNiftyRegisterPortWithElasticLoadBalancer"}
	if v.ElasticLoadBalancerPort == nil {
	invalidParams.Add(smithy.NewErrParamRequired("ElasticLoadBalancerPort"))
	}
	if v.InstancePort == nil {
	invalidParams.Add(smithy.NewErrParamRequired("InstancePort"))
	}
	if len(v.Protocol) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateRequestNetworkInterfaceOfCreateRemoteAccessVpnGateway(v *types.RequestNetworkInterfaceOfCreateRemoteAccessVpnGateway) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RequestNetworkInterfaceOfCreateRemoteAccessVpnGateway"}
	if v.IpAddress == nil {
	invalidParams.Add(smithy.NewErrParamRequired("IpAddress"))
	}
	if v.NetworkId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("NetworkId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

func validateRequestRemoteUser(v *types.RequestRemoteUser) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RequestRemoteUser"}
	if v.Password == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Password"))
	}
	if v.UserName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("UserName"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateRequestRule(v *types.RequestRule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RequestRule"}
	if v.BreachDuration == nil {
	invalidParams.Add(smithy.NewErrParamRequired("BreachDuration"))
	}
	if v.DataType == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DataType"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateRequestScalingTrigger(v *types.RequestScalingTrigger) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RequestScalingTrigger"}
	if len(v.Resource) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("Resource"))
	}
	if v.UpperThreshold == nil {
	invalidParams.Add(smithy.NewErrParamRequired("UpperThreshold"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateRequestScalingTriggerOfNiftyUpdateAutoScalingGroup(v *types.RequestScalingTriggerOfNiftyUpdateAutoScalingGroup) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RequestScalingTriggerOfNiftyUpdateAutoScalingGroup"}
	if len(v.Resource) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("Resource"))
	}
	if v.UpperThreshold == nil {
	invalidParams.Add(smithy.NewErrParamRequired("UpperThreshold"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

func validateOpAssociateMultiIpAddressGroupInput(v *AssociateMultiIpAddressGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateMultiIpAddressGroupInput"}
	if v.InstanceUniqueId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("InstanceUniqueId"))
	}
	if v.MultiIpAddressGroupId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("MultiIpAddressGroupId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateOpAssociateUsersInput(v *AssociateUsersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateUsersInput"}
	if len(v.FunctionName) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if v.Users == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Users"))
	} else if v.Users != nil {
		if err := validateListOfRequestUsers(v.Users); err != nil {
			invalidParams.AddNested("Users", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpAttachIsoImageInput(v *AttachIsoImageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachIsoImageInput"}
	if v.InstanceUniqueId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("InstanceUniqueId"))
	}
	if v.IsoImageId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("IsoImageId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateOpAttachVolumeInput(v *AttachVolumeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachVolumeInput"}
	if v.InstanceId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.VolumeId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("VolumeId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

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

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

func validateOpConfigureHealthCheckInput(v *ConfigureHealthCheckInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConfigureHealthCheckInput"}
	if v.HealthCheck == nil {
	invalidParams.Add(smithy.NewErrParamRequired("HealthCheck"))
	} else if v.HealthCheck != nil {
		if err := validateRequestHealthCheck(v.HealthCheck); err != nil {
			invalidParams.AddNested("HealthCheck", err.(smithy.InvalidParamsError))
		}
	}
	if v.InstancePort == nil {
	invalidParams.Add(smithy.NewErrParamRequired("InstancePort"))
	}
	if v.LoadBalancerName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
	}
	if v.LoadBalancerPort == nil {
	invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerPort"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateOpCopyInstancesInput(v *CopyInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CopyInstancesInput"}
	if v.CopyInstance == nil {
	invalidParams.Add(smithy.NewErrParamRequired("CopyInstance"))
	} else if v.CopyInstance != nil {
		if err := validateRequestCopyInstance(v.CopyInstance); err != nil {
			invalidParams.AddNested("CopyInstance", err.(smithy.InvalidParamsError))
		}
	}
	if v.InstanceId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

func validateOpCreateDhcpOptionsInput(v *CreateDhcpOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDhcpOptionsInput"}
	if v.DhcpConfiguration == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DhcpConfiguration"))
	} else if v.DhcpConfiguration != nil {
		if err := validateListOfRequestDhcpConfiguration(v.DhcpConfiguration); err != nil {
			invalidParams.AddNested("DhcpConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateOpCreateInstanceBackupRuleInput(v *CreateInstanceBackupRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateInstanceBackupRuleInput"}
	if v.BackupInstanceMaxCount == nil {
	invalidParams.Add(smithy.NewErrParamRequired("BackupInstanceMaxCount"))
	}
	if v.InstanceUniqueId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("InstanceUniqueId"))
	}
	if len(v.TimeSlotId) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("TimeSlotId"))
	}
	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.KeyName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("KeyName"))
	}
	if v.Password == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Password"))
	}
	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 validateOpCreateMultiIpAddressGroupInput(v *CreateMultiIpAddressGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMultiIpAddressGroupInput"}
	if v.IpAddressCount == nil {
	invalidParams.Add(smithy.NewErrParamRequired("IpAddressCount"))
	}
	if v.MultiIpAddressGroupName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("MultiIpAddressGroupName"))
	}
	if v.Placement == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Placement"))
	} else if v.Placement != nil {
		if err := validateRequestPlacementOfCreateMultiIpAddressGroup(v.Placement); err != nil {
			invalidParams.AddNested("Placement", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateOpCreateRemoteAccessVpnGatewayInput(v *CreateRemoteAccessVpnGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRemoteAccessVpnGatewayInput"}
	if v.CipherSuite == nil {
	invalidParams.Add(smithy.NewErrParamRequired("CipherSuite"))
	}
	if v.NetworkInterface == nil {
	invalidParams.Add(smithy.NewErrParamRequired("NetworkInterface"))
	} else if v.NetworkInterface != nil {
		if err := validateListOfRequestNetworkInterfaceOfCreateRemoteAccessVpnGateway(v.NetworkInterface); err != nil {
			invalidParams.AddNested("NetworkInterface", err.(smithy.InvalidParamsError))
		}
	}
	if v.PoolNetworkCidr == nil {
	invalidParams.Add(smithy.NewErrParamRequired("PoolNetworkCidr"))
	}
	if v.SSLCertificateId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("SSLCertificateId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpCreateRemoteAccessVpnGatewayUsersInput(v *CreateRemoteAccessVpnGatewayUsersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRemoteAccessVpnGatewayUsersInput"}
	if v.RemoteAccessVpnGatewayId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("RemoteAccessVpnGatewayId"))
	}
	if v.RemoteUser == nil {
	invalidParams.Add(smithy.NewErrParamRequired("RemoteUser"))
	} else if v.RemoteUser != nil {
		if err := validateListOfRequestRemoteUser(v.RemoteUser); err != nil {
			invalidParams.AddNested("RemoteUser", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpCreateRouteInput(v *CreateRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRouteInput"}
	if v.DestinationCidrBlock == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DestinationCidrBlock"))
	}
	if v.RouteTableId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("RouteTableId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

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

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

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

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

func validateOpDeleteIsoImageInput(v *DeleteIsoImageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIsoImageInput"}
	if v.IsoImageId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("IsoImageId"))
	}
	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.KeyName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("KeyName"))
	}
	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.InstancePort == nil {
	invalidParams.Add(smithy.NewErrParamRequired("InstancePort"))
	}
	if v.LoadBalancerName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
	}
	if v.LoadBalancerPort == nil {
	invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerPort"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

func validateOpDeleteRemoteAccessVpnGatewayConnectionsInput(v *DeleteRemoteAccessVpnGatewayConnectionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRemoteAccessVpnGatewayConnectionsInput"}
	if v.Connection == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Connection"))
	} else if v.Connection != nil {
		if err := validateListOfRequestConnection(v.Connection); err != nil {
			invalidParams.AddNested("Connection", err.(smithy.InvalidParamsError))
		}
	}
	if v.RemoteAccessVpnGatewayId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("RemoteAccessVpnGatewayId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateOpDeleteRemoteAccessVpnGatewayUsersInput(v *DeleteRemoteAccessVpnGatewayUsersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRemoteAccessVpnGatewayUsersInput"}
	if v.RemoteAccessVpnGatewayId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("RemoteAccessVpnGatewayId"))
	}
	if v.RemoteUser == nil {
	invalidParams.Add(smithy.NewErrParamRequired("RemoteUser"))
	} else if v.RemoteUser != nil {
		if err := validateListOfRequestRemoteUserOfDeleteRemoteAccessVpnGatewayUsers(v.RemoteUser); err != nil {
			invalidParams.AddNested("RemoteUser", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpDeleteRouteInput(v *DeleteRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRouteInput"}
	if v.DestinationCidrBlock == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DestinationCidrBlock"))
	}
	if v.RouteTableId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("RouteTableId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

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

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

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

func validateOpDeregisterInstancesFromLoadBalancerInput(v *DeregisterInstancesFromLoadBalancerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeregisterInstancesFromLoadBalancerInput"}
	if v.InstancePort == nil {
	invalidParams.Add(smithy.NewErrParamRequired("InstancePort"))
	}
	if v.Instances == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Instances"))
	} else if v.Instances != nil {
		if err := validateListOfRequestInstances(v.Instances); err != nil {
			invalidParams.AddNested("Instances", err.(smithy.InvalidParamsError))
		}
	}
	if v.LoadBalancerName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
	}
	if v.LoadBalancerPort == nil {
	invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerPort"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpDeregisterInstancesFromSecurityGroupInput(v *DeregisterInstancesFromSecurityGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeregisterInstancesFromSecurityGroupInput"}
	if v.GroupName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if v.InstanceId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

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

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

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

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

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

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

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

func validateOpDetachIsoImageInput(v *DetachIsoImageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DetachIsoImageInput"}
	if v.InstanceUniqueId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("InstanceUniqueId"))
	}
	if v.IsoImageId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("IsoImageId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

func validateOpDisassociateMultiIpAddressGroupInput(v *DisassociateMultiIpAddressGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateMultiIpAddressGroupInput"}
	if v.InstanceUniqueId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("InstanceUniqueId"))
	}
	if v.MultiIpAddressGroupId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("MultiIpAddressGroupId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateOpDissociateUsersInput(v *DissociateUsersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DissociateUsersInput"}
	if len(v.FunctionName) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if v.Users == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Users"))
	} else if v.Users != nil {
		if err := validateListOfRequestUsers(v.Users); err != nil {
			invalidParams.AddNested("Users", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpDownloadSslCertificateInput(v *DownloadSslCertificateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DownloadSslCertificateInput"}
	if len(v.FileType) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("FileType"))
	}
	if v.FqdnId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("FqdnId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateOpImportInstanceOperationInput(v *ImportInstanceOperationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportInstanceOperationInput"}
	if v.Ovf == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Ovf"))
	}
	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.KeyName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("KeyName"))
	}
	if v.PublicKeyMaterial == nil {
	invalidParams.Add(smithy.NewErrParamRequired("PublicKeyMaterial"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpIncreaseMultiIpAddressCountInput(v *IncreaseMultiIpAddressCountInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IncreaseMultiIpAddressCountInput"}
	if v.IpAddressCount == nil {
	invalidParams.Add(smithy.NewErrParamRequired("IpAddressCount"))
	}
	if v.MultiIpAddressGroupId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("MultiIpAddressGroupId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateOpModifyInstanceAttributeInput(v *ModifyInstanceAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyInstanceAttributeInput"}
	if len(v.Attribute) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if v.InstanceId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Value == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

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

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

func validateOpModifyRemoteAccessVpnGatewayUserAttributeInput(v *ModifyRemoteAccessVpnGatewayUserAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyRemoteAccessVpnGatewayUserAttributeInput"}
	if v.RemoteAccessVpnGatewayId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("RemoteAccessVpnGatewayId"))
	}
	if v.UserName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("UserName"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

func validateOpNiftyAssociateImageInput(v *NiftyAssociateImageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyAssociateImageInput"}
	if v.ImageId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
	}
	if v.IsPublic == nil {
	invalidParams.Add(smithy.NewErrParamRequired("IsPublic"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateOpNiftyAssociateRouteTableWithElasticLoadBalancerInput(v *NiftyAssociateRouteTableWithElasticLoadBalancerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyAssociateRouteTableWithElasticLoadBalancerInput"}
	if v.ElasticLoadBalancerId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("ElasticLoadBalancerId"))
	}
	if v.RouteTableId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("RouteTableId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateOpNiftyConfigureElasticLoadBalancerHealthCheckInput(v *NiftyConfigureElasticLoadBalancerHealthCheckInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyConfigureElasticLoadBalancerHealthCheckInput"}
	if v.ElasticLoadBalancerPort == nil {
	invalidParams.Add(smithy.NewErrParamRequired("ElasticLoadBalancerPort"))
	}
	if v.HealthCheck == nil {
	invalidParams.Add(smithy.NewErrParamRequired("HealthCheck"))
	} else if v.HealthCheck != nil {
		if err := validateRequestHealthCheckOfNiftyConfigureElasticLoadBalancerHealthCheck(v.HealthCheck); err != nil {
			invalidParams.AddNested("HealthCheck", err.(smithy.InvalidParamsError))
		}
	}
	if v.InstancePort == nil {
	invalidParams.Add(smithy.NewErrParamRequired("InstancePort"))
	}
	if len(v.Protocol) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpNiftyCreateAlarmInput(v *NiftyCreateAlarmInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyCreateAlarmInput"}
	if v.EmailAddress == nil {
	invalidParams.Add(smithy.NewErrParamRequired("EmailAddress"))
	}
	if len(v.FunctionName) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if v.Rule == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Rule"))
	} else if v.Rule != nil {
		if err := validateListOfRequestRule(v.Rule); err != nil {
			invalidParams.AddNested("Rule", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpNiftyCreateAutoScalingGroupInput(v *NiftyCreateAutoScalingGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyCreateAutoScalingGroupInput"}
	if v.AutoScalingGroupName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.ChangeInCapacity == nil {
	invalidParams.Add(smithy.NewErrParamRequired("ChangeInCapacity"))
	}
	if v.ImageId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("ImageId"))
	}
	if v.MaxSize == nil {
	invalidParams.Add(smithy.NewErrParamRequired("MaxSize"))
	}
	if v.MinSize == nil {
	invalidParams.Add(smithy.NewErrParamRequired("MinSize"))
	}
	if len(v.ScaleoutCondition) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("ScaleoutCondition"))
	}
	if v.ScalingTrigger == nil {
	invalidParams.Add(smithy.NewErrParamRequired("ScalingTrigger"))
	} else if v.ScalingTrigger != nil {
		if err := validateListOfRequestScalingTrigger(v.ScalingTrigger); err != nil {
			invalidParams.AddNested("ScalingTrigger", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpNiftyCreateDhcpIpAddressPoolInput(v *NiftyCreateDhcpIpAddressPoolInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyCreateDhcpIpAddressPoolInput"}
	if v.DhcpConfigId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DhcpConfigId"))
	}
	if v.StartIpAddress == nil {
	invalidParams.Add(smithy.NewErrParamRequired("StartIpAddress"))
	}
	if v.StopIpAddress == nil {
	invalidParams.Add(smithy.NewErrParamRequired("StopIpAddress"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpNiftyCreateDhcpStaticMappingInput(v *NiftyCreateDhcpStaticMappingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyCreateDhcpStaticMappingInput"}
	if v.DhcpConfigId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DhcpConfigId"))
	}
	if v.IpAddress == nil {
	invalidParams.Add(smithy.NewErrParamRequired("IpAddress"))
	}
	if v.MacAddress == nil {
	invalidParams.Add(smithy.NewErrParamRequired("MacAddress"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpNiftyCreateElasticLoadBalancerInput(v *NiftyCreateElasticLoadBalancerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyCreateElasticLoadBalancerInput"}
	if v.AvailabilityZones == nil {
	invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZones"))
	}
	if v.Listeners == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Listeners"))
	} else if v.Listeners != nil {
		if err := validateListOfRequestListenersOfNiftyCreateElasticLoadBalancer(v.Listeners); err != nil {
			invalidParams.AddNested("Listeners", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpNiftyCreateInstanceSnapshotInput(v *NiftyCreateInstanceSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyCreateInstanceSnapshotInput"}
	if v.InstanceId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.SnapshotName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("SnapshotName"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpNiftyCreateNatRuleInput(v *NiftyCreateNatRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyCreateNatRuleInput"}
	if v.NatTableId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("NatTableId"))
	}
	if len(v.NatType) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("NatType"))
	}
	if len(v.Protocol) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
	}
	if v.RuleNumber == nil {
	invalidParams.Add(smithy.NewErrParamRequired("RuleNumber"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateOpNiftyCreateSeparateInstanceRuleInput(v *NiftyCreateSeparateInstanceRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyCreateSeparateInstanceRuleInput"}
	if v.Placement == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Placement"))
	} else if v.Placement != nil {
		if err := validateRequestPlacementOfNiftyCreateSeparateInstanceRule(v.Placement); err != nil {
			invalidParams.AddNested("Placement", err.(smithy.InvalidParamsError))
		}
	}
	if v.SeparateInstanceRuleName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("SeparateInstanceRuleName"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateOpNiftyDeleteAlarmInput(v *NiftyDeleteAlarmInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyDeleteAlarmInput"}
	if len(v.FunctionName) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if v.RuleName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("RuleName"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

func validateOpNiftyDeleteDhcpIpAddressPoolInput(v *NiftyDeleteDhcpIpAddressPoolInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyDeleteDhcpIpAddressPoolInput"}
	if v.DhcpConfigId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DhcpConfigId"))
	}
	if v.StartIpAddress == nil {
	invalidParams.Add(smithy.NewErrParamRequired("StartIpAddress"))
	}
	if v.StopIpAddress == nil {
	invalidParams.Add(smithy.NewErrParamRequired("StopIpAddress"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpNiftyDeleteDhcpStaticMappingInput(v *NiftyDeleteDhcpStaticMappingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyDeleteDhcpStaticMappingInput"}
	if v.DhcpConfigId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DhcpConfigId"))
	}
	if v.IpAddress == nil {
	invalidParams.Add(smithy.NewErrParamRequired("IpAddress"))
	}
	if v.MacAddress == nil {
	invalidParams.Add(smithy.NewErrParamRequired("MacAddress"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateOpNiftyDeleteNatRuleInput(v *NiftyDeleteNatRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyDeleteNatRuleInput"}
	if v.NatTableId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("NatTableId"))
	}
	if len(v.NatType) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("NatType"))
	}
	if v.RuleNumber == nil {
	invalidParams.Add(smithy.NewErrParamRequired("RuleNumber"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpNiftyModifyAddressAttributeInput(v *NiftyModifyAddressAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyModifyAddressAttributeInput"}
	if len(v.Attribute) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if v.Value == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpNiftyModifyCustomerGatewayAttributeInput(v *NiftyModifyCustomerGatewayAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyModifyCustomerGatewayAttributeInput"}
	if len(v.Attribute) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if v.Value == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateOpNiftyModifyInstanceSnapshotAttributeInput(v *NiftyModifyInstanceSnapshotAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyModifyInstanceSnapshotAttributeInput"}
	if len(v.Attribute) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if v.Value == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpNiftyModifyKeyPairAttributeInput(v *NiftyModifyKeyPairAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyModifyKeyPairAttributeInput"}
	if len(v.Attribute) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if v.KeyName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("KeyName"))
	}
	if v.Value == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpNiftyModifyPrivateLanAttributeInput(v *NiftyModifyPrivateLanAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyModifyPrivateLanAttributeInput"}
	if len(v.Attribute) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if v.Value == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpNiftyModifyRouterAttributeInput(v *NiftyModifyRouterAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyModifyRouterAttributeInput"}
	if len(v.Attribute) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if v.Value == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpNiftyModifyVpnGatewayAttributeInput(v *NiftyModifyVpnGatewayAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyModifyVpnGatewayAttributeInput"}
	if len(v.Attribute) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if v.Value == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

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

func validateOpNiftyRegisterPortWithElasticLoadBalancerInput(v *NiftyRegisterPortWithElasticLoadBalancerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyRegisterPortWithElasticLoadBalancerInput"}
	if v.Listeners == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Listeners"))
	} else if v.Listeners != nil {
		if err := validateListOfRequestListenersOfNiftyRegisterPortWithElasticLoadBalancer(v.Listeners); err != nil {
			invalidParams.AddNested("Listeners", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

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

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

func validateOpNiftyReplaceElasticLoadBalancerListenerSSLCertificateInput(v *NiftyReplaceElasticLoadBalancerListenerSSLCertificateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyReplaceElasticLoadBalancerListenerSSLCertificateInput"}
	if v.ElasticLoadBalancerPort == nil {
	invalidParams.Add(smithy.NewErrParamRequired("ElasticLoadBalancerPort"))
	}
	if v.InstancePort == nil {
	invalidParams.Add(smithy.NewErrParamRequired("InstancePort"))
	}
	if len(v.Protocol) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
	}
	if v.SSLCertificateId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("SSLCertificateId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpNiftyReplaceNatRuleInput(v *NiftyReplaceNatRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyReplaceNatRuleInput"}
	if v.NatTableId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("NatTableId"))
	}
	if len(v.NatType) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("NatType"))
	}
	if len(v.Protocol) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
	}
	if v.RuleNumber == nil {
	invalidParams.Add(smithy.NewErrParamRequired("RuleNumber"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpNiftyReplaceNatTableAssociationInput(v *NiftyReplaceNatTableAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyReplaceNatTableAssociationInput"}
	if v.AssociationId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
	}
	if v.NatTableId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("NatTableId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpNiftyReplaceRouteTableAssociationWithElasticLoadBalancerInput(v *NiftyReplaceRouteTableAssociationWithElasticLoadBalancerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyReplaceRouteTableAssociationWithElasticLoadBalancerInput"}
	if v.AssociationId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
	}
	if v.RouteTableId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("RouteTableId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpNiftyReplaceRouteTableAssociationWithVpnGatewayInput(v *NiftyReplaceRouteTableAssociationWithVpnGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyReplaceRouteTableAssociationWithVpnGatewayInput"}
	if v.AssociationId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
	}
	if v.RouteTableId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("RouteTableId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

func validateOpNiftyUpdateAlarmInput(v *NiftyUpdateAlarmInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyUpdateAlarmInput"}
	if len(v.FunctionName) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("FunctionName"))
	}
	if v.Rule == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Rule"))
	} else if v.Rule != nil {
		if err := validateListOfRequestRuleOfNiftyUpdateAlarm(v.Rule); err != nil {
			invalidParams.AddNested("Rule", err.(smithy.InvalidParamsError))
		}
	}
	if v.RuleName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("RuleName"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpNiftyUpdateAutoScalingGroupInput(v *NiftyUpdateAutoScalingGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NiftyUpdateAutoScalingGroupInput"}
	if v.AutoScalingGroupName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupName"))
	}
	if v.ChangeInCapacity == nil {
	invalidParams.Add(smithy.NewErrParamRequired("ChangeInCapacity"))
	}
	if v.MaxSize == nil {
	invalidParams.Add(smithy.NewErrParamRequired("MaxSize"))
	}
	if v.MinSize == nil {
	invalidParams.Add(smithy.NewErrParamRequired("MinSize"))
	}
	if len(v.ScaleoutCondition) == 0 {
	invalidParams.Add(smithy.NewErrParamRequired("ScaleoutCondition"))
	}
	if v.ScalingTrigger == nil {
	invalidParams.Add(smithy.NewErrParamRequired("ScalingTrigger"))
	} else if v.ScalingTrigger != nil {
		if err := validateListOfRequestScalingTriggerOfNiftyUpdateAutoScalingGroup(v.ScalingTrigger); err != nil {
			invalidParams.AddNested("ScalingTrigger", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

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

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

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

func validateOpRegisterCorporateInfoForCertificateInput(v *RegisterCorporateInfoForCertificateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterCorporateInfoForCertificateInput"}
	if v.Agreement == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Agreement"))
	}
	if v.AlphabetName1 == nil {
	invalidParams.Add(smithy.NewErrParamRequired("AlphabetName1"))
	}
	if v.AlphabetName2 == nil {
	invalidParams.Add(smithy.NewErrParamRequired("AlphabetName2"))
	}
	if v.City == nil {
	invalidParams.Add(smithy.NewErrParamRequired("City"))
	}
	if v.CorpGrade == nil {
	invalidParams.Add(smithy.NewErrParamRequired("CorpGrade"))
	}
	if v.CorpName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("CorpName"))
	}
	if v.DivisionName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DivisionName"))
	}
	if v.EmailAddress == nil {
	invalidParams.Add(smithy.NewErrParamRequired("EmailAddress"))
	}
	if v.KanaName1 == nil {
	invalidParams.Add(smithy.NewErrParamRequired("KanaName1"))
	}
	if v.KanaName2 == nil {
	invalidParams.Add(smithy.NewErrParamRequired("KanaName2"))
	}
	if v.Name1 == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Name1"))
	}
	if v.Name2 == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Name2"))
	}
	if v.PhoneNumber == nil {
	invalidParams.Add(smithy.NewErrParamRequired("PhoneNumber"))
	}
	if v.PostName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("PostName"))
	}
	if v.Pref == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Pref"))
	}
	if v.PresidentName1 == nil {
	invalidParams.Add(smithy.NewErrParamRequired("PresidentName1"))
	}
	if v.PresidentName2 == nil {
	invalidParams.Add(smithy.NewErrParamRequired("PresidentName2"))
	}
	if v.Zip1 == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Zip1"))
	}
	if v.Zip2 == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Zip2"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpRegisterInstancesWithLoadBalancerInput(v *RegisterInstancesWithLoadBalancerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterInstancesWithLoadBalancerInput"}
	if v.InstancePort == nil {
	invalidParams.Add(smithy.NewErrParamRequired("InstancePort"))
	}
	if v.Instances == nil {
	invalidParams.Add(smithy.NewErrParamRequired("Instances"))
	} else if v.Instances != nil {
		if err := validateListOfRequestInstances(v.Instances); err != nil {
			invalidParams.AddNested("Instances", err.(smithy.InvalidParamsError))
		}
	}
	if v.LoadBalancerName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
	}
	if v.LoadBalancerPort == nil {
	invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerPort"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpRegisterInstancesWithSecurityGroupInput(v *RegisterInstancesWithSecurityGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterInstancesWithSecurityGroupInput"}
	if v.GroupName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if v.InstanceId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateOpReleaseMultiIpAddressesInput(v *ReleaseMultiIpAddressesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReleaseMultiIpAddressesInput"}
	if v.IpAddress == nil {
	invalidParams.Add(smithy.NewErrParamRequired("IpAddress"))
	}
	if v.MultiIpAddressGroupId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("MultiIpAddressGroupId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

func validateOpReplaceRouteInput(v *ReplaceRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReplaceRouteInput"}
	if v.DestinationCidrBlock == nil {
	invalidParams.Add(smithy.NewErrParamRequired("DestinationCidrBlock"))
	}
	if v.RouteTableId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("RouteTableId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpReplaceRouteTableAssociationInput(v *ReplaceRouteTableAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReplaceRouteTableAssociationInput"}
	if v.AssociationId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("AssociationId"))
	}
	if v.RouteTableId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("RouteTableId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

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

func validateOpSetLoadBalancerListenerSSLCertificateInput(v *SetLoadBalancerListenerSSLCertificateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetLoadBalancerListenerSSLCertificateInput"}
	if v.InstancePort == nil {
	invalidParams.Add(smithy.NewErrParamRequired("InstancePort"))
	}
	if v.LoadBalancerName == nil {
	invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerName"))
	}
	if v.LoadBalancerPort == nil {
	invalidParams.Add(smithy.NewErrParamRequired("LoadBalancerPort"))
	}
	if v.SSLCertificateId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("SSLCertificateId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpSetRemoteAccessVpnGatewayCACertificateInput(v *SetRemoteAccessVpnGatewayCACertificateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetRemoteAccessVpnGatewayCACertificateInput"}
	if v.CACertificateId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("CACertificateId"))
	}
	if v.RemoteAccessVpnGatewayId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("RemoteAccessVpnGatewayId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

func validateOpSetRemoteAccessVpnGatewaySSLCertificateInput(v *SetRemoteAccessVpnGatewaySSLCertificateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetRemoteAccessVpnGatewaySSLCertificateInput"}
	if v.RemoteAccessVpnGatewayId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("RemoteAccessVpnGatewayId"))
	}
	if v.SSLCertificateId == nil {
	invalidParams.Add(smithy.NewErrParamRequired("SSLCertificateId"))
	}
	if invalidParams.Len() > 0 {
	return invalidParams
	} else {
	return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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