service/deadline/validators.go

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

package deadline

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

type validateOpAssociateMemberToFarm struct {
}

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

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

type validateOpAssociateMemberToFleet struct {
}

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

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

type validateOpAssociateMemberToJob struct {
}

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

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

type validateOpAssociateMemberToQueue struct {
}

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

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

type validateOpAssumeFleetRoleForRead struct {
}

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

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

type validateOpAssumeFleetRoleForWorker struct {
}

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

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

type validateOpAssumeQueueRoleForRead struct {
}

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

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

type validateOpAssumeQueueRoleForUser struct {
}

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

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

type validateOpAssumeQueueRoleForWorker struct {
}

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

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

type validateOpBatchGetJobEntity struct {
}

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

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

type validateOpCopyJobTemplate struct {
}

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

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

type validateOpCreateBudget struct {
}

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

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

type validateOpCreateFarm struct {
}

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

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

type validateOpCreateFleet struct {
}

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

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

type validateOpCreateJob struct {
}

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

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

type validateOpCreateLicenseEndpoint struct {
}

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

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

type validateOpCreateLimit struct {
}

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

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

type validateOpCreateMonitor struct {
}

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

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

type validateOpCreateQueueEnvironment struct {
}

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

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

type validateOpCreateQueueFleetAssociation struct {
}

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

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

type validateOpCreateQueue struct {
}

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

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

type validateOpCreateQueueLimitAssociation struct {
}

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

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

type validateOpCreateStorageProfile struct {
}

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

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

type validateOpCreateWorker struct {
}

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

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

type validateOpDeleteBudget struct {
}

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

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

type validateOpDeleteFarm struct {
}

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

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

type validateOpDeleteFleet struct {
}

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

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

type validateOpDeleteLicenseEndpoint struct {
}

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

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

type validateOpDeleteLimit struct {
}

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

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

type validateOpDeleteMeteredProduct struct {
}

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

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

type validateOpDeleteMonitor struct {
}

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

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

type validateOpDeleteQueueEnvironment struct {
}

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

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

type validateOpDeleteQueueFleetAssociation struct {
}

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

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

type validateOpDeleteQueue struct {
}

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

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

type validateOpDeleteQueueLimitAssociation struct {
}

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

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

type validateOpDeleteStorageProfile struct {
}

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

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

type validateOpDeleteWorker struct {
}

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

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

type validateOpDisassociateMemberFromFarm struct {
}

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

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

type validateOpDisassociateMemberFromFleet struct {
}

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

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

type validateOpDisassociateMemberFromJob struct {
}

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

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

type validateOpDisassociateMemberFromQueue struct {
}

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

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

type validateOpGetBudget struct {
}

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

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

type validateOpGetFarm struct {
}

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

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

type validateOpGetFleet struct {
}

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

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

type validateOpGetJob struct {
}

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

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

type validateOpGetLicenseEndpoint struct {
}

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

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

type validateOpGetLimit struct {
}

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

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

type validateOpGetMonitor struct {
}

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

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

type validateOpGetQueueEnvironment struct {
}

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

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

type validateOpGetQueueFleetAssociation struct {
}

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

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

type validateOpGetQueue struct {
}

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

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

type validateOpGetQueueLimitAssociation struct {
}

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

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

type validateOpGetSessionAction struct {
}

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

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

type validateOpGetSession struct {
}

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

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

type validateOpGetSessionsStatisticsAggregation struct {
}

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

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

type validateOpGetStep struct {
}

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

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

type validateOpGetStorageProfileForQueue struct {
}

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

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

type validateOpGetStorageProfile struct {
}

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

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

type validateOpGetTask struct {
}

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

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

type validateOpGetWorker struct {
}

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

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

type validateOpListBudgets struct {
}

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

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

type validateOpListFarmMembers struct {
}

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

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

type validateOpListFleetMembers struct {
}

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

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

type validateOpListFleets struct {
}

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

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

type validateOpListJobMembers struct {
}

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

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

type validateOpListJobParameterDefinitions struct {
}

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

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

type validateOpListJobs struct {
}

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

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

type validateOpListLimits struct {
}

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

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

type validateOpListMeteredProducts struct {
}

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

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

type validateOpListQueueEnvironments struct {
}

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

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

type validateOpListQueueFleetAssociations struct {
}

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

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

type validateOpListQueueLimitAssociations struct {
}

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

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

type validateOpListQueueMembers struct {
}

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

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

type validateOpListQueues struct {
}

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

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

type validateOpListSessionActions struct {
}

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

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

type validateOpListSessionsForWorker struct {
}

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

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

type validateOpListSessions struct {
}

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

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

type validateOpListStepConsumers struct {
}

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

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

type validateOpListStepDependencies struct {
}

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

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

type validateOpListSteps struct {
}

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

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

type validateOpListStorageProfilesForQueue struct {
}

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

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

type validateOpListStorageProfiles struct {
}

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

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

type validateOpListTagsForResource struct {
}

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

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

type validateOpListTasks struct {
}

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

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

type validateOpListWorkers struct {
}

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

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

type validateOpPutMeteredProduct struct {
}

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

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

type validateOpSearchJobs struct {
}

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

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

type validateOpSearchSteps struct {
}

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

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

type validateOpSearchTasks struct {
}

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

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

type validateOpSearchWorkers struct {
}

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

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

type validateOpStartSessionsStatisticsAggregation struct {
}

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

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

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

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

type validateOpUpdateFarm struct {
}

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

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

type validateOpUpdateFleet struct {
}

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

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

type validateOpUpdateJob struct {
}

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

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

type validateOpUpdateLimit struct {
}

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

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

type validateOpUpdateMonitor struct {
}

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

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

type validateOpUpdateQueueEnvironment struct {
}

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

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

type validateOpUpdateQueueFleetAssociation struct {
}

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

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

type validateOpUpdateQueue struct {
}

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

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

type validateOpUpdateQueueLimitAssociation struct {
}

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

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

type validateOpUpdateSession struct {
}

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

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

type validateOpUpdateStep struct {
}

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

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

type validateOpUpdateStorageProfile struct {
}

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

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

type validateOpUpdateTask struct {
}

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

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

type validateOpUpdateWorker struct {
}

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

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

type validateOpUpdateWorkerSchedule struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpStartSessionsStatisticsAggregationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartSessionsStatisticsAggregation{}, 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 addOpUpdateBudgetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateBudget{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateAcceleratorCapabilities(v *types.AcceleratorCapabilities) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AcceleratorCapabilities"}
	if v.Selections == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Selections"))
	} else if v.Selections != nil {
		if err := validateAcceleratorSelections(v.Selections); err != nil {
			invalidParams.AddNested("Selections", err.(smithy.InvalidParamsError))
		}
	}
	if v.Count != nil {
		if err := validateAcceleratorCountRange(v.Count); err != nil {
			invalidParams.AddNested("Count", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

func validateBudgetSchedule(v types.BudgetSchedule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BudgetSchedule"}
	switch uv := v.(type) {
	case *types.BudgetScheduleMemberFixed:
		if err := validateFixedBudgetSchedule(&uv.Value); err != nil {
			invalidParams.AddNested("[fixed]", err.(smithy.InvalidParamsError))
		}

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

func validateCustomerManagedFleetConfiguration(v *types.CustomerManagedFleetConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomerManagedFleetConfiguration"}
	if len(v.Mode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Mode"))
	}
	if v.WorkerCapabilities == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkerCapabilities"))
	} else if v.WorkerCapabilities != nil {
		if err := validateCustomerManagedWorkerCapabilities(v.WorkerCapabilities); err != nil {
			invalidParams.AddNested("WorkerCapabilities", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomerManagedWorkerCapabilities(v *types.CustomerManagedWorkerCapabilities) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomerManagedWorkerCapabilities"}
	if v.VCpuCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VCpuCount"))
	} else if v.VCpuCount != nil {
		if err := validateVCpuCountRange(v.VCpuCount); err != nil {
			invalidParams.AddNested("VCpuCount", err.(smithy.InvalidParamsError))
		}
	}
	if v.MemoryMiB == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryMiB"))
	} else if v.MemoryMiB != nil {
		if err := validateMemoryMiBRange(v.MemoryMiB); err != nil {
			invalidParams.AddNested("MemoryMiB", err.(smithy.InvalidParamsError))
		}
	}
	if v.AcceleratorCount != nil {
		if err := validateAcceleratorCountRange(v.AcceleratorCount); err != nil {
			invalidParams.AddNested("AcceleratorCount", err.(smithy.InvalidParamsError))
		}
	}
	if v.AcceleratorTotalMemoryMiB != nil {
		if err := validateAcceleratorTotalMemoryMiBRange(v.AcceleratorTotalMemoryMiB); err != nil {
			invalidParams.AddNested("AcceleratorTotalMemoryMiB", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.OsFamily) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("OsFamily"))
	}
	if len(v.CpuArchitectureType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("CpuArchitectureType"))
	}
	if v.CustomAmounts != nil {
		if err := validateCustomFleetAmountCapabilities(v.CustomAmounts); err != nil {
			invalidParams.AddNested("CustomAmounts", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomAttributes != nil {
		if err := validateCustomFleetAttributeCapabilities(v.CustomAttributes); err != nil {
			invalidParams.AddNested("CustomAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateEnvironmentDetailsIdentifiers(v *types.EnvironmentDetailsIdentifiers) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnvironmentDetailsIdentifiers"}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if v.EnvironmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateFixedBudgetSchedule(v *types.FixedBudgetSchedule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FixedBudgetSchedule"}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateFleetConfiguration(v types.FleetConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FleetConfiguration"}
	switch uv := v.(type) {
	case *types.FleetConfigurationMemberCustomerManaged:
		if err := validateCustomerManagedFleetConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[customerManaged]", err.(smithy.InvalidParamsError))
		}

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

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

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

func validateJobAttachmentSettings(v *types.JobAttachmentSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "JobAttachmentSettings"}
	if v.S3BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3BucketName"))
	}
	if v.RootPrefix == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RootPrefix"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateJobEntityIdentifiersUnion(v types.JobEntityIdentifiersUnion) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "JobEntityIdentifiersUnion"}
	switch uv := v.(type) {
	case *types.JobEntityIdentifiersUnionMemberEnvironmentDetails:
		if err := validateEnvironmentDetailsIdentifiers(&uv.Value); err != nil {
			invalidParams.AddNested("[environmentDetails]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

func validateJobRunAsUser(v *types.JobRunAsUser) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "JobRunAsUser"}
	if v.Posix != nil {
		if err := validatePosixUser(v.Posix); err != nil {
			invalidParams.AddNested("Posix", err.(smithy.InvalidParamsError))
		}
	}
	if v.Windows != nil {
		if err := validateWindowsUser(v.Windows); err != nil {
			invalidParams.AddNested("Windows", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.RunAs) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RunAs"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateManifestProperties(v *types.ManifestProperties) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ManifestProperties"}
	if v.RootPath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RootPath"))
	}
	if len(v.RootPathFormat) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RootPathFormat"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateSearchFilterExpression(v types.SearchFilterExpression) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchFilterExpression"}
	switch uv := v.(type) {
	case *types.SearchFilterExpressionMemberDateTimeFilter:
		if err := validateDateTimeFilterExpression(&uv.Value); err != nil {
			invalidParams.AddNested("[dateTimeFilter]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

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

func validateSearchGroupedFilterExpressions(v *types.SearchGroupedFilterExpressions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchGroupedFilterExpressions"}
	if v.Filters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
	} else if v.Filters != nil {
		if err := validateSearchFilterExpressions(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.Operator) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Operator"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSearchSortExpression(v types.SearchSortExpression) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchSortExpression"}
	switch uv := v.(type) {
	case *types.SearchSortExpressionMemberFieldSort:
		if err := validateFieldSortExpression(&uv.Value); err != nil {
			invalidParams.AddNested("[fieldSort]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

func validateServiceManagedEc2FleetConfiguration(v *types.ServiceManagedEc2FleetConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ServiceManagedEc2FleetConfiguration"}
	if v.InstanceCapabilities == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceCapabilities"))
	} else if v.InstanceCapabilities != nil {
		if err := validateServiceManagedEc2InstanceCapabilities(v.InstanceCapabilities); err != nil {
			invalidParams.AddNested("InstanceCapabilities", err.(smithy.InvalidParamsError))
		}
	}
	if v.InstanceMarketOptions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceMarketOptions"))
	} else if v.InstanceMarketOptions != nil {
		if err := validateServiceManagedEc2InstanceMarketOptions(v.InstanceMarketOptions); err != nil {
			invalidParams.AddNested("InstanceMarketOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateServiceManagedEc2InstanceCapabilities(v *types.ServiceManagedEc2InstanceCapabilities) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ServiceManagedEc2InstanceCapabilities"}
	if v.VCpuCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VCpuCount"))
	} else if v.VCpuCount != nil {
		if err := validateVCpuCountRange(v.VCpuCount); err != nil {
			invalidParams.AddNested("VCpuCount", err.(smithy.InvalidParamsError))
		}
	}
	if v.MemoryMiB == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemoryMiB"))
	} else if v.MemoryMiB != nil {
		if err := validateMemoryMiBRange(v.MemoryMiB); err != nil {
			invalidParams.AddNested("MemoryMiB", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.OsFamily) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("OsFamily"))
	}
	if len(v.CpuArchitectureType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("CpuArchitectureType"))
	}
	if v.AcceleratorCapabilities != nil {
		if err := validateAcceleratorCapabilities(v.AcceleratorCapabilities); err != nil {
			invalidParams.AddNested("AcceleratorCapabilities", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomAmounts != nil {
		if err := validateCustomFleetAmountCapabilities(v.CustomAmounts); err != nil {
			invalidParams.AddNested("CustomAmounts", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomAttributes != nil {
		if err := validateCustomFleetAttributeCapabilities(v.CustomAttributes); err != nil {
			invalidParams.AddNested("CustomAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateStepDetailsIdentifiers(v *types.StepDetailsIdentifiers) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StepDetailsIdentifiers"}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if v.StepId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StepId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

func validateWorkerCapabilities(v *types.WorkerCapabilities) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WorkerCapabilities"}
	if v.Amounts == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Amounts"))
	} else if v.Amounts != nil {
		if err := validateWorkerAmountCapabilityList(v.Amounts); err != nil {
			invalidParams.AddNested("Amounts", err.(smithy.InvalidParamsError))
		}
	}
	if v.Attributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Attributes"))
	} else if v.Attributes != nil {
		if err := validateWorkerAttributeCapabilityList(v.Attributes); err != nil {
			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateMemberToFarmInput(v *AssociateMemberToFarmInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateMemberToFarmInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.PrincipalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalId"))
	}
	if len(v.PrincipalType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalType"))
	}
	if v.IdentityStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdentityStoreId"))
	}
	if len(v.MembershipLevel) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipLevel"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateMemberToFleetInput(v *AssociateMemberToFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateMemberToFleetInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if v.PrincipalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalId"))
	}
	if len(v.PrincipalType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalType"))
	}
	if v.IdentityStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdentityStoreId"))
	}
	if len(v.MembershipLevel) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipLevel"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateMemberToJobInput(v *AssociateMemberToJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateMemberToJobInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if v.PrincipalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalId"))
	}
	if len(v.PrincipalType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalType"))
	}
	if v.IdentityStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdentityStoreId"))
	}
	if len(v.MembershipLevel) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipLevel"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateMemberToQueueInput(v *AssociateMemberToQueueInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateMemberToQueueInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.PrincipalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalId"))
	}
	if len(v.PrincipalType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalType"))
	}
	if v.IdentityStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdentityStoreId"))
	}
	if len(v.MembershipLevel) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipLevel"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssumeFleetRoleForReadInput(v *AssumeFleetRoleForReadInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssumeFleetRoleForReadInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssumeFleetRoleForWorkerInput(v *AssumeFleetRoleForWorkerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssumeFleetRoleForWorkerInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if v.WorkerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkerId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssumeQueueRoleForReadInput(v *AssumeQueueRoleForReadInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssumeQueueRoleForReadInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssumeQueueRoleForUserInput(v *AssumeQueueRoleForUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssumeQueueRoleForUserInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssumeQueueRoleForWorkerInput(v *AssumeQueueRoleForWorkerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssumeQueueRoleForWorkerInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if v.WorkerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkerId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchGetJobEntityInput(v *BatchGetJobEntityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetJobEntityInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if v.WorkerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkerId"))
	}
	if v.Identifiers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifiers"))
	} else if v.Identifiers != nil {
		if err := validateJobEntityIdentifiers(v.Identifiers); err != nil {
			invalidParams.AddNested("Identifiers", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCopyJobTemplateInput(v *CopyJobTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CopyJobTemplateInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.TargetS3Location == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetS3Location"))
	} else if v.TargetS3Location != nil {
		if err := validateS3Location(v.TargetS3Location); err != nil {
			invalidParams.AddNested("TargetS3Location", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateBudgetInput(v *CreateBudgetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateBudgetInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.UsageTrackingResource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsageTrackingResource"))
	}
	if v.DisplayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DisplayName"))
	}
	if v.ApproximateDollarLimit == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApproximateDollarLimit"))
	}
	if v.Actions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Actions"))
	} else if v.Actions != nil {
		if err := validateBudgetActionsToAdd(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Schedule == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Schedule"))
	} else if v.Schedule != nil {
		if err := validateBudgetSchedule(v.Schedule); err != nil {
			invalidParams.AddNested("Schedule", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateFleetInput(v *CreateFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFleetInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.DisplayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DisplayName"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.MaxWorkerCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxWorkerCount"))
	}
	if v.Configuration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Configuration"))
	} else if v.Configuration != nil {
		if err := validateFleetConfiguration(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateJobInput(v *CreateJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateJobInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.Priority == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Priority"))
	}
	if v.Attachments != nil {
		if err := validateAttachments(v.Attachments); err != nil {
			invalidParams.AddNested("Attachments", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLicenseEndpointInput(v *CreateLicenseEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLicenseEndpointInput"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if v.SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
	}
	if v.SecurityGroupIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLimitInput(v *CreateLimitInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLimitInput"}
	if v.DisplayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DisplayName"))
	}
	if v.AmountRequirementName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AmountRequirementName"))
	}
	if v.MaxCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxCount"))
	}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMonitorInput(v *CreateMonitorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMonitorInput"}
	if v.DisplayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DisplayName"))
	}
	if v.IdentityCenterInstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdentityCenterInstanceArn"))
	}
	if v.Subdomain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Subdomain"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateQueueEnvironmentInput(v *CreateQueueEnvironmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateQueueEnvironmentInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.Priority == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Priority"))
	}
	if len(v.TemplateType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateType"))
	}
	if v.Template == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Template"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateQueueFleetAssociationInput(v *CreateQueueFleetAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateQueueFleetAssociationInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateQueueInput(v *CreateQueueInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateQueueInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.DisplayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DisplayName"))
	}
	if v.JobAttachmentSettings != nil {
		if err := validateJobAttachmentSettings(v.JobAttachmentSettings); err != nil {
			invalidParams.AddNested("JobAttachmentSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.JobRunAsUser != nil {
		if err := validateJobRunAsUser(v.JobRunAsUser); err != nil {
			invalidParams.AddNested("JobRunAsUser", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateQueueLimitAssociationInput(v *CreateQueueLimitAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateQueueLimitAssociationInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.LimitId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LimitId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateStorageProfileInput(v *CreateStorageProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateStorageProfileInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.DisplayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DisplayName"))
	}
	if len(v.OsFamily) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("OsFamily"))
	}
	if v.FileSystemLocations != nil {
		if err := validateFileSystemLocationsList(v.FileSystemLocations); err != nil {
			invalidParams.AddNested("FileSystemLocations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateWorkerInput(v *CreateWorkerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateWorkerInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteBudgetInput(v *DeleteBudgetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteBudgetInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.BudgetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BudgetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpDeleteLimitInput(v *DeleteLimitInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteLimitInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.LimitId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LimitId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteMeteredProductInput(v *DeleteMeteredProductInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteMeteredProductInput"}
	if v.LicenseEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LicenseEndpointId"))
	}
	if v.ProductId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProductId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteQueueEnvironmentInput(v *DeleteQueueEnvironmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteQueueEnvironmentInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.QueueEnvironmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueEnvironmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteQueueFleetAssociationInput(v *DeleteQueueFleetAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteQueueFleetAssociationInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteQueueInput(v *DeleteQueueInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteQueueInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteQueueLimitAssociationInput(v *DeleteQueueLimitAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteQueueLimitAssociationInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.LimitId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LimitId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteStorageProfileInput(v *DeleteStorageProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteStorageProfileInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.StorageProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StorageProfileId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteWorkerInput(v *DeleteWorkerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteWorkerInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if v.WorkerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkerId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateMemberFromFarmInput(v *DisassociateMemberFromFarmInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateMemberFromFarmInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.PrincipalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateMemberFromFleetInput(v *DisassociateMemberFromFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateMemberFromFleetInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if v.PrincipalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateMemberFromJobInput(v *DisassociateMemberFromJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateMemberFromJobInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if v.PrincipalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateMemberFromQueueInput(v *DisassociateMemberFromQueueInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateMemberFromQueueInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.PrincipalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetBudgetInput(v *GetBudgetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetBudgetInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.BudgetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BudgetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetFleetInput(v *GetFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetFleetInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetJobInput(v *GetJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetJobInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetLimitInput(v *GetLimitInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetLimitInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.LimitId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LimitId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetQueueEnvironmentInput(v *GetQueueEnvironmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetQueueEnvironmentInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.QueueEnvironmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueEnvironmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetQueueFleetAssociationInput(v *GetQueueFleetAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetQueueFleetAssociationInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetQueueInput(v *GetQueueInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetQueueInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetQueueLimitAssociationInput(v *GetQueueLimitAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetQueueLimitAssociationInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.LimitId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LimitId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSessionActionInput(v *GetSessionActionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSessionActionInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if v.SessionActionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionActionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSessionInput(v *GetSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSessionInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSessionsStatisticsAggregationInput(v *GetSessionsStatisticsAggregationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSessionsStatisticsAggregationInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.AggregationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AggregationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetStepInput(v *GetStepInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetStepInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if v.StepId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StepId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetStorageProfileForQueueInput(v *GetStorageProfileForQueueInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetStorageProfileForQueueInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.StorageProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StorageProfileId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetStorageProfileInput(v *GetStorageProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetStorageProfileInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.StorageProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StorageProfileId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetTaskInput(v *GetTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTaskInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if v.StepId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StepId"))
	}
	if v.TaskId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetWorkerInput(v *GetWorkerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetWorkerInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if v.WorkerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkerId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListFleetMembersInput(v *ListFleetMembersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListFleetMembersInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListJobMembersInput(v *ListJobMembersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListJobMembersInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListJobParameterDefinitionsInput(v *ListJobParameterDefinitionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListJobParameterDefinitionsInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListJobsInput(v *ListJobsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListJobsInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListQueueEnvironmentsInput(v *ListQueueEnvironmentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListQueueEnvironmentsInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListQueueMembersInput(v *ListQueueMembersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListQueueMembersInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListSessionActionsInput(v *ListSessionActionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListSessionActionsInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListSessionsForWorkerInput(v *ListSessionsForWorkerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListSessionsForWorkerInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if v.WorkerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkerId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListSessionsInput(v *ListSessionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListSessionsInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListStepConsumersInput(v *ListStepConsumersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListStepConsumersInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if v.StepId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StepId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListStepDependenciesInput(v *ListStepDependenciesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListStepDependenciesInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if v.StepId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StepId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListStepsInput(v *ListStepsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListStepsInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListStorageProfilesForQueueInput(v *ListStorageProfilesForQueueInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListStorageProfilesForQueueInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListTasksInput(v *ListTasksInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTasksInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if v.StepId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StepId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListWorkersInput(v *ListWorkersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListWorkersInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutMeteredProductInput(v *PutMeteredProductInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutMeteredProductInput"}
	if v.LicenseEndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LicenseEndpointId"))
	}
	if v.ProductId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProductId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchJobsInput(v *SearchJobsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchJobsInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueIds"))
	}
	if v.FilterExpressions != nil {
		if err := validateSearchGroupedFilterExpressions(v.FilterExpressions); err != nil {
			invalidParams.AddNested("FilterExpressions", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortExpressions != nil {
		if err := validateSearchSortExpressions(v.SortExpressions); err != nil {
			invalidParams.AddNested("SortExpressions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ItemOffset == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ItemOffset"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchStepsInput(v *SearchStepsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchStepsInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueIds"))
	}
	if v.FilterExpressions != nil {
		if err := validateSearchGroupedFilterExpressions(v.FilterExpressions); err != nil {
			invalidParams.AddNested("FilterExpressions", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortExpressions != nil {
		if err := validateSearchSortExpressions(v.SortExpressions); err != nil {
			invalidParams.AddNested("SortExpressions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ItemOffset == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ItemOffset"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchTasksInput(v *SearchTasksInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchTasksInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueIds"))
	}
	if v.FilterExpressions != nil {
		if err := validateSearchGroupedFilterExpressions(v.FilterExpressions); err != nil {
			invalidParams.AddNested("FilterExpressions", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortExpressions != nil {
		if err := validateSearchSortExpressions(v.SortExpressions); err != nil {
			invalidParams.AddNested("SortExpressions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ItemOffset == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ItemOffset"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchWorkersInput(v *SearchWorkersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchWorkersInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.FleetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetIds"))
	}
	if v.FilterExpressions != nil {
		if err := validateSearchGroupedFilterExpressions(v.FilterExpressions); err != nil {
			invalidParams.AddNested("FilterExpressions", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortExpressions != nil {
		if err := validateSearchSortExpressions(v.SortExpressions); err != nil {
			invalidParams.AddNested("SortExpressions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ItemOffset == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ItemOffset"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartSessionsStatisticsAggregationInput(v *StartSessionsStatisticsAggregationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartSessionsStatisticsAggregationInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.ResourceIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceIds"))
	}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if v.GroupBy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupBy"))
	}
	if v.Statistics == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Statistics"))
	}
	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 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 validateOpUpdateBudgetInput(v *UpdateBudgetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateBudgetInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.BudgetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BudgetId"))
	}
	if v.ActionsToAdd != nil {
		if err := validateBudgetActionsToAdd(v.ActionsToAdd); err != nil {
			invalidParams.AddNested("ActionsToAdd", err.(smithy.InvalidParamsError))
		}
	}
	if v.ActionsToRemove != nil {
		if err := validateBudgetActionsToRemove(v.ActionsToRemove); err != nil {
			invalidParams.AddNested("ActionsToRemove", err.(smithy.InvalidParamsError))
		}
	}
	if v.Schedule != nil {
		if err := validateBudgetSchedule(v.Schedule); err != nil {
			invalidParams.AddNested("Schedule", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateFleetInput(v *UpdateFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFleetInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if v.Configuration != nil {
		if err := validateFleetConfiguration(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateJobInput(v *UpdateJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateJobInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateLimitInput(v *UpdateLimitInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateLimitInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.LimitId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LimitId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateQueueEnvironmentInput(v *UpdateQueueEnvironmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateQueueEnvironmentInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.QueueEnvironmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueEnvironmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateQueueFleetAssociationInput(v *UpdateQueueFleetAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateQueueFleetAssociationInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateQueueInput(v *UpdateQueueInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateQueueInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.JobAttachmentSettings != nil {
		if err := validateJobAttachmentSettings(v.JobAttachmentSettings); err != nil {
			invalidParams.AddNested("JobAttachmentSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.JobRunAsUser != nil {
		if err := validateJobRunAsUser(v.JobRunAsUser); err != nil {
			invalidParams.AddNested("JobRunAsUser", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateQueueLimitAssociationInput(v *UpdateQueueLimitAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateQueueLimitAssociationInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.LimitId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LimitId"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateSessionInput(v *UpdateSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSessionInput"}
	if len(v.TargetLifecycleStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TargetLifecycleStatus"))
	}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateStepInput(v *UpdateStepInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateStepInput"}
	if len(v.TargetTaskRunStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TargetTaskRunStatus"))
	}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if v.StepId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StepId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateStorageProfileInput(v *UpdateStorageProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateStorageProfileInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.StorageProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StorageProfileId"))
	}
	if v.FileSystemLocationsToAdd != nil {
		if err := validateFileSystemLocationsList(v.FileSystemLocationsToAdd); err != nil {
			invalidParams.AddNested("FileSystemLocationsToAdd", err.(smithy.InvalidParamsError))
		}
	}
	if v.FileSystemLocationsToRemove != nil {
		if err := validateFileSystemLocationsList(v.FileSystemLocationsToRemove); err != nil {
			invalidParams.AddNested("FileSystemLocationsToRemove", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateTaskInput(v *UpdateTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTaskInput"}
	if len(v.TargetRunStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TargetRunStatus"))
	}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.QueueId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueueId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if v.StepId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StepId"))
	}
	if v.TaskId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TaskId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateWorkerInput(v *UpdateWorkerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateWorkerInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if v.WorkerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkerId"))
	}
	if v.Capabilities != nil {
		if err := validateWorkerCapabilities(v.Capabilities); err != nil {
			invalidParams.AddNested("Capabilities", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateWorkerScheduleInput(v *UpdateWorkerScheduleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateWorkerScheduleInput"}
	if v.FarmId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FarmId"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if v.WorkerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkerId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}