service/iotwireless/validators.go

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

package iotwireless

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

type validateOpAssociateAwsAccountWithPartnerAccount struct {
}

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

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

type validateOpAssociateMulticastGroupWithFuotaTask struct {
}

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

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

type validateOpAssociateWirelessDeviceWithFuotaTask struct {
}

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

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

type validateOpAssociateWirelessDeviceWithMulticastGroup struct {
}

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

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

type validateOpAssociateWirelessDeviceWithThing struct {
}

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

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

type validateOpAssociateWirelessGatewayWithCertificate struct {
}

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

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

type validateOpAssociateWirelessGatewayWithThing struct {
}

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

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

type validateOpCancelMulticastGroupSession struct {
}

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

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

type validateOpCreateDestination struct {
}

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

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

type validateOpCreateDeviceProfile struct {
}

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

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

type validateOpCreateFuotaTask struct {
}

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

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

type validateOpCreateMulticastGroup struct {
}

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

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

type validateOpCreateNetworkAnalyzerConfiguration struct {
}

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

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

type validateOpCreateServiceProfile struct {
}

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

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

type validateOpCreateWirelessDevice struct {
}

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

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

type validateOpCreateWirelessGateway struct {
}

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

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

type validateOpCreateWirelessGatewayTaskDefinition struct {
}

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

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

type validateOpCreateWirelessGatewayTask struct {
}

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

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

type validateOpDeleteDestination struct {
}

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

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

type validateOpDeleteDeviceProfile struct {
}

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

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

type validateOpDeleteFuotaTask struct {
}

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

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

type validateOpDeleteMulticastGroup struct {
}

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

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

type validateOpDeleteNetworkAnalyzerConfiguration struct {
}

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

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

type validateOpDeleteQueuedMessages struct {
}

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

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

type validateOpDeleteServiceProfile struct {
}

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

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

type validateOpDeleteWirelessDeviceImportTask struct {
}

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

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

type validateOpDeleteWirelessDevice struct {
}

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

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

type validateOpDeleteWirelessGateway struct {
}

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

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

type validateOpDeleteWirelessGatewayTaskDefinition struct {
}

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

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

type validateOpDeleteWirelessGatewayTask struct {
}

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

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

type validateOpDeregisterWirelessDevice struct {
}

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

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

type validateOpDisassociateAwsAccountFromPartnerAccount struct {
}

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

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

type validateOpDisassociateMulticastGroupFromFuotaTask struct {
}

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

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

type validateOpDisassociateWirelessDeviceFromFuotaTask struct {
}

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

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

type validateOpDisassociateWirelessDeviceFromMulticastGroup struct {
}

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

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

type validateOpDisassociateWirelessDeviceFromThing struct {
}

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

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

type validateOpDisassociateWirelessGatewayFromCertificate struct {
}

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

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

type validateOpDisassociateWirelessGatewayFromThing struct {
}

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

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

type validateOpGetDestination struct {
}

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

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

type validateOpGetDeviceProfile struct {
}

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

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

type validateOpGetFuotaTask struct {
}

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

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

type validateOpGetMulticastGroup struct {
}

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

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

type validateOpGetMulticastGroupSession struct {
}

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

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

type validateOpGetNetworkAnalyzerConfiguration struct {
}

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

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

type validateOpGetPartnerAccount struct {
}

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

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

type validateOpGetPositionConfiguration struct {
}

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

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

type validateOpGetPositionEstimate struct {
}

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

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

type validateOpGetPosition struct {
}

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

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

type validateOpGetResourceEventConfiguration struct {
}

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

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

type validateOpGetResourceLogLevel struct {
}

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

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

type validateOpGetResourcePosition struct {
}

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

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

type validateOpGetServiceProfile struct {
}

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

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

type validateOpGetWirelessDeviceImportTask struct {
}

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

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

type validateOpGetWirelessDevice struct {
}

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

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

type validateOpGetWirelessDeviceStatistics struct {
}

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

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

type validateOpGetWirelessGatewayCertificate struct {
}

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

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

type validateOpGetWirelessGatewayFirmwareInformation struct {
}

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

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

type validateOpGetWirelessGateway struct {
}

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

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

type validateOpGetWirelessGatewayStatistics struct {
}

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

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

type validateOpGetWirelessGatewayTaskDefinition struct {
}

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

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

type validateOpGetWirelessGatewayTask struct {
}

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

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

type validateOpListDevicesForWirelessDeviceImportTask struct {
}

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

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

type validateOpListEventConfigurations struct {
}

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

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

type validateOpListMulticastGroupsByFuotaTask struct {
}

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

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

type validateOpListQueuedMessages struct {
}

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

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

type validateOpListTagsForResource struct {
}

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

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

type validateOpPutPositionConfiguration struct {
}

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

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

type validateOpPutResourceLogLevel struct {
}

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

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

type validateOpResetResourceLogLevel struct {
}

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

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

type validateOpSendDataToMulticastGroup struct {
}

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

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

type validateOpSendDataToWirelessDevice struct {
}

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

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

type validateOpStartBulkAssociateWirelessDeviceWithMulticastGroup struct {
}

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

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

type validateOpStartBulkDisassociateWirelessDeviceFromMulticastGroup struct {
}

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

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

type validateOpStartFuotaTask struct {
}

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

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

type validateOpStartMulticastGroupSession struct {
}

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

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

type validateOpStartSingleWirelessDeviceImportTask struct {
}

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

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

type validateOpStartWirelessDeviceImportTask struct {
}

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

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

type validateOpTagResource struct {
}

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

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

type validateOpTestWirelessDevice struct {
}

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

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

type validateOpUntagResource struct {
}

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

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

type validateOpUpdateDestination struct {
}

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

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

type validateOpUpdateFuotaTask struct {
}

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

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

type validateOpUpdateLogLevelsByResourceTypes struct {
}

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

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

type validateOpUpdateMulticastGroup struct {
}

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

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

type validateOpUpdateNetworkAnalyzerConfiguration struct {
}

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

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

type validateOpUpdatePartnerAccount struct {
}

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

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

type validateOpUpdatePosition struct {
}

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

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

type validateOpUpdateResourceEventConfiguration struct {
}

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

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

type validateOpUpdateResourcePosition struct {
}

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

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

type validateOpUpdateWirelessDeviceImportTask struct {
}

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

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

type validateOpUpdateWirelessDevice struct {
}

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

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

type validateOpUpdateWirelessGateway struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateCdmaLocalId(v *types.CdmaLocalId) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CdmaLocalId"}
	if v.PnOffset == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PnOffset"))
	}
	if v.CdmaChannel == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CdmaChannel"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCdmaNmrObj(v *types.CdmaNmrObj) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CdmaNmrObj"}
	if v.PnOffset == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PnOffset"))
	}
	if v.CdmaChannel == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CdmaChannel"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCdmaObj(v *types.CdmaObj) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CdmaObj"}
	if v.SystemId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SystemId"))
	}
	if v.NetworkId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkId"))
	}
	if v.BaseStationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BaseStationId"))
	}
	if v.CdmaLocalId != nil {
		if err := validateCdmaLocalId(v.CdmaLocalId); err != nil {
			invalidParams.AddNested("CdmaLocalId", err.(smithy.InvalidParamsError))
		}
	}
	if v.CdmaNmr != nil {
		if err := validateCdmaNmrList(v.CdmaNmr); err != nil {
			invalidParams.AddNested("CdmaNmr", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCellTowers(v *types.CellTowers) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CellTowers"}
	if v.Gsm != nil {
		if err := validateGsmList(v.Gsm); err != nil {
			invalidParams.AddNested("Gsm", err.(smithy.InvalidParamsError))
		}
	}
	if v.Wcdma != nil {
		if err := validateWcdmaList(v.Wcdma); err != nil {
			invalidParams.AddNested("Wcdma", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tdscdma != nil {
		if err := validateTdscdmaList(v.Tdscdma); err != nil {
			invalidParams.AddNested("Tdscdma", err.(smithy.InvalidParamsError))
		}
	}
	if v.Lte != nil {
		if err := validateLteList(v.Lte); err != nil {
			invalidParams.AddNested("Lte", err.(smithy.InvalidParamsError))
		}
	}
	if v.Cdma != nil {
		if err := validateCdmaList(v.Cdma); err != nil {
			invalidParams.AddNested("Cdma", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFuotaTaskEventLogOption(v *types.FuotaTaskEventLogOption) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FuotaTaskEventLogOption"}
	if len(v.Event) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Event"))
	}
	if len(v.LogLevel) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LogLevel"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateFuotaTaskLogOption(v *types.FuotaTaskLogOption) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FuotaTaskLogOption"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if len(v.LogLevel) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LogLevel"))
	}
	if v.Events != nil {
		if err := validateFuotaTaskEventLogOptionList(v.Events); err != nil {
			invalidParams.AddNested("Events", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateGatewayListItem(v *types.GatewayListItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GatewayListItem"}
	if v.GatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayId"))
	}
	if v.DownlinkFrequency == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DownlinkFrequency"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGlobalIdentity(v *types.GlobalIdentity) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GlobalIdentity"}
	if v.Lac == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Lac"))
	}
	if v.GeranCid == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GeranCid"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateGsmLocalId(v *types.GsmLocalId) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GsmLocalId"}
	if v.Bsic == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Bsic"))
	}
	if v.Bcch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Bcch"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateGsmNmrObj(v *types.GsmNmrObj) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GsmNmrObj"}
	if v.Bsic == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Bsic"))
	}
	if v.Bcch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Bcch"))
	}
	if v.GlobalIdentity != nil {
		if err := validateGlobalIdentity(v.GlobalIdentity); err != nil {
			invalidParams.AddNested("GlobalIdentity", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGsmObj(v *types.GsmObj) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GsmObj"}
	if v.Mcc == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Mcc"))
	}
	if v.Mnc == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Mnc"))
	}
	if v.Lac == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Lac"))
	}
	if v.GeranCid == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GeranCid"))
	}
	if v.GsmLocalId != nil {
		if err := validateGsmLocalId(v.GsmLocalId); err != nil {
			invalidParams.AddNested("GsmLocalId", err.(smithy.InvalidParamsError))
		}
	}
	if v.GsmNmr != nil {
		if err := validateGsmNmrList(v.GsmNmr); err != nil {
			invalidParams.AddNested("GsmNmr", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateLoRaWANSendDataToDevice(v *types.LoRaWANSendDataToDevice) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LoRaWANSendDataToDevice"}
	if v.ParticipatingGateways != nil {
		if err := validateParticipatingGateways(v.ParticipatingGateways); err != nil {
			invalidParams.AddNested("ParticipatingGateways", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateLteLocalId(v *types.LteLocalId) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LteLocalId"}
	if v.Pci == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Pci"))
	}
	if v.Earfcn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Earfcn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateLteNmrObj(v *types.LteNmrObj) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LteNmrObj"}
	if v.Pci == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Pci"))
	}
	if v.Earfcn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Earfcn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLteObj(v *types.LteObj) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LteObj"}
	if v.Mcc == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Mcc"))
	}
	if v.Mnc == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Mnc"))
	}
	if v.EutranCid == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EutranCid"))
	}
	if v.LteLocalId != nil {
		if err := validateLteLocalId(v.LteLocalId); err != nil {
			invalidParams.AddNested("LteLocalId", err.(smithy.InvalidParamsError))
		}
	}
	if v.LteNmr != nil {
		if err := validateLteNmrList(v.LteNmr); err != nil {
			invalidParams.AddNested("LteNmr", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateParticipatingGateways(v *types.ParticipatingGateways) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParticipatingGateways"}
	if len(v.DownlinkMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DownlinkMode"))
	}
	if v.GatewayList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayList"))
	} else if v.GatewayList != nil {
		if err := validateGatewayList(v.GatewayList); err != nil {
			invalidParams.AddNested("GatewayList", err.(smithy.InvalidParamsError))
		}
	}
	if v.TransmissionInterval == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransmissionInterval"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePositionSolverConfigurations(v *types.PositionSolverConfigurations) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PositionSolverConfigurations"}
	if v.SemtechGnss != nil {
		if err := validateSemtechGnssConfiguration(v.SemtechGnss); err != nil {
			invalidParams.AddNested("SemtechGnss", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSemtechGnssConfiguration(v *types.SemtechGnssConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SemtechGnssConfiguration"}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if len(v.Fec) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Fec"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateTdscdmaLocalId(v *types.TdscdmaLocalId) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TdscdmaLocalId"}
	if v.Uarfcn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Uarfcn"))
	}
	if v.CellParams == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CellParams"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTdscdmaNmrObj(v *types.TdscdmaNmrObj) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TdscdmaNmrObj"}
	if v.Uarfcn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Uarfcn"))
	}
	if v.CellParams == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CellParams"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTdscdmaObj(v *types.TdscdmaObj) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TdscdmaObj"}
	if v.Mcc == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Mcc"))
	}
	if v.Mnc == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Mnc"))
	}
	if v.UtranCid == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UtranCid"))
	}
	if v.TdscdmaLocalId != nil {
		if err := validateTdscdmaLocalId(v.TdscdmaLocalId); err != nil {
			invalidParams.AddNested("TdscdmaLocalId", err.(smithy.InvalidParamsError))
		}
	}
	if v.TdscdmaNmr != nil {
		if err := validateTdscdmaNmrList(v.TdscdmaNmr); err != nil {
			invalidParams.AddNested("TdscdmaNmr", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateWcdmaLocalId(v *types.WcdmaLocalId) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WcdmaLocalId"}
	if v.Uarfcndl == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Uarfcndl"))
	}
	if v.Psc == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Psc"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateWcdmaNmrObj(v *types.WcdmaNmrObj) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WcdmaNmrObj"}
	if v.Uarfcndl == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Uarfcndl"))
	}
	if v.Psc == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Psc"))
	}
	if v.UtranCid == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UtranCid"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWcdmaObj(v *types.WcdmaObj) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WcdmaObj"}
	if v.Mcc == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Mcc"))
	}
	if v.Mnc == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Mnc"))
	}
	if v.UtranCid == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UtranCid"))
	}
	if v.WcdmaLocalId != nil {
		if err := validateWcdmaLocalId(v.WcdmaLocalId); err != nil {
			invalidParams.AddNested("WcdmaLocalId", err.(smithy.InvalidParamsError))
		}
	}
	if v.WcdmaNmr != nil {
		if err := validateWcdmaNmrList(v.WcdmaNmr); err != nil {
			invalidParams.AddNested("WcdmaNmr", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWiFiAccessPoint(v *types.WiFiAccessPoint) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WiFiAccessPoint"}
	if v.MacAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MacAddress"))
	}
	if v.Rss == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Rss"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateWirelessDeviceEventLogOption(v *types.WirelessDeviceEventLogOption) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WirelessDeviceEventLogOption"}
	if len(v.Event) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Event"))
	}
	if len(v.LogLevel) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LogLevel"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateWirelessDeviceLogOption(v *types.WirelessDeviceLogOption) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WirelessDeviceLogOption"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if len(v.LogLevel) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LogLevel"))
	}
	if v.Events != nil {
		if err := validateWirelessDeviceEventLogOptionList(v.Events); err != nil {
			invalidParams.AddNested("Events", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateWirelessGatewayEventLogOption(v *types.WirelessGatewayEventLogOption) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WirelessGatewayEventLogOption"}
	if len(v.Event) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Event"))
	}
	if len(v.LogLevel) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LogLevel"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateWirelessGatewayLogOption(v *types.WirelessGatewayLogOption) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WirelessGatewayLogOption"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if len(v.LogLevel) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LogLevel"))
	}
	if v.Events != nil {
		if err := validateWirelessGatewayEventLogOptionList(v.Events); err != nil {
			invalidParams.AddNested("Events", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateWirelessMetadata(v *types.WirelessMetadata) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WirelessMetadata"}
	if v.LoRaWAN != nil {
		if err := validateLoRaWANSendDataToDevice(v.LoRaWAN); err != nil {
			invalidParams.AddNested("LoRaWAN", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateAwsAccountWithPartnerAccountInput(v *AssociateAwsAccountWithPartnerAccountInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateAwsAccountWithPartnerAccountInput"}
	if v.Sidewalk == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Sidewalk"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

func validateOpCreateDestinationInput(v *CreateDestinationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDestinationInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.ExpressionType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ExpressionType"))
	}
	if v.Expression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateFuotaTaskInput(v *CreateFuotaTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFuotaTaskInput"}
	if v.FirmwareUpdateImage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FirmwareUpdateImage"))
	}
	if v.FirmwareUpdateRole == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FirmwareUpdateRole"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMulticastGroupInput(v *CreateMulticastGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMulticastGroupInput"}
	if v.LoRaWAN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LoRaWAN"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpCreateWirelessDeviceInput(v *CreateWirelessDeviceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateWirelessDeviceInput"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.DestinationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationName"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateWirelessGatewayInput(v *CreateWirelessGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateWirelessGatewayInput"}
	if v.LoRaWAN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LoRaWAN"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpDisassociateAwsAccountFromPartnerAccountInput(v *DisassociateAwsAccountFromPartnerAccountInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateAwsAccountFromPartnerAccountInput"}
	if v.PartnerAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartnerAccountId"))
	}
	if len(v.PartnerType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PartnerType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpGetPartnerAccountInput(v *GetPartnerAccountInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPartnerAccountInput"}
	if v.PartnerAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartnerAccountId"))
	}
	if len(v.PartnerType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PartnerType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetPositionConfigurationInput(v *GetPositionConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPositionConfigurationInput"}
	if v.ResourceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
	}
	if len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetPositionEstimateInput(v *GetPositionEstimateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPositionEstimateInput"}
	if v.WiFiAccessPoints != nil {
		if err := validateWiFiAccessPoints(v.WiFiAccessPoints); err != nil {
			invalidParams.AddNested("WiFiAccessPoints", err.(smithy.InvalidParamsError))
		}
	}
	if v.CellTowers != nil {
		if err := validateCellTowers(v.CellTowers); err != nil {
			invalidParams.AddNested("CellTowers", err.(smithy.InvalidParamsError))
		}
	}
	if v.Ip != nil {
		if err := validateIp(v.Ip); err != nil {
			invalidParams.AddNested("Ip", err.(smithy.InvalidParamsError))
		}
	}
	if v.Gnss != nil {
		if err := validateGnss(v.Gnss); err != nil {
			invalidParams.AddNested("Gnss", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetPositionInput(v *GetPositionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPositionInput"}
	if v.ResourceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
	}
	if len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetResourceLogLevelInput(v *GetResourceLogLevelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetResourceLogLevelInput"}
	if v.ResourceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
	}
	if v.ResourceType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetResourcePositionInput(v *GetResourcePositionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetResourcePositionInput"}
	if v.ResourceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
	}
	if len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpPutPositionConfigurationInput(v *PutPositionConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutPositionConfigurationInput"}
	if v.ResourceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
	}
	if len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if v.Solvers != nil {
		if err := validatePositionSolverConfigurations(v.Solvers); err != nil {
			invalidParams.AddNested("Solvers", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutResourceLogLevelInput(v *PutResourceLogLevelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutResourceLogLevelInput"}
	if v.ResourceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
	}
	if v.ResourceType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if len(v.LogLevel) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LogLevel"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpResetResourceLogLevelInput(v *ResetResourceLogLevelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResetResourceLogLevelInput"}
	if v.ResourceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
	}
	if v.ResourceType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpSendDataToWirelessDeviceInput(v *SendDataToWirelessDeviceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SendDataToWirelessDeviceInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.TransmitMode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransmitMode"))
	}
	if v.PayloadData == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PayloadData"))
	}
	if v.WirelessMetadata != nil {
		if err := validateWirelessMetadata(v.WirelessMetadata); err != nil {
			invalidParams.AddNested("WirelessMetadata", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartBulkAssociateWirelessDeviceWithMulticastGroupInput(v *StartBulkAssociateWirelessDeviceWithMulticastGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartBulkAssociateWirelessDeviceWithMulticastGroupInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartBulkDisassociateWirelessDeviceFromMulticastGroupInput(v *StartBulkDisassociateWirelessDeviceFromMulticastGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartBulkDisassociateWirelessDeviceFromMulticastGroupInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpStartSingleWirelessDeviceImportTaskInput(v *StartSingleWirelessDeviceImportTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartSingleWirelessDeviceImportTaskInput"}
	if v.DestinationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationName"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.Sidewalk == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Sidewalk"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartWirelessDeviceImportTaskInput(v *StartWirelessDeviceImportTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartWirelessDeviceImportTaskInput"}
	if v.DestinationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationName"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.Sidewalk == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Sidewalk"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpUpdateLogLevelsByResourceTypesInput(v *UpdateLogLevelsByResourceTypesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateLogLevelsByResourceTypesInput"}
	if v.FuotaTaskLogOptions != nil {
		if err := validateFuotaTaskLogOptionList(v.FuotaTaskLogOptions); err != nil {
			invalidParams.AddNested("FuotaTaskLogOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.WirelessDeviceLogOptions != nil {
		if err := validateWirelessDeviceLogOptionList(v.WirelessDeviceLogOptions); err != nil {
			invalidParams.AddNested("WirelessDeviceLogOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.WirelessGatewayLogOptions != nil {
		if err := validateWirelessGatewayLogOptionList(v.WirelessGatewayLogOptions); err != nil {
			invalidParams.AddNested("WirelessGatewayLogOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpUpdatePartnerAccountInput(v *UpdatePartnerAccountInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePartnerAccountInput"}
	if v.Sidewalk == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Sidewalk"))
	}
	if v.PartnerAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartnerAccountId"))
	}
	if len(v.PartnerType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PartnerType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdatePositionInput(v *UpdatePositionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePositionInput"}
	if v.ResourceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
	}
	if len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if v.Position == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Position"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateResourcePositionInput(v *UpdateResourcePositionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateResourcePositionInput"}
	if v.ResourceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
	}
	if len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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