validators.go

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

package datasync

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

type validateOpAddStorageSystem struct {
}

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

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

type validateOpCancelTaskExecution struct {
}

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

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

type validateOpCreateAgent struct {
}

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

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

type validateOpCreateLocationAzureBlob struct {
}

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

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

type validateOpCreateLocationEfs struct {
}

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

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

type validateOpCreateLocationFsxLustre struct {
}

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

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

type validateOpCreateLocationFsxOntap struct {
}

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

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

type validateOpCreateLocationFsxOpenZfs struct {
}

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

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

type validateOpCreateLocationFsxWindows struct {
}

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

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

type validateOpCreateLocationHdfs struct {
}

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

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

type validateOpCreateLocationNfs struct {
}

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

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

type validateOpCreateLocationObjectStorage struct {
}

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

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

type validateOpCreateLocationS3 struct {
}

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

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

type validateOpCreateLocationSmb struct {
}

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

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

type validateOpCreateTask struct {
}

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

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

type validateOpDeleteAgent struct {
}

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

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

type validateOpDeleteLocation struct {
}

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

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

type validateOpDeleteTask struct {
}

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

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

type validateOpDescribeAgent struct {
}

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

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

type validateOpDescribeDiscoveryJob struct {
}

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

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

type validateOpDescribeLocationAzureBlob struct {
}

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

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

type validateOpDescribeLocationEfs struct {
}

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

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

type validateOpDescribeLocationFsxLustre struct {
}

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

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

type validateOpDescribeLocationFsxOntap struct {
}

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

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

type validateOpDescribeLocationFsxOpenZfs struct {
}

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

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

type validateOpDescribeLocationFsxWindows struct {
}

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

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

type validateOpDescribeLocationHdfs struct {
}

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

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

type validateOpDescribeLocationNfs struct {
}

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

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

type validateOpDescribeLocationObjectStorage struct {
}

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

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

type validateOpDescribeLocationS3 struct {
}

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

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

type validateOpDescribeLocationSmb struct {
}

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

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

type validateOpDescribeStorageSystem struct {
}

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

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

type validateOpDescribeStorageSystemResourceMetrics struct {
}

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

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

type validateOpDescribeStorageSystemResources struct {
}

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

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

type validateOpDescribeTaskExecution struct {
}

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

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

type validateOpDescribeTask struct {
}

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

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

type validateOpGenerateRecommendations struct {
}

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

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

type validateOpListLocations struct {
}

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

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

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

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

type validateOpRemoveStorageSystem struct {
}

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

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

type validateOpStartDiscoveryJob struct {
}

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

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

type validateOpStartTaskExecution struct {
}

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

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

type validateOpStopDiscoveryJob struct {
}

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

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

type validateOpTagResource struct {
}

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

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

type validateOpUntagResource struct {
}

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

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

type validateOpUpdateAgent struct {
}

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

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

type validateOpUpdateDiscoveryJob struct {
}

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

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

type validateOpUpdateLocationAzureBlob struct {
}

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

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

type validateOpUpdateLocationHdfs struct {
}

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

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

type validateOpUpdateLocationNfs struct {
}

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

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

type validateOpUpdateLocationObjectStorage struct {
}

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

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

type validateOpUpdateLocationSmb struct {
}

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

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

type validateOpUpdateStorageSystem struct {
}

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

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

type validateOpUpdateTaskExecution struct {
}

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

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

type validateOpUpdateTask struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateCredentials(v *types.Credentials) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Credentials"}
	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 validateDiscoveryServerConfiguration(v *types.DiscoveryServerConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DiscoveryServerConfiguration"}
	if v.ServerHostname == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServerHostname"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEc2Config(v *types.Ec2Config) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Ec2Config"}
	if v.SubnetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetArn"))
	}
	if v.SecurityGroupArns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupArns"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFsxProtocol(v *types.FsxProtocol) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FsxProtocol"}
	if v.SMB != nil {
		if err := validateFsxProtocolSmb(v.SMB); err != nil {
			invalidParams.AddNested("SMB", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateHdfsNameNode(v *types.HdfsNameNode) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HdfsNameNode"}
	if v.Hostname == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Hostname"))
	}
	if v.Port == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Port"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateLocationFilter(v *types.LocationFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LocationFilter"}
	if len(v.Name) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Values == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Values"))
	}
	if len(v.Operator) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Operator"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateManifestConfig(v *types.ManifestConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ManifestConfig"}
	if v.Source != nil {
		if err := validateSourceManifestConfig(v.Source); err != nil {
			invalidParams.AddNested("Source", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateReportDestination(v *types.ReportDestination) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReportDestination"}
	if v.S3 != nil {
		if err := validateReportDestinationS3(v.S3); err != nil {
			invalidParams.AddNested("S3", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateReportDestinationS3(v *types.ReportDestinationS3) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReportDestinationS3"}
	if v.S3BucketArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3BucketArn"))
	}
	if v.BucketAccessRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BucketAccessRoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateS3ManifestConfig(v *types.S3ManifestConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3ManifestConfig"}
	if v.ManifestObjectPath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ManifestObjectPath"))
	}
	if v.BucketAccessRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BucketAccessRoleArn"))
	}
	if v.S3BucketArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3BucketArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSourceManifestConfig(v *types.SourceManifestConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SourceManifestConfig"}
	if v.S3 == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3"))
	} else if v.S3 != nil {
		if err := validateS3ManifestConfig(v.S3); err != nil {
			invalidParams.AddNested("S3", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTaskFilter(v *types.TaskFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TaskFilter"}
	if len(v.Name) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Values == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Values"))
	}
	if len(v.Operator) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Operator"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTaskReportConfig(v *types.TaskReportConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TaskReportConfig"}
	if v.Destination != nil {
		if err := validateReportDestination(v.Destination); err != nil {
			invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpAddStorageSystemInput(v *AddStorageSystemInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddStorageSystemInput"}
	if v.ServerConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServerConfiguration"))
	} else if v.ServerConfiguration != nil {
		if err := validateDiscoveryServerConfiguration(v.ServerConfiguration); err != nil {
			invalidParams.AddNested("ServerConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.SystemType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SystemType"))
	}
	if v.AgentArns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentArns"))
	}
	if v.Tags != nil {
		if err := validateInputTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.ClientToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
	}
	if v.Credentials == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Credentials"))
	} else if v.Credentials != nil {
		if err := validateCredentials(v.Credentials); err != nil {
			invalidParams.AddNested("Credentials", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateAgentInput(v *CreateAgentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAgentInput"}
	if v.ActivationKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActivationKey"))
	}
	if v.Tags != nil {
		if err := validateInputTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLocationAzureBlobInput(v *CreateLocationAzureBlobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLocationAzureBlobInput"}
	if v.ContainerUrl == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContainerUrl"))
	}
	if len(v.AuthenticationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AuthenticationType"))
	}
	if v.SasConfiguration != nil {
		if err := validateAzureBlobSasConfiguration(v.SasConfiguration); err != nil {
			invalidParams.AddNested("SasConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.AgentArns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentArns"))
	}
	if v.Tags != nil {
		if err := validateInputTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLocationEfsInput(v *CreateLocationEfsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLocationEfsInput"}
	if v.EfsFilesystemArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EfsFilesystemArn"))
	}
	if v.Ec2Config == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Ec2Config"))
	} else if v.Ec2Config != nil {
		if err := validateEc2Config(v.Ec2Config); err != nil {
			invalidParams.AddNested("Ec2Config", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateInputTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLocationFsxLustreInput(v *CreateLocationFsxLustreInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLocationFsxLustreInput"}
	if v.FsxFilesystemArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FsxFilesystemArn"))
	}
	if v.SecurityGroupArns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupArns"))
	}
	if v.Tags != nil {
		if err := validateInputTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLocationFsxOntapInput(v *CreateLocationFsxOntapInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLocationFsxOntapInput"}
	if v.Protocol == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
	} else if v.Protocol != nil {
		if err := validateFsxProtocol(v.Protocol); err != nil {
			invalidParams.AddNested("Protocol", err.(smithy.InvalidParamsError))
		}
	}
	if v.SecurityGroupArns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupArns"))
	}
	if v.StorageVirtualMachineArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StorageVirtualMachineArn"))
	}
	if v.Tags != nil {
		if err := validateInputTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLocationFsxOpenZfsInput(v *CreateLocationFsxOpenZfsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLocationFsxOpenZfsInput"}
	if v.FsxFilesystemArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FsxFilesystemArn"))
	}
	if v.Protocol == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
	} else if v.Protocol != nil {
		if err := validateFsxProtocol(v.Protocol); err != nil {
			invalidParams.AddNested("Protocol", err.(smithy.InvalidParamsError))
		}
	}
	if v.SecurityGroupArns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupArns"))
	}
	if v.Tags != nil {
		if err := validateInputTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLocationFsxWindowsInput(v *CreateLocationFsxWindowsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLocationFsxWindowsInput"}
	if v.FsxFilesystemArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FsxFilesystemArn"))
	}
	if v.SecurityGroupArns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupArns"))
	}
	if v.Tags != nil {
		if err := validateInputTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.User == nil {
		invalidParams.Add(smithy.NewErrParamRequired("User"))
	}
	if v.Password == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Password"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLocationHdfsInput(v *CreateLocationHdfsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLocationHdfsInput"}
	if v.NameNodes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NameNodes"))
	} else if v.NameNodes != nil {
		if err := validateHdfsNameNodeList(v.NameNodes); err != nil {
			invalidParams.AddNested("NameNodes", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.AuthenticationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AuthenticationType"))
	}
	if v.AgentArns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentArns"))
	}
	if v.Tags != nil {
		if err := validateInputTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLocationNfsInput(v *CreateLocationNfsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLocationNfsInput"}
	if v.Subdirectory == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Subdirectory"))
	}
	if v.ServerHostname == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServerHostname"))
	}
	if v.OnPremConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OnPremConfig"))
	} else if v.OnPremConfig != nil {
		if err := validateOnPremConfig(v.OnPremConfig); err != nil {
			invalidParams.AddNested("OnPremConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateInputTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLocationObjectStorageInput(v *CreateLocationObjectStorageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLocationObjectStorageInput"}
	if v.ServerHostname == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServerHostname"))
	}
	if v.BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
	}
	if v.AgentArns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentArns"))
	}
	if v.Tags != nil {
		if err := validateInputTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLocationS3Input(v *CreateLocationS3Input) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLocationS3Input"}
	if v.S3BucketArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3BucketArn"))
	}
	if v.S3Config == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3Config"))
	} else if v.S3Config != nil {
		if err := validateS3Config(v.S3Config); err != nil {
			invalidParams.AddNested("S3Config", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateInputTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLocationSmbInput(v *CreateLocationSmbInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLocationSmbInput"}
	if v.Subdirectory == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Subdirectory"))
	}
	if v.ServerHostname == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServerHostname"))
	}
	if v.User == nil {
		invalidParams.Add(smithy.NewErrParamRequired("User"))
	}
	if v.Password == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Password"))
	}
	if v.AgentArns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AgentArns"))
	}
	if v.Tags != nil {
		if err := validateInputTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTaskInput(v *CreateTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTaskInput"}
	if v.SourceLocationArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceLocationArn"))
	}
	if v.DestinationLocationArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationLocationArn"))
	}
	if v.Schedule != nil {
		if err := validateTaskSchedule(v.Schedule); err != nil {
			invalidParams.AddNested("Schedule", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateInputTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.ManifestConfig != nil {
		if err := validateManifestConfig(v.ManifestConfig); err != nil {
			invalidParams.AddNested("ManifestConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.TaskReportConfig != nil {
		if err := validateTaskReportConfig(v.TaskReportConfig); err != nil {
			invalidParams.AddNested("TaskReportConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpListLocationsInput(v *ListLocationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListLocationsInput"}
	if v.Filters != nil {
		if err := validateLocationFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	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 validateOpListTasksInput(v *ListTasksInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTasksInput"}
	if v.Filters != nil {
		if err := validateTaskFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpStartDiscoveryJobInput(v *StartDiscoveryJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartDiscoveryJobInput"}
	if v.StorageSystemArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StorageSystemArn"))
	}
	if v.CollectionDurationMinutes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollectionDurationMinutes"))
	}
	if v.ClientToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
	}
	if v.Tags != nil {
		if err := validateInputTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartTaskExecutionInput(v *StartTaskExecutionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartTaskExecutionInput"}
	if v.TaskArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskArn"))
	}
	if v.ManifestConfig != nil {
		if err := validateManifestConfig(v.ManifestConfig); err != nil {
			invalidParams.AddNested("ManifestConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.TaskReportConfig != nil {
		if err := validateTaskReportConfig(v.TaskReportConfig); err != nil {
			invalidParams.AddNested("TaskReportConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateInputTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpUpdateDiscoveryJobInput(v *UpdateDiscoveryJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDiscoveryJobInput"}
	if v.DiscoveryJobArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DiscoveryJobArn"))
	}
	if v.CollectionDurationMinutes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollectionDurationMinutes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateLocationAzureBlobInput(v *UpdateLocationAzureBlobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateLocationAzureBlobInput"}
	if v.LocationArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocationArn"))
	}
	if v.SasConfiguration != nil {
		if err := validateAzureBlobSasConfiguration(v.SasConfiguration); err != nil {
			invalidParams.AddNested("SasConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateLocationHdfsInput(v *UpdateLocationHdfsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateLocationHdfsInput"}
	if v.LocationArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocationArn"))
	}
	if v.NameNodes != nil {
		if err := validateHdfsNameNodeList(v.NameNodes); err != nil {
			invalidParams.AddNested("NameNodes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateLocationNfsInput(v *UpdateLocationNfsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateLocationNfsInput"}
	if v.LocationArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocationArn"))
	}
	if v.OnPremConfig != nil {
		if err := validateOnPremConfig(v.OnPremConfig); err != nil {
			invalidParams.AddNested("OnPremConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpUpdateStorageSystemInput(v *UpdateStorageSystemInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateStorageSystemInput"}
	if v.StorageSystemArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StorageSystemArn"))
	}
	if v.ServerConfiguration != nil {
		if err := validateDiscoveryServerConfiguration(v.ServerConfiguration); err != nil {
			invalidParams.AddNested("ServerConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Credentials != nil {
		if err := validateCredentials(v.Credentials); err != nil {
			invalidParams.AddNested("Credentials", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateTaskExecutionInput(v *UpdateTaskExecutionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTaskExecutionInput"}
	if v.TaskExecutionArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskExecutionArn"))
	}
	if v.Options == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Options"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateTaskInput(v *UpdateTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTaskInput"}
	if v.TaskArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskArn"))
	}
	if v.Schedule != nil {
		if err := validateTaskSchedule(v.Schedule); err != nil {
			invalidParams.AddNested("Schedule", err.(smithy.InvalidParamsError))
		}
	}
	if v.ManifestConfig != nil {
		if err := validateManifestConfig(v.ManifestConfig); err != nil {
			invalidParams.AddNested("ManifestConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.TaskReportConfig != nil {
		if err := validateTaskReportConfig(v.TaskReportConfig); err != nil {
			invalidParams.AddNested("TaskReportConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}