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

package storagegateway

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

type validateOpActivateGateway struct {
}

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

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

type validateOpAddCache struct {
}

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

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

type validateOpAddTagsToResource struct {
}

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

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

type validateOpAddUploadBuffer struct {
}

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

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

type validateOpAddWorkingStorage struct {
}

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

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

type validateOpAssignTapePool struct {
}

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

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

type validateOpAttachVolume struct {
}

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

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

type validateOpCancelArchival struct {
}

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

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

type validateOpCancelRetrieval struct {
}

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

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

type validateOpCreateCachediSCSIVolume struct {
}

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

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

type validateOpCreateNFSFileShare struct {
}

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

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

type validateOpCreateSMBFileShare struct {
}

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

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

type validateOpCreateSnapshotFromVolumeRecoveryPoint struct {
}

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

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

type validateOpCreateSnapshot struct {
}

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

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

type validateOpCreateStorediSCSIVolume struct {
}

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

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

type validateOpCreateTapePool struct {
}

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

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

type validateOpCreateTapes struct {
}

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

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

type validateOpCreateTapeWithBarcode struct {
}

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

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

type validateOpDeleteAutomaticTapeCreationPolicy struct {
}

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

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

type validateOpDeleteBandwidthRateLimit struct {
}

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

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

type validateOpDeleteChapCredentials struct {
}

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

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

type validateOpDeleteFileShare struct {
}

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

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

type validateOpDeleteGateway struct {
}

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

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

type validateOpDeleteSnapshotSchedule struct {
}

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

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

type validateOpDeleteTapeArchive struct {
}

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

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

type validateOpDeleteTape struct {
}

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

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

type validateOpDeleteTapePool struct {
}

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

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

type validateOpDeleteVolume struct {
}

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

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

type validateOpDescribeAvailabilityMonitorTest struct {
}

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

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

type validateOpDescribeBandwidthRateLimit struct {
}

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

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

type validateOpDescribeBandwidthRateLimitSchedule struct {
}

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

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

type validateOpDescribeCachediSCSIVolumes struct {
}

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

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

type validateOpDescribeCache struct {
}

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

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

type validateOpDescribeChapCredentials struct {
}

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

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

type validateOpDescribeGatewayInformation struct {
}

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

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

type validateOpDescribeMaintenanceStartTime struct {
}

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

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

type validateOpDescribeNFSFileShares struct {
}

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

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

type validateOpDescribeSMBFileShares struct {
}

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

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

type validateOpDescribeSMBSettings struct {
}

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

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

type validateOpDescribeSnapshotSchedule struct {
}

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

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

type validateOpDescribeStorediSCSIVolumes struct {
}

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

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

type validateOpDescribeTapeRecoveryPoints struct {
}

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

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

type validateOpDescribeTapes struct {
}

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

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

type validateOpDescribeUploadBuffer struct {
}

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

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

type validateOpDescribeVTLDevices struct {
}

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

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

type validateOpDescribeWorkingStorage struct {
}

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

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

type validateOpDetachVolume struct {
}

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

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

type validateOpDisableGateway struct {
}

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

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

type validateOpJoinDomain struct {
}

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

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

type validateOpListLocalDisks struct {
}

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

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

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

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

type validateOpListVolumeRecoveryPoints struct {
}

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

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

type validateOpNotifyWhenUploaded struct {
}

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

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

type validateOpRefreshCache struct {
}

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

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

type validateOpRemoveTagsFromResource struct {
}

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

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

type validateOpResetCache struct {
}

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

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

type validateOpRetrieveTapeArchive struct {
}

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

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

type validateOpRetrieveTapeRecoveryPoint struct {
}

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

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

type validateOpSetLocalConsolePassword struct {
}

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

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

type validateOpSetSMBGuestPassword struct {
}

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

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

type validateOpShutdownGateway struct {
}

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

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

type validateOpStartAvailabilityMonitorTest struct {
}

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

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

type validateOpStartGateway struct {
}

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

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

type validateOpUpdateAutomaticTapeCreationPolicy struct {
}

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

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

type validateOpUpdateBandwidthRateLimit struct {
}

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

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

type validateOpUpdateBandwidthRateLimitSchedule struct {
}

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

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

type validateOpUpdateChapCredentials struct {
}

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

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

type validateOpUpdateGatewayInformation struct {
}

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

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

type validateOpUpdateGatewaySoftwareNow struct {
}

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

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

type validateOpUpdateMaintenanceStartTime struct {
}

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

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

type validateOpUpdateNFSFileShare struct {
}

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

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

type validateOpUpdateSMBFileShare struct {
}

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

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

type validateOpUpdateSMBFileShareVisibility struct {
}

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

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

type validateOpUpdateSMBSecurityStrategy struct {
}

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

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

type validateOpUpdateSnapshotSchedule struct {
}

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

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

type validateOpUpdateVTLDeviceType struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateAutomaticTapeCreationRule(v *types.AutomaticTapeCreationRule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AutomaticTapeCreationRule"}
	if v.TapeBarcodePrefix == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TapeBarcodePrefix"))
	}
	if v.PoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PoolId"))
	}
	if v.TapeSizeInBytes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TapeSizeInBytes"))
	}
	if v.MinimumNumTapes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MinimumNumTapes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateBandwidthRateLimitInterval(v *types.BandwidthRateLimitInterval) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BandwidthRateLimitInterval"}
	if v.StartHourOfDay == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartHourOfDay"))
	}
	if v.StartMinuteOfHour == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartMinuteOfHour"))
	}
	if v.EndHourOfDay == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndHourOfDay"))
	}
	if v.EndMinuteOfHour == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndMinuteOfHour"))
	}
	if v.DaysOfWeek == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DaysOfWeek"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBandwidthRateLimitIntervals(v []types.BandwidthRateLimitInterval) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BandwidthRateLimitIntervals"}
	for i := range v {
		if err := validateBandwidthRateLimitInterval(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	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 validateTags(v []types.Tag) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Tags"}
	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 validateOpActivateGatewayInput(v *ActivateGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ActivateGatewayInput"}
	if v.ActivationKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActivationKey"))
	}
	if v.GatewayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayName"))
	}
	if v.GatewayTimezone == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayTimezone"))
	}
	if v.GatewayRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayRegion"))
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddCacheInput(v *AddCacheInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddCacheInput"}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if v.DiskIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DiskIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddTagsToResourceInput(v *AddTagsToResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddTagsToResourceInput"}
	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 := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddUploadBufferInput(v *AddUploadBufferInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddUploadBufferInput"}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if v.DiskIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DiskIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddWorkingStorageInput(v *AddWorkingStorageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddWorkingStorageInput"}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if v.DiskIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DiskIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssignTapePoolInput(v *AssignTapePoolInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssignTapePoolInput"}
	if v.TapeARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TapeARN"))
	}
	if v.PoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCancelArchivalInput(v *CancelArchivalInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelArchivalInput"}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if v.TapeARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TapeARN"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCancelRetrievalInput(v *CancelRetrievalInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelRetrievalInput"}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if v.TapeARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TapeARN"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCachediSCSIVolumeInput(v *CreateCachediSCSIVolumeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCachediSCSIVolumeInput"}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if v.TargetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetName"))
	}
	if v.NetworkInterfaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceId"))
	}
	if v.ClientToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateNFSFileShareInput(v *CreateNFSFileShareInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateNFSFileShareInput"}
	if v.ClientToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
	}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if v.Role == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Role"))
	}
	if v.LocationARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocationARN"))
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSMBFileShareInput(v *CreateSMBFileShareInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSMBFileShareInput"}
	if v.ClientToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
	}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if v.Role == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Role"))
	}
	if v.LocationARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocationARN"))
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpCreateStorediSCSIVolumeInput(v *CreateStorediSCSIVolumeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateStorediSCSIVolumeInput"}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if v.DiskId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DiskId"))
	}
	if v.TargetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetName"))
	}
	if v.NetworkInterfaceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkInterfaceId"))
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateTapesInput(v *CreateTapesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTapesInput"}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if v.TapeSizeInBytes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TapeSizeInBytes"))
	}
	if v.ClientToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
	}
	if v.NumTapesToCreate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NumTapesToCreate"))
	}
	if v.TapeBarcodePrefix == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TapeBarcodePrefix"))
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteBandwidthRateLimitInput(v *DeleteBandwidthRateLimitInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteBandwidthRateLimitInput"}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if v.BandwidthType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BandwidthType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteChapCredentialsInput(v *DeleteChapCredentialsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteChapCredentialsInput"}
	if v.TargetARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetARN"))
	}
	if v.InitiatorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InitiatorName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpDeleteTapeInput(v *DeleteTapeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTapeInput"}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if v.TapeARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TapeARN"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpJoinDomainInput(v *JoinDomainInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "JoinDomainInput"}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if v.UserName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
	}
	if v.Password == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Password"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListLocalDisksInput(v *ListLocalDisksInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListLocalDisksInput"}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	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 validateOpListVolumeInitiatorsInput(v *ListVolumeInitiatorsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListVolumeInitiatorsInput"}
	if v.VolumeARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VolumeARN"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpRemoveTagsFromResourceInput(v *RemoveTagsFromResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveTagsFromResourceInput"}
	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 validateOpResetCacheInput(v *ResetCacheInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResetCacheInput"}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRetrieveTapeArchiveInput(v *RetrieveTapeArchiveInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RetrieveTapeArchiveInput"}
	if v.TapeARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TapeARN"))
	}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRetrieveTapeRecoveryPointInput(v *RetrieveTapeRecoveryPointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RetrieveTapeRecoveryPointInput"}
	if v.TapeARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TapeARN"))
	}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSetLocalConsolePasswordInput(v *SetLocalConsolePasswordInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetLocalConsolePasswordInput"}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if v.LocalConsolePassword == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocalConsolePassword"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSetSMBGuestPasswordInput(v *SetSMBGuestPasswordInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetSMBGuestPasswordInput"}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if v.Password == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Password"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpUpdateAutomaticTapeCreationPolicyInput(v *UpdateAutomaticTapeCreationPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAutomaticTapeCreationPolicyInput"}
	if v.AutomaticTapeCreationRules == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutomaticTapeCreationRules"))
	} else if v.AutomaticTapeCreationRules != nil {
		if err := validateAutomaticTapeCreationRules(v.AutomaticTapeCreationRules); err != nil {
			invalidParams.AddNested("AutomaticTapeCreationRules", err.(smithy.InvalidParamsError))
		}
	}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateBandwidthRateLimitScheduleInput(v *UpdateBandwidthRateLimitScheduleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateBandwidthRateLimitScheduleInput"}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if v.BandwidthRateLimitIntervals == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BandwidthRateLimitIntervals"))
	} else if v.BandwidthRateLimitIntervals != nil {
		if err := validateBandwidthRateLimitIntervals(v.BandwidthRateLimitIntervals); err != nil {
			invalidParams.AddNested("BandwidthRateLimitIntervals", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateChapCredentialsInput(v *UpdateChapCredentialsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateChapCredentialsInput"}
	if v.TargetARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetARN"))
	}
	if v.SecretToAuthenticateInitiator == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecretToAuthenticateInitiator"))
	}
	if v.InitiatorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InitiatorName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpUpdateMaintenanceStartTimeInput(v *UpdateMaintenanceStartTimeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateMaintenanceStartTimeInput"}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if v.HourOfDay == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HourOfDay"))
	}
	if v.MinuteOfHour == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MinuteOfHour"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpUpdateSMBFileShareVisibilityInput(v *UpdateSMBFileShareVisibilityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSMBFileShareVisibilityInput"}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if v.FileSharesVisible == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FileSharesVisible"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateSMBSecurityStrategyInput(v *UpdateSMBSecurityStrategyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSMBSecurityStrategyInput"}
	if v.GatewayARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayARN"))
	}
	if len(v.SMBSecurityStrategy) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SMBSecurityStrategy"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateVTLDeviceTypeInput(v *UpdateVTLDeviceTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateVTLDeviceTypeInput"}
	if v.VTLDeviceARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VTLDeviceARN"))
	}
	if v.DeviceType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}