service/gamelift/validators.go

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

package gamelift

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

type validateOpAcceptMatch struct {
}

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

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

type validateOpClaimGameServer struct {
}

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

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

type validateOpCreateAlias struct {
}

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

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

type validateOpCreateBuild struct {
}

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

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

type validateOpCreateContainerFleet struct {
}

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

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

type validateOpCreateContainerGroupDefinition struct {
}

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

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

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

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

type validateOpCreateGameServerGroup struct {
}

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

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

type validateOpCreateGameSession struct {
}

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

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

type validateOpCreateGameSessionQueue struct {
}

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

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

type validateOpCreateLocation struct {
}

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

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

type validateOpCreateMatchmakingConfiguration struct {
}

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

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

type validateOpCreateMatchmakingRuleSet struct {
}

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

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

type validateOpCreatePlayerSession struct {
}

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

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

type validateOpCreatePlayerSessions struct {
}

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

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

type validateOpCreateScript struct {
}

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

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

type validateOpCreateVpcPeeringAuthorization struct {
}

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

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

type validateOpCreateVpcPeeringConnection struct {
}

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

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

type validateOpDeleteAlias struct {
}

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

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

type validateOpDeleteBuild struct {
}

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

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

type validateOpDeleteContainerFleet struct {
}

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

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

type validateOpDeleteContainerGroupDefinition struct {
}

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

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

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

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

type validateOpDeleteGameServerGroup struct {
}

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

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

type validateOpDeleteGameSessionQueue struct {
}

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

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

type validateOpDeleteLocation struct {
}

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

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

type validateOpDeleteMatchmakingConfiguration struct {
}

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

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

type validateOpDeleteMatchmakingRuleSet struct {
}

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

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

type validateOpDeleteScalingPolicy struct {
}

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

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

type validateOpDeleteScript struct {
}

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

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

type validateOpDeleteVpcPeeringAuthorization struct {
}

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

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

type validateOpDeleteVpcPeeringConnection struct {
}

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

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

type validateOpDeregisterCompute struct {
}

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

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

type validateOpDeregisterGameServer struct {
}

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

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

type validateOpDescribeAlias struct {
}

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

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

type validateOpDescribeBuild struct {
}

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

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

type validateOpDescribeCompute struct {
}

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

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

type validateOpDescribeContainerFleet struct {
}

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

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

type validateOpDescribeContainerGroupDefinition struct {
}

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

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

type validateOpDescribeFleetDeployment struct {
}

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

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

type validateOpDescribeFleetEvents struct {
}

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

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

type validateOpDescribeFleetLocationAttributes struct {
}

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

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

type validateOpDescribeFleetLocationCapacity struct {
}

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

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

type validateOpDescribeFleetLocationUtilization struct {
}

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

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

type validateOpDescribeFleetPortSettings struct {
}

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

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

type validateOpDescribeGameServerGroup struct {
}

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

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

type validateOpDescribeGameServer struct {
}

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

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

type validateOpDescribeGameServerInstances struct {
}

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

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

type validateOpDescribeGameSessionPlacement struct {
}

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

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

type validateOpDescribeInstances struct {
}

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

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

type validateOpDescribeMatchmaking struct {
}

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

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

type validateOpDescribeRuntimeConfiguration struct {
}

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

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

type validateOpDescribeScalingPolicies struct {
}

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

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

type validateOpDescribeScript struct {
}

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

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

type validateOpGetComputeAccess struct {
}

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

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

type validateOpGetComputeAuthToken struct {
}

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

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

type validateOpGetGameSessionLogUrl struct {
}

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

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

type validateOpGetInstanceAccess struct {
}

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

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

type validateOpListCompute struct {
}

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

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

type validateOpListContainerGroupDefinitionVersions struct {
}

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

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

type validateOpListGameServers struct {
}

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

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

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

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

type validateOpRegisterCompute struct {
}

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

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

type validateOpRegisterGameServer struct {
}

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

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

type validateOpRequestUploadCredentials struct {
}

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

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

type validateOpResolveAlias struct {
}

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

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

type validateOpResumeGameServerGroup struct {
}

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

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

type validateOpStartFleetActions struct {
}

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

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

type validateOpStartGameSessionPlacement struct {
}

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

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

type validateOpStartMatchBackfill struct {
}

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

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

type validateOpStartMatchmaking struct {
}

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

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

type validateOpStopFleetActions struct {
}

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

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

type validateOpStopGameSessionPlacement struct {
}

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

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

type validateOpStopMatchmaking struct {
}

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

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

type validateOpSuspendGameServerGroup struct {
}

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

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

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

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

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

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

type validateOpUpdateBuild struct {
}

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

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

type validateOpUpdateContainerFleet struct {
}

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

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

type validateOpUpdateContainerGroupDefinition struct {
}

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

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

type validateOpUpdateFleetAttributes struct {
}

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

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

type validateOpUpdateFleetCapacity struct {
}

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

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

type validateOpUpdateFleetPortSettings struct {
}

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

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

type validateOpUpdateGameServerGroup struct {
}

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

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

type validateOpUpdateGameServer struct {
}

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

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

type validateOpUpdateGameSession struct {
}

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

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

type validateOpUpdateGameSessionQueue struct {
}

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

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

type validateOpUpdateMatchmakingConfiguration struct {
}

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

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

type validateOpUpdateRuntimeConfiguration struct {
}

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

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

type validateOpUpdateScript struct {
}

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

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

type validateOpValidateMatchmakingRuleSet struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateConnectionPortRange(v *types.ConnectionPortRange) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConnectionPortRange"}
	if v.FromPort == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FromPort"))
	}
	if v.ToPort == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ToPort"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateContainerEnvironment(v *types.ContainerEnvironment) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContainerEnvironment"}
	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 validateContainerEnvironmentList(v []types.ContainerEnvironment) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContainerEnvironmentList"}
	for i := range v {
		if err := validateContainerEnvironment(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateContainerPortConfiguration(v *types.ContainerPortConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContainerPortConfiguration"}
	if v.ContainerPortRanges == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContainerPortRanges"))
	} else if v.ContainerPortRanges != nil {
		if err := validateContainerPortRangeList(v.ContainerPortRanges); err != nil {
			invalidParams.AddNested("ContainerPortRanges", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateContainerPortRange(v *types.ContainerPortRange) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContainerPortRange"}
	if v.FromPort == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FromPort"))
	}
	if v.ToPort == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ToPort"))
	}
	if len(v.Protocol) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateGameServerContainerDefinitionInput(v *types.GameServerContainerDefinitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GameServerContainerDefinitionInput"}
	if v.ContainerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContainerName"))
	}
	if v.DependsOn != nil {
		if err := validateContainerDependencyList(v.DependsOn); err != nil {
			invalidParams.AddNested("DependsOn", err.(smithy.InvalidParamsError))
		}
	}
	if v.MountPoints != nil {
		if err := validateContainerMountPointList(v.MountPoints); err != nil {
			invalidParams.AddNested("MountPoints", err.(smithy.InvalidParamsError))
		}
	}
	if v.EnvironmentOverride != nil {
		if err := validateContainerEnvironmentList(v.EnvironmentOverride); err != nil {
			invalidParams.AddNested("EnvironmentOverride", err.(smithy.InvalidParamsError))
		}
	}
	if v.ImageUri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageUri"))
	}
	if v.PortConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortConfiguration"))
	} else if v.PortConfiguration != nil {
		if err := validateContainerPortConfiguration(v.PortConfiguration); err != nil {
			invalidParams.AddNested("PortConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ServerSdkVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServerSdkVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGameServerGroupAutoScalingPolicy(v *types.GameServerGroupAutoScalingPolicy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GameServerGroupAutoScalingPolicy"}
	if v.TargetTrackingConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetTrackingConfiguration"))
	} else if v.TargetTrackingConfiguration != nil {
		if err := validateTargetTrackingConfiguration(v.TargetTrackingConfiguration); err != nil {
			invalidParams.AddNested("TargetTrackingConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateIpPermission(v *types.IpPermission) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IpPermission"}
	if v.FromPort == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FromPort"))
	}
	if v.ToPort == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ToPort"))
	}
	if v.IpRange == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpRange"))
	}
	if len(v.Protocol) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateRuntimeConfiguration(v *types.RuntimeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RuntimeConfiguration"}
	if v.ServerProcesses != nil {
		if err := validateServerProcessList(v.ServerProcesses); err != nil {
			invalidParams.AddNested("ServerProcesses", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateServerProcess(v *types.ServerProcess) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ServerProcess"}
	if v.LaunchPath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchPath"))
	}
	if v.ConcurrentExecutions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConcurrentExecutions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSupportContainerDefinitionInput(v *types.SupportContainerDefinitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SupportContainerDefinitionInput"}
	if v.ContainerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContainerName"))
	}
	if v.DependsOn != nil {
		if err := validateContainerDependencyList(v.DependsOn); err != nil {
			invalidParams.AddNested("DependsOn", err.(smithy.InvalidParamsError))
		}
	}
	if v.MountPoints != nil {
		if err := validateContainerMountPointList(v.MountPoints); err != nil {
			invalidParams.AddNested("MountPoints", err.(smithy.InvalidParamsError))
		}
	}
	if v.EnvironmentOverride != nil {
		if err := validateContainerEnvironmentList(v.EnvironmentOverride); err != nil {
			invalidParams.AddNested("EnvironmentOverride", err.(smithy.InvalidParamsError))
		}
	}
	if v.HealthCheck != nil {
		if err := validateContainerHealthCheck(v.HealthCheck); err != nil {
			invalidParams.AddNested("HealthCheck", err.(smithy.InvalidParamsError))
		}
	}
	if v.ImageUri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImageUri"))
	}
	if v.PortConfiguration != nil {
		if err := validateContainerPortConfiguration(v.PortConfiguration); err != nil {
			invalidParams.AddNested("PortConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpAcceptMatchInput(v *AcceptMatchInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AcceptMatchInput"}
	if v.TicketId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TicketId"))
	}
	if v.PlayerIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PlayerIds"))
	}
	if len(v.AcceptanceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AcceptanceType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpCreateContainerFleetInput(v *CreateContainerFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateContainerFleetInput"}
	if v.FleetRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetRoleArn"))
	}
	if v.InstanceConnectionPortRange != nil {
		if err := validateConnectionPortRange(v.InstanceConnectionPortRange); err != nil {
			invalidParams.AddNested("InstanceConnectionPortRange", err.(smithy.InvalidParamsError))
		}
	}
	if v.InstanceInboundPermissions != nil {
		if err := validateIpPermissionsList(v.InstanceInboundPermissions); err != nil {
			invalidParams.AddNested("InstanceInboundPermissions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Locations != nil {
		if err := validateLocationConfigurationList(v.Locations); err != nil {
			invalidParams.AddNested("Locations", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateContainerGroupDefinitionInput(v *CreateContainerGroupDefinitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateContainerGroupDefinitionInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.TotalMemoryLimitMebibytes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TotalMemoryLimitMebibytes"))
	}
	if v.TotalVcpuLimit == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TotalVcpuLimit"))
	}
	if v.GameServerContainerDefinition != nil {
		if err := validateGameServerContainerDefinitionInput(v.GameServerContainerDefinition); err != nil {
			invalidParams.AddNested("GameServerContainerDefinition", err.(smithy.InvalidParamsError))
		}
	}
	if v.SupportContainerDefinitions != nil {
		if err := validateSupportContainerDefinitionInputList(v.SupportContainerDefinitions); err != nil {
			invalidParams.AddNested("SupportContainerDefinitions", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.OperatingSystem) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("OperatingSystem"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFleetInput(v *CreateFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFleetInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.EC2InboundPermissions != nil {
		if err := validateIpPermissionsList(v.EC2InboundPermissions); err != nil {
			invalidParams.AddNested("EC2InboundPermissions", err.(smithy.InvalidParamsError))
		}
	}
	if v.RuntimeConfiguration != nil {
		if err := validateRuntimeConfiguration(v.RuntimeConfiguration); err != nil {
			invalidParams.AddNested("RuntimeConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CertificateConfiguration != nil {
		if err := validateCertificateConfiguration(v.CertificateConfiguration); err != nil {
			invalidParams.AddNested("CertificateConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Locations != nil {
		if err := validateLocationConfigurationList(v.Locations); err != nil {
			invalidParams.AddNested("Locations", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.AnywhereConfiguration != nil {
		if err := validateAnywhereConfiguration(v.AnywhereConfiguration); err != nil {
			invalidParams.AddNested("AnywhereConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFleetLocationsInput(v *CreateFleetLocationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFleetLocationsInput"}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if v.Locations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Locations"))
	} else if v.Locations != nil {
		if err := validateLocationConfigurationList(v.Locations); err != nil {
			invalidParams.AddNested("Locations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateGameServerGroupInput(v *CreateGameServerGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateGameServerGroupInput"}
	if v.GameServerGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.MinSize == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MinSize"))
	}
	if v.MaxSize == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxSize"))
	}
	if v.LaunchTemplate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchTemplate"))
	}
	if v.InstanceDefinitions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceDefinitions"))
	} else if v.InstanceDefinitions != nil {
		if err := validateInstanceDefinitions(v.InstanceDefinitions); err != nil {
			invalidParams.AddNested("InstanceDefinitions", err.(smithy.InvalidParamsError))
		}
	}
	if v.AutoScalingPolicy != nil {
		if err := validateGameServerGroupAutoScalingPolicy(v.AutoScalingPolicy); err != nil {
			invalidParams.AddNested("AutoScalingPolicy", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateGameSessionInput(v *CreateGameSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateGameSessionInput"}
	if v.MaximumPlayerSessionCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaximumPlayerSessionCount"))
	}
	if v.GameProperties != nil {
		if err := validateGamePropertyList(v.GameProperties); err != nil {
			invalidParams.AddNested("GameProperties", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpCreateMatchmakingConfigurationInput(v *CreateMatchmakingConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMatchmakingConfigurationInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.RequestTimeoutSeconds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequestTimeoutSeconds"))
	}
	if v.AcceptanceRequired == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AcceptanceRequired"))
	}
	if v.RuleSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleSetName"))
	}
	if v.GameProperties != nil {
		if err := validateGamePropertyList(v.GameProperties); err != nil {
			invalidParams.AddNested("GameProperties", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreatePlayerSessionInput(v *CreatePlayerSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePlayerSessionInput"}
	if v.GameSessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GameSessionId"))
	}
	if v.PlayerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PlayerId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePlayerSessionsInput(v *CreatePlayerSessionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePlayerSessionsInput"}
	if v.GameSessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GameSessionId"))
	}
	if v.PlayerIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PlayerIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateVpcPeeringAuthorizationInput(v *CreateVpcPeeringAuthorizationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVpcPeeringAuthorizationInput"}
	if v.GameLiftAwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GameLiftAwsAccountId"))
	}
	if v.PeerVpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PeerVpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateVpcPeeringConnectionInput(v *CreateVpcPeeringConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVpcPeeringConnectionInput"}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if v.PeerVpcAwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PeerVpcAwsAccountId"))
	}
	if v.PeerVpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PeerVpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpDeleteVpcPeeringAuthorizationInput(v *DeleteVpcPeeringAuthorizationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVpcPeeringAuthorizationInput"}
	if v.GameLiftAwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GameLiftAwsAccountId"))
	}
	if v.PeerVpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PeerVpcId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeregisterGameServerInput(v *DeregisterGameServerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeregisterGameServerInput"}
	if v.GameServerGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
	}
	if v.GameServerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GameServerId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpDescribeGameServerInput(v *DescribeGameServerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeGameServerInput"}
	if v.GameServerGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
	}
	if v.GameServerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GameServerId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpListGameServersInput(v *ListGameServersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListGameServersInput"}
	if v.GameServerGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
	}
	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 validateOpPutScalingPolicyInput(v *PutScalingPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutScalingPolicyInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if len(v.MetricName) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
	}
	if v.TargetConfiguration != nil {
		if err := validateTargetConfiguration(v.TargetConfiguration); err != nil {
			invalidParams.AddNested("TargetConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpRegisterGameServerInput(v *RegisterGameServerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterGameServerInput"}
	if v.GameServerGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
	}
	if v.GameServerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GameServerId"))
	}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpResumeGameServerGroupInput(v *ResumeGameServerGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResumeGameServerGroupInput"}
	if v.GameServerGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
	}
	if v.ResumeActions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResumeActions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpStartGameSessionPlacementInput(v *StartGameSessionPlacementInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartGameSessionPlacementInput"}
	if v.PlacementId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PlacementId"))
	}
	if v.GameSessionQueueName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GameSessionQueueName"))
	}
	if v.GameProperties != nil {
		if err := validateGamePropertyList(v.GameProperties); err != nil {
			invalidParams.AddNested("GameProperties", err.(smithy.InvalidParamsError))
		}
	}
	if v.MaximumPlayerSessionCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaximumPlayerSessionCount"))
	}
	if v.PriorityConfigurationOverride != nil {
		if err := validatePriorityConfigurationOverride(v.PriorityConfigurationOverride); err != nil {
			invalidParams.AddNested("PriorityConfigurationOverride", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartMatchBackfillInput(v *StartMatchBackfillInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartMatchBackfillInput"}
	if v.ConfigurationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationName"))
	}
	if v.Players == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Players"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartMatchmakingInput(v *StartMatchmakingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartMatchmakingInput"}
	if v.ConfigurationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationName"))
	}
	if v.Players == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Players"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpSuspendGameServerGroupInput(v *SuspendGameServerGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SuspendGameServerGroupInput"}
	if v.GameServerGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
	}
	if v.SuspendActions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SuspendActions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpTerminateGameSessionInput(v *TerminateGameSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TerminateGameSessionInput"}
	if v.GameSessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GameSessionId"))
	}
	if len(v.TerminationMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TerminationMode"))
	}
	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 validateOpUpdateAliasInput(v *UpdateAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAliasInput"}
	if v.AliasId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AliasId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateContainerFleetInput(v *UpdateContainerFleetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateContainerFleetInput"}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if v.InstanceConnectionPortRange != nil {
		if err := validateConnectionPortRange(v.InstanceConnectionPortRange); err != nil {
			invalidParams.AddNested("InstanceConnectionPortRange", err.(smithy.InvalidParamsError))
		}
	}
	if v.InstanceInboundPermissionAuthorizations != nil {
		if err := validateIpPermissionsList(v.InstanceInboundPermissionAuthorizations); err != nil {
			invalidParams.AddNested("InstanceInboundPermissionAuthorizations", err.(smithy.InvalidParamsError))
		}
	}
	if v.InstanceInboundPermissionRevocations != nil {
		if err := validateIpPermissionsList(v.InstanceInboundPermissionRevocations); err != nil {
			invalidParams.AddNested("InstanceInboundPermissionRevocations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateContainerGroupDefinitionInput(v *UpdateContainerGroupDefinitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateContainerGroupDefinitionInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.GameServerContainerDefinition != nil {
		if err := validateGameServerContainerDefinitionInput(v.GameServerContainerDefinition); err != nil {
			invalidParams.AddNested("GameServerContainerDefinition", err.(smithy.InvalidParamsError))
		}
	}
	if v.SupportContainerDefinitions != nil {
		if err := validateSupportContainerDefinitionInputList(v.SupportContainerDefinitions); err != nil {
			invalidParams.AddNested("SupportContainerDefinitions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateFleetAttributesInput(v *UpdateFleetAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFleetAttributesInput"}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if v.AnywhereConfiguration != nil {
		if err := validateAnywhereConfiguration(v.AnywhereConfiguration); err != nil {
			invalidParams.AddNested("AnywhereConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateFleetPortSettingsInput(v *UpdateFleetPortSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFleetPortSettingsInput"}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if v.InboundPermissionAuthorizations != nil {
		if err := validateIpPermissionsList(v.InboundPermissionAuthorizations); err != nil {
			invalidParams.AddNested("InboundPermissionAuthorizations", err.(smithy.InvalidParamsError))
		}
	}
	if v.InboundPermissionRevocations != nil {
		if err := validateIpPermissionsList(v.InboundPermissionRevocations); err != nil {
			invalidParams.AddNested("InboundPermissionRevocations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateGameServerGroupInput(v *UpdateGameServerGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateGameServerGroupInput"}
	if v.GameServerGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
	}
	if v.InstanceDefinitions != nil {
		if err := validateInstanceDefinitions(v.InstanceDefinitions); err != nil {
			invalidParams.AddNested("InstanceDefinitions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateGameServerInput(v *UpdateGameServerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateGameServerInput"}
	if v.GameServerGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GameServerGroupName"))
	}
	if v.GameServerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GameServerId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateGameSessionInput(v *UpdateGameSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateGameSessionInput"}
	if v.GameSessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GameSessionId"))
	}
	if v.GameProperties != nil {
		if err := validateGamePropertyList(v.GameProperties); err != nil {
			invalidParams.AddNested("GameProperties", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateMatchmakingConfigurationInput(v *UpdateMatchmakingConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateMatchmakingConfigurationInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.GameProperties != nil {
		if err := validateGamePropertyList(v.GameProperties); err != nil {
			invalidParams.AddNested("GameProperties", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRuntimeConfigurationInput(v *UpdateRuntimeConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRuntimeConfigurationInput"}
	if v.FleetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetId"))
	}
	if v.RuntimeConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuntimeConfiguration"))
	} else if v.RuntimeConfiguration != nil {
		if err := validateRuntimeConfiguration(v.RuntimeConfiguration); err != nil {
			invalidParams.AddNested("RuntimeConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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