validators.go

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

package quicksight

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

type validateOpCancelIngestion struct {
}

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

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

type validateOpCreateAccountCustomization struct {
}

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

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

type validateOpCreateAccountSubscription struct {
}

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

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

type validateOpCreateAnalysis struct {
}

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

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

type validateOpCreateDashboard struct {
}

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

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

type validateOpCreateDataSet struct {
}

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

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

type validateOpCreateDataSource struct {
}

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

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

type validateOpCreateFolder struct {
}

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

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

type validateOpCreateFolderMembership struct {
}

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

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

type validateOpCreateGroup struct {
}

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

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

type validateOpCreateGroupMembership struct {
}

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

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

type validateOpCreateIAMPolicyAssignment struct {
}

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

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

type validateOpCreateIngestion struct {
}

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

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

type validateOpCreateNamespace struct {
}

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

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

type validateOpCreateTemplateAlias struct {
}

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

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

type validateOpCreateTemplate struct {
}

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

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

type validateOpCreateThemeAlias struct {
}

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

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

type validateOpCreateTheme struct {
}

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

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

type validateOpDeleteAccountCustomization struct {
}

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

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

type validateOpDeleteAnalysis struct {
}

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

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

type validateOpDeleteDashboard struct {
}

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

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

type validateOpDeleteDataSet struct {
}

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

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

type validateOpDeleteDataSource struct {
}

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

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

type validateOpDeleteFolder struct {
}

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

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

type validateOpDeleteFolderMembership struct {
}

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

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

type validateOpDeleteGroup struct {
}

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

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

type validateOpDeleteGroupMembership struct {
}

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

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

type validateOpDeleteIAMPolicyAssignment struct {
}

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

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

type validateOpDeleteNamespace struct {
}

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

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

type validateOpDeleteTemplateAlias struct {
}

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

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

type validateOpDeleteTemplate struct {
}

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

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

type validateOpDeleteThemeAlias struct {
}

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

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

type validateOpDeleteTheme struct {
}

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

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

type validateOpDeleteUserByPrincipalId struct {
}

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

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

type validateOpDeleteUser struct {
}

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

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

type validateOpDescribeAccountCustomization struct {
}

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

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

type validateOpDescribeAccountSettings struct {
}

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

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

type validateOpDescribeAccountSubscription struct {
}

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

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

type validateOpDescribeAnalysis struct {
}

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

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

type validateOpDescribeAnalysisPermissions struct {
}

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

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

type validateOpDescribeDashboard struct {
}

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

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

type validateOpDescribeDashboardPermissions struct {
}

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

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

type validateOpDescribeDataSet struct {
}

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

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

type validateOpDescribeDataSetPermissions struct {
}

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

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

type validateOpDescribeDataSource struct {
}

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

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

type validateOpDescribeDataSourcePermissions struct {
}

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

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

type validateOpDescribeFolder struct {
}

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

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

type validateOpDescribeFolderPermissions struct {
}

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

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

type validateOpDescribeFolderResolvedPermissions struct {
}

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

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

type validateOpDescribeGroup struct {
}

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

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

type validateOpDescribeGroupMembership struct {
}

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

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

type validateOpDescribeIAMPolicyAssignment struct {
}

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

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

type validateOpDescribeIngestion struct {
}

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

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

type validateOpDescribeIpRestriction struct {
}

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

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

type validateOpDescribeNamespace struct {
}

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

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

type validateOpDescribeTemplateAlias struct {
}

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

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

type validateOpDescribeTemplate struct {
}

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

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

type validateOpDescribeTemplatePermissions struct {
}

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

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

type validateOpDescribeThemeAlias struct {
}

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

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

type validateOpDescribeTheme struct {
}

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

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

type validateOpDescribeThemePermissions struct {
}

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

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

type validateOpDescribeUser struct {
}

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

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

type validateOpGenerateEmbedUrlForAnonymousUser struct {
}

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

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

type validateOpGenerateEmbedUrlForRegisteredUser struct {
}

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

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

type validateOpGetDashboardEmbedUrl struct {
}

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

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

type validateOpGetSessionEmbedUrl struct {
}

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

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

type validateOpListAnalyses struct {
}

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

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

type validateOpListDashboards struct {
}

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

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

type validateOpListDashboardVersions struct {
}

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

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

type validateOpListDataSets struct {
}

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

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

type validateOpListDataSources struct {
}

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

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

type validateOpListFolderMembers struct {
}

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

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

type validateOpListFolders struct {
}

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

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

type validateOpListGroupMemberships struct {
}

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

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

type validateOpListGroups struct {
}

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

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

type validateOpListIAMPolicyAssignmentsForUser struct {
}

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

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

type validateOpListIAMPolicyAssignments struct {
}

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

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

type validateOpListIngestions struct {
}

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

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

type validateOpListNamespaces struct {
}

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

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

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

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

type validateOpListTemplates struct {
}

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

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

type validateOpListTemplateVersions struct {
}

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

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

type validateOpListThemeAliases struct {
}

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

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

type validateOpListThemes struct {
}

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

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

type validateOpListThemeVersions struct {
}

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

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

type validateOpListUserGroups struct {
}

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

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

type validateOpListUsers struct {
}

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

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

type validateOpRegisterUser struct {
}

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

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

type validateOpRestoreAnalysis struct {
}

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

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

type validateOpSearchAnalyses struct {
}

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

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

type validateOpSearchDashboards struct {
}

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

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

type validateOpSearchFolders struct {
}

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

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

type validateOpSearchGroups struct {
}

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

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

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

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

type validateOpUpdateAccountSettings struct {
}

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

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

type validateOpUpdateAnalysis struct {
}

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

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

type validateOpUpdateAnalysisPermissions struct {
}

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

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

type validateOpUpdateDashboard struct {
}

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

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

type validateOpUpdateDashboardPermissions struct {
}

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

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

type validateOpUpdateDashboardPublishedVersion struct {
}

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

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

type validateOpUpdateDataSet struct {
}

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

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

type validateOpUpdateDataSetPermissions struct {
}

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

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

type validateOpUpdateDataSource struct {
}

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

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

type validateOpUpdateDataSourcePermissions struct {
}

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

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

type validateOpUpdateFolder struct {
}

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

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

type validateOpUpdateFolderPermissions struct {
}

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

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

type validateOpUpdateGroup struct {
}

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

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

type validateOpUpdateIAMPolicyAssignment struct {
}

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

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

type validateOpUpdateIpRestriction struct {
}

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

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

type validateOpUpdatePublicSharingSettings struct {
}

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

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

type validateOpUpdateTemplateAlias struct {
}

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

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

type validateOpUpdateTemplate struct {
}

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

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

type validateOpUpdateTemplatePermissions struct {
}

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

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

type validateOpUpdateThemeAlias struct {
}

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

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

type validateOpUpdateTheme struct {
}

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

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

type validateOpUpdateThemePermissions struct {
}

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

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

type validateOpUpdateUser struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpSearchGroupsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSearchGroups{}, 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 addOpUpdateAccountCustomizationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateAccountCustomization{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateAnalysisSourceEntity(v *types.AnalysisSourceEntity) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AnalysisSourceEntity"}
	if v.SourceTemplate != nil {
		if err := validateAnalysisSourceTemplate(v.SourceTemplate); err != nil {
			invalidParams.AddNested("SourceTemplate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAnalysisSourceTemplate(v *types.AnalysisSourceTemplate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AnalysisSourceTemplate"}
	if v.DataSetReferences == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetReferences"))
	} else if v.DataSetReferences != nil {
		if err := validateDataSetReferenceList(v.DataSetReferences); err != nil {
			invalidParams.AddNested("DataSetReferences", err.(smithy.InvalidParamsError))
		}
	}
	if v.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateAnonymousUserDashboardVisualEmbeddingConfiguration(v *types.AnonymousUserDashboardVisualEmbeddingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AnonymousUserDashboardVisualEmbeddingConfiguration"}
	if v.InitialDashboardVisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InitialDashboardVisualId"))
	} else if v.InitialDashboardVisualId != nil {
		if err := validateDashboardVisualId(v.InitialDashboardVisualId); err != nil {
			invalidParams.AddNested("InitialDashboardVisualId", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAnonymousUserEmbeddingExperienceConfiguration(v *types.AnonymousUserEmbeddingExperienceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AnonymousUserEmbeddingExperienceConfiguration"}
	if v.Dashboard != nil {
		if err := validateAnonymousUserDashboardEmbeddingConfiguration(v.Dashboard); err != nil {
			invalidParams.AddNested("Dashboard", err.(smithy.InvalidParamsError))
		}
	}
	if v.DashboardVisual != nil {
		if err := validateAnonymousUserDashboardVisualEmbeddingConfiguration(v.DashboardVisual); err != nil {
			invalidParams.AddNested("DashboardVisual", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAuroraParameters(v *types.AuroraParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AuroraParameters"}
	if v.Host == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Host"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAuroraPostgreSqlParameters(v *types.AuroraPostgreSqlParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AuroraPostgreSqlParameters"}
	if v.Host == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Host"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCalculatedColumn(v *types.CalculatedColumn) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CalculatedColumn"}
	if v.ColumnName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnName"))
	}
	if v.ColumnId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnId"))
	}
	if v.Expression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCastColumnTypeOperation(v *types.CastColumnTypeOperation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CastColumnTypeOperation"}
	if v.ColumnName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnName"))
	}
	if len(v.NewColumnType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("NewColumnType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateColumnGroup(v *types.ColumnGroup) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ColumnGroup"}
	if v.GeoSpatialColumnGroup != nil {
		if err := validateGeoSpatialColumnGroup(v.GeoSpatialColumnGroup); err != nil {
			invalidParams.AddNested("GeoSpatialColumnGroup", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCreateColumnsOperation(v *types.CreateColumnsOperation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateColumnsOperation"}
	if v.Columns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Columns"))
	} else if v.Columns != nil {
		if err := validateCalculatedColumnList(v.Columns); err != nil {
			invalidParams.AddNested("Columns", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCredentialPair(v *types.CredentialPair) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CredentialPair"}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if v.Password == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Password"))
	}
	if v.AlternateDataSourceParameters != nil {
		if err := validateDataSourceParametersList(v.AlternateDataSourceParameters); err != nil {
			invalidParams.AddNested("AlternateDataSourceParameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomSql(v *types.CustomSql) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomSql"}
	if v.DataSourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceArn"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.SqlQuery == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SqlQuery"))
	}
	if v.Columns != nil {
		if err := validateInputColumnList(v.Columns); err != nil {
			invalidParams.AddNested("Columns", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateDashboardSourceEntity(v *types.DashboardSourceEntity) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DashboardSourceEntity"}
	if v.SourceTemplate != nil {
		if err := validateDashboardSourceTemplate(v.SourceTemplate); err != nil {
			invalidParams.AddNested("SourceTemplate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDashboardSourceTemplate(v *types.DashboardSourceTemplate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DashboardSourceTemplate"}
	if v.DataSetReferences == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetReferences"))
	} else if v.DataSetReferences != nil {
		if err := validateDataSetReferenceList(v.DataSetReferences); err != nil {
			invalidParams.AddNested("DataSetReferences", err.(smithy.InvalidParamsError))
		}
	}
	if v.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDashboardVisualId(v *types.DashboardVisualId) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DashboardVisualId"}
	if v.DashboardId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
	}
	if v.SheetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SheetId"))
	}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDataSetReference(v *types.DataSetReference) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataSetReference"}
	if v.DataSetPlaceholder == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetPlaceholder"))
	}
	if v.DataSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDataSourceCredentials(v *types.DataSourceCredentials) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataSourceCredentials"}
	if v.CredentialPair != nil {
		if err := validateCredentialPair(v.CredentialPair); err != nil {
			invalidParams.AddNested("CredentialPair", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDataSourceParameters(v types.DataSourceParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataSourceParameters"}
	switch uv := v.(type) {
	case *types.DataSourceParametersMemberAmazonElasticsearchParameters:
		if err := validateAmazonElasticsearchParameters(&uv.Value); err != nil {
			invalidParams.AddNested("[AmazonElasticsearchParameters]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateLogicalTable(v *types.LogicalTable) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LogicalTable"}
	if v.Alias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Alias"))
	}
	if v.DataTransforms != nil {
		if err := validateTransformOperationList(v.DataTransforms); err != nil {
			invalidParams.AddNested("DataTransforms", err.(smithy.InvalidParamsError))
		}
	}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	} else if v.Source != nil {
		if err := validateLogicalTableSource(v.Source); err != nil {
			invalidParams.AddNested("Source", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLogicalTableMap(v map[string]types.LogicalTable) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LogicalTableMap"}
	for key := range v {
		value := v[key]
		if err := validateLogicalTable(&value); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLogicalTableSource(v *types.LogicalTableSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LogicalTableSource"}
	if v.JoinInstruction != nil {
		if err := validateJoinInstruction(v.JoinInstruction); err != nil {
			invalidParams.AddNested("JoinInstruction", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateMariaDbParameters(v *types.MariaDbParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MariaDbParameters"}
	if v.Host == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Host"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMySqlParameters(v *types.MySqlParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MySqlParameters"}
	if v.Host == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Host"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOracleParameters(v *types.OracleParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OracleParameters"}
	if v.Host == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Host"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateParameters(v *types.Parameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Parameters"}
	if v.StringParameters != nil {
		if err := validateStringParameterList(v.StringParameters); err != nil {
			invalidParams.AddNested("StringParameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.IntegerParameters != nil {
		if err := validateIntegerParameterList(v.IntegerParameters); err != nil {
			invalidParams.AddNested("IntegerParameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.DecimalParameters != nil {
		if err := validateDecimalParameterList(v.DecimalParameters); err != nil {
			invalidParams.AddNested("DecimalParameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.DateTimeParameters != nil {
		if err := validateDateTimeParameterList(v.DateTimeParameters); err != nil {
			invalidParams.AddNested("DateTimeParameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePhysicalTable(v types.PhysicalTable) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PhysicalTable"}
	switch uv := v.(type) {
	case *types.PhysicalTableMemberCustomSql:
		if err := validateCustomSql(&uv.Value); err != nil {
			invalidParams.AddNested("[CustomSql]", err.(smithy.InvalidParamsError))
		}

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

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

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

func validatePhysicalTableMap(v map[string]types.PhysicalTable) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PhysicalTableMap"}
	for key := range v {
		if err := validatePhysicalTable(v[key]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePostgreSqlParameters(v *types.PostgreSqlParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PostgreSqlParameters"}
	if v.Host == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Host"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePrestoParameters(v *types.PrestoParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PrestoParameters"}
	if v.Host == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Host"))
	}
	if v.Catalog == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Catalog"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRdsParameters(v *types.RdsParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RdsParameters"}
	if v.InstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceId"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateRegisteredUserDashboardVisualEmbeddingConfiguration(v *types.RegisteredUserDashboardVisualEmbeddingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisteredUserDashboardVisualEmbeddingConfiguration"}
	if v.InitialDashboardVisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InitialDashboardVisualId"))
	} else if v.InitialDashboardVisualId != nil {
		if err := validateDashboardVisualId(v.InitialDashboardVisualId); err != nil {
			invalidParams.AddNested("InitialDashboardVisualId", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRegisteredUserEmbeddingExperienceConfiguration(v *types.RegisteredUserEmbeddingExperienceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisteredUserEmbeddingExperienceConfiguration"}
	if v.Dashboard != nil {
		if err := validateRegisteredUserDashboardEmbeddingConfiguration(v.Dashboard); err != nil {
			invalidParams.AddNested("Dashboard", err.(smithy.InvalidParamsError))
		}
	}
	if v.DashboardVisual != nil {
		if err := validateRegisteredUserDashboardVisualEmbeddingConfiguration(v.DashboardVisual); err != nil {
			invalidParams.AddNested("DashboardVisual", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRelationalTable(v *types.RelationalTable) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RelationalTable"}
	if v.DataSourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceArn"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.InputColumns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputColumns"))
	} else if v.InputColumns != nil {
		if err := validateInputColumnList(v.InputColumns); err != nil {
			invalidParams.AddNested("InputColumns", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRenameColumnOperation(v *types.RenameColumnOperation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RenameColumnOperation"}
	if v.ColumnName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnName"))
	}
	if v.NewColumnName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NewColumnName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResourcePermission(v *types.ResourcePermission) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResourcePermission"}
	if v.Principal == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Principal"))
	}
	if v.Actions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Actions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRowLevelPermissionDataSet(v *types.RowLevelPermissionDataSet) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RowLevelPermissionDataSet"}
	if v.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	if len(v.PermissionPolicy) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionPolicy"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRowLevelPermissionTagConfiguration(v *types.RowLevelPermissionTagConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RowLevelPermissionTagConfiguration"}
	if v.TagRules == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagRules"))
	} else if v.TagRules != nil {
		if err := validateRowLevelPermissionTagRuleList(v.TagRules); err != nil {
			invalidParams.AddNested("TagRules", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRowLevelPermissionTagRule(v *types.RowLevelPermissionTagRule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RowLevelPermissionTagRule"}
	if v.TagKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKey"))
	}
	if v.ColumnName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateS3Parameters(v *types.S3Parameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3Parameters"}
	if v.ManifestFileLocation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ManifestFileLocation"))
	} else if v.ManifestFileLocation != nil {
		if err := validateManifestFileLocation(v.ManifestFileLocation); err != nil {
			invalidParams.AddNested("ManifestFileLocation", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3Source(v *types.S3Source) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3Source"}
	if v.DataSourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceArn"))
	}
	if v.InputColumns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputColumns"))
	} else if v.InputColumns != nil {
		if err := validateInputColumnList(v.InputColumns); err != nil {
			invalidParams.AddNested("InputColumns", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateSnowflakeParameters(v *types.SnowflakeParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SnowflakeParameters"}
	if v.Host == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Host"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if v.Warehouse == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Warehouse"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSqlServerParameters(v *types.SqlServerParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SqlServerParameters"}
	if v.Host == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Host"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateStringParameterList(v []types.StringParameter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StringParameterList"}
	for i := range v {
		if err := validateStringParameter(&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 validateTagColumnOperation(v *types.TagColumnOperation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagColumnOperation"}
	if v.ColumnName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnName"))
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	}
	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 validateTemplateSourceAnalysis(v *types.TemplateSourceAnalysis) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TemplateSourceAnalysis"}
	if v.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	if v.DataSetReferences == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetReferences"))
	} else if v.DataSetReferences != nil {
		if err := validateDataSetReferenceList(v.DataSetReferences); err != nil {
			invalidParams.AddNested("DataSetReferences", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTemplateSourceEntity(v *types.TemplateSourceEntity) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TemplateSourceEntity"}
	if v.SourceAnalysis != nil {
		if err := validateTemplateSourceAnalysis(v.SourceAnalysis); err != nil {
			invalidParams.AddNested("SourceAnalysis", err.(smithy.InvalidParamsError))
		}
	}
	if v.SourceTemplate != nil {
		if err := validateTemplateSourceTemplate(v.SourceTemplate); err != nil {
			invalidParams.AddNested("SourceTemplate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTeradataParameters(v *types.TeradataParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TeradataParameters"}
	if v.Host == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Host"))
	}
	if v.Database == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Database"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTransformOperation(v types.TransformOperation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TransformOperation"}
	switch uv := v.(type) {
	case *types.TransformOperationMemberCastColumnTypeOperation:
		if err := validateCastColumnTypeOperation(&uv.Value); err != nil {
			invalidParams.AddNested("[CastColumnTypeOperation]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

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

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

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

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

func validateUntagColumnOperation(v *types.UntagColumnOperation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UntagColumnOperation"}
	if v.ColumnName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnName"))
	}
	if v.TagNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpCancelIngestionInput(v *CancelIngestionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelIngestionInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DataSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
	}
	if v.IngestionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IngestionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAccountCustomizationInput(v *CreateAccountCustomizationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAccountCustomizationInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.AccountCustomization == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountCustomization"))
	}
	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 validateOpCreateAccountSubscriptionInput(v *CreateAccountSubscriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAccountSubscriptionInput"}
	if len(v.Edition) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Edition"))
	}
	if len(v.AuthenticationMethod) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AuthenticationMethod"))
	}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.AccountName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountName"))
	}
	if v.NotificationEmail == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NotificationEmail"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAnalysisInput(v *CreateAnalysisInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAnalysisInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.AnalysisId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Parameters != nil {
		if err := validateParameters(v.Parameters); err != nil {
			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.Permissions != nil {
		if err := validateResourcePermissionList(v.Permissions); err != nil {
			invalidParams.AddNested("Permissions", err.(smithy.InvalidParamsError))
		}
	}
	if v.SourceEntity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceEntity"))
	} else if v.SourceEntity != nil {
		if err := validateAnalysisSourceEntity(v.SourceEntity); err != nil {
			invalidParams.AddNested("SourceEntity", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDashboardInput(v *CreateDashboardInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDashboardInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DashboardId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Parameters != nil {
		if err := validateParameters(v.Parameters); err != nil {
			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.Permissions != nil {
		if err := validateResourcePermissionList(v.Permissions); err != nil {
			invalidParams.AddNested("Permissions", err.(smithy.InvalidParamsError))
		}
	}
	if v.SourceEntity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceEntity"))
	} else if v.SourceEntity != nil {
		if err := validateDashboardSourceEntity(v.SourceEntity); err != nil {
			invalidParams.AddNested("SourceEntity", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDataSetInput(v *CreateDataSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDataSetInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DataSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.PhysicalTableMap == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PhysicalTableMap"))
	} else if v.PhysicalTableMap != nil {
		if err := validatePhysicalTableMap(v.PhysicalTableMap); err != nil {
			invalidParams.AddNested("PhysicalTableMap", err.(smithy.InvalidParamsError))
		}
	}
	if v.LogicalTableMap != nil {
		if err := validateLogicalTableMap(v.LogicalTableMap); err != nil {
			invalidParams.AddNested("LogicalTableMap", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.ImportMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ImportMode"))
	}
	if v.ColumnGroups != nil {
		if err := validateColumnGroupList(v.ColumnGroups); err != nil {
			invalidParams.AddNested("ColumnGroups", err.(smithy.InvalidParamsError))
		}
	}
	if v.Permissions != nil {
		if err := validateResourcePermissionList(v.Permissions); err != nil {
			invalidParams.AddNested("Permissions", err.(smithy.InvalidParamsError))
		}
	}
	if v.RowLevelPermissionDataSet != nil {
		if err := validateRowLevelPermissionDataSet(v.RowLevelPermissionDataSet); err != nil {
			invalidParams.AddNested("RowLevelPermissionDataSet", err.(smithy.InvalidParamsError))
		}
	}
	if v.RowLevelPermissionTagConfiguration != nil {
		if err := validateRowLevelPermissionTagConfiguration(v.RowLevelPermissionTagConfiguration); err != nil {
			invalidParams.AddNested("RowLevelPermissionTagConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDataSourceInput(v *CreateDataSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDataSourceInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DataSourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.DataSourceParameters != nil {
		if err := validateDataSourceParameters(v.DataSourceParameters); err != nil {
			invalidParams.AddNested("DataSourceParameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.Credentials != nil {
		if err := validateDataSourceCredentials(v.Credentials); err != nil {
			invalidParams.AddNested("Credentials", err.(smithy.InvalidParamsError))
		}
	}
	if v.Permissions != nil {
		if err := validateResourcePermissionList(v.Permissions); err != nil {
			invalidParams.AddNested("Permissions", err.(smithy.InvalidParamsError))
		}
	}
	if v.VpcConnectionProperties != nil {
		if err := validateVpcConnectionProperties(v.VpcConnectionProperties); err != nil {
			invalidParams.AddNested("VpcConnectionProperties", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFolderInput(v *CreateFolderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFolderInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.FolderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FolderId"))
	}
	if v.Permissions != nil {
		if err := validateResourcePermissionList(v.Permissions); err != nil {
			invalidParams.AddNested("Permissions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFolderMembershipInput(v *CreateFolderMembershipInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFolderMembershipInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.FolderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FolderId"))
	}
	if v.MemberId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemberId"))
	}
	if len(v.MemberType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MemberType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateGroupInput(v *CreateGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateGroupInput"}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateGroupMembershipInput(v *CreateGroupMembershipInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateGroupMembershipInput"}
	if v.MemberName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemberName"))
	}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateIAMPolicyAssignmentInput(v *CreateIAMPolicyAssignmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateIAMPolicyAssignmentInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.AssignmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssignmentName"))
	}
	if len(v.AssignmentStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AssignmentStatus"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateIngestionInput(v *CreateIngestionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateIngestionInput"}
	if v.DataSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
	}
	if v.IngestionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IngestionId"))
	}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateNamespaceInput(v *CreateNamespaceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateNamespaceInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if len(v.IdentityStore) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("IdentityStore"))
	}
	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 validateOpCreateTemplateAliasInput(v *CreateTemplateAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTemplateAliasInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
	}
	if v.AliasName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AliasName"))
	}
	if v.TemplateVersionNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateVersionNumber"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTemplateInput(v *CreateTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTemplateInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
	}
	if v.Permissions != nil {
		if err := validateResourcePermissionList(v.Permissions); err != nil {
			invalidParams.AddNested("Permissions", err.(smithy.InvalidParamsError))
		}
	}
	if v.SourceEntity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceEntity"))
	} else if v.SourceEntity != nil {
		if err := validateTemplateSourceEntity(v.SourceEntity); err != nil {
			invalidParams.AddNested("SourceEntity", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateThemeAliasInput(v *CreateThemeAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateThemeAliasInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.ThemeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
	}
	if v.AliasName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AliasName"))
	}
	if v.ThemeVersionNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ThemeVersionNumber"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateThemeInput(v *CreateThemeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateThemeInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.ThemeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.BaseThemeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BaseThemeId"))
	}
	if v.Configuration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Configuration"))
	}
	if v.Permissions != nil {
		if err := validateResourcePermissionList(v.Permissions); err != nil {
			invalidParams.AddNested("Permissions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteAnalysisInput(v *DeleteAnalysisInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAnalysisInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.AnalysisId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteDashboardInput(v *DeleteDashboardInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDashboardInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DashboardId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteDataSetInput(v *DeleteDataSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDataSetInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DataSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteDataSourceInput(v *DeleteDataSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDataSourceInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DataSourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteFolderInput(v *DeleteFolderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteFolderInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.FolderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FolderId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteFolderMembershipInput(v *DeleteFolderMembershipInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteFolderMembershipInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.FolderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FolderId"))
	}
	if v.MemberId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemberId"))
	}
	if len(v.MemberType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MemberType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteGroupInput(v *DeleteGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteGroupInput"}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteGroupMembershipInput(v *DeleteGroupMembershipInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteGroupMembershipInput"}
	if v.MemberName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemberName"))
	}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteIAMPolicyAssignmentInput(v *DeleteIAMPolicyAssignmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIAMPolicyAssignmentInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.AssignmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssignmentName"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteTemplateAliasInput(v *DeleteTemplateAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTemplateAliasInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
	}
	if v.AliasName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AliasName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTemplateInput(v *DeleteTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTemplateInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteThemeAliasInput(v *DeleteThemeAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteThemeAliasInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.ThemeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
	}
	if v.AliasName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AliasName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteThemeInput(v *DeleteThemeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteThemeInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.ThemeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteUserByPrincipalIdInput(v *DeleteUserByPrincipalIdInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserByPrincipalIdInput"}
	if v.PrincipalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalId"))
	}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteUserInput(v *DeleteUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserInput"}
	if v.UserName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
	}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpDescribeAnalysisInput(v *DescribeAnalysisInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeAnalysisInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.AnalysisId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeAnalysisPermissionsInput(v *DescribeAnalysisPermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeAnalysisPermissionsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.AnalysisId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeDashboardInput(v *DescribeDashboardInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDashboardInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DashboardId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeDashboardPermissionsInput(v *DescribeDashboardPermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDashboardPermissionsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DashboardId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeDataSetInput(v *DescribeDataSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDataSetInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DataSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeDataSetPermissionsInput(v *DescribeDataSetPermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDataSetPermissionsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DataSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeDataSourceInput(v *DescribeDataSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDataSourceInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DataSourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeDataSourcePermissionsInput(v *DescribeDataSourcePermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDataSourcePermissionsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DataSourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeFolderInput(v *DescribeFolderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeFolderInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.FolderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FolderId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeFolderPermissionsInput(v *DescribeFolderPermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeFolderPermissionsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.FolderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FolderId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeFolderResolvedPermissionsInput(v *DescribeFolderResolvedPermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeFolderResolvedPermissionsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.FolderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FolderId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeGroupInput(v *DescribeGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeGroupInput"}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeGroupMembershipInput(v *DescribeGroupMembershipInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeGroupMembershipInput"}
	if v.MemberName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemberName"))
	}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeIAMPolicyAssignmentInput(v *DescribeIAMPolicyAssignmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeIAMPolicyAssignmentInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.AssignmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssignmentName"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeIngestionInput(v *DescribeIngestionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeIngestionInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DataSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
	}
	if v.IngestionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IngestionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDescribeTemplateAliasInput(v *DescribeTemplateAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeTemplateAliasInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
	}
	if v.AliasName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AliasName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeTemplateInput(v *DescribeTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeTemplateInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeTemplatePermissionsInput(v *DescribeTemplatePermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeTemplatePermissionsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeThemeAliasInput(v *DescribeThemeAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeThemeAliasInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.ThemeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
	}
	if v.AliasName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AliasName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeThemeInput(v *DescribeThemeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeThemeInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.ThemeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeThemePermissionsInput(v *DescribeThemePermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeThemePermissionsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.ThemeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeUserInput(v *DescribeUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeUserInput"}
	if v.UserName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
	}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGenerateEmbedUrlForAnonymousUserInput(v *GenerateEmbedUrlForAnonymousUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GenerateEmbedUrlForAnonymousUserInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if v.SessionTags != nil {
		if err := validateSessionTagList(v.SessionTags); err != nil {
			invalidParams.AddNested("SessionTags", err.(smithy.InvalidParamsError))
		}
	}
	if v.AuthorizedResourceArns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthorizedResourceArns"))
	}
	if v.ExperienceConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExperienceConfiguration"))
	} else if v.ExperienceConfiguration != nil {
		if err := validateAnonymousUserEmbeddingExperienceConfiguration(v.ExperienceConfiguration); err != nil {
			invalidParams.AddNested("ExperienceConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGenerateEmbedUrlForRegisteredUserInput(v *GenerateEmbedUrlForRegisteredUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GenerateEmbedUrlForRegisteredUserInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.UserArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserArn"))
	}
	if v.ExperienceConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExperienceConfiguration"))
	} else if v.ExperienceConfiguration != nil {
		if err := validateRegisteredUserEmbeddingExperienceConfiguration(v.ExperienceConfiguration); err != nil {
			invalidParams.AddNested("ExperienceConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDashboardEmbedUrlInput(v *GetDashboardEmbedUrlInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDashboardEmbedUrlInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DashboardId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
	}
	if len(v.IdentityType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("IdentityType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpListDashboardVersionsInput(v *ListDashboardVersionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDashboardVersionsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DashboardId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListFolderMembersInput(v *ListFolderMembersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListFolderMembersInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.FolderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FolderId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListGroupMembershipsInput(v *ListGroupMembershipsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListGroupMembershipsInput"}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListIAMPolicyAssignmentsForUserInput(v *ListIAMPolicyAssignmentsForUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListIAMPolicyAssignmentsForUserInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.UserName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListIngestionsInput(v *ListIngestionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListIngestionsInput"}
	if v.DataSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
	}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListNamespacesInput(v *ListNamespacesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListNamespacesInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	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 validateOpListTemplateAliasesInput(v *ListTemplateAliasesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTemplateAliasesInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListTemplateVersionsInput(v *ListTemplateVersionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTemplateVersionsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListThemeAliasesInput(v *ListThemeAliasesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListThemeAliasesInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.ThemeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListThemeVersionsInput(v *ListThemeVersionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListThemeVersionsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.ThemeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListUserGroupsInput(v *ListUserGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListUserGroupsInput"}
	if v.UserName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
	}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpRegisterUserInput(v *RegisterUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterUserInput"}
	if len(v.IdentityType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("IdentityType"))
	}
	if v.Email == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Email"))
	}
	if len(v.UserRole) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("UserRole"))
	}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRestoreAnalysisInput(v *RestoreAnalysisInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RestoreAnalysisInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.AnalysisId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchAnalysesInput(v *SearchAnalysesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchAnalysesInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Filters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchDashboardsInput(v *SearchDashboardsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchDashboardsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Filters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
	} else if v.Filters != nil {
		if err := validateDashboardSearchFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchFoldersInput(v *SearchFoldersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchFoldersInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Filters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchGroupsInput(v *SearchGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchGroupsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if v.Filters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
	} else if v.Filters != nil {
		if err := validateGroupSearchFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTagResourceInput(v *TagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	} 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 validateOpUpdateAccountCustomizationInput(v *UpdateAccountCustomizationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAccountCustomizationInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.AccountCustomization == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountCustomization"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAccountSettingsInput(v *UpdateAccountSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAccountSettingsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DefaultNamespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultNamespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAnalysisInput(v *UpdateAnalysisInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAnalysisInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.AnalysisId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Parameters != nil {
		if err := validateParameters(v.Parameters); err != nil {
			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.SourceEntity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceEntity"))
	} else if v.SourceEntity != nil {
		if err := validateAnalysisSourceEntity(v.SourceEntity); err != nil {
			invalidParams.AddNested("SourceEntity", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAnalysisPermissionsInput(v *UpdateAnalysisPermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAnalysisPermissionsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.AnalysisId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisId"))
	}
	if v.GrantPermissions != nil {
		if err := validateUpdateResourcePermissionList(v.GrantPermissions); err != nil {
			invalidParams.AddNested("GrantPermissions", err.(smithy.InvalidParamsError))
		}
	}
	if v.RevokePermissions != nil {
		if err := validateUpdateResourcePermissionList(v.RevokePermissions); err != nil {
			invalidParams.AddNested("RevokePermissions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDashboardInput(v *UpdateDashboardInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDashboardInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DashboardId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.SourceEntity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceEntity"))
	} else if v.SourceEntity != nil {
		if err := validateDashboardSourceEntity(v.SourceEntity); err != nil {
			invalidParams.AddNested("SourceEntity", err.(smithy.InvalidParamsError))
		}
	}
	if v.Parameters != nil {
		if err := validateParameters(v.Parameters); err != nil {
			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDashboardPermissionsInput(v *UpdateDashboardPermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDashboardPermissionsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DashboardId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
	}
	if v.GrantPermissions != nil {
		if err := validateUpdateResourcePermissionList(v.GrantPermissions); err != nil {
			invalidParams.AddNested("GrantPermissions", err.(smithy.InvalidParamsError))
		}
	}
	if v.RevokePermissions != nil {
		if err := validateUpdateResourcePermissionList(v.RevokePermissions); err != nil {
			invalidParams.AddNested("RevokePermissions", err.(smithy.InvalidParamsError))
		}
	}
	if v.GrantLinkPermissions != nil {
		if err := validateUpdateLinkPermissionList(v.GrantLinkPermissions); err != nil {
			invalidParams.AddNested("GrantLinkPermissions", err.(smithy.InvalidParamsError))
		}
	}
	if v.RevokeLinkPermissions != nil {
		if err := validateUpdateLinkPermissionList(v.RevokeLinkPermissions); err != nil {
			invalidParams.AddNested("RevokeLinkPermissions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDashboardPublishedVersionInput(v *UpdateDashboardPublishedVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDashboardPublishedVersionInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DashboardId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
	}
	if v.VersionNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VersionNumber"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDataSetInput(v *UpdateDataSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDataSetInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DataSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.PhysicalTableMap == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PhysicalTableMap"))
	} else if v.PhysicalTableMap != nil {
		if err := validatePhysicalTableMap(v.PhysicalTableMap); err != nil {
			invalidParams.AddNested("PhysicalTableMap", err.(smithy.InvalidParamsError))
		}
	}
	if v.LogicalTableMap != nil {
		if err := validateLogicalTableMap(v.LogicalTableMap); err != nil {
			invalidParams.AddNested("LogicalTableMap", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.ImportMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ImportMode"))
	}
	if v.ColumnGroups != nil {
		if err := validateColumnGroupList(v.ColumnGroups); err != nil {
			invalidParams.AddNested("ColumnGroups", err.(smithy.InvalidParamsError))
		}
	}
	if v.RowLevelPermissionDataSet != nil {
		if err := validateRowLevelPermissionDataSet(v.RowLevelPermissionDataSet); err != nil {
			invalidParams.AddNested("RowLevelPermissionDataSet", err.(smithy.InvalidParamsError))
		}
	}
	if v.RowLevelPermissionTagConfiguration != nil {
		if err := validateRowLevelPermissionTagConfiguration(v.RowLevelPermissionTagConfiguration); err != nil {
			invalidParams.AddNested("RowLevelPermissionTagConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDataSetPermissionsInput(v *UpdateDataSetPermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDataSetPermissionsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DataSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
	}
	if v.GrantPermissions != nil {
		if err := validateResourcePermissionList(v.GrantPermissions); err != nil {
			invalidParams.AddNested("GrantPermissions", err.(smithy.InvalidParamsError))
		}
	}
	if v.RevokePermissions != nil {
		if err := validateResourcePermissionList(v.RevokePermissions); err != nil {
			invalidParams.AddNested("RevokePermissions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDataSourceInput(v *UpdateDataSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDataSourceInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DataSourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.DataSourceParameters != nil {
		if err := validateDataSourceParameters(v.DataSourceParameters); err != nil {
			invalidParams.AddNested("DataSourceParameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.Credentials != nil {
		if err := validateDataSourceCredentials(v.Credentials); err != nil {
			invalidParams.AddNested("Credentials", err.(smithy.InvalidParamsError))
		}
	}
	if v.VpcConnectionProperties != nil {
		if err := validateVpcConnectionProperties(v.VpcConnectionProperties); err != nil {
			invalidParams.AddNested("VpcConnectionProperties", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDataSourcePermissionsInput(v *UpdateDataSourcePermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDataSourcePermissionsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DataSourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceId"))
	}
	if v.GrantPermissions != nil {
		if err := validateResourcePermissionList(v.GrantPermissions); err != nil {
			invalidParams.AddNested("GrantPermissions", err.(smithy.InvalidParamsError))
		}
	}
	if v.RevokePermissions != nil {
		if err := validateResourcePermissionList(v.RevokePermissions); err != nil {
			invalidParams.AddNested("RevokePermissions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateFolderPermissionsInput(v *UpdateFolderPermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFolderPermissionsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.FolderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FolderId"))
	}
	if v.GrantPermissions != nil {
		if err := validateResourcePermissionList(v.GrantPermissions); err != nil {
			invalidParams.AddNested("GrantPermissions", err.(smithy.InvalidParamsError))
		}
	}
	if v.RevokePermissions != nil {
		if err := validateResourcePermissionList(v.RevokePermissions); err != nil {
			invalidParams.AddNested("RevokePermissions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateGroupInput(v *UpdateGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateGroupInput"}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateIAMPolicyAssignmentInput(v *UpdateIAMPolicyAssignmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateIAMPolicyAssignmentInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.AssignmentName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssignmentName"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpUpdateTemplateAliasInput(v *UpdateTemplateAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTemplateAliasInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
	}
	if v.AliasName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AliasName"))
	}
	if v.TemplateVersionNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateVersionNumber"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateTemplateInput(v *UpdateTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTemplateInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
	}
	if v.SourceEntity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceEntity"))
	} else if v.SourceEntity != nil {
		if err := validateTemplateSourceEntity(v.SourceEntity); err != nil {
			invalidParams.AddNested("SourceEntity", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateTemplatePermissionsInput(v *UpdateTemplatePermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTemplatePermissionsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateId"))
	}
	if v.GrantPermissions != nil {
		if err := validateUpdateResourcePermissionList(v.GrantPermissions); err != nil {
			invalidParams.AddNested("GrantPermissions", err.(smithy.InvalidParamsError))
		}
	}
	if v.RevokePermissions != nil {
		if err := validateUpdateResourcePermissionList(v.RevokePermissions); err != nil {
			invalidParams.AddNested("RevokePermissions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateThemeAliasInput(v *UpdateThemeAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateThemeAliasInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.ThemeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
	}
	if v.AliasName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AliasName"))
	}
	if v.ThemeVersionNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ThemeVersionNumber"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateThemeInput(v *UpdateThemeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateThemeInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.ThemeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
	}
	if v.BaseThemeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BaseThemeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateThemePermissionsInput(v *UpdateThemePermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateThemePermissionsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.ThemeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ThemeId"))
	}
	if v.GrantPermissions != nil {
		if err := validateUpdateResourcePermissionList(v.GrantPermissions); err != nil {
			invalidParams.AddNested("GrantPermissions", err.(smithy.InvalidParamsError))
		}
	}
	if v.RevokePermissions != nil {
		if err := validateUpdateResourcePermissionList(v.RevokePermissions); err != nil {
			invalidParams.AddNested("RevokePermissions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateUserInput(v *UpdateUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserInput"}
	if v.UserName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
	}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Namespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if v.Email == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Email"))
	}
	if len(v.Role) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Role"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}