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

package ecs

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

type validateOpCreateCapacityProvider struct {
}

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

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

type validateOpCreateCluster struct {
}

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

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

type validateOpCreateService struct {
}

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

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

type validateOpCreateTaskSet struct {
}

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

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

type validateOpDeleteAccountSetting struct {
}

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

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

type validateOpDeleteAttributes struct {
}

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

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

type validateOpDeleteCapacityProvider struct {
}

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

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

type validateOpDeleteCluster struct {
}

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

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

type validateOpDeleteService struct {
}

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

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

type validateOpDeleteTaskDefinitions struct {
}

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

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

type validateOpDeleteTaskSet struct {
}

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

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

type validateOpDeregisterContainerInstance struct {
}

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

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

type validateOpDeregisterTaskDefinition struct {
}

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

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

type validateOpDescribeContainerInstances struct {
}

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

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

type validateOpDescribeServiceDeployments struct {
}

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

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

type validateOpDescribeServiceRevisions struct {
}

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

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

type validateOpDescribeServices struct {
}

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

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

type validateOpDescribeTaskDefinition struct {
}

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

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

type validateOpDescribeTaskSets struct {
}

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

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

type validateOpDescribeTasks struct {
}

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

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

type validateOpExecuteCommand struct {
}

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

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

type validateOpGetTaskProtection struct {
}

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

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

type validateOpListAttributes struct {
}

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

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

type validateOpListServiceDeployments struct {
}

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

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

type validateOpListServicesByNamespace struct {
}

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

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

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

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

type validateOpPutAccountSetting struct {
}

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

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

type validateOpPutAttributes struct {
}

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

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

type validateOpPutClusterCapacityProviders struct {
}

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

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

type validateOpRegisterContainerInstance struct {
}

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

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

type validateOpRegisterTaskDefinition struct {
}

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

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

type validateOpRunTask struct {
}

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

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

type validateOpStartTask struct {
}

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

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

type validateOpStopTask struct {
}

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

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

type validateOpSubmitAttachmentStateChanges struct {
}

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

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

type validateOpSubmitTaskStateChange struct {
}

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

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

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

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

type validateOpUpdateCluster struct {
}

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

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

type validateOpUpdateClusterSettings struct {
}

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

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

type validateOpUpdateContainerAgent struct {
}

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

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

type validateOpUpdateContainerInstancesState struct {
}

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

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

type validateOpUpdateService struct {
}

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

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

type validateOpUpdateServicePrimaryTaskSet struct {
}

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

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

type validateOpUpdateTaskProtection struct {
}

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

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

type validateOpUpdateTaskSet struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpSubmitTaskStateChangeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSubmitTaskStateChange{}, 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 addOpUpdateCapacityProviderValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateCapacityProvider{}, middleware.After)
}

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

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

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

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

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

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

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

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

func validateAttachmentStateChange(v *types.AttachmentStateChange) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachmentStateChange"}
	if v.AttachmentArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttachmentArn"))
	}
	if v.Status == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

func validateContainerDefinition(v *types.ContainerDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContainerDefinition"}
	if v.RepositoryCredentials != nil {
		if err := validateRepositoryCredentials(v.RepositoryCredentials); err != nil {
			invalidParams.AddNested("RepositoryCredentials", err.(smithy.InvalidParamsError))
		}
	}
	if v.RestartPolicy != nil {
		if err := validateContainerRestartPolicy(v.RestartPolicy); err != nil {
			invalidParams.AddNested("RestartPolicy", err.(smithy.InvalidParamsError))
		}
	}
	if v.EnvironmentFiles != nil {
		if err := validateEnvironmentFiles(v.EnvironmentFiles); err != nil {
			invalidParams.AddNested("EnvironmentFiles", err.(smithy.InvalidParamsError))
		}
	}
	if v.LinuxParameters != nil {
		if err := validateLinuxParameters(v.LinuxParameters); err != nil {
			invalidParams.AddNested("LinuxParameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.Secrets != nil {
		if err := validateSecretList(v.Secrets); err != nil {
			invalidParams.AddNested("Secrets", err.(smithy.InvalidParamsError))
		}
	}
	if v.DependsOn != nil {
		if err := validateContainerDependencies(v.DependsOn); err != nil {
			invalidParams.AddNested("DependsOn", err.(smithy.InvalidParamsError))
		}
	}
	if v.ExtraHosts != nil {
		if err := validateHostEntryList(v.ExtraHosts); err != nil {
			invalidParams.AddNested("ExtraHosts", err.(smithy.InvalidParamsError))
		}
	}
	if v.Ulimits != nil {
		if err := validateUlimitList(v.Ulimits); err != nil {
			invalidParams.AddNested("Ulimits", err.(smithy.InvalidParamsError))
		}
	}
	if v.LogConfiguration != nil {
		if err := validateLogConfiguration(v.LogConfiguration); err != nil {
			invalidParams.AddNested("LogConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.HealthCheck != nil {
		if err := validateHealthCheck(v.HealthCheck); err != nil {
			invalidParams.AddNested("HealthCheck", err.(smithy.InvalidParamsError))
		}
	}
	if v.ResourceRequirements != nil {
		if err := validateResourceRequirements(v.ResourceRequirements); err != nil {
			invalidParams.AddNested("ResourceRequirements", err.(smithy.InvalidParamsError))
		}
	}
	if v.FirelensConfiguration != nil {
		if err := validateFirelensConfiguration(v.FirelensConfiguration); err != nil {
			invalidParams.AddNested("FirelensConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateContainerOverride(v *types.ContainerOverride) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContainerOverride"}
	if v.EnvironmentFiles != nil {
		if err := validateEnvironmentFiles(v.EnvironmentFiles); err != nil {
			invalidParams.AddNested("EnvironmentFiles", err.(smithy.InvalidParamsError))
		}
	}
	if v.ResourceRequirements != nil {
		if err := validateResourceRequirements(v.ResourceRequirements); err != nil {
			invalidParams.AddNested("ResourceRequirements", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateDeploymentConfiguration(v *types.DeploymentConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeploymentConfiguration"}
	if v.DeploymentCircuitBreaker != nil {
		if err := validateDeploymentCircuitBreaker(v.DeploymentCircuitBreaker); err != nil {
			invalidParams.AddNested("DeploymentCircuitBreaker", err.(smithy.InvalidParamsError))
		}
	}
	if v.Alarms != nil {
		if err := validateDeploymentAlarms(v.Alarms); err != nil {
			invalidParams.AddNested("Alarms", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

func validateFSxWindowsFileServerAuthorizationConfig(v *types.FSxWindowsFileServerAuthorizationConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FSxWindowsFileServerAuthorizationConfig"}
	if v.CredentialsParameter == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CredentialsParameter"))
	}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFSxWindowsFileServerVolumeConfiguration(v *types.FSxWindowsFileServerVolumeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FSxWindowsFileServerVolumeConfiguration"}
	if v.FileSystemId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FileSystemId"))
	}
	if v.RootDirectory == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RootDirectory"))
	}
	if v.AuthorizationConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthorizationConfig"))
	} else if v.AuthorizationConfig != nil {
		if err := validateFSxWindowsFileServerAuthorizationConfig(v.AuthorizationConfig); err != nil {
			invalidParams.AddNested("AuthorizationConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateInferenceAccelerator(v *types.InferenceAccelerator) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InferenceAccelerator"}
	if v.DeviceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceName"))
	}
	if v.DeviceType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateLinuxParameters(v *types.LinuxParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LinuxParameters"}
	if v.Devices != nil {
		if err := validateDevicesList(v.Devices); err != nil {
			invalidParams.AddNested("Devices", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tmpfs != nil {
		if err := validateTmpfsList(v.Tmpfs); err != nil {
			invalidParams.AddNested("Tmpfs", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLogConfiguration(v *types.LogConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LogConfiguration"}
	if len(v.LogDriver) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LogDriver"))
	}
	if v.SecretOptions != nil {
		if err := validateSecretList(v.SecretOptions); err != nil {
			invalidParams.AddNested("SecretOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateManagedAgentStateChange(v *types.ManagedAgentStateChange) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ManagedAgentStateChange"}
	if v.ContainerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContainerName"))
	}
	if len(v.ManagedAgentName) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ManagedAgentName"))
	}
	if v.Status == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateNetworkConfiguration(v *types.NetworkConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NetworkConfiguration"}
	if v.AwsvpcConfiguration != nil {
		if err := validateAwsVpcConfiguration(v.AwsvpcConfiguration); err != nil {
			invalidParams.AddNested("AwsvpcConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePlatformDevice(v *types.PlatformDevice) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PlatformDevice"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

func validateServiceConnectConfiguration(v *types.ServiceConnectConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ServiceConnectConfiguration"}
	if v.Services != nil {
		if err := validateServiceConnectServiceList(v.Services); err != nil {
			invalidParams.AddNested("Services", err.(smithy.InvalidParamsError))
		}
	}
	if v.LogConfiguration != nil {
		if err := validateLogConfiguration(v.LogConfiguration); err != nil {
			invalidParams.AddNested("LogConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateServiceConnectService(v *types.ServiceConnectService) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ServiceConnectService"}
	if v.PortName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortName"))
	}
	if v.ClientAliases != nil {
		if err := validateServiceConnectClientAliasList(v.ClientAliases); err != nil {
			invalidParams.AddNested("ClientAliases", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tls != nil {
		if err := validateServiceConnectTlsConfiguration(v.Tls); err != nil {
			invalidParams.AddNested("Tls", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateServiceManagedEBSVolumeConfiguration(v *types.ServiceManagedEBSVolumeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ServiceManagedEBSVolumeConfiguration"}
	if v.TagSpecifications != nil {
		if err := validateEBSTagSpecifications(v.TagSpecifications); err != nil {
			invalidParams.AddNested("TagSpecifications", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateServiceVolumeConfiguration(v *types.ServiceVolumeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ServiceVolumeConfiguration"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ManagedEBSVolume != nil {
		if err := validateServiceManagedEBSVolumeConfiguration(v.ManagedEBSVolume); err != nil {
			invalidParams.AddNested("ManagedEBSVolume", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTaskManagedEBSVolumeConfiguration(v *types.TaskManagedEBSVolumeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TaskManagedEBSVolumeConfiguration"}
	if v.TagSpecifications != nil {
		if err := validateEBSTagSpecifications(v.TagSpecifications); err != nil {
			invalidParams.AddNested("TagSpecifications", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.TerminationPolicy != nil {
		if err := validateTaskManagedEBSVolumeTerminationPolicy(v.TerminationPolicy); err != nil {
			invalidParams.AddNested("TerminationPolicy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTaskOverride(v *types.TaskOverride) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TaskOverride"}
	if v.ContainerOverrides != nil {
		if err := validateContainerOverrides(v.ContainerOverrides); err != nil {
			invalidParams.AddNested("ContainerOverrides", err.(smithy.InvalidParamsError))
		}
	}
	if v.EphemeralStorage != nil {
		if err := validateEphemeralStorage(v.EphemeralStorage); err != nil {
			invalidParams.AddNested("EphemeralStorage", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTaskVolumeConfiguration(v *types.TaskVolumeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TaskVolumeConfiguration"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ManagedEBSVolume != nil {
		if err := validateTaskManagedEBSVolumeConfiguration(v.ManagedEBSVolume); err != nil {
			invalidParams.AddNested("ManagedEBSVolume", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateVolume(v *types.Volume) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Volume"}
	if v.EfsVolumeConfiguration != nil {
		if err := validateEFSVolumeConfiguration(v.EfsVolumeConfiguration); err != nil {
			invalidParams.AddNested("EfsVolumeConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.FsxWindowsFileServerVolumeConfiguration != nil {
		if err := validateFSxWindowsFileServerVolumeConfiguration(v.FsxWindowsFileServerVolumeConfiguration); err != nil {
			invalidParams.AddNested("FsxWindowsFileServerVolumeConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateVpcLatticeConfiguration(v *types.VpcLatticeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VpcLatticeConfiguration"}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.TargetGroupArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetGroupArn"))
	}
	if v.PortName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateCapacityProviderInput(v *CreateCapacityProviderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCapacityProviderInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.AutoScalingGroupProvider == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupProvider"))
	} else if v.AutoScalingGroupProvider != nil {
		if err := validateAutoScalingGroupProvider(v.AutoScalingGroupProvider); err != nil {
			invalidParams.AddNested("AutoScalingGroupProvider", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateClusterInput(v *CreateClusterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateClusterInput"}
	if v.DefaultCapacityProviderStrategy != nil {
		if err := validateCapacityProviderStrategy(v.DefaultCapacityProviderStrategy); err != nil {
			invalidParams.AddNested("DefaultCapacityProviderStrategy", err.(smithy.InvalidParamsError))
		}
	}
	if v.ServiceConnectDefaults != nil {
		if err := validateClusterServiceConnectDefaultsRequest(v.ServiceConnectDefaults); err != nil {
			invalidParams.AddNested("ServiceConnectDefaults", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateServiceInput(v *CreateServiceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateServiceInput"}
	if v.ServiceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
	}
	if v.CapacityProviderStrategy != nil {
		if err := validateCapacityProviderStrategy(v.CapacityProviderStrategy); err != nil {
			invalidParams.AddNested("CapacityProviderStrategy", err.(smithy.InvalidParamsError))
		}
	}
	if v.DeploymentConfiguration != nil {
		if err := validateDeploymentConfiguration(v.DeploymentConfiguration); err != nil {
			invalidParams.AddNested("DeploymentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.NetworkConfiguration != nil {
		if err := validateNetworkConfiguration(v.NetworkConfiguration); err != nil {
			invalidParams.AddNested("NetworkConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.DeploymentController != nil {
		if err := validateDeploymentController(v.DeploymentController); err != nil {
			invalidParams.AddNested("DeploymentController", err.(smithy.InvalidParamsError))
		}
	}
	if v.ServiceConnectConfiguration != nil {
		if err := validateServiceConnectConfiguration(v.ServiceConnectConfiguration); err != nil {
			invalidParams.AddNested("ServiceConnectConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.VolumeConfigurations != nil {
		if err := validateServiceVolumeConfigurations(v.VolumeConfigurations); err != nil {
			invalidParams.AddNested("VolumeConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.VpcLatticeConfigurations != nil {
		if err := validateVpcLatticeConfigurations(v.VpcLatticeConfigurations); err != nil {
			invalidParams.AddNested("VpcLatticeConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTaskSetInput(v *CreateTaskSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTaskSetInput"}
	if v.Service == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Service"))
	}
	if v.Cluster == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cluster"))
	}
	if v.TaskDefinition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskDefinition"))
	}
	if v.NetworkConfiguration != nil {
		if err := validateNetworkConfiguration(v.NetworkConfiguration); err != nil {
			invalidParams.AddNested("NetworkConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CapacityProviderStrategy != nil {
		if err := validateCapacityProviderStrategy(v.CapacityProviderStrategy); err != nil {
			invalidParams.AddNested("CapacityProviderStrategy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteAttributesInput(v *DeleteAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAttributesInput"}
	if v.Attributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Attributes"))
	} else if v.Attributes != nil {
		if err := validateAttributes(v.Attributes); err != nil {
			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpDeleteTaskSetInput(v *DeleteTaskSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTaskSetInput"}
	if v.Cluster == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cluster"))
	}
	if v.Service == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Service"))
	}
	if v.TaskSet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskSet"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

func validateOpDescribeTaskSetsInput(v *DescribeTaskSetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeTaskSetsInput"}
	if v.Cluster == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cluster"))
	}
	if v.Service == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Service"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpExecuteCommandInput(v *ExecuteCommandInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExecuteCommandInput"}
	if v.Command == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Command"))
	}
	if v.Task == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Task"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListAttributesInput(v *ListAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAttributesInput"}
	if len(v.TargetType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TargetType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListServicesByNamespaceInput(v *ListServicesByNamespaceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListServicesByNamespaceInput"}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	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 validateOpPutAccountSettingDefaultInput(v *PutAccountSettingDefaultInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutAccountSettingDefaultInput"}
	if len(v.Name) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpPutAttributesInput(v *PutAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutAttributesInput"}
	if v.Attributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Attributes"))
	} else if v.Attributes != nil {
		if err := validateAttributes(v.Attributes); err != nil {
			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutClusterCapacityProvidersInput(v *PutClusterCapacityProvidersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutClusterCapacityProvidersInput"}
	if v.Cluster == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cluster"))
	}
	if v.CapacityProviders == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapacityProviders"))
	}
	if v.DefaultCapacityProviderStrategy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultCapacityProviderStrategy"))
	} else if v.DefaultCapacityProviderStrategy != nil {
		if err := validateCapacityProviderStrategy(v.DefaultCapacityProviderStrategy); err != nil {
			invalidParams.AddNested("DefaultCapacityProviderStrategy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRegisterContainerInstanceInput(v *RegisterContainerInstanceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterContainerInstanceInput"}
	if v.Attributes != nil {
		if err := validateAttributes(v.Attributes); err != nil {
			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.PlatformDevices != nil {
		if err := validatePlatformDevices(v.PlatformDevices); err != nil {
			invalidParams.AddNested("PlatformDevices", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRegisterTaskDefinitionInput(v *RegisterTaskDefinitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterTaskDefinitionInput"}
	if v.Family == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Family"))
	}
	if v.ContainerDefinitions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContainerDefinitions"))
	} else if v.ContainerDefinitions != nil {
		if err := validateContainerDefinitions(v.ContainerDefinitions); err != nil {
			invalidParams.AddNested("ContainerDefinitions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Volumes != nil {
		if err := validateVolumeList(v.Volumes); err != nil {
			invalidParams.AddNested("Volumes", err.(smithy.InvalidParamsError))
		}
	}
	if v.ProxyConfiguration != nil {
		if err := validateProxyConfiguration(v.ProxyConfiguration); err != nil {
			invalidParams.AddNested("ProxyConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.InferenceAccelerators != nil {
		if err := validateInferenceAccelerators(v.InferenceAccelerators); err != nil {
			invalidParams.AddNested("InferenceAccelerators", err.(smithy.InvalidParamsError))
		}
	}
	if v.EphemeralStorage != nil {
		if err := validateEphemeralStorage(v.EphemeralStorage); err != nil {
			invalidParams.AddNested("EphemeralStorage", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRunTaskInput(v *RunTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RunTaskInput"}
	if v.CapacityProviderStrategy != nil {
		if err := validateCapacityProviderStrategy(v.CapacityProviderStrategy); err != nil {
			invalidParams.AddNested("CapacityProviderStrategy", err.(smithy.InvalidParamsError))
		}
	}
	if v.NetworkConfiguration != nil {
		if err := validateNetworkConfiguration(v.NetworkConfiguration); err != nil {
			invalidParams.AddNested("NetworkConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Overrides != nil {
		if err := validateTaskOverride(v.Overrides); err != nil {
			invalidParams.AddNested("Overrides", err.(smithy.InvalidParamsError))
		}
	}
	if v.TaskDefinition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskDefinition"))
	}
	if v.VolumeConfigurations != nil {
		if err := validateTaskVolumeConfigurations(v.VolumeConfigurations); err != nil {
			invalidParams.AddNested("VolumeConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartTaskInput(v *StartTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartTaskInput"}
	if v.ContainerInstances == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContainerInstances"))
	}
	if v.NetworkConfiguration != nil {
		if err := validateNetworkConfiguration(v.NetworkConfiguration); err != nil {
			invalidParams.AddNested("NetworkConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Overrides != nil {
		if err := validateTaskOverride(v.Overrides); err != nil {
			invalidParams.AddNested("Overrides", err.(smithy.InvalidParamsError))
		}
	}
	if v.TaskDefinition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskDefinition"))
	}
	if v.VolumeConfigurations != nil {
		if err := validateTaskVolumeConfigurations(v.VolumeConfigurations); err != nil {
			invalidParams.AddNested("VolumeConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpSubmitAttachmentStateChangesInput(v *SubmitAttachmentStateChangesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SubmitAttachmentStateChangesInput"}
	if v.Attachments == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Attachments"))
	} else if v.Attachments != nil {
		if err := validateAttachmentStateChanges(v.Attachments); err != nil {
			invalidParams.AddNested("Attachments", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSubmitTaskStateChangeInput(v *SubmitTaskStateChangeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SubmitTaskStateChangeInput"}
	if v.Attachments != nil {
		if err := validateAttachmentStateChanges(v.Attachments); err != nil {
			invalidParams.AddNested("Attachments", err.(smithy.InvalidParamsError))
		}
	}
	if v.ManagedAgents != nil {
		if err := validateManagedAgentStateChanges(v.ManagedAgents); err != nil {
			invalidParams.AddNested("ManagedAgents", err.(smithy.InvalidParamsError))
		}
	}
	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 validateOpUpdateCapacityProviderInput(v *UpdateCapacityProviderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCapacityProviderInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.AutoScalingGroupProvider == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AutoScalingGroupProvider"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateClusterInput(v *UpdateClusterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateClusterInput"}
	if v.Cluster == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cluster"))
	}
	if v.ServiceConnectDefaults != nil {
		if err := validateClusterServiceConnectDefaultsRequest(v.ServiceConnectDefaults); err != nil {
			invalidParams.AddNested("ServiceConnectDefaults", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateClusterSettingsInput(v *UpdateClusterSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateClusterSettingsInput"}
	if v.Cluster == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cluster"))
	}
	if v.Settings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Settings"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateContainerInstancesStateInput(v *UpdateContainerInstancesStateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateContainerInstancesStateInput"}
	if v.ContainerInstances == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContainerInstances"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateServiceInput(v *UpdateServiceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateServiceInput"}
	if v.Service == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Service"))
	}
	if v.CapacityProviderStrategy != nil {
		if err := validateCapacityProviderStrategy(v.CapacityProviderStrategy); err != nil {
			invalidParams.AddNested("CapacityProviderStrategy", err.(smithy.InvalidParamsError))
		}
	}
	if v.DeploymentConfiguration != nil {
		if err := validateDeploymentConfiguration(v.DeploymentConfiguration); err != nil {
			invalidParams.AddNested("DeploymentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.NetworkConfiguration != nil {
		if err := validateNetworkConfiguration(v.NetworkConfiguration); err != nil {
			invalidParams.AddNested("NetworkConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ServiceConnectConfiguration != nil {
		if err := validateServiceConnectConfiguration(v.ServiceConnectConfiguration); err != nil {
			invalidParams.AddNested("ServiceConnectConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.VolumeConfigurations != nil {
		if err := validateServiceVolumeConfigurations(v.VolumeConfigurations); err != nil {
			invalidParams.AddNested("VolumeConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.VpcLatticeConfigurations != nil {
		if err := validateVpcLatticeConfigurations(v.VpcLatticeConfigurations); err != nil {
			invalidParams.AddNested("VpcLatticeConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateServicePrimaryTaskSetInput(v *UpdateServicePrimaryTaskSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateServicePrimaryTaskSetInput"}
	if v.Cluster == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cluster"))
	}
	if v.Service == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Service"))
	}
	if v.PrimaryTaskSet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrimaryTaskSet"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateTaskProtectionInput(v *UpdateTaskProtectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTaskProtectionInput"}
	if v.Cluster == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cluster"))
	}
	if v.Tasks == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tasks"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateTaskSetInput(v *UpdateTaskSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTaskSetInput"}
	if v.Cluster == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cluster"))
	}
	if v.Service == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Service"))
	}
	if v.TaskSet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskSet"))
	}
	if v.Scale == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Scale"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}
