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

package robomaker

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

type validateOpBatchDeleteWorlds struct {
}

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

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

type validateOpBatchDescribeSimulationJob struct {
}

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

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

type validateOpCancelDeploymentJob struct {
}

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

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

type validateOpCancelSimulationJobBatch struct {
}

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

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

type validateOpCancelSimulationJob struct {
}

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

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

type validateOpCancelWorldExportJob struct {
}

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

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

type validateOpCancelWorldGenerationJob struct {
}

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

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

type validateOpCreateDeploymentJob struct {
}

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

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

type validateOpCreateFleet struct {
}

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

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

type validateOpCreateRobotApplication struct {
}

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

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

type validateOpCreateRobotApplicationVersion struct {
}

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

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

type validateOpCreateRobot struct {
}

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

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

type validateOpCreateSimulationApplication struct {
}

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

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

type validateOpCreateSimulationApplicationVersion struct {
}

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

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

type validateOpCreateSimulationJob struct {
}

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

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

type validateOpCreateWorldExportJob struct {
}

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

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

type validateOpCreateWorldGenerationJob struct {
}

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

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

type validateOpCreateWorldTemplate struct {
}

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

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

type validateOpDeleteFleet struct {
}

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

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

type validateOpDeleteRobotApplication struct {
}

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

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

type validateOpDeleteRobot struct {
}

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

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

type validateOpDeleteSimulationApplication struct {
}

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

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

type validateOpDeleteWorldTemplate struct {
}

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

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

type validateOpDeregisterRobot struct {
}

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

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

type validateOpDescribeDeploymentJob struct {
}

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

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

type validateOpDescribeFleet struct {
}

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

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

type validateOpDescribeRobotApplication struct {
}

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

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

type validateOpDescribeRobot struct {
}

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

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

type validateOpDescribeSimulationApplication struct {
}

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

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

type validateOpDescribeSimulationJobBatch struct {
}

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

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

type validateOpDescribeSimulationJob struct {
}

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

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

type validateOpDescribeWorldExportJob struct {
}

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

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

type validateOpDescribeWorldGenerationJob struct {
}

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

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

type validateOpDescribeWorld struct {
}

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

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

type validateOpDescribeWorldTemplate struct {
}

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

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

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

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

type validateOpRestartSimulationJob struct {
}

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

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

type validateOpStartSimulationJobBatch struct {
}

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

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

type validateOpSyncDeploymentJob struct {
}

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

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

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

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

type validateOpUpdateSimulationApplication struct {
}

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

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

type validateOpUpdateWorldTemplate struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpSyncDeploymentJobValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSyncDeploymentJob{}, 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 addOpUpdateRobotApplicationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateRobotApplication{}, middleware.After)
}

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

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

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

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

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

func validateDeploymentApplicationConfig(v *types.DeploymentApplicationConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeploymentApplicationConfig"}
	if v.Application == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Application"))
	}
	if v.ApplicationVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationVersion"))
	}
	if v.LaunchConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchConfig"))
	} else if v.LaunchConfig != nil {
		if err := validateDeploymentLaunchConfig(v.LaunchConfig); err != nil {
			invalidParams.AddNested("LaunchConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDeploymentConfig(v *types.DeploymentConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeploymentConfig"}
	if v.DownloadConditionFile != nil {
		if err := validateS3Object(v.DownloadConditionFile); err != nil {
			invalidParams.AddNested("DownloadConditionFile", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDeploymentLaunchConfig(v *types.DeploymentLaunchConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeploymentLaunchConfig"}
	if v.PackageName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PackageName"))
	}
	if v.LaunchFile == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchFile"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLaunchConfig(v *types.LaunchConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LaunchConfig"}
	if v.PortForwardingConfig != nil {
		if err := validatePortForwardingConfig(v.PortForwardingConfig); err != nil {
			invalidParams.AddNested("PortForwardingConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePortForwardingConfig(v *types.PortForwardingConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PortForwardingConfig"}
	if v.PortMappings != nil {
		if err := validatePortMappingList(v.PortMappings); err != nil {
			invalidParams.AddNested("PortMappings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePortMapping(v *types.PortMapping) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PortMapping"}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRobotApplicationConfig(v *types.RobotApplicationConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RobotApplicationConfig"}
	if v.Application == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Application"))
	}
	if v.LaunchConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchConfig"))
	} else if v.LaunchConfig != nil {
		if err := validateLaunchConfig(v.LaunchConfig); err != nil {
			invalidParams.AddNested("LaunchConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.UploadConfigurations != nil {
		if err := validateUploadConfigurations(v.UploadConfigurations); err != nil {
			invalidParams.AddNested("UploadConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tools != nil {
		if err := validateTools(v.Tools); err != nil {
			invalidParams.AddNested("Tools", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateSimulationApplicationConfig(v *types.SimulationApplicationConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SimulationApplicationConfig"}
	if v.Application == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Application"))
	}
	if v.LaunchConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchConfig"))
	} else if v.LaunchConfig != nil {
		if err := validateLaunchConfig(v.LaunchConfig); err != nil {
			invalidParams.AddNested("LaunchConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.UploadConfigurations != nil {
		if err := validateUploadConfigurations(v.UploadConfigurations); err != nil {
			invalidParams.AddNested("UploadConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tools != nil {
		if err := validateTools(v.Tools); err != nil {
			invalidParams.AddNested("Tools", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSimulationJobRequest(v *types.SimulationJobRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SimulationJobRequest"}
	if v.RobotApplications != nil {
		if err := validateRobotApplicationConfigs(v.RobotApplications); err != nil {
			invalidParams.AddNested("RobotApplications", err.(smithy.InvalidParamsError))
		}
	}
	if v.SimulationApplications != nil {
		if err := validateSimulationApplicationConfigs(v.SimulationApplications); err != nil {
			invalidParams.AddNested("SimulationApplications", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataSources != nil {
		if err := validateDataSourceConfigs(v.DataSources); err != nil {
			invalidParams.AddNested("DataSources", err.(smithy.InvalidParamsError))
		}
	}
	if v.VpcConfig != nil {
		if err := validateVPCConfig(v.VpcConfig); err != nil {
			invalidParams.AddNested("VpcConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTemplateLocation(v *types.TemplateLocation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TemplateLocation"}
	if v.S3Bucket == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3Bucket"))
	}
	if v.S3Key == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3Key"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateUploadConfiguration(v *types.UploadConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UploadConfiguration"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Path == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Path"))
	}
	if len(v.UploadBehavior) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("UploadBehavior"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

func validateOpCreateDeploymentJobInput(v *CreateDeploymentJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDeploymentJobInput"}
	if v.DeploymentConfig != nil {
		if err := validateDeploymentConfig(v.DeploymentConfig); err != nil {
			invalidParams.AddNested("DeploymentConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if v.Fleet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Fleet"))
	}
	if v.DeploymentApplicationConfigs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeploymentApplicationConfigs"))
	} else if v.DeploymentApplicationConfigs != nil {
		if err := validateDeploymentApplicationConfigs(v.DeploymentApplicationConfigs); err != nil {
			invalidParams.AddNested("DeploymentApplicationConfigs", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpCreateRobotInput(v *CreateRobotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRobotInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Architecture) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Architecture"))
	}
	if v.GreengrassGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GreengrassGroupId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSimulationApplicationInput(v *CreateSimulationApplicationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSimulationApplicationInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.SimulationSoftwareSuite == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SimulationSoftwareSuite"))
	}
	if v.RobotSoftwareSuite == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RobotSoftwareSuite"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateSimulationJobInput(v *CreateSimulationJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSimulationJobInput"}
	if v.IamRole == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IamRole"))
	}
	if v.RobotApplications != nil {
		if err := validateRobotApplicationConfigs(v.RobotApplications); err != nil {
			invalidParams.AddNested("RobotApplications", err.(smithy.InvalidParamsError))
		}
	}
	if v.SimulationApplications != nil {
		if err := validateSimulationApplicationConfigs(v.SimulationApplications); err != nil {
			invalidParams.AddNested("SimulationApplications", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataSources != nil {
		if err := validateDataSourceConfigs(v.DataSources); err != nil {
			invalidParams.AddNested("DataSources", err.(smithy.InvalidParamsError))
		}
	}
	if v.VpcConfig != nil {
		if err := validateVPCConfig(v.VpcConfig); err != nil {
			invalidParams.AddNested("VpcConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateWorldExportJobInput(v *CreateWorldExportJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateWorldExportJobInput"}
	if v.Worlds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Worlds"))
	}
	if v.OutputLocation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputLocation"))
	}
	if v.IamRole == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IamRole"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateWorldGenerationJobInput(v *CreateWorldGenerationJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateWorldGenerationJobInput"}
	if v.Template == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Template"))
	}
	if v.WorldCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorldCount"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateWorldTemplateInput(v *CreateWorldTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateWorldTemplateInput"}
	if v.TemplateLocation != nil {
		if err := validateTemplateLocation(v.TemplateLocation); err != nil {
			invalidParams.AddNested("TemplateLocation", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpDeregisterRobotInput(v *DeregisterRobotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeregisterRobotInput"}
	if v.Fleet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Fleet"))
	}
	if v.Robot == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Robot"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

func validateOpDescribeWorldTemplateInput(v *DescribeWorldTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeWorldTemplateInput"}
	if v.Template == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Template"))
	}
	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 validateOpRegisterRobotInput(v *RegisterRobotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterRobotInput"}
	if v.Fleet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Fleet"))
	}
	if v.Robot == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Robot"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpStartSimulationJobBatchInput(v *StartSimulationJobBatchInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartSimulationJobBatchInput"}
	if v.CreateSimulationJobRequests == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CreateSimulationJobRequests"))
	} else if v.CreateSimulationJobRequests != nil {
		if err := validateCreateSimulationJobRequests(v.CreateSimulationJobRequests); err != nil {
			invalidParams.AddNested("CreateSimulationJobRequests", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSyncDeploymentJobInput(v *SyncDeploymentJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SyncDeploymentJobInput"}
	if v.ClientRequestToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientRequestToken"))
	}
	if v.Fleet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Fleet"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpUpdateRobotApplicationInput(v *UpdateRobotApplicationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRobotApplicationInput"}
	if v.Application == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Application"))
	}
	if v.RobotSoftwareSuite == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RobotSoftwareSuite"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateSimulationApplicationInput(v *UpdateSimulationApplicationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSimulationApplicationInput"}
	if v.Application == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Application"))
	}
	if v.SimulationSoftwareSuite == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SimulationSoftwareSuite"))
	}
	if v.RobotSoftwareSuite == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RobotSoftwareSuite"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateWorldTemplateInput(v *UpdateWorldTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateWorldTemplateInput"}
	if v.Template == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Template"))
	}
	if v.TemplateLocation != nil {
		if err := validateTemplateLocation(v.TemplateLocation); err != nil {
			invalidParams.AddNested("TemplateLocation", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}
