validators.go

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

package forecast

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

type validateOpCreateAutoPredictor struct {
}

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

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

type validateOpCreateDatasetGroup struct {
}

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

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

type validateOpCreateDatasetImportJob struct {
}

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

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

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

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

type validateOpCreateExplainability struct {
}

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

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

type validateOpCreateForecastExportJob struct {
}

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

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

type validateOpCreateForecast struct {
}

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

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

type validateOpCreateMonitor struct {
}

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

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

type validateOpCreatePredictorBacktestExportJob struct {
}

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

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

type validateOpCreatePredictor struct {
}

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

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

type validateOpCreateWhatIfAnalysis struct {
}

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

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

type validateOpCreateWhatIfForecastExport struct {
}

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

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

type validateOpCreateWhatIfForecast struct {
}

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

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

type validateOpDeleteDatasetGroup struct {
}

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

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

type validateOpDeleteDatasetImportJob struct {
}

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

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

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

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

type validateOpDeleteExplainability struct {
}

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

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

type validateOpDeleteForecastExportJob struct {
}

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

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

type validateOpDeleteForecast struct {
}

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

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

type validateOpDeleteMonitor struct {
}

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

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

type validateOpDeletePredictorBacktestExportJob struct {
}

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

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

type validateOpDeletePredictor struct {
}

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

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

type validateOpDeleteResourceTree struct {
}

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

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

type validateOpDeleteWhatIfAnalysis struct {
}

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

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

type validateOpDeleteWhatIfForecastExport struct {
}

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

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

type validateOpDeleteWhatIfForecast struct {
}

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

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

type validateOpDescribeAutoPredictor struct {
}

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

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

type validateOpDescribeDatasetGroup struct {
}

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

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

type validateOpDescribeDatasetImportJob struct {
}

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

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

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

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

type validateOpDescribeExplainability struct {
}

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

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

type validateOpDescribeForecastExportJob struct {
}

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

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

type validateOpDescribeForecast struct {
}

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

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

type validateOpDescribeMonitor struct {
}

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

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

type validateOpDescribePredictorBacktestExportJob struct {
}

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

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

type validateOpDescribePredictor struct {
}

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

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

type validateOpDescribeWhatIfAnalysis struct {
}

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

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

type validateOpDescribeWhatIfForecastExport struct {
}

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

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

type validateOpDescribeWhatIfForecast struct {
}

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

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

type validateOpGetAccuracyMetrics struct {
}

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

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

type validateOpListDatasetImportJobs struct {
}

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

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

type validateOpListExplainabilities struct {
}

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

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

type validateOpListExplainabilityExports struct {
}

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

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

type validateOpListForecastExportJobs struct {
}

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

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

type validateOpListForecasts struct {
}

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

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

type validateOpListMonitorEvaluations struct {
}

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

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

type validateOpListMonitors struct {
}

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

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

type validateOpListPredictorBacktestExportJobs struct {
}

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

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

type validateOpListPredictors struct {
}

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

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

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

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

type validateOpListWhatIfForecastExports struct {
}

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

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

type validateOpListWhatIfForecasts struct {
}

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

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

type validateOpResumeResource struct {
}

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

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

type validateOpStopResource struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpStopResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStopResource{}, 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 addOpUpdateDatasetGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateDatasetGroup{}, middleware.After)
}

func validateAction(v *types.Action) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Action"}
	if v.AttributeName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeName"))
	}
	if len(v.Operation) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Operation"))
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

func validateDataConfig(v *types.DataConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataConfig"}
	if v.DatasetGroupArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatasetGroupArn"))
	}
	if v.AttributeConfigs != nil {
		if err := validateAttributeConfigs(v.AttributeConfigs); err != nil {
			invalidParams.AddNested("AttributeConfigs", err.(smithy.InvalidParamsError))
		}
	}
	if v.AdditionalDatasets != nil {
		if err := validateAdditionalDatasets(v.AdditionalDatasets); err != nil {
			invalidParams.AddNested("AdditionalDatasets", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDataDestination(v *types.DataDestination) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataDestination"}
	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 invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDataSource(v *types.DataSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataSource"}
	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 invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateExplainabilityConfig(v *types.ExplainabilityConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExplainabilityConfig"}
	if len(v.TimeSeriesGranularity) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TimeSeriesGranularity"))
	}
	if len(v.TimePointGranularity) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TimePointGranularity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFeaturization(v *types.Featurization) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Featurization"}
	if v.AttributeName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeName"))
	}
	if v.FeaturizationPipeline != nil {
		if err := validateFeaturizationPipeline(v.FeaturizationPipeline); err != nil {
			invalidParams.AddNested("FeaturizationPipeline", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFeaturizationConfig(v *types.FeaturizationConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FeaturizationConfig"}
	if v.ForecastFrequency == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ForecastFrequency"))
	}
	if v.Featurizations != nil {
		if err := validateFeaturizations(v.Featurizations); err != nil {
			invalidParams.AddNested("Featurizations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateHyperParameterTuningJobConfig(v *types.HyperParameterTuningJobConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HyperParameterTuningJobConfig"}
	if v.ParameterRanges != nil {
		if err := validateParameterRanges(v.ParameterRanges); err != nil {
			invalidParams.AddNested("ParameterRanges", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInputDataConfig(v *types.InputDataConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InputDataConfig"}
	if v.DatasetGroupArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatasetGroupArn"))
	}
	if v.SupplementaryFeatures != nil {
		if err := validateSupplementaryFeatures(v.SupplementaryFeatures); err != nil {
			invalidParams.AddNested("SupplementaryFeatures", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateParameterRanges(v *types.ParameterRanges) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParameterRanges"}
	if v.CategoricalParameterRanges != nil {
		if err := validateCategoricalParameterRanges(v.CategoricalParameterRanges); err != nil {
			invalidParams.AddNested("CategoricalParameterRanges", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContinuousParameterRanges != nil {
		if err := validateContinuousParameterRanges(v.ContinuousParameterRanges); err != nil {
			invalidParams.AddNested("ContinuousParameterRanges", err.(smithy.InvalidParamsError))
		}
	}
	if v.IntegerParameterRanges != nil {
		if err := validateIntegerParameterRanges(v.IntegerParameterRanges); err != nil {
			invalidParams.AddNested("IntegerParameterRanges", err.(smithy.InvalidParamsError))
		}
	}
	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.Path == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Path"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateTimeSeriesCondition(v *types.TimeSeriesCondition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TimeSeriesCondition"}
	if v.AttributeName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeName"))
	}
	if v.AttributeValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeValue"))
	}
	if len(v.Condition) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Condition"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTimeSeriesIdentifiers(v *types.TimeSeriesIdentifiers) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TimeSeriesIdentifiers"}
	if v.DataSource != nil {
		if err := validateDataSource(v.DataSource); err != nil {
			invalidParams.AddNested("DataSource", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTimeSeriesSelector(v *types.TimeSeriesSelector) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TimeSeriesSelector"}
	if v.TimeSeriesIdentifiers != nil {
		if err := validateTimeSeriesIdentifiers(v.TimeSeriesIdentifiers); err != nil {
			invalidParams.AddNested("TimeSeriesIdentifiers", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTimeSeriesTransformation(v *types.TimeSeriesTransformation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TimeSeriesTransformation"}
	if v.Action != nil {
		if err := validateAction(v.Action); err != nil {
			invalidParams.AddNested("Action", err.(smithy.InvalidParamsError))
		}
	}
	if v.TimeSeriesConditions != nil {
		if err := validateTimeSeriesConditions(v.TimeSeriesConditions); err != nil {
			invalidParams.AddNested("TimeSeriesConditions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateAutoPredictorInput(v *CreateAutoPredictorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAutoPredictorInput"}
	if v.PredictorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PredictorName"))
	}
	if v.DataConfig != nil {
		if err := validateDataConfig(v.DataConfig); err != nil {
			invalidParams.AddNested("DataConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.EncryptionConfig != nil {
		if err := validateEncryptionConfig(v.EncryptionConfig); err != nil {
			invalidParams.AddNested("EncryptionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.MonitorConfig != nil {
		if err := validateMonitorConfig(v.MonitorConfig); err != nil {
			invalidParams.AddNested("MonitorConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateDatasetImportJobInput(v *CreateDatasetImportJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDatasetImportJobInput"}
	if v.DatasetImportJobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatasetImportJobName"))
	}
	if v.DatasetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatasetArn"))
	}
	if v.DataSource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSource"))
	} else if v.DataSource != nil {
		if err := validateDataSource(v.DataSource); err != nil {
			invalidParams.AddNested("DataSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDatasetInput(v *CreateDatasetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDatasetInput"}
	if v.DatasetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatasetName"))
	}
	if len(v.Domain) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if len(v.DatasetType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DatasetType"))
	}
	if v.Schema == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Schema"))
	}
	if v.EncryptionConfig != nil {
		if err := validateEncryptionConfig(v.EncryptionConfig); err != nil {
			invalidParams.AddNested("EncryptionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateExplainabilityExportInput(v *CreateExplainabilityExportInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateExplainabilityExportInput"}
	if v.ExplainabilityExportName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExplainabilityExportName"))
	}
	if v.ExplainabilityArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExplainabilityArn"))
	}
	if v.Destination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
	} else if v.Destination != nil {
		if err := validateDataDestination(v.Destination); err != nil {
			invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateExplainabilityInput(v *CreateExplainabilityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateExplainabilityInput"}
	if v.ExplainabilityName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExplainabilityName"))
	}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if v.ExplainabilityConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExplainabilityConfig"))
	} else if v.ExplainabilityConfig != nil {
		if err := validateExplainabilityConfig(v.ExplainabilityConfig); err != nil {
			invalidParams.AddNested("ExplainabilityConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataSource != nil {
		if err := validateDataSource(v.DataSource); err != nil {
			invalidParams.AddNested("DataSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateForecastExportJobInput(v *CreateForecastExportJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateForecastExportJobInput"}
	if v.ForecastExportJobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ForecastExportJobName"))
	}
	if v.ForecastArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ForecastArn"))
	}
	if v.Destination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
	} else if v.Destination != nil {
		if err := validateDataDestination(v.Destination); err != nil {
			invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateForecastInput(v *CreateForecastInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateForecastInput"}
	if v.ForecastName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ForecastName"))
	}
	if v.PredictorArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PredictorArn"))
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.TimeSeriesSelector != nil {
		if err := validateTimeSeriesSelector(v.TimeSeriesSelector); err != nil {
			invalidParams.AddNested("TimeSeriesSelector", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreatePredictorBacktestExportJobInput(v *CreatePredictorBacktestExportJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePredictorBacktestExportJobInput"}
	if v.PredictorBacktestExportJobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PredictorBacktestExportJobName"))
	}
	if v.PredictorArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PredictorArn"))
	}
	if v.Destination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
	} else if v.Destination != nil {
		if err := validateDataDestination(v.Destination); err != nil {
			invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePredictorInput(v *CreatePredictorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePredictorInput"}
	if v.PredictorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PredictorName"))
	}
	if v.ForecastHorizon == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ForecastHorizon"))
	}
	if v.HPOConfig != nil {
		if err := validateHyperParameterTuningJobConfig(v.HPOConfig); err != nil {
			invalidParams.AddNested("HPOConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.InputDataConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputDataConfig"))
	} else if v.InputDataConfig != nil {
		if err := validateInputDataConfig(v.InputDataConfig); err != nil {
			invalidParams.AddNested("InputDataConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.FeaturizationConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FeaturizationConfig"))
	} else if v.FeaturizationConfig != nil {
		if err := validateFeaturizationConfig(v.FeaturizationConfig); err != nil {
			invalidParams.AddNested("FeaturizationConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.EncryptionConfig != nil {
		if err := validateEncryptionConfig(v.EncryptionConfig); err != nil {
			invalidParams.AddNested("EncryptionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateWhatIfAnalysisInput(v *CreateWhatIfAnalysisInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateWhatIfAnalysisInput"}
	if v.WhatIfAnalysisName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WhatIfAnalysisName"))
	}
	if v.ForecastArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ForecastArn"))
	}
	if v.TimeSeriesSelector != nil {
		if err := validateTimeSeriesSelector(v.TimeSeriesSelector); err != nil {
			invalidParams.AddNested("TimeSeriesSelector", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateWhatIfForecastExportInput(v *CreateWhatIfForecastExportInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateWhatIfForecastExportInput"}
	if v.WhatIfForecastExportName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WhatIfForecastExportName"))
	}
	if v.WhatIfForecastArns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WhatIfForecastArns"))
	}
	if v.Destination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
	} else if v.Destination != nil {
		if err := validateDataDestination(v.Destination); err != nil {
			invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateWhatIfForecastInput(v *CreateWhatIfForecastInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateWhatIfForecastInput"}
	if v.WhatIfForecastName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WhatIfForecastName"))
	}
	if v.WhatIfAnalysisArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WhatIfAnalysisArn"))
	}
	if v.TimeSeriesTransformations != nil {
		if err := validateTimeSeriesTransformations(v.TimeSeriesTransformations); err != nil {
			invalidParams.AddNested("TimeSeriesTransformations", err.(smithy.InvalidParamsError))
		}
	}
	if v.TimeSeriesReplacementsDataSource != nil {
		if err := validateTimeSeriesReplacementsDataSource(v.TimeSeriesReplacementsDataSource); err != nil {
			invalidParams.AddNested("TimeSeriesReplacementsDataSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteDatasetImportJobInput(v *DeleteDatasetImportJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDatasetImportJobInput"}
	if v.DatasetImportJobArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatasetImportJobArn"))
	}
	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.DatasetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatasetArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpDescribeDatasetImportJobInput(v *DescribeDatasetImportJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDatasetImportJobInput"}
	if v.DatasetImportJobArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatasetImportJobArn"))
	}
	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.DatasetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatasetArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

func validateOpListDatasetImportJobsInput(v *ListDatasetImportJobsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDatasetImportJobsInput"}
	if v.Filters != nil {
		if err := validateFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListExplainabilitiesInput(v *ListExplainabilitiesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListExplainabilitiesInput"}
	if v.Filters != nil {
		if err := validateFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListExplainabilityExportsInput(v *ListExplainabilityExportsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListExplainabilityExportsInput"}
	if v.Filters != nil {
		if err := validateFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListForecastExportJobsInput(v *ListForecastExportJobsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListForecastExportJobsInput"}
	if v.Filters != nil {
		if err := validateFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListForecastsInput(v *ListForecastsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListForecastsInput"}
	if v.Filters != nil {
		if err := validateFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListMonitorEvaluationsInput(v *ListMonitorEvaluationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListMonitorEvaluationsInput"}
	if v.MonitorArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MonitorArn"))
	}
	if v.Filters != nil {
		if err := validateFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListMonitorsInput(v *ListMonitorsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListMonitorsInput"}
	if v.Filters != nil {
		if err := validateFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListPredictorBacktestExportJobsInput(v *ListPredictorBacktestExportJobsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListPredictorBacktestExportJobsInput"}
	if v.Filters != nil {
		if err := validateFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListPredictorsInput(v *ListPredictorsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListPredictorsInput"}
	if v.Filters != nil {
		if err := validateFilters(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 validateOpListWhatIfAnalysesInput(v *ListWhatIfAnalysesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListWhatIfAnalysesInput"}
	if v.Filters != nil {
		if err := validateFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListWhatIfForecastExportsInput(v *ListWhatIfForecastExportsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListWhatIfForecastExportsInput"}
	if v.Filters != nil {
		if err := validateFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListWhatIfForecastsInput(v *ListWhatIfForecastsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListWhatIfForecastsInput"}
	if v.Filters != nil {
		if err := validateFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpStopResourceInput(v *StopResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopResourceInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	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 := validateTags(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 validateOpUpdateDatasetGroupInput(v *UpdateDatasetGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDatasetGroupInput"}
	if v.DatasetGroupArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatasetGroupArn"))
	}
	if v.DatasetArns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatasetArns"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}