validators.go

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

package iotanalytics

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

type validateOpBatchPutMessage struct {
}

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

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

type validateOpCancelPipelineReprocessing struct {
}

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

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

type validateOpCreateChannel struct {
}

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

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

type validateOpCreateDatasetContent struct {
}

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

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

type validateOpCreateDataset struct {
}

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

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

type validateOpCreateDatastore struct {
}

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

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

type validateOpCreatePipeline struct {
}

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

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

type validateOpDeleteChannel struct {
}

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

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

type validateOpDeleteDatasetContent struct {
}

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

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

type validateOpDeleteDataset struct {
}

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

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

type validateOpDeleteDatastore struct {
}

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

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

type validateOpDeletePipeline struct {
}

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

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

type validateOpDescribeChannel struct {
}

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

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

type validateOpDescribeDataset struct {
}

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

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

type validateOpDescribeDatastore struct {
}

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

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

type validateOpDescribePipeline struct {
}

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

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

type validateOpGetDatasetContent struct {
}

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

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

type validateOpListDatasetContents struct {
}

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

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

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

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

type validateOpRunPipelineActivity struct {
}

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

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

type validateOpSampleChannelData struct {
}

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

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

type validateOpStartPipelineReprocessing struct {
}

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

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

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

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

type validateOpUpdateDataset struct {
}

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

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

type validateOpUpdateDatastore struct {
}

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

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

type validateOpUpdatePipeline struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpStartPipelineReprocessingValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartPipelineReprocessing{}, 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 addOpUpdateChannelValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateChannel{}, middleware.After)
}

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

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

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

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

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

func validateChannelStorage(v *types.ChannelStorage) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChannelStorage"}
	if v.CustomerManagedS3 != nil {
		if err := validateCustomerManagedChannelS3Storage(v.CustomerManagedS3); err != nil {
			invalidParams.AddNested("CustomerManagedS3", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateContainerDatasetAction(v *types.ContainerDatasetAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContainerDatasetAction"}
	if v.Image == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Image"))
	}
	if v.ExecutionRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExecutionRoleArn"))
	}
	if v.ResourceConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceConfiguration"))
	} else if v.ResourceConfiguration != nil {
		if err := validateResourceConfiguration(v.ResourceConfiguration); err != nil {
			invalidParams.AddNested("ResourceConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Variables != nil {
		if err := validateVariables(v.Variables); err != nil {
			invalidParams.AddNested("Variables", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomerManagedChannelS3Storage(v *types.CustomerManagedChannelS3Storage) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomerManagedChannelS3Storage"}
	if v.Bucket == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Bucket"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomerManagedDatastoreS3Storage(v *types.CustomerManagedDatastoreS3Storage) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomerManagedDatastoreS3Storage"}
	if v.Bucket == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Bucket"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDatasetAction(v *types.DatasetAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DatasetAction"}
	if v.QueryAction != nil {
		if err := validateSqlQueryDatasetAction(v.QueryAction); err != nil {
			invalidParams.AddNested("QueryAction", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContainerAction != nil {
		if err := validateContainerDatasetAction(v.ContainerAction); err != nil {
			invalidParams.AddNested("ContainerAction", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDatasetContentDeliveryDestination(v *types.DatasetContentDeliveryDestination) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DatasetContentDeliveryDestination"}
	if v.IotEventsDestinationConfiguration != nil {
		if err := validateIotEventsDestinationConfiguration(v.IotEventsDestinationConfiguration); err != nil {
			invalidParams.AddNested("IotEventsDestinationConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3DestinationConfiguration != nil {
		if err := validateS3DestinationConfiguration(v.S3DestinationConfiguration); err != nil {
			invalidParams.AddNested("S3DestinationConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDatasetContentDeliveryRule(v *types.DatasetContentDeliveryRule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DatasetContentDeliveryRule"}
	if v.Destination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
	} else if v.Destination != nil {
		if err := validateDatasetContentDeliveryDestination(v.Destination); err != nil {
			invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateDatasetTrigger(v *types.DatasetTrigger) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DatasetTrigger"}
	if v.Dataset != nil {
		if err := validateTriggeringDataset(v.Dataset); err != nil {
			invalidParams.AddNested("Dataset", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateDatastoreIotSiteWiseMultiLayerStorage(v *types.DatastoreIotSiteWiseMultiLayerStorage) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DatastoreIotSiteWiseMultiLayerStorage"}
	if v.CustomerManagedS3Storage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CustomerManagedS3Storage"))
	} else if v.CustomerManagedS3Storage != nil {
		if err := validateIotSiteWiseCustomerManagedDatastoreS3Storage(v.CustomerManagedS3Storage); err != nil {
			invalidParams.AddNested("CustomerManagedS3Storage", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDatastorePartition(v *types.DatastorePartition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DatastorePartition"}
	if v.AttributePartition != nil {
		if err := validatePartition(v.AttributePartition); err != nil {
			invalidParams.AddNested("AttributePartition", err.(smithy.InvalidParamsError))
		}
	}
	if v.TimestampPartition != nil {
		if err := validateTimestampPartition(v.TimestampPartition); err != nil {
			invalidParams.AddNested("TimestampPartition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDatastorePartitions(v *types.DatastorePartitions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DatastorePartitions"}
	if v.Partitions != nil {
		if err := validatePartitions(v.Partitions); err != nil {
			invalidParams.AddNested("Partitions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDatastoreStorage(v types.DatastoreStorage) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DatastoreStorage"}
	switch uv := v.(type) {
	case *types.DatastoreStorageMemberCustomerManagedS3:
		if err := validateCustomerManagedDatastoreS3Storage(&uv.Value); err != nil {
			invalidParams.AddNested("[customerManagedS3]", err.(smithy.InvalidParamsError))
		}

	case *types.DatastoreStorageMemberIotSiteWiseMultiLayerStorage:
		if err := validateDatastoreIotSiteWiseMultiLayerStorage(&uv.Value); err != nil {
			invalidParams.AddNested("[iotSiteWiseMultiLayerStorage]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDeltaTime(v *types.DeltaTime) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeltaTime"}
	if v.OffsetSeconds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OffsetSeconds"))
	}
	if v.TimeExpression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimeExpression"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDeviceRegistryEnrichActivity(v *types.DeviceRegistryEnrichActivity) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeviceRegistryEnrichActivity"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Attribute == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if v.ThingName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ThingName"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDeviceShadowEnrichActivity(v *types.DeviceShadowEnrichActivity) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeviceShadowEnrichActivity"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Attribute == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if v.ThingName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ThingName"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFileFormatConfiguration(v *types.FileFormatConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FileFormatConfiguration"}
	if v.ParquetConfiguration != nil {
		if err := validateParquetConfiguration(v.ParquetConfiguration); err != nil {
			invalidParams.AddNested("ParquetConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateGlueConfiguration(v *types.GlueConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GlueConfiguration"}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateIotEventsDestinationConfiguration(v *types.IotEventsDestinationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IotEventsDestinationConfiguration"}
	if v.InputName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputName"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateLambdaActivity(v *types.LambdaActivity) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LambdaActivity"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.LambdaName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LambdaName"))
	}
	if v.BatchSize == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BatchSize"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLateDataRule(v *types.LateDataRule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LateDataRule"}
	if v.RuleConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleConfiguration"))
	} else if v.RuleConfiguration != nil {
		if err := validateLateDataRuleConfiguration(v.RuleConfiguration); err != nil {
			invalidParams.AddNested("RuleConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLateDataRuleConfiguration(v *types.LateDataRuleConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LateDataRuleConfiguration"}
	if v.DeltaTimeSessionWindowConfiguration != nil {
		if err := validateDeltaTimeSessionWindowConfiguration(v.DeltaTimeSessionWindowConfiguration); err != nil {
			invalidParams.AddNested("DeltaTimeSessionWindowConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateLoggingOptions(v *types.LoggingOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LoggingOptions"}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if len(v.Level) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Level"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMathActivity(v *types.MathActivity) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MathActivity"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Attribute == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if v.Math == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Math"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateParquetConfiguration(v *types.ParquetConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParquetConfiguration"}
	if v.SchemaDefinition != nil {
		if err := validateSchemaDefinition(v.SchemaDefinition); err != nil {
			invalidParams.AddNested("SchemaDefinition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validatePipelineActivity(v *types.PipelineActivity) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PipelineActivity"}
	if v.Channel != nil {
		if err := validateChannelActivity(v.Channel); err != nil {
			invalidParams.AddNested("Channel", err.(smithy.InvalidParamsError))
		}
	}
	if v.Lambda != nil {
		if err := validateLambdaActivity(v.Lambda); err != nil {
			invalidParams.AddNested("Lambda", err.(smithy.InvalidParamsError))
		}
	}
	if v.Datastore != nil {
		if err := validateDatastoreActivity(v.Datastore); err != nil {
			invalidParams.AddNested("Datastore", err.(smithy.InvalidParamsError))
		}
	}
	if v.AddAttributes != nil {
		if err := validateAddAttributesActivity(v.AddAttributes); err != nil {
			invalidParams.AddNested("AddAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.RemoveAttributes != nil {
		if err := validateRemoveAttributesActivity(v.RemoveAttributes); err != nil {
			invalidParams.AddNested("RemoveAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.SelectAttributes != nil {
		if err := validateSelectAttributesActivity(v.SelectAttributes); err != nil {
			invalidParams.AddNested("SelectAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filter != nil {
		if err := validateFilterActivity(v.Filter); err != nil {
			invalidParams.AddNested("Filter", err.(smithy.InvalidParamsError))
		}
	}
	if v.Math != nil {
		if err := validateMathActivity(v.Math); err != nil {
			invalidParams.AddNested("Math", err.(smithy.InvalidParamsError))
		}
	}
	if v.DeviceRegistryEnrich != nil {
		if err := validateDeviceRegistryEnrichActivity(v.DeviceRegistryEnrich); err != nil {
			invalidParams.AddNested("DeviceRegistryEnrich", err.(smithy.InvalidParamsError))
		}
	}
	if v.DeviceShadowEnrich != nil {
		if err := validateDeviceShadowEnrichActivity(v.DeviceShadowEnrich); err != nil {
			invalidParams.AddNested("DeviceShadowEnrich", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateQueryFilter(v *types.QueryFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "QueryFilter"}
	if v.DeltaTime != nil {
		if err := validateDeltaTime(v.DeltaTime); err != nil {
			invalidParams.AddNested("DeltaTime", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateResourceConfiguration(v *types.ResourceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResourceConfiguration"}
	if len(v.ComputeType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ComputeType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3DestinationConfiguration(v *types.S3DestinationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3DestinationConfiguration"}
	if v.Bucket == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Bucket"))
	}
	if v.Key == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Key"))
	}
	if v.GlueConfiguration != nil {
		if err := validateGlueConfiguration(v.GlueConfiguration); err != nil {
			invalidParams.AddNested("GlueConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSchemaDefinition(v *types.SchemaDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SchemaDefinition"}
	if v.Columns != nil {
		if err := validateColumns(v.Columns); err != nil {
			invalidParams.AddNested("Columns", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSqlQueryDatasetAction(v *types.SqlQueryDatasetAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SqlQueryDatasetAction"}
	if v.SqlQuery == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SqlQuery"))
	}
	if v.Filters != nil {
		if err := validateQueryFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", 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 validateTagList(v []types.Tag) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
	for i := range v {
		if err := validateTag(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateVariable(v *types.Variable) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Variable"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.DatasetContentVersionValue != nil {
		if err := validateDatasetContentVersionValue(v.DatasetContentVersionValue); err != nil {
			invalidParams.AddNested("DatasetContentVersionValue", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputFileUriValue != nil {
		if err := validateOutputFileUriValue(v.OutputFileUriValue); err != nil {
			invalidParams.AddNested("OutputFileUriValue", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpBatchPutMessageInput(v *BatchPutMessageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchPutMessageInput"}
	if v.ChannelName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
	}
	if v.Messages == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Messages"))
	} else if v.Messages != nil {
		if err := validateMessages(v.Messages); err != nil {
			invalidParams.AddNested("Messages", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCancelPipelineReprocessingInput(v *CancelPipelineReprocessingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelPipelineReprocessingInput"}
	if v.PipelineName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PipelineName"))
	}
	if v.ReprocessingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReprocessingId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpCreateDatasetInput(v *CreateDatasetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDatasetInput"}
	if v.DatasetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatasetName"))
	}
	if v.Actions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Actions"))
	} else if v.Actions != nil {
		if err := validateDatasetActions(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Triggers != nil {
		if err := validateDatasetTriggers(v.Triggers); err != nil {
			invalidParams.AddNested("Triggers", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContentDeliveryRules != nil {
		if err := validateDatasetContentDeliveryRules(v.ContentDeliveryRules); err != nil {
			invalidParams.AddNested("ContentDeliveryRules", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.LateDataRules != nil {
		if err := validateLateDataRules(v.LateDataRules); err != nil {
			invalidParams.AddNested("LateDataRules", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDatastoreInput(v *CreateDatastoreInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDatastoreInput"}
	if v.DatastoreName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatastoreName"))
	}
	if v.DatastoreStorage != nil {
		if err := validateDatastoreStorage(v.DatastoreStorage); err != nil {
			invalidParams.AddNested("DatastoreStorage", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.FileFormatConfiguration != nil {
		if err := validateFileFormatConfiguration(v.FileFormatConfiguration); err != nil {
			invalidParams.AddNested("FileFormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.DatastorePartitions != nil {
		if err := validateDatastorePartitions(v.DatastorePartitions); err != nil {
			invalidParams.AddNested("DatastorePartitions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

func validateOpListDatasetContentsInput(v *ListDatasetContentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDatasetContentsInput"}
	if v.DatasetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatasetName"))
	}
	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 validateOpPutLoggingOptionsInput(v *PutLoggingOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutLoggingOptionsInput"}
	if v.LoggingOptions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LoggingOptions"))
	} else if v.LoggingOptions != nil {
		if err := validateLoggingOptions(v.LoggingOptions); err != nil {
			invalidParams.AddNested("LoggingOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRunPipelineActivityInput(v *RunPipelineActivityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RunPipelineActivityInput"}
	if v.PipelineActivity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PipelineActivity"))
	} else if v.PipelineActivity != nil {
		if err := validatePipelineActivity(v.PipelineActivity); err != nil {
			invalidParams.AddNested("PipelineActivity", err.(smithy.InvalidParamsError))
		}
	}
	if v.Payloads == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Payloads"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpUpdateChannelInput(v *UpdateChannelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateChannelInput"}
	if v.ChannelName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelName"))
	}
	if v.ChannelStorage != nil {
		if err := validateChannelStorage(v.ChannelStorage); err != nil {
			invalidParams.AddNested("ChannelStorage", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDatasetInput(v *UpdateDatasetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDatasetInput"}
	if v.DatasetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatasetName"))
	}
	if v.Actions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Actions"))
	} else if v.Actions != nil {
		if err := validateDatasetActions(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Triggers != nil {
		if err := validateDatasetTriggers(v.Triggers); err != nil {
			invalidParams.AddNested("Triggers", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContentDeliveryRules != nil {
		if err := validateDatasetContentDeliveryRules(v.ContentDeliveryRules); err != nil {
			invalidParams.AddNested("ContentDeliveryRules", err.(smithy.InvalidParamsError))
		}
	}
	if v.LateDataRules != nil {
		if err := validateLateDataRules(v.LateDataRules); err != nil {
			invalidParams.AddNested("LateDataRules", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDatastoreInput(v *UpdateDatastoreInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDatastoreInput"}
	if v.DatastoreName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatastoreName"))
	}
	if v.DatastoreStorage != nil {
		if err := validateDatastoreStorage(v.DatastoreStorage); err != nil {
			invalidParams.AddNested("DatastoreStorage", err.(smithy.InvalidParamsError))
		}
	}
	if v.FileFormatConfiguration != nil {
		if err := validateFileFormatConfiguration(v.FileFormatConfiguration); err != nil {
			invalidParams.AddNested("FileFormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdatePipelineInput(v *UpdatePipelineInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePipelineInput"}
	if v.PipelineName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PipelineName"))
	}
	if v.PipelineActivities == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PipelineActivities"))
	} else if v.PipelineActivities != nil {
		if err := validatePipelineActivities(v.PipelineActivities); err != nil {
			invalidParams.AddNested("PipelineActivities", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}