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

package workspacesweb

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

type validateOpAssociateBrowserSettings struct {
}

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

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

type validateOpAssociateIpAccessSettings struct {
}

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

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

type validateOpAssociateNetworkSettings struct {
}

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

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

type validateOpAssociateTrustStore struct {
}

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

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

type validateOpAssociateUserAccessLoggingSettings struct {
}

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

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

type validateOpAssociateUserSettings struct {
}

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

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

type validateOpCreateBrowserSettings struct {
}

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

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

type validateOpCreateIdentityProvider struct {
}

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

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

type validateOpCreateIpAccessSettings struct {
}

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

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

type validateOpCreateNetworkSettings struct {
}

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

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

type validateOpCreatePortal struct {
}

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

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

type validateOpCreateTrustStore struct {
}

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

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

type validateOpCreateUserAccessLoggingSettings struct {
}

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

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

type validateOpCreateUserSettings struct {
}

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

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

type validateOpDeleteBrowserSettings struct {
}

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

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

type validateOpDeleteIdentityProvider struct {
}

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

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

type validateOpDeleteIpAccessSettings struct {
}

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

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

type validateOpDeleteNetworkSettings struct {
}

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

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

type validateOpDeletePortal struct {
}

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

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

type validateOpDeleteTrustStore struct {
}

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

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

type validateOpDeleteUserAccessLoggingSettings struct {
}

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

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

type validateOpDeleteUserSettings struct {
}

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

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

type validateOpDisassociateBrowserSettings struct {
}

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

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

type validateOpDisassociateIpAccessSettings struct {
}

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

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

type validateOpDisassociateNetworkSettings struct {
}

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

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

type validateOpDisassociateTrustStore struct {
}

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

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

type validateOpDisassociateUserAccessLoggingSettings struct {
}

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

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

type validateOpDisassociateUserSettings struct {
}

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

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

type validateOpGetBrowserSettings struct {
}

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

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

type validateOpGetIdentityProvider struct {
}

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

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

type validateOpGetIpAccessSettings struct {
}

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

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

type validateOpGetNetworkSettings struct {
}

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

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

type validateOpGetPortal struct {
}

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

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

type validateOpGetPortalServiceProviderMetadata struct {
}

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

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

type validateOpGetTrustStoreCertificate struct {
}

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

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

type validateOpGetTrustStore struct {
}

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

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

type validateOpGetUserAccessLoggingSettings struct {
}

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

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

type validateOpGetUserSettings struct {
}

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

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

type validateOpListIdentityProviders struct {
}

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

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

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

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

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

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

type validateOpUpdateIdentityProvider struct {
}

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

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

type validateOpUpdateIpAccessSettings struct {
}

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

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

type validateOpUpdateNetworkSettings struct {
}

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

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

type validateOpUpdatePortal struct {
}

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

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

type validateOpUpdateTrustStore struct {
}

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

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

type validateOpUpdateUserAccessLoggingSettings struct {
}

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

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

type validateOpUpdateUserSettings struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpListTrustStoreCertificatesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListTrustStoreCertificates{}, 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 addOpUpdateBrowserSettingsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateBrowserSettings{}, middleware.After)
}

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

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

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

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

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

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

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

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

func validateIpRuleList(v []types.IpRule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IpRuleList"}
	for i := range v {
		if err := validateIpRule(&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 validateOpAssociateBrowserSettingsInput(v *AssociateBrowserSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateBrowserSettingsInput"}
	if v.PortalArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortalArn"))
	}
	if v.BrowserSettingsArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BrowserSettingsArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateIpAccessSettingsInput(v *AssociateIpAccessSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateIpAccessSettingsInput"}
	if v.PortalArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortalArn"))
	}
	if v.IpAccessSettingsArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpAccessSettingsArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateNetworkSettingsInput(v *AssociateNetworkSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateNetworkSettingsInput"}
	if v.PortalArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortalArn"))
	}
	if v.NetworkSettingsArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkSettingsArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateTrustStoreInput(v *AssociateTrustStoreInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateTrustStoreInput"}
	if v.PortalArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortalArn"))
	}
	if v.TrustStoreArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrustStoreArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateUserAccessLoggingSettingsInput(v *AssociateUserAccessLoggingSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateUserAccessLoggingSettingsInput"}
	if v.PortalArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortalArn"))
	}
	if v.UserAccessLoggingSettingsArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserAccessLoggingSettingsArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateUserSettingsInput(v *AssociateUserSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateUserSettingsInput"}
	if v.PortalArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortalArn"))
	}
	if v.UserSettingsArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserSettingsArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateIdentityProviderInput(v *CreateIdentityProviderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateIdentityProviderInput"}
	if v.PortalArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortalArn"))
	}
	if v.IdentityProviderName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdentityProviderName"))
	}
	if len(v.IdentityProviderType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("IdentityProviderType"))
	}
	if v.IdentityProviderDetails == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdentityProviderDetails"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateNetworkSettingsInput(v *CreateNetworkSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateNetworkSettingsInput"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if v.SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
	}
	if v.SecurityGroupIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupIds"))
	}
	if 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 validateOpCreatePortalInput(v *CreatePortalInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePortalInput"}
	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 validateOpCreateTrustStoreInput(v *CreateTrustStoreInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTrustStoreInput"}
	if v.CertificateList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CertificateList"))
	}
	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 validateOpCreateUserAccessLoggingSettingsInput(v *CreateUserAccessLoggingSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateUserAccessLoggingSettingsInput"}
	if v.KinesisStreamArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KinesisStreamArn"))
	}
	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 validateOpCreateUserSettingsInput(v *CreateUserSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateUserSettingsInput"}
	if len(v.CopyAllowed) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("CopyAllowed"))
	}
	if len(v.PasteAllowed) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PasteAllowed"))
	}
	if len(v.DownloadAllowed) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DownloadAllowed"))
	}
	if len(v.UploadAllowed) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("UploadAllowed"))
	}
	if len(v.PrintAllowed) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PrintAllowed"))
	}
	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 validateOpDeleteBrowserSettingsInput(v *DeleteBrowserSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteBrowserSettingsInput"}
	if v.BrowserSettingsArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BrowserSettingsArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpGetTrustStoreCertificateInput(v *GetTrustStoreCertificateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTrustStoreCertificateInput"}
	if v.TrustStoreArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrustStoreArn"))
	}
	if v.Thumbprint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Thumbprint"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpListIdentityProvidersInput(v *ListIdentityProvidersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListIdentityProvidersInput"}
	if v.PortalArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortalArn"))
	}
	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 validateOpListTrustStoreCertificatesInput(v *ListTrustStoreCertificatesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTrustStoreCertificatesInput"}
	if v.TrustStoreArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrustStoreArn"))
	}
	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 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 validateOpUpdateBrowserSettingsInput(v *UpdateBrowserSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateBrowserSettingsInput"}
	if v.BrowserSettingsArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BrowserSettingsArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateIpAccessSettingsInput(v *UpdateIpAccessSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateIpAccessSettingsInput"}
	if v.IpAccessSettingsArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpAccessSettingsArn"))
	}
	if v.IpRules != nil {
		if err := validateIpRuleList(v.IpRules); err != nil {
			invalidParams.AddNested("IpRules", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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