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

package location

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

type validateOpAssociateTrackerConsumer struct {
}

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

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

type validateOpBatchDeleteDevicePositionHistory struct {
}

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

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

type validateOpBatchDeleteGeofence struct {
}

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

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

type validateOpBatchEvaluateGeofences struct {
}

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

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

type validateOpBatchGetDevicePosition struct {
}

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

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

type validateOpBatchPutGeofence struct {
}

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

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

type validateOpBatchUpdateDevicePosition struct {
}

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

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

type validateOpCalculateRoute struct {
}

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

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

type validateOpCalculateRouteMatrix struct {
}

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

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

type validateOpCreateGeofenceCollection struct {
}

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

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

type validateOpCreateKey struct {
}

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

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

type validateOpCreateMap struct {
}

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

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

type validateOpCreatePlaceIndex struct {
}

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

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

type validateOpCreateRouteCalculator struct {
}

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

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

type validateOpCreateTracker struct {
}

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

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

type validateOpDeleteGeofenceCollection struct {
}

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

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

type validateOpDeleteKey struct {
}

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

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

type validateOpDeleteMap struct {
}

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

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

type validateOpDeletePlaceIndex struct {
}

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

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

type validateOpDeleteRouteCalculator struct {
}

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

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

type validateOpDeleteTracker struct {
}

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

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

type validateOpDescribeGeofenceCollection struct {
}

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

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

type validateOpDescribeKey struct {
}

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

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

type validateOpDescribeMap struct {
}

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

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

type validateOpDescribePlaceIndex struct {
}

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

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

type validateOpDescribeRouteCalculator struct {
}

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

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

type validateOpDescribeTracker struct {
}

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

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

type validateOpDisassociateTrackerConsumer struct {
}

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

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

type validateOpGetDevicePositionHistory struct {
}

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

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

type validateOpGetDevicePosition struct {
}

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

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

type validateOpGetGeofence struct {
}

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

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

type validateOpGetMapGlyphs struct {
}

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

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

type validateOpGetMapSprites struct {
}

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

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

type validateOpGetMapStyleDescriptor struct {
}

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

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

type validateOpGetMapTile struct {
}

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

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

type validateOpGetPlace struct {
}

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

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

type validateOpListDevicePositions struct {
}

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

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

type validateOpListGeofences struct {
}

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

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

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

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

type validateOpPutGeofence struct {
}

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

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

type validateOpSearchPlaceIndexForPosition struct {
}

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

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

type validateOpSearchPlaceIndexForSuggestions struct {
}

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

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

type validateOpSearchPlaceIndexForText struct {
}

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

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

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

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

type validateOpUpdateKey struct {
}

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

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

type validateOpUpdateMap struct {
}

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

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

type validateOpUpdatePlaceIndex struct {
}

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

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

type validateOpUpdateRouteCalculator struct {
}

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

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

type validateOpUpdateTracker struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateApiKeyRestrictions(v *types.ApiKeyRestrictions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ApiKeyRestrictions"}
	if v.AllowActions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AllowActions"))
	}
	if v.AllowResources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AllowResources"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBatchPutGeofenceRequestEntry(v *types.BatchPutGeofenceRequestEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchPutGeofenceRequestEntry"}
	if v.GeofenceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GeofenceId"))
	}
	if v.Geometry == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Geometry"))
	} else if v.Geometry != nil {
		if err := validateGeofenceGeometry(v.Geometry); err != nil {
			invalidParams.AddNested("Geometry", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCircle(v *types.Circle) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Circle"}
	if v.Center == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Center"))
	}
	if v.Radius == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Radius"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDevicePositionUpdate(v *types.DevicePositionUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DevicePositionUpdate"}
	if v.DeviceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceId"))
	}
	if v.SampleTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SampleTime"))
	}
	if v.Position == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Position"))
	}
	if v.Accuracy != nil {
		if err := validatePositionalAccuracy(v.Accuracy); err != nil {
			invalidParams.AddNested("Accuracy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateGeofenceGeometry(v *types.GeofenceGeometry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GeofenceGeometry"}
	if v.Circle != nil {
		if err := validateCircle(v.Circle); err != nil {
			invalidParams.AddNested("Circle", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpAssociateTrackerConsumerInput(v *AssociateTrackerConsumerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateTrackerConsumerInput"}
	if v.TrackerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrackerName"))
	}
	if v.ConsumerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConsumerArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchDeleteDevicePositionHistoryInput(v *BatchDeleteDevicePositionHistoryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteDevicePositionHistoryInput"}
	if v.TrackerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrackerName"))
	}
	if v.DeviceIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchDeleteGeofenceInput(v *BatchDeleteGeofenceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteGeofenceInput"}
	if v.CollectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollectionName"))
	}
	if v.GeofenceIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GeofenceIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchEvaluateGeofencesInput(v *BatchEvaluateGeofencesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchEvaluateGeofencesInput"}
	if v.CollectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollectionName"))
	}
	if v.DevicePositionUpdates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DevicePositionUpdates"))
	} else if v.DevicePositionUpdates != nil {
		if err := validateDevicePositionUpdateList(v.DevicePositionUpdates); err != nil {
			invalidParams.AddNested("DevicePositionUpdates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchGetDevicePositionInput(v *BatchGetDevicePositionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetDevicePositionInput"}
	if v.TrackerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrackerName"))
	}
	if v.DeviceIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchPutGeofenceInput(v *BatchPutGeofenceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchPutGeofenceInput"}
	if v.CollectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollectionName"))
	}
	if v.Entries == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Entries"))
	} else if v.Entries != nil {
		if err := validateBatchPutGeofenceRequestEntryList(v.Entries); err != nil {
			invalidParams.AddNested("Entries", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchUpdateDevicePositionInput(v *BatchUpdateDevicePositionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchUpdateDevicePositionInput"}
	if v.TrackerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrackerName"))
	}
	if v.Updates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Updates"))
	} else if v.Updates != nil {
		if err := validateDevicePositionUpdateList(v.Updates); err != nil {
			invalidParams.AddNested("Updates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCalculateRouteInput(v *CalculateRouteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CalculateRouteInput"}
	if v.CalculatorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CalculatorName"))
	}
	if v.DeparturePosition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeparturePosition"))
	}
	if v.DestinationPosition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationPosition"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCalculateRouteMatrixInput(v *CalculateRouteMatrixInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CalculateRouteMatrixInput"}
	if v.CalculatorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CalculatorName"))
	}
	if v.DeparturePositions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeparturePositions"))
	}
	if v.DestinationPositions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationPositions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateKeyInput(v *CreateKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateKeyInput"}
	if v.KeyName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyName"))
	}
	if v.Restrictions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Restrictions"))
	} else if v.Restrictions != nil {
		if err := validateApiKeyRestrictions(v.Restrictions); err != nil {
			invalidParams.AddNested("Restrictions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMapInput(v *CreateMapInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMapInput"}
	if v.MapName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MapName"))
	}
	if v.Configuration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Configuration"))
	} else if v.Configuration != nil {
		if err := validateMapConfiguration(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePlaceIndexInput(v *CreatePlaceIndexInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePlaceIndexInput"}
	if v.IndexName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexName"))
	}
	if v.DataSource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSource"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRouteCalculatorInput(v *CreateRouteCalculatorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRouteCalculatorInput"}
	if v.CalculatorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CalculatorName"))
	}
	if v.DataSource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSource"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpDisassociateTrackerConsumerInput(v *DisassociateTrackerConsumerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateTrackerConsumerInput"}
	if v.TrackerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrackerName"))
	}
	if v.ConsumerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConsumerArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDevicePositionHistoryInput(v *GetDevicePositionHistoryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDevicePositionHistoryInput"}
	if v.TrackerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrackerName"))
	}
	if v.DeviceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDevicePositionInput(v *GetDevicePositionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDevicePositionInput"}
	if v.TrackerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrackerName"))
	}
	if v.DeviceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetGeofenceInput(v *GetGeofenceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetGeofenceInput"}
	if v.CollectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollectionName"))
	}
	if v.GeofenceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GeofenceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetMapGlyphsInput(v *GetMapGlyphsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMapGlyphsInput"}
	if v.MapName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MapName"))
	}
	if v.FontStack == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FontStack"))
	}
	if v.FontUnicodeRange == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FontUnicodeRange"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetMapSpritesInput(v *GetMapSpritesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMapSpritesInput"}
	if v.MapName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MapName"))
	}
	if v.FileName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FileName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetMapTileInput(v *GetMapTileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMapTileInput"}
	if v.MapName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MapName"))
	}
	if v.Z == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Z"))
	}
	if v.X == nil {
		invalidParams.Add(smithy.NewErrParamRequired("X"))
	}
	if v.Y == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Y"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetPlaceInput(v *GetPlaceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPlaceInput"}
	if v.IndexName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexName"))
	}
	if v.PlaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PlaceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListGeofencesInput(v *ListGeofencesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListGeofencesInput"}
	if v.CollectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollectionName"))
	}
	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 validateOpListTrackerConsumersInput(v *ListTrackerConsumersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTrackerConsumersInput"}
	if v.TrackerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrackerName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutGeofenceInput(v *PutGeofenceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutGeofenceInput"}
	if v.CollectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollectionName"))
	}
	if v.GeofenceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GeofenceId"))
	}
	if v.Geometry == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Geometry"))
	} else if v.Geometry != nil {
		if err := validateGeofenceGeometry(v.Geometry); err != nil {
			invalidParams.AddNested("Geometry", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchPlaceIndexForPositionInput(v *SearchPlaceIndexForPositionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchPlaceIndexForPositionInput"}
	if v.IndexName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexName"))
	}
	if v.Position == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Position"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchPlaceIndexForSuggestionsInput(v *SearchPlaceIndexForSuggestionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchPlaceIndexForSuggestionsInput"}
	if v.IndexName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexName"))
	}
	if v.Text == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Text"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchPlaceIndexForTextInput(v *SearchPlaceIndexForTextInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchPlaceIndexForTextInput"}
	if v.IndexName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexName"))
	}
	if v.Text == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Text"))
	}
	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"))
	}
	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 validateOpUpdateGeofenceCollectionInput(v *UpdateGeofenceCollectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateGeofenceCollectionInput"}
	if v.CollectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollectionName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateKeyInput(v *UpdateKeyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateKeyInput"}
	if v.KeyName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyName"))
	}
	if v.Restrictions != nil {
		if err := validateApiKeyRestrictions(v.Restrictions); err != nil {
			invalidParams.AddNested("Restrictions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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