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

package nimble

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

type validateOpAcceptEulas struct {
}

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

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

type validateOpCreateLaunchProfile struct {
}

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

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

type validateOpCreateStreamingImage struct {
}

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

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

type validateOpCreateStreamingSession struct {
}

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

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

type validateOpCreateStreamingSessionStream struct {
}

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

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

type validateOpCreateStudioComponent struct {
}

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

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

type validateOpCreateStudio struct {
}

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

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

type validateOpDeleteLaunchProfile struct {
}

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

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

type validateOpDeleteLaunchProfileMember struct {
}

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

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

type validateOpDeleteStreamingImage struct {
}

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

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

type validateOpDeleteStreamingSession struct {
}

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

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

type validateOpDeleteStudioComponent struct {
}

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

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

type validateOpDeleteStudio struct {
}

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

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

type validateOpDeleteStudioMember struct {
}

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

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

type validateOpGetEula struct {
}

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

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

type validateOpGetLaunchProfileDetails struct {
}

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

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

type validateOpGetLaunchProfileInitialization struct {
}

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

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

type validateOpGetLaunchProfile struct {
}

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

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

type validateOpGetLaunchProfileMember struct {
}

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

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

type validateOpGetStreamingImage struct {
}

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

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

type validateOpGetStreamingSessionBackup struct {
}

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

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

type validateOpGetStreamingSession struct {
}

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

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

type validateOpGetStreamingSessionStream struct {
}

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

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

type validateOpGetStudioComponent struct {
}

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

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

type validateOpGetStudio struct {
}

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

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

type validateOpGetStudioMember struct {
}

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

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

type validateOpListEulaAcceptances struct {
}

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

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

type validateOpListLaunchProfileMembers struct {
}

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

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

type validateOpListLaunchProfiles struct {
}

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

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

type validateOpListStreamingImages struct {
}

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

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

type validateOpListStreamingSessionBackups struct {
}

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

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

type validateOpListStreamingSessions struct {
}

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

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

type validateOpListStudioComponents struct {
}

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

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

type validateOpListStudioMembers struct {
}

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

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

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

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

type validateOpPutStudioMembers struct {
}

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

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

type validateOpStartStreamingSession struct {
}

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

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

type validateOpStartStudioSSOConfigurationRepair struct {
}

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

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

type validateOpStopStreamingSession struct {
}

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

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

type validateOpTagResource struct {
}

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

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

type validateOpUntagResource struct {
}

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

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

type validateOpUpdateLaunchProfile struct {
}

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

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

type validateOpUpdateLaunchProfileMember struct {
}

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

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

type validateOpUpdateStreamingImage struct {
}

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

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

type validateOpUpdateStudioComponent struct {
}

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

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

type validateOpUpdateStudio struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateNewLaunchProfileMember(v *types.NewLaunchProfileMember) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NewLaunchProfileMember"}
	if len(v.Persona) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Persona"))
	}
	if v.PrincipalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateNewStudioMember(v *types.NewStudioMember) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NewStudioMember"}
	if len(v.Persona) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Persona"))
	}
	if v.PrincipalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateStreamConfigurationCreate(v *types.StreamConfigurationCreate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StreamConfigurationCreate"}
	if len(v.ClipboardMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ClipboardMode"))
	}
	if v.Ec2InstanceTypes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Ec2InstanceTypes"))
	}
	if v.StreamingImageIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StreamingImageIds"))
	}
	if v.SessionStorage != nil {
		if err := validateStreamConfigurationSessionStorage(v.SessionStorage); err != nil {
			invalidParams.AddNested("SessionStorage", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpCreateLaunchProfileInput(v *CreateLaunchProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLaunchProfileInput"}
	if v.Ec2SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Ec2SubnetIds"))
	}
	if v.LaunchProfileProtocolVersions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchProfileProtocolVersions"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.StreamConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StreamConfiguration"))
	} else if v.StreamConfiguration != nil {
		if err := validateStreamConfigurationCreate(v.StreamConfiguration); err != nil {
			invalidParams.AddNested("StreamConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.StudioComponentIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioComponentIds"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateStreamingSessionInput(v *CreateStreamingSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateStreamingSessionInput"}
	if v.LaunchProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchProfileId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateStreamingSessionStreamInput(v *CreateStreamingSessionStreamInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateStreamingSessionStreamInput"}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateStudioInput(v *CreateStudioInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateStudioInput"}
	if v.AdminRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AdminRoleArn"))
	}
	if v.DisplayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DisplayName"))
	}
	if v.StudioEncryptionConfiguration != nil {
		if err := validateStudioEncryptionConfiguration(v.StudioEncryptionConfiguration); err != nil {
			invalidParams.AddNested("StudioEncryptionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.StudioName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioName"))
	}
	if v.UserRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserRoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteLaunchProfileInput(v *DeleteLaunchProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteLaunchProfileInput"}
	if v.LaunchProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchProfileId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteLaunchProfileMemberInput(v *DeleteLaunchProfileMemberInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteLaunchProfileMemberInput"}
	if v.LaunchProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchProfileId"))
	}
	if v.PrincipalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteStreamingImageInput(v *DeleteStreamingImageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteStreamingImageInput"}
	if v.StreamingImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StreamingImageId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteStreamingSessionInput(v *DeleteStreamingSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteStreamingSessionInput"}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteStudioComponentInput(v *DeleteStudioComponentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteStudioComponentInput"}
	if v.StudioComponentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioComponentId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpGetLaunchProfileDetailsInput(v *GetLaunchProfileDetailsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetLaunchProfileDetailsInput"}
	if v.LaunchProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchProfileId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetLaunchProfileInitializationInput(v *GetLaunchProfileInitializationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetLaunchProfileInitializationInput"}
	if v.LaunchProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchProfileId"))
	}
	if v.LaunchProfileProtocolVersions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchProfileProtocolVersions"))
	}
	if v.LaunchPurpose == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchPurpose"))
	}
	if v.Platform == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Platform"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetLaunchProfileInput(v *GetLaunchProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetLaunchProfileInput"}
	if v.LaunchProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchProfileId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetLaunchProfileMemberInput(v *GetLaunchProfileMemberInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetLaunchProfileMemberInput"}
	if v.LaunchProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchProfileId"))
	}
	if v.PrincipalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetStreamingImageInput(v *GetStreamingImageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetStreamingImageInput"}
	if v.StreamingImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StreamingImageId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetStreamingSessionBackupInput(v *GetStreamingSessionBackupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetStreamingSessionBackupInput"}
	if v.BackupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetStreamingSessionInput(v *GetStreamingSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetStreamingSessionInput"}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetStreamingSessionStreamInput(v *GetStreamingSessionStreamInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetStreamingSessionStreamInput"}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if v.StreamId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StreamId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetStudioComponentInput(v *GetStudioComponentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetStudioComponentInput"}
	if v.StudioComponentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioComponentId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpListLaunchProfileMembersInput(v *ListLaunchProfileMembersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListLaunchProfileMembersInput"}
	if v.LaunchProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchProfileId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpListStudioMembersInput(v *ListStudioMembersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListStudioMembersInput"}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	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 validateOpPutLaunchProfileMembersInput(v *PutLaunchProfileMembersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutLaunchProfileMembersInput"}
	if v.IdentityStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdentityStoreId"))
	}
	if v.LaunchProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchProfileId"))
	}
	if v.Members == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Members"))
	} else if v.Members != nil {
		if err := validateNewLaunchProfileMemberList(v.Members); err != nil {
			invalidParams.AddNested("Members", err.(smithy.InvalidParamsError))
		}
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutStudioMembersInput(v *PutStudioMembersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutStudioMembersInput"}
	if v.IdentityStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdentityStoreId"))
	}
	if v.Members == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Members"))
	} else if v.Members != nil {
		if err := validateNewStudioMemberList(v.Members); err != nil {
			invalidParams.AddNested("Members", err.(smithy.InvalidParamsError))
		}
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartStreamingSessionInput(v *StartStreamingSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartStreamingSessionInput"}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpStopStreamingSessionInput(v *StopStreamingSessionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopStreamingSessionInput"}
	if v.SessionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SessionId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpUpdateLaunchProfileInput(v *UpdateLaunchProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateLaunchProfileInput"}
	if v.LaunchProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchProfileId"))
	}
	if v.StreamConfiguration != nil {
		if err := validateStreamConfigurationCreate(v.StreamConfiguration); err != nil {
			invalidParams.AddNested("StreamConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateLaunchProfileMemberInput(v *UpdateLaunchProfileMemberInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateLaunchProfileMemberInput"}
	if v.LaunchProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LaunchProfileId"))
	}
	if len(v.Persona) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Persona"))
	}
	if v.PrincipalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateStreamingImageInput(v *UpdateStreamingImageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateStreamingImageInput"}
	if v.StreamingImageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StreamingImageId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateStudioComponentInput(v *UpdateStudioComponentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateStudioComponentInput"}
	if v.StudioComponentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioComponentId"))
	}
	if v.StudioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StudioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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