// 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 validateOpCreateRefreshSchedule struct {
}

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

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

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

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

type validateOpCreateTopicRefreshSchedule struct {
}

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

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

type validateOpCreateVPCConnection struct {
}

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

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

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

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

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

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

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

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

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

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

type validateOpDeleteTopicRefreshSchedule struct {
}

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

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

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

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

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

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

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

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

type validateOpDescribeAssetBundleImportJob struct {
}

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

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

type validateOpDescribeDashboardDefinition struct {
}

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

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

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

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

type validateOpDescribeDashboardSnapshotJobResult struct {
}

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

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

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

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

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

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

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

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

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

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

type validateOpDescribeTopicPermissions struct {
}

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

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

type validateOpDescribeTopicRefresh struct {
}

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

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

type validateOpDescribeTopicRefreshSchedule struct {
}

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

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

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

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

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

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

type validateOpListAssetBundleImportJobs struct {
}

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

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

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

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

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

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

type validateOpListTopics struct {
}

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

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

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

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

type validateOpPutDataSetRefreshProperties struct {
}

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

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

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

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

type validateOpSearchDataSources struct {
}

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

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

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

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

type validateOpStartAssetBundleImportJob struct {
}

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

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

type validateOpStartDashboardSnapshotJob struct {
}

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

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

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

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

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

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

type validateOpUpdateTopicPermissions struct {
}

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

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

type validateOpUpdateTopicRefreshSchedule struct {
}

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

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

type validateOpUpdateVPCConnection struct {
}

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

func (m *validateOpUpdateVPCConnection) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateVPCConnectionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateVPCConnectionInput(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 addOpCreateRefreshScheduleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateRefreshSchedule{}, 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 addOpCreateTopicValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateTopic{}, middleware.After)
}

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

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

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

func addOpDeleteAccountSubscriptionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteAccountSubscription{}, 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 addOpDeleteDataSetRefreshPropertiesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteDataSetRefreshProperties{}, 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 addOpDeleteRefreshScheduleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteRefreshSchedule{}, 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 addOpDeleteTopicValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteTopic{}, middleware.After)
}

func addOpDeleteTopicRefreshScheduleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteTopicRefreshSchedule{}, 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 addOpDeleteVPCConnectionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteVPCConnection{}, 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 addOpDescribeAnalysisDefinitionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeAnalysisDefinition{}, 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 addOpDescribeAssetBundleExportJobValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeAssetBundleExportJob{}, middleware.After)
}

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

func addOpDescribeDashboardDefinitionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeDashboardDefinition{}, 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 addOpDescribeDashboardSnapshotJobValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeDashboardSnapshotJob{}, middleware.After)
}

func addOpDescribeDashboardSnapshotJobResultValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeDashboardSnapshotJobResult{}, 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 addOpDescribeDataSetRefreshPropertiesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeDataSetRefreshProperties{}, 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 addOpDescribeRefreshScheduleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeRefreshSchedule{}, middleware.After)
}

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

func addOpDescribeTemplateDefinitionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeTemplateDefinition{}, 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 addOpDescribeTopicValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeTopic{}, middleware.After)
}

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

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

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

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

func addOpDescribeVPCConnectionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeVPCConnection{}, 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 addOpListAssetBundleExportJobsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListAssetBundleExportJobs{}, middleware.After)
}

func addOpListAssetBundleImportJobsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListAssetBundleImportJobs{}, 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 addOpListRefreshSchedulesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListRefreshSchedules{}, 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 addOpListTopicRefreshSchedulesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListTopicRefreshSchedules{}, middleware.After)
}

func addOpListTopicsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListTopics{}, 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 addOpListVPCConnectionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListVPCConnections{}, middleware.After)
}

func addOpPutDataSetRefreshPropertiesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutDataSetRefreshProperties{}, 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 addOpSearchDataSetsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSearchDataSets{}, middleware.After)
}

func addOpSearchDataSourcesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSearchDataSources{}, 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 addOpStartAssetBundleExportJobValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartAssetBundleExportJob{}, middleware.After)
}

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

func addOpStartDashboardSnapshotJobValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartDashboardSnapshotJob{}, 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 addOpUpdateRefreshScheduleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateRefreshSchedule{}, 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 addOpUpdateTopicValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateTopic{}, middleware.After)
}

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

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

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

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

func validateAggregationSortConfiguration(v *types.AggregationSortConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AggregationSortConfiguration"}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.SortDirection) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SortDirection"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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 validateAnalysisDefaults(v *types.AnalysisDefaults) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AnalysisDefaults"}
	if v.DefaultNewSheetConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultNewSheetConfiguration"))
	} else if v.DefaultNewSheetConfiguration != nil {
		if err := validateDefaultNewSheetConfiguration(v.DefaultNewSheetConfiguration); err != nil {
			invalidParams.AddNested("DefaultNewSheetConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAnalysisDefinition(v *types.AnalysisDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AnalysisDefinition"}
	if v.DataSetIdentifierDeclarations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetIdentifierDeclarations"))
	} else if v.DataSetIdentifierDeclarations != nil {
		if err := validateDataSetIdentifierDeclarationList(v.DataSetIdentifierDeclarations); err != nil {
			invalidParams.AddNested("DataSetIdentifierDeclarations", err.(smithy.InvalidParamsError))
		}
	}
	if v.Sheets != nil {
		if err := validateSheetDefinitionList(v.Sheets); err != nil {
			invalidParams.AddNested("Sheets", err.(smithy.InvalidParamsError))
		}
	}
	if v.CalculatedFields != nil {
		if err := validateCalculatedFields(v.CalculatedFields); err != nil {
			invalidParams.AddNested("CalculatedFields", err.(smithy.InvalidParamsError))
		}
	}
	if v.ParameterDeclarations != nil {
		if err := validateParameterDeclarationList(v.ParameterDeclarations); err != nil {
			invalidParams.AddNested("ParameterDeclarations", err.(smithy.InvalidParamsError))
		}
	}
	if v.FilterGroups != nil {
		if err := validateFilterGroupList(v.FilterGroups); err != nil {
			invalidParams.AddNested("FilterGroups", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnConfigurations != nil {
		if err := validateColumnConfigurationList(v.ColumnConfigurations); err != nil {
			invalidParams.AddNested("ColumnConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.AnalysisDefaults != nil {
		if err := validateAnalysisDefaults(v.AnalysisDefaults); err != nil {
			invalidParams.AddNested("AnalysisDefaults", err.(smithy.InvalidParamsError))
		}
	}
	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 v.QSearchBar != nil {
		if err := validateAnonymousUserQSearchBarEmbeddingConfiguration(v.QSearchBar); err != nil {
			invalidParams.AddNested("QSearchBar", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateAssetBundleCloudFormationOverridePropertyConfiguration(v *types.AssetBundleCloudFormationOverridePropertyConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssetBundleCloudFormationOverridePropertyConfiguration"}
	if v.VPCConnections != nil {
		if err := validateAssetBundleExportJobVPCConnectionOverridePropertiesList(v.VPCConnections); err != nil {
			invalidParams.AddNested("VPCConnections", err.(smithy.InvalidParamsError))
		}
	}
	if v.RefreshSchedules != nil {
		if err := validateAssetBundleExportJobRefreshScheduleOverridePropertiesList(v.RefreshSchedules); err != nil {
			invalidParams.AddNested("RefreshSchedules", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataSources != nil {
		if err := validateAssetBundleExportJobDataSourceOverridePropertiesList(v.DataSources); err != nil {
			invalidParams.AddNested("DataSources", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataSets != nil {
		if err := validateAssetBundleExportJobDataSetOverridePropertiesList(v.DataSets); err != nil {
			invalidParams.AddNested("DataSets", err.(smithy.InvalidParamsError))
		}
	}
	if v.Themes != nil {
		if err := validateAssetBundleExportJobThemeOverridePropertiesList(v.Themes); err != nil {
			invalidParams.AddNested("Themes", err.(smithy.InvalidParamsError))
		}
	}
	if v.Analyses != nil {
		if err := validateAssetBundleExportJobAnalysisOverridePropertiesList(v.Analyses); err != nil {
			invalidParams.AddNested("Analyses", err.(smithy.InvalidParamsError))
		}
	}
	if v.Dashboards != nil {
		if err := validateAssetBundleExportJobDashboardOverridePropertiesList(v.Dashboards); err != nil {
			invalidParams.AddNested("Dashboards", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateAssetBundleImportJobDataSourceCredentialPair(v *types.AssetBundleImportJobDataSourceCredentialPair) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssetBundleImportJobDataSourceCredentialPair"}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if v.Password == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Password"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateAssetBundleImportJobOverrideParameters(v *types.AssetBundleImportJobOverrideParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssetBundleImportJobOverrideParameters"}
	if v.VPCConnections != nil {
		if err := validateAssetBundleImportJobVPCConnectionOverrideParametersList(v.VPCConnections); err != nil {
			invalidParams.AddNested("VPCConnections", err.(smithy.InvalidParamsError))
		}
	}
	if v.RefreshSchedules != nil {
		if err := validateAssetBundleImportJobRefreshScheduleOverrideParametersList(v.RefreshSchedules); err != nil {
			invalidParams.AddNested("RefreshSchedules", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataSources != nil {
		if err := validateAssetBundleImportJobDataSourceOverrideParametersList(v.DataSources); err != nil {
			invalidParams.AddNested("DataSources", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataSets != nil {
		if err := validateAssetBundleImportJobDataSetOverrideParametersList(v.DataSets); err != nil {
			invalidParams.AddNested("DataSets", err.(smithy.InvalidParamsError))
		}
	}
	if v.Themes != nil {
		if err := validateAssetBundleImportJobThemeOverrideParametersList(v.Themes); err != nil {
			invalidParams.AddNested("Themes", err.(smithy.InvalidParamsError))
		}
	}
	if v.Analyses != nil {
		if err := validateAssetBundleImportJobAnalysisOverrideParametersList(v.Analyses); err != nil {
			invalidParams.AddNested("Analyses", err.(smithy.InvalidParamsError))
		}
	}
	if v.Dashboards != nil {
		if err := validateAssetBundleImportJobDashboardOverrideParametersList(v.Dashboards); err != nil {
			invalidParams.AddNested("Dashboards", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAssetBundleImportJobRefreshScheduleOverrideParameters(v *types.AssetBundleImportJobRefreshScheduleOverrideParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssetBundleImportJobRefreshScheduleOverrideParameters"}
	if v.DataSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
	}
	if v.ScheduleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScheduleId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateAssetBundleImportJobVPCConnectionOverrideParametersList(v []types.AssetBundleImportJobVPCConnectionOverrideParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssetBundleImportJobVPCConnectionOverrideParametersList"}
	for i := range v {
		if err := validateAssetBundleImportJobVPCConnectionOverrideParameters(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), 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 validateAxisLabelOptions(v *types.AxisLabelOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AxisLabelOptions"}
	if v.ApplyTo != nil {
		if err := validateAxisLabelReferenceOptions(v.ApplyTo); err != nil {
			invalidParams.AddNested("ApplyTo", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateAxisLabelReferenceOptions(v *types.AxisLabelReferenceOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AxisLabelReferenceOptions"}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBarChartAggregatedFieldWells(v *types.BarChartAggregatedFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BarChartAggregatedFieldWells"}
	if v.Category != nil {
		if err := validateDimensionFieldList(v.Category); err != nil {
			invalidParams.AddNested("Category", err.(smithy.InvalidParamsError))
		}
	}
	if v.Values != nil {
		if err := validateMeasureFieldList(v.Values); err != nil {
			invalidParams.AddNested("Values", err.(smithy.InvalidParamsError))
		}
	}
	if v.Colors != nil {
		if err := validateDimensionFieldList(v.Colors); err != nil {
			invalidParams.AddNested("Colors", err.(smithy.InvalidParamsError))
		}
	}
	if v.SmallMultiples != nil {
		if err := validateSmallMultiplesDimensionFieldList(v.SmallMultiples); err != nil {
			invalidParams.AddNested("SmallMultiples", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBarChartConfiguration(v *types.BarChartConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BarChartConfiguration"}
	if v.FieldWells != nil {
		if err := validateBarChartFieldWells(v.FieldWells); err != nil {
			invalidParams.AddNested("FieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortConfiguration != nil {
		if err := validateBarChartSortConfiguration(v.SortConfiguration); err != nil {
			invalidParams.AddNested("SortConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.VisualPalette != nil {
		if err := validateVisualPalette(v.VisualPalette); err != nil {
			invalidParams.AddNested("VisualPalette", err.(smithy.InvalidParamsError))
		}
	}
	if v.CategoryLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.CategoryLabelOptions); err != nil {
			invalidParams.AddNested("CategoryLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ValueLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.ValueLabelOptions); err != nil {
			invalidParams.AddNested("ValueLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColorLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.ColorLabelOptions); err != nil {
			invalidParams.AddNested("ColorLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tooltip != nil {
		if err := validateTooltipOptions(v.Tooltip); err != nil {
			invalidParams.AddNested("Tooltip", err.(smithy.InvalidParamsError))
		}
	}
	if v.ReferenceLines != nil {
		if err := validateReferenceLineList(v.ReferenceLines); err != nil {
			invalidParams.AddNested("ReferenceLines", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContributionAnalysisDefaults != nil {
		if err := validateContributionAnalysisDefaultList(v.ContributionAnalysisDefaults); err != nil {
			invalidParams.AddNested("ContributionAnalysisDefaults", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBarChartFieldWells(v *types.BarChartFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BarChartFieldWells"}
	if v.BarChartAggregatedFieldWells != nil {
		if err := validateBarChartAggregatedFieldWells(v.BarChartAggregatedFieldWells); err != nil {
			invalidParams.AddNested("BarChartAggregatedFieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBarChartSortConfiguration(v *types.BarChartSortConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BarChartSortConfiguration"}
	if v.CategorySort != nil {
		if err := validateFieldSortOptionsList(v.CategorySort); err != nil {
			invalidParams.AddNested("CategorySort", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColorSort != nil {
		if err := validateFieldSortOptionsList(v.ColorSort); err != nil {
			invalidParams.AddNested("ColorSort", err.(smithy.InvalidParamsError))
		}
	}
	if v.SmallMultiplesSort != nil {
		if err := validateFieldSortOptionsList(v.SmallMultiplesSort); err != nil {
			invalidParams.AddNested("SmallMultiplesSort", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBarChartVisual(v *types.BarChartVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BarChartVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.ChartConfiguration != nil {
		if err := validateBarChartConfiguration(v.ChartConfiguration); err != nil {
			invalidParams.AddNested("ChartConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnHierarchies != nil {
		if err := validateColumnHierarchyList(v.ColumnHierarchies); err != nil {
			invalidParams.AddNested("ColumnHierarchies", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBodySectionConfiguration(v *types.BodySectionConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BodySectionConfiguration"}
	if v.SectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SectionId"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	} else if v.Content != nil {
		if err := validateBodySectionContent(v.Content); err != nil {
			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateBodySectionContent(v *types.BodySectionContent) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BodySectionContent"}
	if v.Layout != nil {
		if err := validateSectionLayoutConfiguration(v.Layout); err != nil {
			invalidParams.AddNested("Layout", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBookmarksConfigurations(v *types.BookmarksConfigurations) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BookmarksConfigurations"}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBoxPlotAggregatedFieldWells(v *types.BoxPlotAggregatedFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BoxPlotAggregatedFieldWells"}
	if v.GroupBy != nil {
		if err := validateBoxPlotDimensionFieldList(v.GroupBy); err != nil {
			invalidParams.AddNested("GroupBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.Values != nil {
		if err := validateBoxPlotMeasureFieldList(v.Values); err != nil {
			invalidParams.AddNested("Values", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBoxPlotChartConfiguration(v *types.BoxPlotChartConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BoxPlotChartConfiguration"}
	if v.FieldWells != nil {
		if err := validateBoxPlotFieldWells(v.FieldWells); err != nil {
			invalidParams.AddNested("FieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortConfiguration != nil {
		if err := validateBoxPlotSortConfiguration(v.SortConfiguration); err != nil {
			invalidParams.AddNested("SortConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CategoryLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.CategoryLabelOptions); err != nil {
			invalidParams.AddNested("CategoryLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.PrimaryYAxisLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.PrimaryYAxisLabelOptions); err != nil {
			invalidParams.AddNested("PrimaryYAxisLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tooltip != nil {
		if err := validateTooltipOptions(v.Tooltip); err != nil {
			invalidParams.AddNested("Tooltip", err.(smithy.InvalidParamsError))
		}
	}
	if v.ReferenceLines != nil {
		if err := validateReferenceLineList(v.ReferenceLines); err != nil {
			invalidParams.AddNested("ReferenceLines", err.(smithy.InvalidParamsError))
		}
	}
	if v.VisualPalette != nil {
		if err := validateVisualPalette(v.VisualPalette); err != nil {
			invalidParams.AddNested("VisualPalette", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateBoxPlotFieldWells(v *types.BoxPlotFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BoxPlotFieldWells"}
	if v.BoxPlotAggregatedFieldWells != nil {
		if err := validateBoxPlotAggregatedFieldWells(v.BoxPlotAggregatedFieldWells); err != nil {
			invalidParams.AddNested("BoxPlotAggregatedFieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateBoxPlotSortConfiguration(v *types.BoxPlotSortConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BoxPlotSortConfiguration"}
	if v.CategorySort != nil {
		if err := validateFieldSortOptionsList(v.CategorySort); err != nil {
			invalidParams.AddNested("CategorySort", err.(smithy.InvalidParamsError))
		}
	}
	if v.PaginationConfiguration != nil {
		if err := validatePaginationConfiguration(v.PaginationConfiguration); err != nil {
			invalidParams.AddNested("PaginationConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBoxPlotVisual(v *types.BoxPlotVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BoxPlotVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.ChartConfiguration != nil {
		if err := validateBoxPlotChartConfiguration(v.ChartConfiguration); err != nil {
			invalidParams.AddNested("ChartConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnHierarchies != nil {
		if err := validateColumnHierarchyList(v.ColumnHierarchies); err != nil {
			invalidParams.AddNested("ColumnHierarchies", err.(smithy.InvalidParamsError))
		}
	}
	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 validateCalculatedField(v *types.CalculatedField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CalculatedField"}
	if v.DataSetIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetIdentifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Expression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCalculatedMeasureField(v *types.CalculatedMeasureField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CalculatedMeasureField"}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if v.Expression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCascadingControlConfiguration(v *types.CascadingControlConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CascadingControlConfiguration"}
	if v.SourceControls != nil {
		if err := validateCascadingControlSourceList(v.SourceControls); err != nil {
			invalidParams.AddNested("SourceControls", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCascadingControlSource(v *types.CascadingControlSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CascadingControlSource"}
	if v.ColumnToMatch != nil {
		if err := validateColumnIdentifier(v.ColumnToMatch); err != nil {
			invalidParams.AddNested("ColumnToMatch", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCascadingControlSourceList(v []types.CascadingControlSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CascadingControlSourceList"}
	for i := range v {
		if err := validateCascadingControlSource(&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 validateCategoricalDimensionField(v *types.CategoricalDimensionField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CategoricalDimensionField"}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if v.FormatConfiguration != nil {
		if err := validateStringFormatConfiguration(v.FormatConfiguration); err != nil {
			invalidParams.AddNested("FormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCategoricalMeasureField(v *types.CategoricalMeasureField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CategoricalMeasureField"}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if v.FormatConfiguration != nil {
		if err := validateStringFormatConfiguration(v.FormatConfiguration); err != nil {
			invalidParams.AddNested("FormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCategoryDrillDownFilter(v *types.CategoryDrillDownFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CategoryDrillDownFilter"}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if v.CategoryValues == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CategoryValues"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCategoryFilter(v *types.CategoryFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CategoryFilter"}
	if v.FilterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilterId"))
	}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if v.Configuration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Configuration"))
	} else if v.Configuration != nil {
		if err := validateCategoryFilterConfiguration(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCategoryFilterConfiguration(v *types.CategoryFilterConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CategoryFilterConfiguration"}
	if v.FilterListConfiguration != nil {
		if err := validateFilterListConfiguration(v.FilterListConfiguration); err != nil {
			invalidParams.AddNested("FilterListConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomFilterListConfiguration != nil {
		if err := validateCustomFilterListConfiguration(v.CustomFilterListConfiguration); err != nil {
			invalidParams.AddNested("CustomFilterListConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomFilterConfiguration != nil {
		if err := validateCustomFilterConfiguration(v.CustomFilterConfiguration); err != nil {
			invalidParams.AddNested("CustomFilterConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateChartAxisLabelOptions(v *types.ChartAxisLabelOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChartAxisLabelOptions"}
	if v.AxisLabelOptions != nil {
		if err := validateAxisLabelOptionsList(v.AxisLabelOptions); err != nil {
			invalidParams.AddNested("AxisLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateColorScale(v *types.ColorScale) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ColorScale"}
	if v.Colors == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Colors"))
	}
	if len(v.ColorFillType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ColorFillType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateColorsConfiguration(v *types.ColorsConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ColorsConfiguration"}
	if v.CustomColors != nil {
		if err := validateCustomColorsList(v.CustomColors); err != nil {
			invalidParams.AddNested("CustomColors", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateColumnConfiguration(v *types.ColumnConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ColumnConfiguration"}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if v.FormatConfiguration != nil {
		if err := validateFormatConfiguration(v.FormatConfiguration); err != nil {
			invalidParams.AddNested("FormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColorsConfiguration != nil {
		if err := validateColorsConfiguration(v.ColorsConfiguration); err != nil {
			invalidParams.AddNested("ColorsConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateColumnConfigurationList(v []types.ColumnConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ColumnConfigurationList"}
	for i := range v {
		if err := validateColumnConfiguration(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	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 validateColumnHierarchy(v *types.ColumnHierarchy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ColumnHierarchy"}
	if v.ExplicitHierarchy != nil {
		if err := validateExplicitHierarchy(v.ExplicitHierarchy); err != nil {
			invalidParams.AddNested("ExplicitHierarchy", err.(smithy.InvalidParamsError))
		}
	}
	if v.DateTimeHierarchy != nil {
		if err := validateDateTimeHierarchy(v.DateTimeHierarchy); err != nil {
			invalidParams.AddNested("DateTimeHierarchy", err.(smithy.InvalidParamsError))
		}
	}
	if v.PredefinedHierarchy != nil {
		if err := validatePredefinedHierarchy(v.PredefinedHierarchy); err != nil {
			invalidParams.AddNested("PredefinedHierarchy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateColumnSort(v *types.ColumnSort) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ColumnSort"}
	if v.SortBy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SortBy"))
	} else if v.SortBy != nil {
		if err := validateColumnIdentifier(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.Direction) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Direction"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateColumnTooltipItem(v *types.ColumnTooltipItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ColumnTooltipItem"}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateComboChartAggregatedFieldWells(v *types.ComboChartAggregatedFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ComboChartAggregatedFieldWells"}
	if v.Category != nil {
		if err := validateDimensionFieldList(v.Category); err != nil {
			invalidParams.AddNested("Category", err.(smithy.InvalidParamsError))
		}
	}
	if v.BarValues != nil {
		if err := validateMeasureFieldList(v.BarValues); err != nil {
			invalidParams.AddNested("BarValues", err.(smithy.InvalidParamsError))
		}
	}
	if v.Colors != nil {
		if err := validateDimensionFieldList(v.Colors); err != nil {
			invalidParams.AddNested("Colors", err.(smithy.InvalidParamsError))
		}
	}
	if v.LineValues != nil {
		if err := validateMeasureFieldList(v.LineValues); err != nil {
			invalidParams.AddNested("LineValues", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateComboChartConfiguration(v *types.ComboChartConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ComboChartConfiguration"}
	if v.FieldWells != nil {
		if err := validateComboChartFieldWells(v.FieldWells); err != nil {
			invalidParams.AddNested("FieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortConfiguration != nil {
		if err := validateComboChartSortConfiguration(v.SortConfiguration); err != nil {
			invalidParams.AddNested("SortConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CategoryLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.CategoryLabelOptions); err != nil {
			invalidParams.AddNested("CategoryLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.PrimaryYAxisLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.PrimaryYAxisLabelOptions); err != nil {
			invalidParams.AddNested("PrimaryYAxisLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.SecondaryYAxisLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.SecondaryYAxisLabelOptions); err != nil {
			invalidParams.AddNested("SecondaryYAxisLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColorLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.ColorLabelOptions); err != nil {
			invalidParams.AddNested("ColorLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tooltip != nil {
		if err := validateTooltipOptions(v.Tooltip); err != nil {
			invalidParams.AddNested("Tooltip", err.(smithy.InvalidParamsError))
		}
	}
	if v.ReferenceLines != nil {
		if err := validateReferenceLineList(v.ReferenceLines); err != nil {
			invalidParams.AddNested("ReferenceLines", err.(smithy.InvalidParamsError))
		}
	}
	if v.VisualPalette != nil {
		if err := validateVisualPalette(v.VisualPalette); err != nil {
			invalidParams.AddNested("VisualPalette", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateComboChartFieldWells(v *types.ComboChartFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ComboChartFieldWells"}
	if v.ComboChartAggregatedFieldWells != nil {
		if err := validateComboChartAggregatedFieldWells(v.ComboChartAggregatedFieldWells); err != nil {
			invalidParams.AddNested("ComboChartAggregatedFieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateComboChartSortConfiguration(v *types.ComboChartSortConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ComboChartSortConfiguration"}
	if v.CategorySort != nil {
		if err := validateFieldSortOptionsList(v.CategorySort); err != nil {
			invalidParams.AddNested("CategorySort", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColorSort != nil {
		if err := validateFieldSortOptionsList(v.ColorSort); err != nil {
			invalidParams.AddNested("ColorSort", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateComboChartVisual(v *types.ComboChartVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ComboChartVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.ChartConfiguration != nil {
		if err := validateComboChartConfiguration(v.ChartConfiguration); err != nil {
			invalidParams.AddNested("ChartConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnHierarchies != nil {
		if err := validateColumnHierarchyList(v.ColumnHierarchies); err != nil {
			invalidParams.AddNested("ColumnHierarchies", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateComparisonConfiguration(v *types.ComparisonConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ComparisonConfiguration"}
	if v.ComparisonFormat != nil {
		if err := validateComparisonFormatConfiguration(v.ComparisonFormat); err != nil {
			invalidParams.AddNested("ComparisonFormat", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateComparisonFormatConfiguration(v *types.ComparisonFormatConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ComparisonFormatConfiguration"}
	if v.NumberDisplayFormatConfiguration != nil {
		if err := validateNumberDisplayFormatConfiguration(v.NumberDisplayFormatConfiguration); err != nil {
			invalidParams.AddNested("NumberDisplayFormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.PercentageDisplayFormatConfiguration != nil {
		if err := validatePercentageDisplayFormatConfiguration(v.PercentageDisplayFormatConfiguration); err != nil {
			invalidParams.AddNested("PercentageDisplayFormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateComputation(v *types.Computation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Computation"}
	if v.TopBottomRanked != nil {
		if err := validateTopBottomRankedComputation(v.TopBottomRanked); err != nil {
			invalidParams.AddNested("TopBottomRanked", err.(smithy.InvalidParamsError))
		}
	}
	if v.TopBottomMovers != nil {
		if err := validateTopBottomMoversComputation(v.TopBottomMovers); err != nil {
			invalidParams.AddNested("TopBottomMovers", err.(smithy.InvalidParamsError))
		}
	}
	if v.TotalAggregation != nil {
		if err := validateTotalAggregationComputation(v.TotalAggregation); err != nil {
			invalidParams.AddNested("TotalAggregation", err.(smithy.InvalidParamsError))
		}
	}
	if v.MaximumMinimum != nil {
		if err := validateMaximumMinimumComputation(v.MaximumMinimum); err != nil {
			invalidParams.AddNested("MaximumMinimum", err.(smithy.InvalidParamsError))
		}
	}
	if v.MetricComparison != nil {
		if err := validateMetricComparisonComputation(v.MetricComparison); err != nil {
			invalidParams.AddNested("MetricComparison", err.(smithy.InvalidParamsError))
		}
	}
	if v.PeriodOverPeriod != nil {
		if err := validatePeriodOverPeriodComputation(v.PeriodOverPeriod); err != nil {
			invalidParams.AddNested("PeriodOverPeriod", err.(smithy.InvalidParamsError))
		}
	}
	if v.PeriodToDate != nil {
		if err := validatePeriodToDateComputation(v.PeriodToDate); err != nil {
			invalidParams.AddNested("PeriodToDate", err.(smithy.InvalidParamsError))
		}
	}
	if v.GrowthRate != nil {
		if err := validateGrowthRateComputation(v.GrowthRate); err != nil {
			invalidParams.AddNested("GrowthRate", err.(smithy.InvalidParamsError))
		}
	}
	if v.UniqueValues != nil {
		if err := validateUniqueValuesComputation(v.UniqueValues); err != nil {
			invalidParams.AddNested("UniqueValues", err.(smithy.InvalidParamsError))
		}
	}
	if v.Forecast != nil {
		if err := validateForecastComputation(v.Forecast); err != nil {
			invalidParams.AddNested("Forecast", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateConditionalFormattingColor(v *types.ConditionalFormattingColor) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConditionalFormattingColor"}
	if v.Solid != nil {
		if err := validateConditionalFormattingSolidColor(v.Solid); err != nil {
			invalidParams.AddNested("Solid", err.(smithy.InvalidParamsError))
		}
	}
	if v.Gradient != nil {
		if err := validateConditionalFormattingGradientColor(v.Gradient); err != nil {
			invalidParams.AddNested("Gradient", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConditionalFormattingCustomIconCondition(v *types.ConditionalFormattingCustomIconCondition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConditionalFormattingCustomIconCondition"}
	if v.Expression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
	}
	if v.IconOptions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IconOptions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConditionalFormattingGradientColor(v *types.ConditionalFormattingGradientColor) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConditionalFormattingGradientColor"}
	if v.Expression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
	}
	if v.Color == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Color"))
	} else if v.Color != nil {
		if err := validateGradientColor(v.Color); err != nil {
			invalidParams.AddNested("Color", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConditionalFormattingIcon(v *types.ConditionalFormattingIcon) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConditionalFormattingIcon"}
	if v.IconSet != nil {
		if err := validateConditionalFormattingIconSet(v.IconSet); err != nil {
			invalidParams.AddNested("IconSet", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomCondition != nil {
		if err := validateConditionalFormattingCustomIconCondition(v.CustomCondition); err != nil {
			invalidParams.AddNested("CustomCondition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateContributionAnalysisDefault(v *types.ContributionAnalysisDefault) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContributionAnalysisDefault"}
	if v.MeasureFieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MeasureFieldId"))
	}
	if v.ContributorDimensions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContributorDimensions"))
	} else if v.ContributorDimensions != nil {
		if err := validateContributorDimensionList(v.ContributorDimensions); err != nil {
			invalidParams.AddNested("ContributorDimensions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateContributorDimensionList(v []types.ColumnIdentifier) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContributorDimensionList"}
	for i := range v {
		if err := validateColumnIdentifier(&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 validateCurrencyDisplayFormatConfiguration(v *types.CurrencyDisplayFormatConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CurrencyDisplayFormatConfiguration"}
	if v.DecimalPlacesConfiguration != nil {
		if err := validateDecimalPlacesConfiguration(v.DecimalPlacesConfiguration); err != nil {
			invalidParams.AddNested("DecimalPlacesConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.NegativeValueConfiguration != nil {
		if err := validateNegativeValueConfiguration(v.NegativeValueConfiguration); err != nil {
			invalidParams.AddNested("NegativeValueConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.NullValueFormatConfiguration != nil {
		if err := validateNullValueFormatConfiguration(v.NullValueFormatConfiguration); err != nil {
			invalidParams.AddNested("NullValueFormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCustomActionFilterOperation(v *types.CustomActionFilterOperation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomActionFilterOperation"}
	if v.SelectedFieldsConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SelectedFieldsConfiguration"))
	} else if v.SelectedFieldsConfiguration != nil {
		if err := validateFilterOperationSelectedFieldsConfiguration(v.SelectedFieldsConfiguration); err != nil {
			invalidParams.AddNested("SelectedFieldsConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.TargetVisualsConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetVisualsConfiguration"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomActionNavigationOperation(v *types.CustomActionNavigationOperation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomActionNavigationOperation"}
	if v.LocalNavigationConfiguration != nil {
		if err := validateLocalNavigationConfiguration(v.LocalNavigationConfiguration); err != nil {
			invalidParams.AddNested("LocalNavigationConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomActionSetParametersOperation(v *types.CustomActionSetParametersOperation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomActionSetParametersOperation"}
	if v.ParameterValueConfigurations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterValueConfigurations"))
	} else if v.ParameterValueConfigurations != nil {
		if err := validateSetParameterValueConfigurationList(v.ParameterValueConfigurations); err != nil {
			invalidParams.AddNested("ParameterValueConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomActionURLOperation(v *types.CustomActionURLOperation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomActionURLOperation"}
	if v.URLTemplate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("URLTemplate"))
	}
	if len(v.URLTarget) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("URLTarget"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateCustomContentVisual(v *types.CustomContentVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomContentVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataSetIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomFilterConfiguration(v *types.CustomFilterConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomFilterConfiguration"}
	if len(v.MatchOperator) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MatchOperator"))
	}
	if len(v.NullOption) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("NullOption"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomFilterListConfiguration(v *types.CustomFilterListConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomFilterListConfiguration"}
	if len(v.MatchOperator) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MatchOperator"))
	}
	if len(v.NullOption) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("NullOption"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomNarrativeOptions(v *types.CustomNarrativeOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomNarrativeOptions"}
	if v.Narrative == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Narrative"))
	}
	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 validateCustomValuesConfiguration(v *types.CustomValuesConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomValuesConfiguration"}
	if v.CustomValues == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CustomValues"))
	}
	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 validateDashboardVersionDefinition(v *types.DashboardVersionDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DashboardVersionDefinition"}
	if v.DataSetIdentifierDeclarations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetIdentifierDeclarations"))
	} else if v.DataSetIdentifierDeclarations != nil {
		if err := validateDataSetIdentifierDeclarationList(v.DataSetIdentifierDeclarations); err != nil {
			invalidParams.AddNested("DataSetIdentifierDeclarations", err.(smithy.InvalidParamsError))
		}
	}
	if v.Sheets != nil {
		if err := validateSheetDefinitionList(v.Sheets); err != nil {
			invalidParams.AddNested("Sheets", err.(smithy.InvalidParamsError))
		}
	}
	if v.CalculatedFields != nil {
		if err := validateCalculatedFields(v.CalculatedFields); err != nil {
			invalidParams.AddNested("CalculatedFields", err.(smithy.InvalidParamsError))
		}
	}
	if v.ParameterDeclarations != nil {
		if err := validateParameterDeclarationList(v.ParameterDeclarations); err != nil {
			invalidParams.AddNested("ParameterDeclarations", err.(smithy.InvalidParamsError))
		}
	}
	if v.FilterGroups != nil {
		if err := validateFilterGroupList(v.FilterGroups); err != nil {
			invalidParams.AddNested("FilterGroups", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnConfigurations != nil {
		if err := validateColumnConfigurationList(v.ColumnConfigurations); err != nil {
			invalidParams.AddNested("ColumnConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.AnalysisDefaults != nil {
		if err := validateAnalysisDefaults(v.AnalysisDefaults); err != nil {
			invalidParams.AddNested("AnalysisDefaults", err.(smithy.InvalidParamsError))
		}
	}
	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 validateDataBarsOptions(v *types.DataBarsOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataBarsOptions"}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDataFieldSeriesItem(v *types.DataFieldSeriesItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataFieldSeriesItem"}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if len(v.AxisBinding) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AxisBinding"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDataPathColor(v *types.DataPathColor) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataPathColor"}
	if v.Element == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Element"))
	} else if v.Element != nil {
		if err := validateDataPathValue(v.Element); err != nil {
			invalidParams.AddNested("Element", err.(smithy.InvalidParamsError))
		}
	}
	if v.Color == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Color"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDataPathSort(v *types.DataPathSort) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataPathSort"}
	if len(v.Direction) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Direction"))
	}
	if v.SortPaths == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SortPaths"))
	} else if v.SortPaths != nil {
		if err := validateDataPathValueList(v.SortPaths); err != nil {
			invalidParams.AddNested("SortPaths", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDataPathValue(v *types.DataPathValue) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataPathValue"}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if v.FieldValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldValue"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateDatasetMetadata(v *types.DatasetMetadata) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DatasetMetadata"}
	if v.DatasetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatasetArn"))
	}
	if v.Filters != nil {
		if err := validateTopicFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if v.Columns != nil {
		if err := validateTopicColumns(v.Columns); err != nil {
			invalidParams.AddNested("Columns", err.(smithy.InvalidParamsError))
		}
	}
	if v.CalculatedFields != nil {
		if err := validateTopicCalculatedFields(v.CalculatedFields); err != nil {
			invalidParams.AddNested("CalculatedFields", err.(smithy.InvalidParamsError))
		}
	}
	if v.NamedEntities != nil {
		if err := validateTopicNamedEntities(v.NamedEntities); err != nil {
			invalidParams.AddNested("NamedEntities", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDatasetParameter(v *types.DatasetParameter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DatasetParameter"}
	if v.StringDatasetParameter != nil {
		if err := validateStringDatasetParameter(v.StringDatasetParameter); err != nil {
			invalidParams.AddNested("StringDatasetParameter", err.(smithy.InvalidParamsError))
		}
	}
	if v.DecimalDatasetParameter != nil {
		if err := validateDecimalDatasetParameter(v.DecimalDatasetParameter); err != nil {
			invalidParams.AddNested("DecimalDatasetParameter", err.(smithy.InvalidParamsError))
		}
	}
	if v.IntegerDatasetParameter != nil {
		if err := validateIntegerDatasetParameter(v.IntegerDatasetParameter); err != nil {
			invalidParams.AddNested("IntegerDatasetParameter", err.(smithy.InvalidParamsError))
		}
	}
	if v.DateTimeDatasetParameter != nil {
		if err := validateDateTimeDatasetParameter(v.DateTimeDatasetParameter); err != nil {
			invalidParams.AddNested("DateTimeDatasetParameter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDatasetParameterList(v []types.DatasetParameter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DatasetParameterList"}
	for i := range v {
		if err := validateDatasetParameter(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	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 validateDataSetRefreshProperties(v *types.DataSetRefreshProperties) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataSetRefreshProperties"}
	if v.RefreshConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RefreshConfiguration"))
	} else if v.RefreshConfiguration != nil {
		if err := validateRefreshConfiguration(v.RefreshConfiguration); err != nil {
			invalidParams.AddNested("RefreshConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDataSetSearchFilter(v *types.DataSetSearchFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataSetSearchFilter"}
	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 validateDataSetSearchFilterList(v []types.DataSetSearchFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataSetSearchFilterList"}
	for i := range v {
		if err := validateDataSetSearchFilter(&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.DataSourceParametersMemberDatabricksParameters:
		if err := validateDatabricksParameters(&uv.Value); err != nil {
			invalidParams.AddNested("[DatabricksParameters]", 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 validateDataSourceSearchFilter(v *types.DataSourceSearchFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataSourceSearchFilter"}
	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 validateDataSourceSearchFilterList(v []types.DataSourceSearchFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataSourceSearchFilterList"}
	for i := range v {
		if err := validateDataSourceSearchFilter(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDateDimensionField(v *types.DateDimensionField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DateDimensionField"}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if v.FormatConfiguration != nil {
		if err := validateDateTimeFormatConfiguration(v.FormatConfiguration); err != nil {
			invalidParams.AddNested("FormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDateMeasureField(v *types.DateMeasureField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DateMeasureField"}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if v.FormatConfiguration != nil {
		if err := validateDateTimeFormatConfiguration(v.FormatConfiguration); err != nil {
			invalidParams.AddNested("FormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDateTimeDefaultValues(v *types.DateTimeDefaultValues) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DateTimeDefaultValues"}
	if v.DynamicValue != nil {
		if err := validateDynamicDefaultValue(v.DynamicValue); err != nil {
			invalidParams.AddNested("DynamicValue", err.(smithy.InvalidParamsError))
		}
	}
	if v.RollingDate != nil {
		if err := validateRollingDateConfiguration(v.RollingDate); err != nil {
			invalidParams.AddNested("RollingDate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDateTimeFormatConfiguration(v *types.DateTimeFormatConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DateTimeFormatConfiguration"}
	if v.NullValueFormatConfiguration != nil {
		if err := validateNullValueFormatConfiguration(v.NullValueFormatConfiguration); err != nil {
			invalidParams.AddNested("NullValueFormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.NumericFormatConfiguration != nil {
		if err := validateNumericFormatConfiguration(v.NumericFormatConfiguration); err != nil {
			invalidParams.AddNested("NumericFormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDateTimeHierarchy(v *types.DateTimeHierarchy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DateTimeHierarchy"}
	if v.HierarchyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HierarchyId"))
	}
	if v.DrillDownFilters != nil {
		if err := validateDrillDownFilterList(v.DrillDownFilters); err != nil {
			invalidParams.AddNested("DrillDownFilters", 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 validateDateTimeParameterDeclaration(v *types.DateTimeParameterDeclaration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DateTimeParameterDeclaration"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.DefaultValues != nil {
		if err := validateDateTimeDefaultValues(v.DefaultValues); err != nil {
			invalidParams.AddNested("DefaultValues", err.(smithy.InvalidParamsError))
		}
	}
	if v.MappedDataSetParameters != nil {
		if err := validateMappedDataSetParameters(v.MappedDataSetParameters); err != nil {
			invalidParams.AddNested("MappedDataSetParameters", err.(smithy.InvalidParamsError))
		}
	}
	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 validateDecimalDatasetParameter(v *types.DecimalDatasetParameter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DecimalDatasetParameter"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.ValueType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ValueType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDecimalDefaultValues(v *types.DecimalDefaultValues) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DecimalDefaultValues"}
	if v.DynamicValue != nil {
		if err := validateDynamicDefaultValue(v.DynamicValue); err != nil {
			invalidParams.AddNested("DynamicValue", 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 validateDecimalParameterDeclaration(v *types.DecimalParameterDeclaration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DecimalParameterDeclaration"}
	if len(v.ParameterValueType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterValueType"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.DefaultValues != nil {
		if err := validateDecimalDefaultValues(v.DefaultValues); err != nil {
			invalidParams.AddNested("DefaultValues", err.(smithy.InvalidParamsError))
		}
	}
	if v.MappedDataSetParameters != nil {
		if err := validateMappedDataSetParameters(v.MappedDataSetParameters); err != nil {
			invalidParams.AddNested("MappedDataSetParameters", err.(smithy.InvalidParamsError))
		}
	}
	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 validateDecimalPlacesConfiguration(v *types.DecimalPlacesConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DecimalPlacesConfiguration"}
	if v.DecimalPlaces == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DecimalPlaces"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDefaultFreeFormLayoutConfiguration(v *types.DefaultFreeFormLayoutConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DefaultFreeFormLayoutConfiguration"}
	if v.CanvasSizeOptions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CanvasSizeOptions"))
	} else if v.CanvasSizeOptions != nil {
		if err := validateFreeFormLayoutCanvasSizeOptions(v.CanvasSizeOptions); err != nil {
			invalidParams.AddNested("CanvasSizeOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDefaultGridLayoutConfiguration(v *types.DefaultGridLayoutConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DefaultGridLayoutConfiguration"}
	if v.CanvasSizeOptions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CanvasSizeOptions"))
	} else if v.CanvasSizeOptions != nil {
		if err := validateGridLayoutCanvasSizeOptions(v.CanvasSizeOptions); err != nil {
			invalidParams.AddNested("CanvasSizeOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDefaultInteractiveLayoutConfiguration(v *types.DefaultInteractiveLayoutConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DefaultInteractiveLayoutConfiguration"}
	if v.Grid != nil {
		if err := validateDefaultGridLayoutConfiguration(v.Grid); err != nil {
			invalidParams.AddNested("Grid", err.(smithy.InvalidParamsError))
		}
	}
	if v.FreeForm != nil {
		if err := validateDefaultFreeFormLayoutConfiguration(v.FreeForm); err != nil {
			invalidParams.AddNested("FreeForm", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDefaultNewSheetConfiguration(v *types.DefaultNewSheetConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DefaultNewSheetConfiguration"}
	if v.InteractiveLayoutConfiguration != nil {
		if err := validateDefaultInteractiveLayoutConfiguration(v.InteractiveLayoutConfiguration); err != nil {
			invalidParams.AddNested("InteractiveLayoutConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.PaginatedLayoutConfiguration != nil {
		if err := validateDefaultPaginatedLayoutConfiguration(v.PaginatedLayoutConfiguration); err != nil {
			invalidParams.AddNested("PaginatedLayoutConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDefaultPaginatedLayoutConfiguration(v *types.DefaultPaginatedLayoutConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DefaultPaginatedLayoutConfiguration"}
	if v.SectionBased != nil {
		if err := validateDefaultSectionBasedLayoutConfiguration(v.SectionBased); err != nil {
			invalidParams.AddNested("SectionBased", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDestinationParameterValueConfiguration(v *types.DestinationParameterValueConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DestinationParameterValueConfiguration"}
	if v.CustomValuesConfiguration != nil {
		if err := validateCustomValuesConfiguration(v.CustomValuesConfiguration); err != nil {
			invalidParams.AddNested("CustomValuesConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.SourceColumn != nil {
		if err := validateColumnIdentifier(v.SourceColumn); err != nil {
			invalidParams.AddNested("SourceColumn", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDimensionField(v *types.DimensionField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DimensionField"}
	if v.NumericalDimensionField != nil {
		if err := validateNumericalDimensionField(v.NumericalDimensionField); err != nil {
			invalidParams.AddNested("NumericalDimensionField", err.(smithy.InvalidParamsError))
		}
	}
	if v.CategoricalDimensionField != nil {
		if err := validateCategoricalDimensionField(v.CategoricalDimensionField); err != nil {
			invalidParams.AddNested("CategoricalDimensionField", err.(smithy.InvalidParamsError))
		}
	}
	if v.DateDimensionField != nil {
		if err := validateDateDimensionField(v.DateDimensionField); err != nil {
			invalidParams.AddNested("DateDimensionField", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDrillDownFilter(v *types.DrillDownFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DrillDownFilter"}
	if v.NumericEqualityFilter != nil {
		if err := validateNumericEqualityDrillDownFilter(v.NumericEqualityFilter); err != nil {
			invalidParams.AddNested("NumericEqualityFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.CategoryFilter != nil {
		if err := validateCategoryDrillDownFilter(v.CategoryFilter); err != nil {
			invalidParams.AddNested("CategoryFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.TimeRangeFilter != nil {
		if err := validateTimeRangeDrillDownFilter(v.TimeRangeFilter); err != nil {
			invalidParams.AddNested("TimeRangeFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDynamicDefaultValue(v *types.DynamicDefaultValue) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DynamicDefaultValue"}
	if v.UserNameColumn != nil {
		if err := validateColumnIdentifier(v.UserNameColumn); err != nil {
			invalidParams.AddNested("UserNameColumn", err.(smithy.InvalidParamsError))
		}
	}
	if v.GroupNameColumn != nil {
		if err := validateColumnIdentifier(v.GroupNameColumn); err != nil {
			invalidParams.AddNested("GroupNameColumn", err.(smithy.InvalidParamsError))
		}
	}
	if v.DefaultValueColumn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultValueColumn"))
	} else if v.DefaultValueColumn != nil {
		if err := validateColumnIdentifier(v.DefaultValueColumn); err != nil {
			invalidParams.AddNested("DefaultValueColumn", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEmptyVisual(v *types.EmptyVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EmptyVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.DataSetIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetIdentifier"))
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", 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 validateExcludePeriodConfiguration(v *types.ExcludePeriodConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExcludePeriodConfiguration"}
	if v.Amount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Amount"))
	}
	if len(v.Granularity) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Granularity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateExplicitHierarchy(v *types.ExplicitHierarchy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExplicitHierarchy"}
	if v.HierarchyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HierarchyId"))
	}
	if v.Columns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Columns"))
	} else if v.Columns != nil {
		if err := validateExplicitHierarchyColumnList(v.Columns); err != nil {
			invalidParams.AddNested("Columns", err.(smithy.InvalidParamsError))
		}
	}
	if v.DrillDownFilters != nil {
		if err := validateDrillDownFilterList(v.DrillDownFilters); err != nil {
			invalidParams.AddNested("DrillDownFilters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateFieldBasedTooltip(v *types.FieldBasedTooltip) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FieldBasedTooltip"}
	if v.TooltipFields != nil {
		if err := validateTooltipItemList(v.TooltipFields); err != nil {
			invalidParams.AddNested("TooltipFields", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFieldSeriesItem(v *types.FieldSeriesItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FieldSeriesItem"}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if len(v.AxisBinding) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AxisBinding"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFieldSort(v *types.FieldSort) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FieldSort"}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if len(v.Direction) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Direction"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFieldSortOptions(v *types.FieldSortOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FieldSortOptions"}
	if v.FieldSort != nil {
		if err := validateFieldSort(v.FieldSort); err != nil {
			invalidParams.AddNested("FieldSort", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnSort != nil {
		if err := validateColumnSort(v.ColumnSort); err != nil {
			invalidParams.AddNested("ColumnSort", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateFilledMapAggregatedFieldWells(v *types.FilledMapAggregatedFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilledMapAggregatedFieldWells"}
	if v.Geospatial != nil {
		if err := validateFilledMapDimensionFieldList(v.Geospatial); err != nil {
			invalidParams.AddNested("Geospatial", err.(smithy.InvalidParamsError))
		}
	}
	if v.Values != nil {
		if err := validateFilledMapMeasureFieldList(v.Values); err != nil {
			invalidParams.AddNested("Values", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFilledMapConditionalFormatting(v *types.FilledMapConditionalFormatting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilledMapConditionalFormatting"}
	if v.ConditionalFormattingOptions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConditionalFormattingOptions"))
	} else if v.ConditionalFormattingOptions != nil {
		if err := validateFilledMapConditionalFormattingOptionList(v.ConditionalFormattingOptions); err != nil {
			invalidParams.AddNested("ConditionalFormattingOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFilledMapConditionalFormattingOption(v *types.FilledMapConditionalFormattingOption) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilledMapConditionalFormattingOption"}
	if v.Shape == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Shape"))
	} else if v.Shape != nil {
		if err := validateFilledMapShapeConditionalFormatting(v.Shape); err != nil {
			invalidParams.AddNested("Shape", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateFilledMapConfiguration(v *types.FilledMapConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilledMapConfiguration"}
	if v.FieldWells != nil {
		if err := validateFilledMapFieldWells(v.FieldWells); err != nil {
			invalidParams.AddNested("FieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortConfiguration != nil {
		if err := validateFilledMapSortConfiguration(v.SortConfiguration); err != nil {
			invalidParams.AddNested("SortConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tooltip != nil {
		if err := validateTooltipOptions(v.Tooltip); err != nil {
			invalidParams.AddNested("Tooltip", err.(smithy.InvalidParamsError))
		}
	}
	if v.WindowOptions != nil {
		if err := validateGeospatialWindowOptions(v.WindowOptions); err != nil {
			invalidParams.AddNested("WindowOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateFilledMapFieldWells(v *types.FilledMapFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilledMapFieldWells"}
	if v.FilledMapAggregatedFieldWells != nil {
		if err := validateFilledMapAggregatedFieldWells(v.FilledMapAggregatedFieldWells); err != nil {
			invalidParams.AddNested("FilledMapAggregatedFieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateFilledMapShapeConditionalFormatting(v *types.FilledMapShapeConditionalFormatting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilledMapShapeConditionalFormatting"}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if v.Format != nil {
		if err := validateShapeConditionalFormat(v.Format); err != nil {
			invalidParams.AddNested("Format", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFilledMapSortConfiguration(v *types.FilledMapSortConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilledMapSortConfiguration"}
	if v.CategorySort != nil {
		if err := validateFieldSortOptionsList(v.CategorySort); err != nil {
			invalidParams.AddNested("CategorySort", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFilledMapVisual(v *types.FilledMapVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilledMapVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.ChartConfiguration != nil {
		if err := validateFilledMapConfiguration(v.ChartConfiguration); err != nil {
			invalidParams.AddNested("ChartConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ConditionalFormatting != nil {
		if err := validateFilledMapConditionalFormatting(v.ConditionalFormatting); err != nil {
			invalidParams.AddNested("ConditionalFormatting", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnHierarchies != nil {
		if err := validateColumnHierarchyList(v.ColumnHierarchies); err != nil {
			invalidParams.AddNested("ColumnHierarchies", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFilter(v *types.Filter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Filter"}
	if v.CategoryFilter != nil {
		if err := validateCategoryFilter(v.CategoryFilter); err != nil {
			invalidParams.AddNested("CategoryFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.NumericRangeFilter != nil {
		if err := validateNumericRangeFilter(v.NumericRangeFilter); err != nil {
			invalidParams.AddNested("NumericRangeFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.NumericEqualityFilter != nil {
		if err := validateNumericEqualityFilter(v.NumericEqualityFilter); err != nil {
			invalidParams.AddNested("NumericEqualityFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.TimeEqualityFilter != nil {
		if err := validateTimeEqualityFilter(v.TimeEqualityFilter); err != nil {
			invalidParams.AddNested("TimeEqualityFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.TimeRangeFilter != nil {
		if err := validateTimeRangeFilter(v.TimeRangeFilter); err != nil {
			invalidParams.AddNested("TimeRangeFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.RelativeDatesFilter != nil {
		if err := validateRelativeDatesFilter(v.RelativeDatesFilter); err != nil {
			invalidParams.AddNested("RelativeDatesFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.TopBottomFilter != nil {
		if err := validateTopBottomFilter(v.TopBottomFilter); err != nil {
			invalidParams.AddNested("TopBottomFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFilterControl(v *types.FilterControl) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilterControl"}
	if v.DateTimePicker != nil {
		if err := validateFilterDateTimePickerControl(v.DateTimePicker); err != nil {
			invalidParams.AddNested("DateTimePicker", err.(smithy.InvalidParamsError))
		}
	}
	if v.List != nil {
		if err := validateFilterListControl(v.List); err != nil {
			invalidParams.AddNested("List", err.(smithy.InvalidParamsError))
		}
	}
	if v.Dropdown != nil {
		if err := validateFilterDropDownControl(v.Dropdown); err != nil {
			invalidParams.AddNested("Dropdown", err.(smithy.InvalidParamsError))
		}
	}
	if v.TextField != nil {
		if err := validateFilterTextFieldControl(v.TextField); err != nil {
			invalidParams.AddNested("TextField", err.(smithy.InvalidParamsError))
		}
	}
	if v.TextArea != nil {
		if err := validateFilterTextAreaControl(v.TextArea); err != nil {
			invalidParams.AddNested("TextArea", err.(smithy.InvalidParamsError))
		}
	}
	if v.Slider != nil {
		if err := validateFilterSliderControl(v.Slider); err != nil {
			invalidParams.AddNested("Slider", err.(smithy.InvalidParamsError))
		}
	}
	if v.RelativeDateTime != nil {
		if err := validateFilterRelativeDateTimeControl(v.RelativeDateTime); err != nil {
			invalidParams.AddNested("RelativeDateTime", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateFilterDateTimePickerControl(v *types.FilterDateTimePickerControl) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilterDateTimePickerControl"}
	if v.FilterControlId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilterControlId"))
	}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.SourceFilterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceFilterId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFilterDropDownControl(v *types.FilterDropDownControl) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilterDropDownControl"}
	if v.FilterControlId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilterControlId"))
	}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.SourceFilterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceFilterId"))
	}
	if v.CascadingControlConfiguration != nil {
		if err := validateCascadingControlConfiguration(v.CascadingControlConfiguration); err != nil {
			invalidParams.AddNested("CascadingControlConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFilterGroup(v *types.FilterGroup) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilterGroup"}
	if v.FilterGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilterGroupId"))
	}
	if v.Filters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Filters"))
	} else if v.Filters != nil {
		if err := validateFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if v.ScopeConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScopeConfiguration"))
	} else if v.ScopeConfiguration != nil {
		if err := validateFilterScopeConfiguration(v.ScopeConfiguration); err != nil {
			invalidParams.AddNested("ScopeConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.CrossDataset) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("CrossDataset"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateFilterListControl(v *types.FilterListControl) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilterListControl"}
	if v.FilterControlId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilterControlId"))
	}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.SourceFilterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceFilterId"))
	}
	if v.CascadingControlConfiguration != nil {
		if err := validateCascadingControlConfiguration(v.CascadingControlConfiguration); err != nil {
			invalidParams.AddNested("CascadingControlConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	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 validateFilterOperationSelectedFieldsConfiguration(v *types.FilterOperationSelectedFieldsConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilterOperationSelectedFieldsConfiguration"}
	if v.SelectedColumns != nil {
		if err := validateCustomActionColumnList(v.SelectedColumns); err != nil {
			invalidParams.AddNested("SelectedColumns", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFilterRelativeDateTimeControl(v *types.FilterRelativeDateTimeControl) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilterRelativeDateTimeControl"}
	if v.FilterControlId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilterControlId"))
	}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.SourceFilterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceFilterId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFilterScopeConfiguration(v *types.FilterScopeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilterScopeConfiguration"}
	if v.SelectedSheets != nil {
		if err := validateSelectedSheetsFilterScopeConfiguration(v.SelectedSheets); err != nil {
			invalidParams.AddNested("SelectedSheets", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFilterSliderControl(v *types.FilterSliderControl) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilterSliderControl"}
	if v.FilterControlId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilterControlId"))
	}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.SourceFilterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceFilterId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFilterTextAreaControl(v *types.FilterTextAreaControl) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilterTextAreaControl"}
	if v.FilterControlId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilterControlId"))
	}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.SourceFilterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceFilterId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFilterTextFieldControl(v *types.FilterTextFieldControl) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilterTextFieldControl"}
	if v.FilterControlId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilterControlId"))
	}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.SourceFilterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceFilterId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateForecastComputation(v *types.ForecastComputation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ForecastComputation"}
	if v.ComputationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ComputationId"))
	}
	if v.Time == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Time"))
	} else if v.Time != nil {
		if err := validateDimensionField(v.Time); err != nil {
			invalidParams.AddNested("Time", err.(smithy.InvalidParamsError))
		}
	}
	if v.Value != nil {
		if err := validateMeasureField(v.Value); err != nil {
			invalidParams.AddNested("Value", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateForecastConfiguration(v *types.ForecastConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ForecastConfiguration"}
	if v.Scenario != nil {
		if err := validateForecastScenario(v.Scenario); err != nil {
			invalidParams.AddNested("Scenario", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateForecastScenario(v *types.ForecastScenario) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ForecastScenario"}
	if v.WhatIfPointScenario != nil {
		if err := validateWhatIfPointScenario(v.WhatIfPointScenario); err != nil {
			invalidParams.AddNested("WhatIfPointScenario", err.(smithy.InvalidParamsError))
		}
	}
	if v.WhatIfRangeScenario != nil {
		if err := validateWhatIfRangeScenario(v.WhatIfRangeScenario); err != nil {
			invalidParams.AddNested("WhatIfRangeScenario", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFormatConfiguration(v *types.FormatConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FormatConfiguration"}
	if v.StringFormatConfiguration != nil {
		if err := validateStringFormatConfiguration(v.StringFormatConfiguration); err != nil {
			invalidParams.AddNested("StringFormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.NumberFormatConfiguration != nil {
		if err := validateNumberFormatConfiguration(v.NumberFormatConfiguration); err != nil {
			invalidParams.AddNested("NumberFormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.DateTimeFormatConfiguration != nil {
		if err := validateDateTimeFormatConfiguration(v.DateTimeFormatConfiguration); err != nil {
			invalidParams.AddNested("DateTimeFormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFreeFormLayoutCanvasSizeOptions(v *types.FreeFormLayoutCanvasSizeOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FreeFormLayoutCanvasSizeOptions"}
	if v.ScreenCanvasSizeOptions != nil {
		if err := validateFreeFormLayoutScreenCanvasSizeOptions(v.ScreenCanvasSizeOptions); err != nil {
			invalidParams.AddNested("ScreenCanvasSizeOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFreeFormLayoutConfiguration(v *types.FreeFormLayoutConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FreeFormLayoutConfiguration"}
	if v.Elements == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Elements"))
	} else if v.Elements != nil {
		if err := validateFreeFromLayoutElementList(v.Elements); err != nil {
			invalidParams.AddNested("Elements", err.(smithy.InvalidParamsError))
		}
	}
	if v.CanvasSizeOptions != nil {
		if err := validateFreeFormLayoutCanvasSizeOptions(v.CanvasSizeOptions); err != nil {
			invalidParams.AddNested("CanvasSizeOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFreeFormLayoutElement(v *types.FreeFormLayoutElement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FreeFormLayoutElement"}
	if v.ElementId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ElementId"))
	}
	if len(v.ElementType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ElementType"))
	}
	if v.XAxisLocation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("XAxisLocation"))
	}
	if v.YAxisLocation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("YAxisLocation"))
	}
	if v.Width == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Width"))
	}
	if v.Height == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Height"))
	}
	if v.RenderingRules != nil {
		if err := validateSheetElementRenderingRuleList(v.RenderingRules); err != nil {
			invalidParams.AddNested("RenderingRules", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateFreeFormSectionLayoutConfiguration(v *types.FreeFormSectionLayoutConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FreeFormSectionLayoutConfiguration"}
	if v.Elements == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Elements"))
	} else if v.Elements != nil {
		if err := validateFreeFromLayoutElementList(v.Elements); err != nil {
			invalidParams.AddNested("Elements", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateFunnelChartAggregatedFieldWells(v *types.FunnelChartAggregatedFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FunnelChartAggregatedFieldWells"}
	if v.Category != nil {
		if err := validateFunnelChartDimensionFieldList(v.Category); err != nil {
			invalidParams.AddNested("Category", err.(smithy.InvalidParamsError))
		}
	}
	if v.Values != nil {
		if err := validateFunnelChartMeasureFieldList(v.Values); err != nil {
			invalidParams.AddNested("Values", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFunnelChartConfiguration(v *types.FunnelChartConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FunnelChartConfiguration"}
	if v.FieldWells != nil {
		if err := validateFunnelChartFieldWells(v.FieldWells); err != nil {
			invalidParams.AddNested("FieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortConfiguration != nil {
		if err := validateFunnelChartSortConfiguration(v.SortConfiguration); err != nil {
			invalidParams.AddNested("SortConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CategoryLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.CategoryLabelOptions); err != nil {
			invalidParams.AddNested("CategoryLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ValueLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.ValueLabelOptions); err != nil {
			invalidParams.AddNested("ValueLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tooltip != nil {
		if err := validateTooltipOptions(v.Tooltip); err != nil {
			invalidParams.AddNested("Tooltip", err.(smithy.InvalidParamsError))
		}
	}
	if v.VisualPalette != nil {
		if err := validateVisualPalette(v.VisualPalette); err != nil {
			invalidParams.AddNested("VisualPalette", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateFunnelChartFieldWells(v *types.FunnelChartFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FunnelChartFieldWells"}
	if v.FunnelChartAggregatedFieldWells != nil {
		if err := validateFunnelChartAggregatedFieldWells(v.FunnelChartAggregatedFieldWells); err != nil {
			invalidParams.AddNested("FunnelChartAggregatedFieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateFunnelChartSortConfiguration(v *types.FunnelChartSortConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FunnelChartSortConfiguration"}
	if v.CategorySort != nil {
		if err := validateFieldSortOptionsList(v.CategorySort); err != nil {
			invalidParams.AddNested("CategorySort", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFunnelChartVisual(v *types.FunnelChartVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FunnelChartVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.ChartConfiguration != nil {
		if err := validateFunnelChartConfiguration(v.ChartConfiguration); err != nil {
			invalidParams.AddNested("ChartConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnHierarchies != nil {
		if err := validateColumnHierarchyList(v.ColumnHierarchies); err != nil {
			invalidParams.AddNested("ColumnHierarchies", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGaugeChartArcConditionalFormatting(v *types.GaugeChartArcConditionalFormatting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GaugeChartArcConditionalFormatting"}
	if v.ForegroundColor != nil {
		if err := validateConditionalFormattingColor(v.ForegroundColor); err != nil {
			invalidParams.AddNested("ForegroundColor", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGaugeChartConditionalFormatting(v *types.GaugeChartConditionalFormatting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GaugeChartConditionalFormatting"}
	if v.ConditionalFormattingOptions != nil {
		if err := validateGaugeChartConditionalFormattingOptionList(v.ConditionalFormattingOptions); err != nil {
			invalidParams.AddNested("ConditionalFormattingOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGaugeChartConditionalFormattingOption(v *types.GaugeChartConditionalFormattingOption) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GaugeChartConditionalFormattingOption"}
	if v.PrimaryValue != nil {
		if err := validateGaugeChartPrimaryValueConditionalFormatting(v.PrimaryValue); err != nil {
			invalidParams.AddNested("PrimaryValue", err.(smithy.InvalidParamsError))
		}
	}
	if v.Arc != nil {
		if err := validateGaugeChartArcConditionalFormatting(v.Arc); err != nil {
			invalidParams.AddNested("Arc", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateGaugeChartConfiguration(v *types.GaugeChartConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GaugeChartConfiguration"}
	if v.FieldWells != nil {
		if err := validateGaugeChartFieldWells(v.FieldWells); err != nil {
			invalidParams.AddNested("FieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.GaugeChartOptions != nil {
		if err := validateGaugeChartOptions(v.GaugeChartOptions); err != nil {
			invalidParams.AddNested("GaugeChartOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.TooltipOptions != nil {
		if err := validateTooltipOptions(v.TooltipOptions); err != nil {
			invalidParams.AddNested("TooltipOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.VisualPalette != nil {
		if err := validateVisualPalette(v.VisualPalette); err != nil {
			invalidParams.AddNested("VisualPalette", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGaugeChartFieldWells(v *types.GaugeChartFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GaugeChartFieldWells"}
	if v.Values != nil {
		if err := validateMeasureFieldList(v.Values); err != nil {
			invalidParams.AddNested("Values", err.(smithy.InvalidParamsError))
		}
	}
	if v.TargetValues != nil {
		if err := validateMeasureFieldList(v.TargetValues); err != nil {
			invalidParams.AddNested("TargetValues", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGaugeChartOptions(v *types.GaugeChartOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GaugeChartOptions"}
	if v.Comparison != nil {
		if err := validateComparisonConfiguration(v.Comparison); err != nil {
			invalidParams.AddNested("Comparison", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGaugeChartPrimaryValueConditionalFormatting(v *types.GaugeChartPrimaryValueConditionalFormatting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GaugeChartPrimaryValueConditionalFormatting"}
	if v.TextColor != nil {
		if err := validateConditionalFormattingColor(v.TextColor); err != nil {
			invalidParams.AddNested("TextColor", err.(smithy.InvalidParamsError))
		}
	}
	if v.Icon != nil {
		if err := validateConditionalFormattingIcon(v.Icon); err != nil {
			invalidParams.AddNested("Icon", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGaugeChartVisual(v *types.GaugeChartVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GaugeChartVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.ChartConfiguration != nil {
		if err := validateGaugeChartConfiguration(v.ChartConfiguration); err != nil {
			invalidParams.AddNested("ChartConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ConditionalFormatting != nil {
		if err := validateGaugeChartConditionalFormatting(v.ConditionalFormatting); err != nil {
			invalidParams.AddNested("ConditionalFormatting", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	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 validateGeospatialCoordinateBounds(v *types.GeospatialCoordinateBounds) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GeospatialCoordinateBounds"}
	if v.North == nil {
		invalidParams.Add(smithy.NewErrParamRequired("North"))
	}
	if v.South == nil {
		invalidParams.Add(smithy.NewErrParamRequired("South"))
	}
	if v.West == nil {
		invalidParams.Add(smithy.NewErrParamRequired("West"))
	}
	if v.East == nil {
		invalidParams.Add(smithy.NewErrParamRequired("East"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGeospatialHeatmapColorScale(v *types.GeospatialHeatmapColorScale) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GeospatialHeatmapColorScale"}
	if v.Colors != nil {
		if err := validateGeospatialHeatmapDataColorList(v.Colors); err != nil {
			invalidParams.AddNested("Colors", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGeospatialHeatmapConfiguration(v *types.GeospatialHeatmapConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GeospatialHeatmapConfiguration"}
	if v.HeatmapColor != nil {
		if err := validateGeospatialHeatmapColorScale(v.HeatmapColor); err != nil {
			invalidParams.AddNested("HeatmapColor", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateGeospatialMapAggregatedFieldWells(v *types.GeospatialMapAggregatedFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GeospatialMapAggregatedFieldWells"}
	if v.Geospatial != nil {
		if err := validateDimensionFieldList(v.Geospatial); err != nil {
			invalidParams.AddNested("Geospatial", err.(smithy.InvalidParamsError))
		}
	}
	if v.Values != nil {
		if err := validateMeasureFieldList(v.Values); err != nil {
			invalidParams.AddNested("Values", err.(smithy.InvalidParamsError))
		}
	}
	if v.Colors != nil {
		if err := validateDimensionFieldList(v.Colors); err != nil {
			invalidParams.AddNested("Colors", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGeospatialMapConfiguration(v *types.GeospatialMapConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GeospatialMapConfiguration"}
	if v.FieldWells != nil {
		if err := validateGeospatialMapFieldWells(v.FieldWells); err != nil {
			invalidParams.AddNested("FieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tooltip != nil {
		if err := validateTooltipOptions(v.Tooltip); err != nil {
			invalidParams.AddNested("Tooltip", err.(smithy.InvalidParamsError))
		}
	}
	if v.WindowOptions != nil {
		if err := validateGeospatialWindowOptions(v.WindowOptions); err != nil {
			invalidParams.AddNested("WindowOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.PointStyleOptions != nil {
		if err := validateGeospatialPointStyleOptions(v.PointStyleOptions); err != nil {
			invalidParams.AddNested("PointStyleOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.VisualPalette != nil {
		if err := validateVisualPalette(v.VisualPalette); err != nil {
			invalidParams.AddNested("VisualPalette", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGeospatialMapFieldWells(v *types.GeospatialMapFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GeospatialMapFieldWells"}
	if v.GeospatialMapAggregatedFieldWells != nil {
		if err := validateGeospatialMapAggregatedFieldWells(v.GeospatialMapAggregatedFieldWells); err != nil {
			invalidParams.AddNested("GeospatialMapAggregatedFieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGeospatialMapVisual(v *types.GeospatialMapVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GeospatialMapVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.ChartConfiguration != nil {
		if err := validateGeospatialMapConfiguration(v.ChartConfiguration); err != nil {
			invalidParams.AddNested("ChartConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnHierarchies != nil {
		if err := validateColumnHierarchyList(v.ColumnHierarchies); err != nil {
			invalidParams.AddNested("ColumnHierarchies", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGeospatialPointStyleOptions(v *types.GeospatialPointStyleOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GeospatialPointStyleOptions"}
	if v.HeatmapConfiguration != nil {
		if err := validateGeospatialHeatmapConfiguration(v.HeatmapConfiguration); err != nil {
			invalidParams.AddNested("HeatmapConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGeospatialWindowOptions(v *types.GeospatialWindowOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GeospatialWindowOptions"}
	if v.Bounds != nil {
		if err := validateGeospatialCoordinateBounds(v.Bounds); err != nil {
			invalidParams.AddNested("Bounds", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGradientColor(v *types.GradientColor) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GradientColor"}
	if v.Stops != nil {
		if err := validateGradientStopList(v.Stops); err != nil {
			invalidParams.AddNested("Stops", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGradientStop(v *types.GradientStop) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GradientStop"}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateGridLayoutCanvasSizeOptions(v *types.GridLayoutCanvasSizeOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GridLayoutCanvasSizeOptions"}
	if v.ScreenCanvasSizeOptions != nil {
		if err := validateGridLayoutScreenCanvasSizeOptions(v.ScreenCanvasSizeOptions); err != nil {
			invalidParams.AddNested("ScreenCanvasSizeOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGridLayoutConfiguration(v *types.GridLayoutConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GridLayoutConfiguration"}
	if v.Elements == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Elements"))
	} else if v.Elements != nil {
		if err := validateGridLayoutElementList(v.Elements); err != nil {
			invalidParams.AddNested("Elements", err.(smithy.InvalidParamsError))
		}
	}
	if v.CanvasSizeOptions != nil {
		if err := validateGridLayoutCanvasSizeOptions(v.CanvasSizeOptions); err != nil {
			invalidParams.AddNested("CanvasSizeOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGridLayoutElement(v *types.GridLayoutElement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GridLayoutElement"}
	if v.ElementId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ElementId"))
	}
	if len(v.ElementType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ElementType"))
	}
	if v.ColumnSpan == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnSpan"))
	}
	if v.RowSpan == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RowSpan"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateGridLayoutScreenCanvasSizeOptions(v *types.GridLayoutScreenCanvasSizeOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GridLayoutScreenCanvasSizeOptions"}
	if len(v.ResizeOption) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResizeOption"))
	}
	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 validateGrowthRateComputation(v *types.GrowthRateComputation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GrowthRateComputation"}
	if v.ComputationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ComputationId"))
	}
	if v.Time == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Time"))
	} else if v.Time != nil {
		if err := validateDimensionField(v.Time); err != nil {
			invalidParams.AddNested("Time", err.(smithy.InvalidParamsError))
		}
	}
	if v.Value != nil {
		if err := validateMeasureField(v.Value); err != nil {
			invalidParams.AddNested("Value", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateHeaderFooterSectionConfiguration(v *types.HeaderFooterSectionConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HeaderFooterSectionConfiguration"}
	if v.SectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SectionId"))
	}
	if v.Layout == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Layout"))
	} else if v.Layout != nil {
		if err := validateSectionLayoutConfiguration(v.Layout); err != nil {
			invalidParams.AddNested("Layout", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateHeatMapAggregatedFieldWells(v *types.HeatMapAggregatedFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HeatMapAggregatedFieldWells"}
	if v.Rows != nil {
		if err := validateHeatMapDimensionFieldList(v.Rows); err != nil {
			invalidParams.AddNested("Rows", err.(smithy.InvalidParamsError))
		}
	}
	if v.Columns != nil {
		if err := validateHeatMapDimensionFieldList(v.Columns); err != nil {
			invalidParams.AddNested("Columns", err.(smithy.InvalidParamsError))
		}
	}
	if v.Values != nil {
		if err := validateHeatMapMeasureFieldList(v.Values); err != nil {
			invalidParams.AddNested("Values", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateHeatMapConfiguration(v *types.HeatMapConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HeatMapConfiguration"}
	if v.FieldWells != nil {
		if err := validateHeatMapFieldWells(v.FieldWells); err != nil {
			invalidParams.AddNested("FieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortConfiguration != nil {
		if err := validateHeatMapSortConfiguration(v.SortConfiguration); err != nil {
			invalidParams.AddNested("SortConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.RowLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.RowLabelOptions); err != nil {
			invalidParams.AddNested("RowLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.ColumnLabelOptions); err != nil {
			invalidParams.AddNested("ColumnLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColorScale != nil {
		if err := validateColorScale(v.ColorScale); err != nil {
			invalidParams.AddNested("ColorScale", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tooltip != nil {
		if err := validateTooltipOptions(v.Tooltip); err != nil {
			invalidParams.AddNested("Tooltip", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateHeatMapFieldWells(v *types.HeatMapFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HeatMapFieldWells"}
	if v.HeatMapAggregatedFieldWells != nil {
		if err := validateHeatMapAggregatedFieldWells(v.HeatMapAggregatedFieldWells); err != nil {
			invalidParams.AddNested("HeatMapAggregatedFieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateHeatMapSortConfiguration(v *types.HeatMapSortConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HeatMapSortConfiguration"}
	if v.HeatMapRowSort != nil {
		if err := validateFieldSortOptionsList(v.HeatMapRowSort); err != nil {
			invalidParams.AddNested("HeatMapRowSort", err.(smithy.InvalidParamsError))
		}
	}
	if v.HeatMapColumnSort != nil {
		if err := validateFieldSortOptionsList(v.HeatMapColumnSort); err != nil {
			invalidParams.AddNested("HeatMapColumnSort", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateHeatMapVisual(v *types.HeatMapVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HeatMapVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.ChartConfiguration != nil {
		if err := validateHeatMapConfiguration(v.ChartConfiguration); err != nil {
			invalidParams.AddNested("ChartConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnHierarchies != nil {
		if err := validateColumnHierarchyList(v.ColumnHierarchies); err != nil {
			invalidParams.AddNested("ColumnHierarchies", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateHistogramAggregatedFieldWells(v *types.HistogramAggregatedFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HistogramAggregatedFieldWells"}
	if v.Values != nil {
		if err := validateHistogramMeasureFieldList(v.Values); err != nil {
			invalidParams.AddNested("Values", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateHistogramConfiguration(v *types.HistogramConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HistogramConfiguration"}
	if v.FieldWells != nil {
		if err := validateHistogramFieldWells(v.FieldWells); err != nil {
			invalidParams.AddNested("FieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.XAxisLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.XAxisLabelOptions); err != nil {
			invalidParams.AddNested("XAxisLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tooltip != nil {
		if err := validateTooltipOptions(v.Tooltip); err != nil {
			invalidParams.AddNested("Tooltip", err.(smithy.InvalidParamsError))
		}
	}
	if v.VisualPalette != nil {
		if err := validateVisualPalette(v.VisualPalette); err != nil {
			invalidParams.AddNested("VisualPalette", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateHistogramFieldWells(v *types.HistogramFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HistogramFieldWells"}
	if v.HistogramAggregatedFieldWells != nil {
		if err := validateHistogramAggregatedFieldWells(v.HistogramAggregatedFieldWells); err != nil {
			invalidParams.AddNested("HistogramAggregatedFieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateHistogramVisual(v *types.HistogramVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HistogramVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.ChartConfiguration != nil {
		if err := validateHistogramConfiguration(v.ChartConfiguration); err != nil {
			invalidParams.AddNested("ChartConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateIncrementalRefresh(v *types.IncrementalRefresh) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IncrementalRefresh"}
	if v.LookbackWindow == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LookbackWindow"))
	} else if v.LookbackWindow != nil {
		if err := validateLookbackWindow(v.LookbackWindow); err != nil {
			invalidParams.AddNested("LookbackWindow", 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 validateInsightConfiguration(v *types.InsightConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InsightConfiguration"}
	if v.Computations != nil {
		if err := validateComputationList(v.Computations); err != nil {
			invalidParams.AddNested("Computations", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomNarrative != nil {
		if err := validateCustomNarrativeOptions(v.CustomNarrative); err != nil {
			invalidParams.AddNested("CustomNarrative", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInsightVisual(v *types.InsightVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InsightVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.InsightConfiguration != nil {
		if err := validateInsightConfiguration(v.InsightConfiguration); err != nil {
			invalidParams.AddNested("InsightConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataSetIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateIntegerDefaultValues(v *types.IntegerDefaultValues) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IntegerDefaultValues"}
	if v.DynamicValue != nil {
		if err := validateDynamicDefaultValue(v.DynamicValue); err != nil {
			invalidParams.AddNested("DynamicValue", 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 validateIntegerParameterDeclaration(v *types.IntegerParameterDeclaration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IntegerParameterDeclaration"}
	if len(v.ParameterValueType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterValueType"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.DefaultValues != nil {
		if err := validateIntegerDefaultValues(v.DefaultValues); err != nil {
			invalidParams.AddNested("DefaultValues", err.(smithy.InvalidParamsError))
		}
	}
	if v.MappedDataSetParameters != nil {
		if err := validateMappedDataSetParameters(v.MappedDataSetParameters); err != nil {
			invalidParams.AddNested("MappedDataSetParameters", err.(smithy.InvalidParamsError))
		}
	}
	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 validateKPIConditionalFormatting(v *types.KPIConditionalFormatting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KPIConditionalFormatting"}
	if v.ConditionalFormattingOptions != nil {
		if err := validateKPIConditionalFormattingOptionList(v.ConditionalFormattingOptions); err != nil {
			invalidParams.AddNested("ConditionalFormattingOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateKPIConditionalFormattingOption(v *types.KPIConditionalFormattingOption) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KPIConditionalFormattingOption"}
	if v.PrimaryValue != nil {
		if err := validateKPIPrimaryValueConditionalFormatting(v.PrimaryValue); err != nil {
			invalidParams.AddNested("PrimaryValue", err.(smithy.InvalidParamsError))
		}
	}
	if v.ProgressBar != nil {
		if err := validateKPIProgressBarConditionalFormatting(v.ProgressBar); err != nil {
			invalidParams.AddNested("ProgressBar", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateKPIConfiguration(v *types.KPIConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KPIConfiguration"}
	if v.FieldWells != nil {
		if err := validateKPIFieldWells(v.FieldWells); err != nil {
			invalidParams.AddNested("FieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortConfiguration != nil {
		if err := validateKPISortConfiguration(v.SortConfiguration); err != nil {
			invalidParams.AddNested("SortConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.KPIOptions != nil {
		if err := validateKPIOptions(v.KPIOptions); err != nil {
			invalidParams.AddNested("KPIOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateKPIFieldWells(v *types.KPIFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KPIFieldWells"}
	if v.Values != nil {
		if err := validateMeasureFieldList(v.Values); err != nil {
			invalidParams.AddNested("Values", err.(smithy.InvalidParamsError))
		}
	}
	if v.TargetValues != nil {
		if err := validateMeasureFieldList(v.TargetValues); err != nil {
			invalidParams.AddNested("TargetValues", err.(smithy.InvalidParamsError))
		}
	}
	if v.TrendGroups != nil {
		if err := validateDimensionFieldList(v.TrendGroups); err != nil {
			invalidParams.AddNested("TrendGroups", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateKPIOptions(v *types.KPIOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KPIOptions"}
	if v.Comparison != nil {
		if err := validateComparisonConfiguration(v.Comparison); err != nil {
			invalidParams.AddNested("Comparison", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateKPIPrimaryValueConditionalFormatting(v *types.KPIPrimaryValueConditionalFormatting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KPIPrimaryValueConditionalFormatting"}
	if v.TextColor != nil {
		if err := validateConditionalFormattingColor(v.TextColor); err != nil {
			invalidParams.AddNested("TextColor", err.(smithy.InvalidParamsError))
		}
	}
	if v.Icon != nil {
		if err := validateConditionalFormattingIcon(v.Icon); err != nil {
			invalidParams.AddNested("Icon", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateKPIProgressBarConditionalFormatting(v *types.KPIProgressBarConditionalFormatting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KPIProgressBarConditionalFormatting"}
	if v.ForegroundColor != nil {
		if err := validateConditionalFormattingColor(v.ForegroundColor); err != nil {
			invalidParams.AddNested("ForegroundColor", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateKPISortConfiguration(v *types.KPISortConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KPISortConfiguration"}
	if v.TrendGroupSort != nil {
		if err := validateFieldSortOptionsList(v.TrendGroupSort); err != nil {
			invalidParams.AddNested("TrendGroupSort", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateKPIVisual(v *types.KPIVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KPIVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.ChartConfiguration != nil {
		if err := validateKPIConfiguration(v.ChartConfiguration); err != nil {
			invalidParams.AddNested("ChartConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ConditionalFormatting != nil {
		if err := validateKPIConditionalFormatting(v.ConditionalFormatting); err != nil {
			invalidParams.AddNested("ConditionalFormatting", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnHierarchies != nil {
		if err := validateColumnHierarchyList(v.ColumnHierarchies); err != nil {
			invalidParams.AddNested("ColumnHierarchies", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLayout(v *types.Layout) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Layout"}
	if v.Configuration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Configuration"))
	} else if v.Configuration != nil {
		if err := validateLayoutConfiguration(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLayoutConfiguration(v *types.LayoutConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LayoutConfiguration"}
	if v.GridLayout != nil {
		if err := validateGridLayoutConfiguration(v.GridLayout); err != nil {
			invalidParams.AddNested("GridLayout", err.(smithy.InvalidParamsError))
		}
	}
	if v.FreeFormLayout != nil {
		if err := validateFreeFormLayoutConfiguration(v.FreeFormLayout); err != nil {
			invalidParams.AddNested("FreeFormLayout", err.(smithy.InvalidParamsError))
		}
	}
	if v.SectionBasedLayout != nil {
		if err := validateSectionBasedLayoutConfiguration(v.SectionBasedLayout); err != nil {
			invalidParams.AddNested("SectionBasedLayout", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateLineChartAggregatedFieldWells(v *types.LineChartAggregatedFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LineChartAggregatedFieldWells"}
	if v.Category != nil {
		if err := validateDimensionFieldList(v.Category); err != nil {
			invalidParams.AddNested("Category", err.(smithy.InvalidParamsError))
		}
	}
	if v.Values != nil {
		if err := validateMeasureFieldList(v.Values); err != nil {
			invalidParams.AddNested("Values", err.(smithy.InvalidParamsError))
		}
	}
	if v.Colors != nil {
		if err := validateDimensionFieldList(v.Colors); err != nil {
			invalidParams.AddNested("Colors", err.(smithy.InvalidParamsError))
		}
	}
	if v.SmallMultiples != nil {
		if err := validateSmallMultiplesDimensionFieldList(v.SmallMultiples); err != nil {
			invalidParams.AddNested("SmallMultiples", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLineChartConfiguration(v *types.LineChartConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LineChartConfiguration"}
	if v.FieldWells != nil {
		if err := validateLineChartFieldWells(v.FieldWells); err != nil {
			invalidParams.AddNested("FieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortConfiguration != nil {
		if err := validateLineChartSortConfiguration(v.SortConfiguration); err != nil {
			invalidParams.AddNested("SortConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ForecastConfigurations != nil {
		if err := validateForecastConfigurationList(v.ForecastConfigurations); err != nil {
			invalidParams.AddNested("ForecastConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.XAxisLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.XAxisLabelOptions); err != nil {
			invalidParams.AddNested("XAxisLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.PrimaryYAxisLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.PrimaryYAxisLabelOptions); err != nil {
			invalidParams.AddNested("PrimaryYAxisLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.SecondaryYAxisLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.SecondaryYAxisLabelOptions); err != nil {
			invalidParams.AddNested("SecondaryYAxisLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Series != nil {
		if err := validateSeriesItemList(v.Series); err != nil {
			invalidParams.AddNested("Series", err.(smithy.InvalidParamsError))
		}
	}
	if v.ReferenceLines != nil {
		if err := validateReferenceLineList(v.ReferenceLines); err != nil {
			invalidParams.AddNested("ReferenceLines", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tooltip != nil {
		if err := validateTooltipOptions(v.Tooltip); err != nil {
			invalidParams.AddNested("Tooltip", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContributionAnalysisDefaults != nil {
		if err := validateContributionAnalysisDefaultList(v.ContributionAnalysisDefaults); err != nil {
			invalidParams.AddNested("ContributionAnalysisDefaults", err.(smithy.InvalidParamsError))
		}
	}
	if v.VisualPalette != nil {
		if err := validateVisualPalette(v.VisualPalette); err != nil {
			invalidParams.AddNested("VisualPalette", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLineChartFieldWells(v *types.LineChartFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LineChartFieldWells"}
	if v.LineChartAggregatedFieldWells != nil {
		if err := validateLineChartAggregatedFieldWells(v.LineChartAggregatedFieldWells); err != nil {
			invalidParams.AddNested("LineChartAggregatedFieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLineChartSortConfiguration(v *types.LineChartSortConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LineChartSortConfiguration"}
	if v.CategorySort != nil {
		if err := validateFieldSortOptionsList(v.CategorySort); err != nil {
			invalidParams.AddNested("CategorySort", err.(smithy.InvalidParamsError))
		}
	}
	if v.SmallMultiplesSort != nil {
		if err := validateFieldSortOptionsList(v.SmallMultiplesSort); err != nil {
			invalidParams.AddNested("SmallMultiplesSort", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLineChartVisual(v *types.LineChartVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LineChartVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.ChartConfiguration != nil {
		if err := validateLineChartConfiguration(v.ChartConfiguration); err != nil {
			invalidParams.AddNested("ChartConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnHierarchies != nil {
		if err := validateColumnHierarchyList(v.ColumnHierarchies); err != nil {
			invalidParams.AddNested("ColumnHierarchies", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLocalNavigationConfiguration(v *types.LocalNavigationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LocalNavigationConfiguration"}
	if v.TargetSheetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetSheetId"))
	}
	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 validateLookbackWindow(v *types.LookbackWindow) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LookbackWindow"}
	if v.ColumnName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnName"))
	}
	if len(v.SizeUnit) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SizeUnit"))
	}
	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 validateMappedDataSetParameter(v *types.MappedDataSetParameter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MappedDataSetParameter"}
	if v.DataSetIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetIdentifier"))
	}
	if v.DataSetParameterName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetParameterName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMappedDataSetParameters(v []types.MappedDataSetParameter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MappedDataSetParameters"}
	for i := range v {
		if err := validateMappedDataSetParameter(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	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 validateMaximumMinimumComputation(v *types.MaximumMinimumComputation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MaximumMinimumComputation"}
	if v.ComputationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ComputationId"))
	}
	if v.Time == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Time"))
	} else if v.Time != nil {
		if err := validateDimensionField(v.Time); err != nil {
			invalidParams.AddNested("Time", err.(smithy.InvalidParamsError))
		}
	}
	if v.Value != nil {
		if err := validateMeasureField(v.Value); err != nil {
			invalidParams.AddNested("Value", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMeasureField(v *types.MeasureField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MeasureField"}
	if v.NumericalMeasureField != nil {
		if err := validateNumericalMeasureField(v.NumericalMeasureField); err != nil {
			invalidParams.AddNested("NumericalMeasureField", err.(smithy.InvalidParamsError))
		}
	}
	if v.CategoricalMeasureField != nil {
		if err := validateCategoricalMeasureField(v.CategoricalMeasureField); err != nil {
			invalidParams.AddNested("CategoricalMeasureField", err.(smithy.InvalidParamsError))
		}
	}
	if v.DateMeasureField != nil {
		if err := validateDateMeasureField(v.DateMeasureField); err != nil {
			invalidParams.AddNested("DateMeasureField", err.(smithy.InvalidParamsError))
		}
	}
	if v.CalculatedMeasureField != nil {
		if err := validateCalculatedMeasureField(v.CalculatedMeasureField); err != nil {
			invalidParams.AddNested("CalculatedMeasureField", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateMetricComparisonComputation(v *types.MetricComparisonComputation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MetricComparisonComputation"}
	if v.ComputationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ComputationId"))
	}
	if v.Time == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Time"))
	} else if v.Time != nil {
		if err := validateDimensionField(v.Time); err != nil {
			invalidParams.AddNested("Time", err.(smithy.InvalidParamsError))
		}
	}
	if v.FromValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FromValue"))
	} else if v.FromValue != nil {
		if err := validateMeasureField(v.FromValue); err != nil {
			invalidParams.AddNested("FromValue", err.(smithy.InvalidParamsError))
		}
	}
	if v.TargetValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetValue"))
	} else if v.TargetValue != nil {
		if err := validateMeasureField(v.TargetValue); err != nil {
			invalidParams.AddNested("TargetValue", err.(smithy.InvalidParamsError))
		}
	}
	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 validateNegativeValueConfiguration(v *types.NegativeValueConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NegativeValueConfiguration"}
	if len(v.DisplayMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DisplayMode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateNumberDisplayFormatConfiguration(v *types.NumberDisplayFormatConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NumberDisplayFormatConfiguration"}
	if v.DecimalPlacesConfiguration != nil {
		if err := validateDecimalPlacesConfiguration(v.DecimalPlacesConfiguration); err != nil {
			invalidParams.AddNested("DecimalPlacesConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.NegativeValueConfiguration != nil {
		if err := validateNegativeValueConfiguration(v.NegativeValueConfiguration); err != nil {
			invalidParams.AddNested("NegativeValueConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.NullValueFormatConfiguration != nil {
		if err := validateNullValueFormatConfiguration(v.NullValueFormatConfiguration); err != nil {
			invalidParams.AddNested("NullValueFormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNumberFormatConfiguration(v *types.NumberFormatConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NumberFormatConfiguration"}
	if v.FormatConfiguration != nil {
		if err := validateNumericFormatConfiguration(v.FormatConfiguration); err != nil {
			invalidParams.AddNested("FormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNumericalDimensionField(v *types.NumericalDimensionField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NumericalDimensionField"}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if v.FormatConfiguration != nil {
		if err := validateNumberFormatConfiguration(v.FormatConfiguration); err != nil {
			invalidParams.AddNested("FormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNumericalMeasureField(v *types.NumericalMeasureField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NumericalMeasureField"}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if v.FormatConfiguration != nil {
		if err := validateNumberFormatConfiguration(v.FormatConfiguration); err != nil {
			invalidParams.AddNested("FormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNumericEqualityDrillDownFilter(v *types.NumericEqualityDrillDownFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NumericEqualityDrillDownFilter"}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNumericEqualityFilter(v *types.NumericEqualityFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NumericEqualityFilter"}
	if v.FilterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilterId"))
	}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.MatchOperator) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MatchOperator"))
	}
	if len(v.NullOption) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("NullOption"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNumericFormatConfiguration(v *types.NumericFormatConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NumericFormatConfiguration"}
	if v.NumberDisplayFormatConfiguration != nil {
		if err := validateNumberDisplayFormatConfiguration(v.NumberDisplayFormatConfiguration); err != nil {
			invalidParams.AddNested("NumberDisplayFormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CurrencyDisplayFormatConfiguration != nil {
		if err := validateCurrencyDisplayFormatConfiguration(v.CurrencyDisplayFormatConfiguration); err != nil {
			invalidParams.AddNested("CurrencyDisplayFormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.PercentageDisplayFormatConfiguration != nil {
		if err := validatePercentageDisplayFormatConfiguration(v.PercentageDisplayFormatConfiguration); err != nil {
			invalidParams.AddNested("PercentageDisplayFormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNumericRangeFilter(v *types.NumericRangeFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NumericRangeFilter"}
	if v.FilterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilterId"))
	}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.NullOption) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("NullOption"))
	}
	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 validateOverrideDatasetParameterOperation(v *types.OverrideDatasetParameterOperation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OverrideDatasetParameterOperation"}
	if v.ParameterName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePaginationConfiguration(v *types.PaginationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PaginationConfiguration"}
	if v.PageSize == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PageSize"))
	}
	if v.PageNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PageNumber"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateParameterControl(v *types.ParameterControl) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParameterControl"}
	if v.DateTimePicker != nil {
		if err := validateParameterDateTimePickerControl(v.DateTimePicker); err != nil {
			invalidParams.AddNested("DateTimePicker", err.(smithy.InvalidParamsError))
		}
	}
	if v.List != nil {
		if err := validateParameterListControl(v.List); err != nil {
			invalidParams.AddNested("List", err.(smithy.InvalidParamsError))
		}
	}
	if v.Dropdown != nil {
		if err := validateParameterDropDownControl(v.Dropdown); err != nil {
			invalidParams.AddNested("Dropdown", err.(smithy.InvalidParamsError))
		}
	}
	if v.TextField != nil {
		if err := validateParameterTextFieldControl(v.TextField); err != nil {
			invalidParams.AddNested("TextField", err.(smithy.InvalidParamsError))
		}
	}
	if v.TextArea != nil {
		if err := validateParameterTextAreaControl(v.TextArea); err != nil {
			invalidParams.AddNested("TextArea", err.(smithy.InvalidParamsError))
		}
	}
	if v.Slider != nil {
		if err := validateParameterSliderControl(v.Slider); err != nil {
			invalidParams.AddNested("Slider", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateParameterDateTimePickerControl(v *types.ParameterDateTimePickerControl) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParameterDateTimePickerControl"}
	if v.ParameterControlId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterControlId"))
	}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.SourceParameterName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceParameterName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateParameterDeclaration(v *types.ParameterDeclaration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParameterDeclaration"}
	if v.StringParameterDeclaration != nil {
		if err := validateStringParameterDeclaration(v.StringParameterDeclaration); err != nil {
			invalidParams.AddNested("StringParameterDeclaration", err.(smithy.InvalidParamsError))
		}
	}
	if v.DecimalParameterDeclaration != nil {
		if err := validateDecimalParameterDeclaration(v.DecimalParameterDeclaration); err != nil {
			invalidParams.AddNested("DecimalParameterDeclaration", err.(smithy.InvalidParamsError))
		}
	}
	if v.IntegerParameterDeclaration != nil {
		if err := validateIntegerParameterDeclaration(v.IntegerParameterDeclaration); err != nil {
			invalidParams.AddNested("IntegerParameterDeclaration", err.(smithy.InvalidParamsError))
		}
	}
	if v.DateTimeParameterDeclaration != nil {
		if err := validateDateTimeParameterDeclaration(v.DateTimeParameterDeclaration); err != nil {
			invalidParams.AddNested("DateTimeParameterDeclaration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateParameterDropDownControl(v *types.ParameterDropDownControl) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParameterDropDownControl"}
	if v.ParameterControlId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterControlId"))
	}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.SourceParameterName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceParameterName"))
	}
	if v.SelectableValues != nil {
		if err := validateParameterSelectableValues(v.SelectableValues); err != nil {
			invalidParams.AddNested("SelectableValues", err.(smithy.InvalidParamsError))
		}
	}
	if v.CascadingControlConfiguration != nil {
		if err := validateCascadingControlConfiguration(v.CascadingControlConfiguration); err != nil {
			invalidParams.AddNested("CascadingControlConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateParameterListControl(v *types.ParameterListControl) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParameterListControl"}
	if v.ParameterControlId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterControlId"))
	}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.SourceParameterName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceParameterName"))
	}
	if v.SelectableValues != nil {
		if err := validateParameterSelectableValues(v.SelectableValues); err != nil {
			invalidParams.AddNested("SelectableValues", err.(smithy.InvalidParamsError))
		}
	}
	if v.CascadingControlConfiguration != nil {
		if err := validateCascadingControlConfiguration(v.CascadingControlConfiguration); err != nil {
			invalidParams.AddNested("CascadingControlConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	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 validateParameterSelectableValues(v *types.ParameterSelectableValues) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParameterSelectableValues"}
	if v.LinkToDataSetColumn != nil {
		if err := validateColumnIdentifier(v.LinkToDataSetColumn); err != nil {
			invalidParams.AddNested("LinkToDataSetColumn", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateParameterSliderControl(v *types.ParameterSliderControl) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParameterSliderControl"}
	if v.ParameterControlId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterControlId"))
	}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.SourceParameterName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceParameterName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateParameterTextAreaControl(v *types.ParameterTextAreaControl) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParameterTextAreaControl"}
	if v.ParameterControlId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterControlId"))
	}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.SourceParameterName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceParameterName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateParameterTextFieldControl(v *types.ParameterTextFieldControl) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ParameterTextFieldControl"}
	if v.ParameterControlId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterControlId"))
	}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.SourceParameterName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceParameterName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePercentageDisplayFormatConfiguration(v *types.PercentageDisplayFormatConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PercentageDisplayFormatConfiguration"}
	if v.DecimalPlacesConfiguration != nil {
		if err := validateDecimalPlacesConfiguration(v.DecimalPlacesConfiguration); err != nil {
			invalidParams.AddNested("DecimalPlacesConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.NegativeValueConfiguration != nil {
		if err := validateNegativeValueConfiguration(v.NegativeValueConfiguration); err != nil {
			invalidParams.AddNested("NegativeValueConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.NullValueFormatConfiguration != nil {
		if err := validateNullValueFormatConfiguration(v.NullValueFormatConfiguration); err != nil {
			invalidParams.AddNested("NullValueFormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePeriodOverPeriodComputation(v *types.PeriodOverPeriodComputation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PeriodOverPeriodComputation"}
	if v.ComputationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ComputationId"))
	}
	if v.Time == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Time"))
	} else if v.Time != nil {
		if err := validateDimensionField(v.Time); err != nil {
			invalidParams.AddNested("Time", err.(smithy.InvalidParamsError))
		}
	}
	if v.Value != nil {
		if err := validateMeasureField(v.Value); err != nil {
			invalidParams.AddNested("Value", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePeriodToDateComputation(v *types.PeriodToDateComputation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PeriodToDateComputation"}
	if v.ComputationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ComputationId"))
	}
	if v.Time == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Time"))
	} else if v.Time != nil {
		if err := validateDimensionField(v.Time); err != nil {
			invalidParams.AddNested("Time", err.(smithy.InvalidParamsError))
		}
	}
	if v.Value != nil {
		if err := validateMeasureField(v.Value); err != nil {
			invalidParams.AddNested("Value", 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 validatePieChartAggregatedFieldWells(v *types.PieChartAggregatedFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PieChartAggregatedFieldWells"}
	if v.Category != nil {
		if err := validateDimensionFieldList(v.Category); err != nil {
			invalidParams.AddNested("Category", err.(smithy.InvalidParamsError))
		}
	}
	if v.Values != nil {
		if err := validateMeasureFieldList(v.Values); err != nil {
			invalidParams.AddNested("Values", err.(smithy.InvalidParamsError))
		}
	}
	if v.SmallMultiples != nil {
		if err := validateSmallMultiplesDimensionFieldList(v.SmallMultiples); err != nil {
			invalidParams.AddNested("SmallMultiples", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePieChartConfiguration(v *types.PieChartConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PieChartConfiguration"}
	if v.FieldWells != nil {
		if err := validatePieChartFieldWells(v.FieldWells); err != nil {
			invalidParams.AddNested("FieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortConfiguration != nil {
		if err := validatePieChartSortConfiguration(v.SortConfiguration); err != nil {
			invalidParams.AddNested("SortConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CategoryLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.CategoryLabelOptions); err != nil {
			invalidParams.AddNested("CategoryLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ValueLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.ValueLabelOptions); err != nil {
			invalidParams.AddNested("ValueLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tooltip != nil {
		if err := validateTooltipOptions(v.Tooltip); err != nil {
			invalidParams.AddNested("Tooltip", err.(smithy.InvalidParamsError))
		}
	}
	if v.VisualPalette != nil {
		if err := validateVisualPalette(v.VisualPalette); err != nil {
			invalidParams.AddNested("VisualPalette", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContributionAnalysisDefaults != nil {
		if err := validateContributionAnalysisDefaultList(v.ContributionAnalysisDefaults); err != nil {
			invalidParams.AddNested("ContributionAnalysisDefaults", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePieChartFieldWells(v *types.PieChartFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PieChartFieldWells"}
	if v.PieChartAggregatedFieldWells != nil {
		if err := validatePieChartAggregatedFieldWells(v.PieChartAggregatedFieldWells); err != nil {
			invalidParams.AddNested("PieChartAggregatedFieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePieChartSortConfiguration(v *types.PieChartSortConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PieChartSortConfiguration"}
	if v.CategorySort != nil {
		if err := validateFieldSortOptionsList(v.CategorySort); err != nil {
			invalidParams.AddNested("CategorySort", err.(smithy.InvalidParamsError))
		}
	}
	if v.SmallMultiplesSort != nil {
		if err := validateFieldSortOptionsList(v.SmallMultiplesSort); err != nil {
			invalidParams.AddNested("SmallMultiplesSort", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePieChartVisual(v *types.PieChartVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PieChartVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.ChartConfiguration != nil {
		if err := validatePieChartConfiguration(v.ChartConfiguration); err != nil {
			invalidParams.AddNested("ChartConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnHierarchies != nil {
		if err := validateColumnHierarchyList(v.ColumnHierarchies); err != nil {
			invalidParams.AddNested("ColumnHierarchies", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePivotFieldSortOptions(v *types.PivotFieldSortOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PivotFieldSortOptions"}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if v.SortBy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SortBy"))
	} else if v.SortBy != nil {
		if err := validatePivotTableSortBy(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validatePivotTableAggregatedFieldWells(v *types.PivotTableAggregatedFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PivotTableAggregatedFieldWells"}
	if v.Rows != nil {
		if err := validatePivotTableDimensionList(v.Rows); err != nil {
			invalidParams.AddNested("Rows", err.(smithy.InvalidParamsError))
		}
	}
	if v.Columns != nil {
		if err := validatePivotTableDimensionList(v.Columns); err != nil {
			invalidParams.AddNested("Columns", err.(smithy.InvalidParamsError))
		}
	}
	if v.Values != nil {
		if err := validatePivotMeasureFieldList(v.Values); err != nil {
			invalidParams.AddNested("Values", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePivotTableCellConditionalFormatting(v *types.PivotTableCellConditionalFormatting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PivotTableCellConditionalFormatting"}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if v.TextFormat != nil {
		if err := validateTextConditionalFormat(v.TextFormat); err != nil {
			invalidParams.AddNested("TextFormat", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePivotTableConditionalFormatting(v *types.PivotTableConditionalFormatting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PivotTableConditionalFormatting"}
	if v.ConditionalFormattingOptions != nil {
		if err := validatePivotTableConditionalFormattingOptionList(v.ConditionalFormattingOptions); err != nil {
			invalidParams.AddNested("ConditionalFormattingOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePivotTableConditionalFormattingOption(v *types.PivotTableConditionalFormattingOption) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PivotTableConditionalFormattingOption"}
	if v.Cell != nil {
		if err := validatePivotTableCellConditionalFormatting(v.Cell); err != nil {
			invalidParams.AddNested("Cell", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validatePivotTableConfiguration(v *types.PivotTableConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PivotTableConfiguration"}
	if v.FieldWells != nil {
		if err := validatePivotTableFieldWells(v.FieldWells); err != nil {
			invalidParams.AddNested("FieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortConfiguration != nil {
		if err := validatePivotTableSortConfiguration(v.SortConfiguration); err != nil {
			invalidParams.AddNested("SortConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.FieldOptions != nil {
		if err := validatePivotTableFieldOptions(v.FieldOptions); err != nil {
			invalidParams.AddNested("FieldOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePivotTableDataPathOption(v *types.PivotTableDataPathOption) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PivotTableDataPathOption"}
	if v.DataPathList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataPathList"))
	} else if v.DataPathList != nil {
		if err := validateDataPathValueList(v.DataPathList); err != nil {
			invalidParams.AddNested("DataPathList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validatePivotTableFieldCollapseStateOption(v *types.PivotTableFieldCollapseStateOption) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PivotTableFieldCollapseStateOption"}
	if v.Target == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Target"))
	} else if v.Target != nil {
		if err := validatePivotTableFieldCollapseStateTarget(v.Target); err != nil {
			invalidParams.AddNested("Target", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validatePivotTableFieldCollapseStateTarget(v *types.PivotTableFieldCollapseStateTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PivotTableFieldCollapseStateTarget"}
	if v.FieldDataPathValues != nil {
		if err := validateDataPathValueList(v.FieldDataPathValues); err != nil {
			invalidParams.AddNested("FieldDataPathValues", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validatePivotTableFieldOptions(v *types.PivotTableFieldOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PivotTableFieldOptions"}
	if v.SelectedFieldOptions != nil {
		if err := validatePivotTableFieldOptionList(v.SelectedFieldOptions); err != nil {
			invalidParams.AddNested("SelectedFieldOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataPathOptions != nil {
		if err := validatePivotTableDataPathOptionList(v.DataPathOptions); err != nil {
			invalidParams.AddNested("DataPathOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.CollapseStateOptions != nil {
		if err := validatePivotTableFieldCollapseStateOptionList(v.CollapseStateOptions); err != nil {
			invalidParams.AddNested("CollapseStateOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePivotTableFieldWells(v *types.PivotTableFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PivotTableFieldWells"}
	if v.PivotTableAggregatedFieldWells != nil {
		if err := validatePivotTableAggregatedFieldWells(v.PivotTableAggregatedFieldWells); err != nil {
			invalidParams.AddNested("PivotTableAggregatedFieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePivotTableSortBy(v *types.PivotTableSortBy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PivotTableSortBy"}
	if v.Field != nil {
		if err := validateFieldSort(v.Field); err != nil {
			invalidParams.AddNested("Field", err.(smithy.InvalidParamsError))
		}
	}
	if v.Column != nil {
		if err := validateColumnSort(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataPath != nil {
		if err := validateDataPathSort(v.DataPath); err != nil {
			invalidParams.AddNested("DataPath", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePivotTableSortConfiguration(v *types.PivotTableSortConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PivotTableSortConfiguration"}
	if v.FieldSortOptions != nil {
		if err := validatePivotFieldSortOptionsList(v.FieldSortOptions); err != nil {
			invalidParams.AddNested("FieldSortOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePivotTableVisual(v *types.PivotTableVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PivotTableVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.ChartConfiguration != nil {
		if err := validatePivotTableConfiguration(v.ChartConfiguration); err != nil {
			invalidParams.AddNested("ChartConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ConditionalFormatting != nil {
		if err := validatePivotTableConditionalFormatting(v.ConditionalFormatting); err != nil {
			invalidParams.AddNested("ConditionalFormatting", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", 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 validatePredefinedHierarchy(v *types.PredefinedHierarchy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PredefinedHierarchy"}
	if v.HierarchyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HierarchyId"))
	}
	if v.Columns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Columns"))
	} else if v.Columns != nil {
		if err := validatePredefinedHierarchyColumnList(v.Columns); err != nil {
			invalidParams.AddNested("Columns", err.(smithy.InvalidParamsError))
		}
	}
	if v.DrillDownFilters != nil {
		if err := validateDrillDownFilterList(v.DrillDownFilters); err != nil {
			invalidParams.AddNested("DrillDownFilters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePredefinedHierarchyColumnList(v []types.ColumnIdentifier) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PredefinedHierarchyColumnList"}
	for i := range v {
		if err := validateColumnIdentifier(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	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 validateRadarChartAggregatedFieldWells(v *types.RadarChartAggregatedFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RadarChartAggregatedFieldWells"}
	if v.Category != nil {
		if err := validateRadarChartCategoryFieldList(v.Category); err != nil {
			invalidParams.AddNested("Category", err.(smithy.InvalidParamsError))
		}
	}
	if v.Color != nil {
		if err := validateRadarChartColorFieldList(v.Color); err != nil {
			invalidParams.AddNested("Color", err.(smithy.InvalidParamsError))
		}
	}
	if v.Values != nil {
		if err := validateRadarChartValuesFieldList(v.Values); err != nil {
			invalidParams.AddNested("Values", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateRadarChartConfiguration(v *types.RadarChartConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RadarChartConfiguration"}
	if v.FieldWells != nil {
		if err := validateRadarChartFieldWells(v.FieldWells); err != nil {
			invalidParams.AddNested("FieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortConfiguration != nil {
		if err := validateRadarChartSortConfiguration(v.SortConfiguration); err != nil {
			invalidParams.AddNested("SortConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.VisualPalette != nil {
		if err := validateVisualPalette(v.VisualPalette); err != nil {
			invalidParams.AddNested("VisualPalette", err.(smithy.InvalidParamsError))
		}
	}
	if v.CategoryLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.CategoryLabelOptions); err != nil {
			invalidParams.AddNested("CategoryLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColorLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.ColorLabelOptions); err != nil {
			invalidParams.AddNested("ColorLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRadarChartFieldWells(v *types.RadarChartFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RadarChartFieldWells"}
	if v.RadarChartAggregatedFieldWells != nil {
		if err := validateRadarChartAggregatedFieldWells(v.RadarChartAggregatedFieldWells); err != nil {
			invalidParams.AddNested("RadarChartAggregatedFieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRadarChartSortConfiguration(v *types.RadarChartSortConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RadarChartSortConfiguration"}
	if v.CategorySort != nil {
		if err := validateFieldSortOptionsList(v.CategorySort); err != nil {
			invalidParams.AddNested("CategorySort", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColorSort != nil {
		if err := validateFieldSortOptionsList(v.ColorSort); err != nil {
			invalidParams.AddNested("ColorSort", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRadarChartVisual(v *types.RadarChartVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RadarChartVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.ChartConfiguration != nil {
		if err := validateRadarChartConfiguration(v.ChartConfiguration); err != nil {
			invalidParams.AddNested("ChartConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnHierarchies != nil {
		if err := validateColumnHierarchyList(v.ColumnHierarchies); err != nil {
			invalidParams.AddNested("ColumnHierarchies", err.(smithy.InvalidParamsError))
		}
	}
	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 validateReferenceLine(v *types.ReferenceLine) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReferenceLine"}
	if v.DataConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataConfiguration"))
	} else if v.DataConfiguration != nil {
		if err := validateReferenceLineDataConfiguration(v.DataConfiguration); err != nil {
			invalidParams.AddNested("DataConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.LabelConfiguration != nil {
		if err := validateReferenceLineLabelConfiguration(v.LabelConfiguration); err != nil {
			invalidParams.AddNested("LabelConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateReferenceLineDataConfiguration(v *types.ReferenceLineDataConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReferenceLineDataConfiguration"}
	if v.StaticConfiguration != nil {
		if err := validateReferenceLineStaticDataConfiguration(v.StaticConfiguration); err != nil {
			invalidParams.AddNested("StaticConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.DynamicConfiguration != nil {
		if err := validateReferenceLineDynamicDataConfiguration(v.DynamicConfiguration); err != nil {
			invalidParams.AddNested("DynamicConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateReferenceLineDynamicDataConfiguration(v *types.ReferenceLineDynamicDataConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReferenceLineDynamicDataConfiguration"}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if v.Calculation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Calculation"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateReferenceLineLabelConfiguration(v *types.ReferenceLineLabelConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReferenceLineLabelConfiguration"}
	if v.ValueLabelConfiguration != nil {
		if err := validateReferenceLineValueLabelConfiguration(v.ValueLabelConfiguration); err != nil {
			invalidParams.AddNested("ValueLabelConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomLabelConfiguration != nil {
		if err := validateReferenceLineCustomLabelConfiguration(v.CustomLabelConfiguration); err != nil {
			invalidParams.AddNested("CustomLabelConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateReferenceLineStaticDataConfiguration(v *types.ReferenceLineStaticDataConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReferenceLineStaticDataConfiguration"}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateReferenceLineValueLabelConfiguration(v *types.ReferenceLineValueLabelConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReferenceLineValueLabelConfiguration"}
	if v.FormatConfiguration != nil {
		if err := validateNumericFormatConfiguration(v.FormatConfiguration); err != nil {
			invalidParams.AddNested("FormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRefreshConfiguration(v *types.RefreshConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RefreshConfiguration"}
	if v.IncrementalRefresh == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IncrementalRefresh"))
	} else if v.IncrementalRefresh != nil {
		if err := validateIncrementalRefresh(v.IncrementalRefresh); err != nil {
			invalidParams.AddNested("IncrementalRefresh", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRefreshSchedule(v *types.RefreshSchedule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RefreshSchedule"}
	if v.ScheduleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScheduleId"))
	}
	if v.ScheduleFrequency == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScheduleFrequency"))
	} else if v.ScheduleFrequency != nil {
		if err := validateRefreshFrequency(v.ScheduleFrequency); err != nil {
			invalidParams.AddNested("ScheduleFrequency", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.RefreshType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RefreshType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRegisteredUserConsoleFeatureConfigurations(v *types.RegisteredUserConsoleFeatureConfigurations) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisteredUserConsoleFeatureConfigurations"}
	if v.StatePersistence != nil {
		if err := validateStatePersistenceConfigurations(v.StatePersistence); err != nil {
			invalidParams.AddNested("StatePersistence", err.(smithy.InvalidParamsError))
		}
	}
	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 v.FeatureConfigurations != nil {
		if err := validateRegisteredUserDashboardFeatureConfigurations(v.FeatureConfigurations); err != nil {
			invalidParams.AddNested("FeatureConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRegisteredUserDashboardFeatureConfigurations(v *types.RegisteredUserDashboardFeatureConfigurations) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisteredUserDashboardFeatureConfigurations"}
	if v.StatePersistence != nil {
		if err := validateStatePersistenceConfigurations(v.StatePersistence); err != nil {
			invalidParams.AddNested("StatePersistence", err.(smithy.InvalidParamsError))
		}
	}
	if v.Bookmarks != nil {
		if err := validateBookmarksConfigurations(v.Bookmarks); err != nil {
			invalidParams.AddNested("Bookmarks", err.(smithy.InvalidParamsError))
		}
	}
	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.QuickSightConsole != nil {
		if err := validateRegisteredUserQuickSightConsoleEmbeddingConfiguration(v.QuickSightConsole); err != nil {
			invalidParams.AddNested("QuickSightConsole", 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 validateRegisteredUserQuickSightConsoleEmbeddingConfiguration(v *types.RegisteredUserQuickSightConsoleEmbeddingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisteredUserQuickSightConsoleEmbeddingConfiguration"}
	if v.FeatureConfigurations != nil {
		if err := validateRegisteredUserConsoleFeatureConfigurations(v.FeatureConfigurations); err != nil {
			invalidParams.AddNested("FeatureConfigurations", 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 validateRelativeDatesFilter(v *types.RelativeDatesFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RelativeDatesFilter"}
	if v.FilterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilterId"))
	}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if v.AnchorDateConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnchorDateConfiguration"))
	}
	if len(v.TimeGranularity) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TimeGranularity"))
	}
	if len(v.RelativeDateType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RelativeDateType"))
	}
	if len(v.NullOption) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("NullOption"))
	}
	if v.ExcludePeriodConfiguration != nil {
		if err := validateExcludePeriodConfiguration(v.ExcludePeriodConfiguration); err != nil {
			invalidParams.AddNested("ExcludePeriodConfiguration", 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 validateRollingDateConfiguration(v *types.RollingDateConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RollingDateConfiguration"}
	if v.Expression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
	}
	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 validateRowSortList(v []types.FieldSortOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RowSortList"}
	for i := range v {
		if err := validateFieldSortOptions(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3BucketConfiguration(v *types.S3BucketConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3BucketConfiguration"}
	if v.BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
	}
	if v.BucketPrefix == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BucketPrefix"))
	}
	if v.BucketRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BucketRegion"))
	}
	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 validateSankeyDiagramAggregatedFieldWells(v *types.SankeyDiagramAggregatedFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SankeyDiagramAggregatedFieldWells"}
	if v.Source != nil {
		if err := validateDimensionFieldList(v.Source); err != nil {
			invalidParams.AddNested("Source", err.(smithy.InvalidParamsError))
		}
	}
	if v.Destination != nil {
		if err := validateDimensionFieldList(v.Destination); err != nil {
			invalidParams.AddNested("Destination", err.(smithy.InvalidParamsError))
		}
	}
	if v.Weight != nil {
		if err := validateMeasureFieldList(v.Weight); err != nil {
			invalidParams.AddNested("Weight", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSankeyDiagramChartConfiguration(v *types.SankeyDiagramChartConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SankeyDiagramChartConfiguration"}
	if v.FieldWells != nil {
		if err := validateSankeyDiagramFieldWells(v.FieldWells); err != nil {
			invalidParams.AddNested("FieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortConfiguration != nil {
		if err := validateSankeyDiagramSortConfiguration(v.SortConfiguration); err != nil {
			invalidParams.AddNested("SortConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSankeyDiagramFieldWells(v *types.SankeyDiagramFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SankeyDiagramFieldWells"}
	if v.SankeyDiagramAggregatedFieldWells != nil {
		if err := validateSankeyDiagramAggregatedFieldWells(v.SankeyDiagramAggregatedFieldWells); err != nil {
			invalidParams.AddNested("SankeyDiagramAggregatedFieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSankeyDiagramSortConfiguration(v *types.SankeyDiagramSortConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SankeyDiagramSortConfiguration"}
	if v.WeightSort != nil {
		if err := validateFieldSortOptionsList(v.WeightSort); err != nil {
			invalidParams.AddNested("WeightSort", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSankeyDiagramVisual(v *types.SankeyDiagramVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SankeyDiagramVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.ChartConfiguration != nil {
		if err := validateSankeyDiagramChartConfiguration(v.ChartConfiguration); err != nil {
			invalidParams.AddNested("ChartConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateScatterPlotCategoricallyAggregatedFieldWells(v *types.ScatterPlotCategoricallyAggregatedFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ScatterPlotCategoricallyAggregatedFieldWells"}
	if v.XAxis != nil {
		if err := validateMeasureFieldList(v.XAxis); err != nil {
			invalidParams.AddNested("XAxis", err.(smithy.InvalidParamsError))
		}
	}
	if v.YAxis != nil {
		if err := validateMeasureFieldList(v.YAxis); err != nil {
			invalidParams.AddNested("YAxis", err.(smithy.InvalidParamsError))
		}
	}
	if v.Category != nil {
		if err := validateDimensionFieldList(v.Category); err != nil {
			invalidParams.AddNested("Category", err.(smithy.InvalidParamsError))
		}
	}
	if v.Size != nil {
		if err := validateMeasureFieldList(v.Size); err != nil {
			invalidParams.AddNested("Size", err.(smithy.InvalidParamsError))
		}
	}
	if v.Label != nil {
		if err := validateDimensionFieldList(v.Label); err != nil {
			invalidParams.AddNested("Label", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateScatterPlotConfiguration(v *types.ScatterPlotConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ScatterPlotConfiguration"}
	if v.FieldWells != nil {
		if err := validateScatterPlotFieldWells(v.FieldWells); err != nil {
			invalidParams.AddNested("FieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.XAxisLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.XAxisLabelOptions); err != nil {
			invalidParams.AddNested("XAxisLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.YAxisLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.YAxisLabelOptions); err != nil {
			invalidParams.AddNested("YAxisLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tooltip != nil {
		if err := validateTooltipOptions(v.Tooltip); err != nil {
			invalidParams.AddNested("Tooltip", err.(smithy.InvalidParamsError))
		}
	}
	if v.VisualPalette != nil {
		if err := validateVisualPalette(v.VisualPalette); err != nil {
			invalidParams.AddNested("VisualPalette", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateScatterPlotFieldWells(v *types.ScatterPlotFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ScatterPlotFieldWells"}
	if v.ScatterPlotCategoricallyAggregatedFieldWells != nil {
		if err := validateScatterPlotCategoricallyAggregatedFieldWells(v.ScatterPlotCategoricallyAggregatedFieldWells); err != nil {
			invalidParams.AddNested("ScatterPlotCategoricallyAggregatedFieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.ScatterPlotUnaggregatedFieldWells != nil {
		if err := validateScatterPlotUnaggregatedFieldWells(v.ScatterPlotUnaggregatedFieldWells); err != nil {
			invalidParams.AddNested("ScatterPlotUnaggregatedFieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateScatterPlotUnaggregatedFieldWells(v *types.ScatterPlotUnaggregatedFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ScatterPlotUnaggregatedFieldWells"}
	if v.XAxis != nil {
		if err := validateDimensionFieldList(v.XAxis); err != nil {
			invalidParams.AddNested("XAxis", err.(smithy.InvalidParamsError))
		}
	}
	if v.YAxis != nil {
		if err := validateDimensionFieldList(v.YAxis); err != nil {
			invalidParams.AddNested("YAxis", err.(smithy.InvalidParamsError))
		}
	}
	if v.Size != nil {
		if err := validateMeasureFieldList(v.Size); err != nil {
			invalidParams.AddNested("Size", err.(smithy.InvalidParamsError))
		}
	}
	if v.Category != nil {
		if err := validateDimensionFieldList(v.Category); err != nil {
			invalidParams.AddNested("Category", err.(smithy.InvalidParamsError))
		}
	}
	if v.Label != nil {
		if err := validateDimensionFieldList(v.Label); err != nil {
			invalidParams.AddNested("Label", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateScatterPlotVisual(v *types.ScatterPlotVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ScatterPlotVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.ChartConfiguration != nil {
		if err := validateScatterPlotConfiguration(v.ChartConfiguration); err != nil {
			invalidParams.AddNested("ChartConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnHierarchies != nil {
		if err := validateColumnHierarchyList(v.ColumnHierarchies); err != nil {
			invalidParams.AddNested("ColumnHierarchies", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSectionBasedLayoutConfiguration(v *types.SectionBasedLayoutConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SectionBasedLayoutConfiguration"}
	if v.HeaderSections == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HeaderSections"))
	} else if v.HeaderSections != nil {
		if err := validateHeaderFooterSectionConfigurationList(v.HeaderSections); err != nil {
			invalidParams.AddNested("HeaderSections", err.(smithy.InvalidParamsError))
		}
	}
	if v.BodySections == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BodySections"))
	} else if v.BodySections != nil {
		if err := validateBodySectionConfigurationList(v.BodySections); err != nil {
			invalidParams.AddNested("BodySections", err.(smithy.InvalidParamsError))
		}
	}
	if v.FooterSections == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FooterSections"))
	} else if v.FooterSections != nil {
		if err := validateHeaderFooterSectionConfigurationList(v.FooterSections); err != nil {
			invalidParams.AddNested("FooterSections", err.(smithy.InvalidParamsError))
		}
	}
	if v.CanvasSizeOptions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CanvasSizeOptions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSectionLayoutConfiguration(v *types.SectionLayoutConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SectionLayoutConfiguration"}
	if v.FreeFormLayout == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FreeFormLayout"))
	} else if v.FreeFormLayout != nil {
		if err := validateFreeFormSectionLayoutConfiguration(v.FreeFormLayout); err != nil {
			invalidParams.AddNested("FreeFormLayout", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSelectedSheetsFilterScopeConfiguration(v *types.SelectedSheetsFilterScopeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SelectedSheetsFilterScopeConfiguration"}
	if v.SheetVisualScopingConfigurations != nil {
		if err := validateSheetVisualScopingConfigurations(v.SheetVisualScopingConfigurations); err != nil {
			invalidParams.AddNested("SheetVisualScopingConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSeriesItem(v *types.SeriesItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SeriesItem"}
	if v.FieldSeriesItem != nil {
		if err := validateFieldSeriesItem(v.FieldSeriesItem); err != nil {
			invalidParams.AddNested("FieldSeriesItem", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataFieldSeriesItem != nil {
		if err := validateDataFieldSeriesItem(v.DataFieldSeriesItem); err != nil {
			invalidParams.AddNested("DataFieldSeriesItem", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSeriesItemList(v []types.SeriesItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SeriesItemList"}
	for i := range v {
		if err := validateSeriesItem(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), 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 validateSetParameterValueConfiguration(v *types.SetParameterValueConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetParameterValueConfiguration"}
	if v.DestinationParameterName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationParameterName"))
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	} else if v.Value != nil {
		if err := validateDestinationParameterValueConfiguration(v.Value); err != nil {
			invalidParams.AddNested("Value", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateShapeConditionalFormat(v *types.ShapeConditionalFormat) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ShapeConditionalFormat"}
	if v.BackgroundColor == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackgroundColor"))
	} else if v.BackgroundColor != nil {
		if err := validateConditionalFormattingColor(v.BackgroundColor); err != nil {
			invalidParams.AddNested("BackgroundColor", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSheetControlLayout(v *types.SheetControlLayout) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SheetControlLayout"}
	if v.Configuration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Configuration"))
	} else if v.Configuration != nil {
		if err := validateSheetControlLayoutConfiguration(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSheetControlLayoutConfiguration(v *types.SheetControlLayoutConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SheetControlLayoutConfiguration"}
	if v.GridLayout != nil {
		if err := validateGridLayoutConfiguration(v.GridLayout); err != nil {
			invalidParams.AddNested("GridLayout", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSheetDefinition(v *types.SheetDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SheetDefinition"}
	if v.SheetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SheetId"))
	}
	if v.ParameterControls != nil {
		if err := validateParameterControlList(v.ParameterControls); err != nil {
			invalidParams.AddNested("ParameterControls", err.(smithy.InvalidParamsError))
		}
	}
	if v.FilterControls != nil {
		if err := validateFilterControlList(v.FilterControls); err != nil {
			invalidParams.AddNested("FilterControls", err.(smithy.InvalidParamsError))
		}
	}
	if v.Visuals != nil {
		if err := validateVisualList(v.Visuals); err != nil {
			invalidParams.AddNested("Visuals", err.(smithy.InvalidParamsError))
		}
	}
	if v.TextBoxes != nil {
		if err := validateSheetTextBoxList(v.TextBoxes); err != nil {
			invalidParams.AddNested("TextBoxes", err.(smithy.InvalidParamsError))
		}
	}
	if v.Layouts != nil {
		if err := validateLayoutList(v.Layouts); err != nil {
			invalidParams.AddNested("Layouts", err.(smithy.InvalidParamsError))
		}
	}
	if v.SheetControlLayouts != nil {
		if err := validateSheetControlLayoutList(v.SheetControlLayouts); err != nil {
			invalidParams.AddNested("SheetControlLayouts", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSheetElementRenderingRule(v *types.SheetElementRenderingRule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SheetElementRenderingRule"}
	if v.Expression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
	}
	if v.ConfigurationOverrides == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationOverrides"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateSheetVisualScopingConfiguration(v *types.SheetVisualScopingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SheetVisualScopingConfiguration"}
	if v.SheetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SheetId"))
	}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateSnapshotAnonymousUser(v *types.SnapshotAnonymousUser) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SnapshotAnonymousUser"}
	if v.RowLevelPermissionTags != nil {
		if err := validateSessionTagList(v.RowLevelPermissionTags); err != nil {
			invalidParams.AddNested("RowLevelPermissionTags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSnapshotConfiguration(v *types.SnapshotConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SnapshotConfiguration"}
	if v.FileGroups == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FileGroups"))
	} else if v.FileGroups != nil {
		if err := validateSnapshotFileGroupList(v.FileGroups); err != nil {
			invalidParams.AddNested("FileGroups", err.(smithy.InvalidParamsError))
		}
	}
	if v.DestinationConfiguration != nil {
		if err := validateSnapshotDestinationConfiguration(v.DestinationConfiguration); err != nil {
			invalidParams.AddNested("DestinationConfiguration", 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 validateSnapshotDestinationConfiguration(v *types.SnapshotDestinationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SnapshotDestinationConfiguration"}
	if v.S3Destinations != nil {
		if err := validateSnapshotS3DestinationConfigurationList(v.S3Destinations); err != nil {
			invalidParams.AddNested("S3Destinations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSnapshotFile(v *types.SnapshotFile) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SnapshotFile"}
	if v.SheetSelections == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SheetSelections"))
	} else if v.SheetSelections != nil {
		if err := validateSnapshotFileSheetSelectionList(v.SheetSelections); err != nil {
			invalidParams.AddNested("SheetSelections", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.FormatType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("FormatType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSnapshotFileGroup(v *types.SnapshotFileGroup) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SnapshotFileGroup"}
	if v.Files != nil {
		if err := validateSnapshotFileList(v.Files); err != nil {
			invalidParams.AddNested("Files", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateSnapshotFileSheetSelection(v *types.SnapshotFileSheetSelection) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SnapshotFileSheetSelection"}
	if v.SheetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SheetId"))
	}
	if len(v.SelectionScope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SelectionScope"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSnapshotS3DestinationConfiguration(v *types.SnapshotS3DestinationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SnapshotS3DestinationConfiguration"}
	if v.BucketConfiguration != nil {
		if err := validateS3BucketConfiguration(v.BucketConfiguration); err != nil {
			invalidParams.AddNested("BucketConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSnapshotUserConfiguration(v *types.SnapshotUserConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SnapshotUserConfiguration"}
	if v.AnonymousUsers != nil {
		if err := validateSnapshotAnonymousUserList(v.AnonymousUsers); err != nil {
			invalidParams.AddNested("AnonymousUsers", 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 validateStatePersistenceConfigurations(v *types.StatePersistenceConfigurations) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StatePersistenceConfigurations"}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateStringDefaultValues(v *types.StringDefaultValues) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StringDefaultValues"}
	if v.DynamicValue != nil {
		if err := validateDynamicDefaultValue(v.DynamicValue); err != nil {
			invalidParams.AddNested("DynamicValue", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateStringFormatConfiguration(v *types.StringFormatConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StringFormatConfiguration"}
	if v.NullValueFormatConfiguration != nil {
		if err := validateNullValueFormatConfiguration(v.NullValueFormatConfiguration); err != nil {
			invalidParams.AddNested("NullValueFormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.NumericFormatConfiguration != nil {
		if err := validateNumericFormatConfiguration(v.NumericFormatConfiguration); err != nil {
			invalidParams.AddNested("NumericFormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	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 validateStringParameterDeclaration(v *types.StringParameterDeclaration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StringParameterDeclaration"}
	if len(v.ParameterValueType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterValueType"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.DefaultValues != nil {
		if err := validateStringDefaultValues(v.DefaultValues); err != nil {
			invalidParams.AddNested("DefaultValues", err.(smithy.InvalidParamsError))
		}
	}
	if v.MappedDataSetParameters != nil {
		if err := validateMappedDataSetParameters(v.MappedDataSetParameters); err != nil {
			invalidParams.AddNested("MappedDataSetParameters", err.(smithy.InvalidParamsError))
		}
	}
	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 validateTableAggregatedFieldWells(v *types.TableAggregatedFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TableAggregatedFieldWells"}
	if v.GroupBy != nil {
		if err := validateDimensionFieldList(v.GroupBy); err != nil {
			invalidParams.AddNested("GroupBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.Values != nil {
		if err := validateMeasureFieldList(v.Values); err != nil {
			invalidParams.AddNested("Values", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTableCellConditionalFormatting(v *types.TableCellConditionalFormatting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TableCellConditionalFormatting"}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if v.TextFormat != nil {
		if err := validateTextConditionalFormat(v.TextFormat); err != nil {
			invalidParams.AddNested("TextFormat", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTableConditionalFormatting(v *types.TableConditionalFormatting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TableConditionalFormatting"}
	if v.ConditionalFormattingOptions != nil {
		if err := validateTableConditionalFormattingOptionList(v.ConditionalFormattingOptions); err != nil {
			invalidParams.AddNested("ConditionalFormattingOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTableConditionalFormattingOption(v *types.TableConditionalFormattingOption) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TableConditionalFormattingOption"}
	if v.Cell != nil {
		if err := validateTableCellConditionalFormatting(v.Cell); err != nil {
			invalidParams.AddNested("Cell", err.(smithy.InvalidParamsError))
		}
	}
	if v.Row != nil {
		if err := validateTableRowConditionalFormatting(v.Row); err != nil {
			invalidParams.AddNested("Row", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTableConfiguration(v *types.TableConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TableConfiguration"}
	if v.FieldWells != nil {
		if err := validateTableFieldWells(v.FieldWells); err != nil {
			invalidParams.AddNested("FieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortConfiguration != nil {
		if err := validateTableSortConfiguration(v.SortConfiguration); err != nil {
			invalidParams.AddNested("SortConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.FieldOptions != nil {
		if err := validateTableFieldOptions(v.FieldOptions); err != nil {
			invalidParams.AddNested("FieldOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.TableInlineVisualizations != nil {
		if err := validateTableInlineVisualizationList(v.TableInlineVisualizations); err != nil {
			invalidParams.AddNested("TableInlineVisualizations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTableFieldLinkConfiguration(v *types.TableFieldLinkConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TableFieldLinkConfiguration"}
	if len(v.Target) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Target"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	} else if v.Content != nil {
		if err := validateTableFieldLinkContentConfiguration(v.Content); err != nil {
			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTableFieldLinkContentConfiguration(v *types.TableFieldLinkContentConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TableFieldLinkContentConfiguration"}
	if v.CustomTextContent != nil {
		if err := validateTableFieldCustomTextContent(v.CustomTextContent); err != nil {
			invalidParams.AddNested("CustomTextContent", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTableFieldOption(v *types.TableFieldOption) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TableFieldOption"}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if v.URLStyling != nil {
		if err := validateTableFieldURLConfiguration(v.URLStyling); err != nil {
			invalidParams.AddNested("URLStyling", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTableFieldOptions(v *types.TableFieldOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TableFieldOptions"}
	if v.SelectedFieldOptions != nil {
		if err := validateTableFieldOptionList(v.SelectedFieldOptions); err != nil {
			invalidParams.AddNested("SelectedFieldOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTableFieldURLConfiguration(v *types.TableFieldURLConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TableFieldURLConfiguration"}
	if v.LinkConfiguration != nil {
		if err := validateTableFieldLinkConfiguration(v.LinkConfiguration); err != nil {
			invalidParams.AddNested("LinkConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTableFieldWells(v *types.TableFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TableFieldWells"}
	if v.TableAggregatedFieldWells != nil {
		if err := validateTableAggregatedFieldWells(v.TableAggregatedFieldWells); err != nil {
			invalidParams.AddNested("TableAggregatedFieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.TableUnaggregatedFieldWells != nil {
		if err := validateTableUnaggregatedFieldWells(v.TableUnaggregatedFieldWells); err != nil {
			invalidParams.AddNested("TableUnaggregatedFieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTableInlineVisualization(v *types.TableInlineVisualization) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TableInlineVisualization"}
	if v.DataBars != nil {
		if err := validateDataBarsOptions(v.DataBars); err != nil {
			invalidParams.AddNested("DataBars", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTableRowConditionalFormatting(v *types.TableRowConditionalFormatting) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TableRowConditionalFormatting"}
	if v.BackgroundColor != nil {
		if err := validateConditionalFormattingColor(v.BackgroundColor); err != nil {
			invalidParams.AddNested("BackgroundColor", err.(smithy.InvalidParamsError))
		}
	}
	if v.TextColor != nil {
		if err := validateConditionalFormattingColor(v.TextColor); err != nil {
			invalidParams.AddNested("TextColor", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTableSortConfiguration(v *types.TableSortConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TableSortConfiguration"}
	if v.RowSort != nil {
		if err := validateRowSortList(v.RowSort); err != nil {
			invalidParams.AddNested("RowSort", err.(smithy.InvalidParamsError))
		}
	}
	if v.PaginationConfiguration != nil {
		if err := validatePaginationConfiguration(v.PaginationConfiguration); err != nil {
			invalidParams.AddNested("PaginationConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTableUnaggregatedFieldWells(v *types.TableUnaggregatedFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TableUnaggregatedFieldWells"}
	if v.Values != nil {
		if err := validateUnaggregatedFieldList(v.Values); err != nil {
			invalidParams.AddNested("Values", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTableVisual(v *types.TableVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TableVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.ChartConfiguration != nil {
		if err := validateTableConfiguration(v.ChartConfiguration); err != nil {
			invalidParams.AddNested("ChartConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ConditionalFormatting != nil {
		if err := validateTableConditionalFormatting(v.ConditionalFormatting); err != nil {
			invalidParams.AddNested("ConditionalFormatting", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", 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 validateTemplateVersionDefinition(v *types.TemplateVersionDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TemplateVersionDefinition"}
	if v.DataSetConfigurations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetConfigurations"))
	}
	if v.Sheets != nil {
		if err := validateSheetDefinitionList(v.Sheets); err != nil {
			invalidParams.AddNested("Sheets", err.(smithy.InvalidParamsError))
		}
	}
	if v.CalculatedFields != nil {
		if err := validateCalculatedFields(v.CalculatedFields); err != nil {
			invalidParams.AddNested("CalculatedFields", err.(smithy.InvalidParamsError))
		}
	}
	if v.ParameterDeclarations != nil {
		if err := validateParameterDeclarationList(v.ParameterDeclarations); err != nil {
			invalidParams.AddNested("ParameterDeclarations", err.(smithy.InvalidParamsError))
		}
	}
	if v.FilterGroups != nil {
		if err := validateFilterGroupList(v.FilterGroups); err != nil {
			invalidParams.AddNested("FilterGroups", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnConfigurations != nil {
		if err := validateColumnConfigurationList(v.ColumnConfigurations); err != nil {
			invalidParams.AddNested("ColumnConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.AnalysisDefaults != nil {
		if err := validateAnalysisDefaults(v.AnalysisDefaults); err != nil {
			invalidParams.AddNested("AnalysisDefaults", err.(smithy.InvalidParamsError))
		}
	}
	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 validateTextConditionalFormat(v *types.TextConditionalFormat) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TextConditionalFormat"}
	if v.BackgroundColor != nil {
		if err := validateConditionalFormattingColor(v.BackgroundColor); err != nil {
			invalidParams.AddNested("BackgroundColor", err.(smithy.InvalidParamsError))
		}
	}
	if v.TextColor != nil {
		if err := validateConditionalFormattingColor(v.TextColor); err != nil {
			invalidParams.AddNested("TextColor", err.(smithy.InvalidParamsError))
		}
	}
	if v.Icon != nil {
		if err := validateConditionalFormattingIcon(v.Icon); err != nil {
			invalidParams.AddNested("Icon", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTimeEqualityFilter(v *types.TimeEqualityFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TimeEqualityFilter"}
	if v.FilterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilterId"))
	}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTimeRangeDrillDownFilter(v *types.TimeRangeDrillDownFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TimeRangeDrillDownFilter"}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if v.RangeMinimum == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RangeMinimum"))
	}
	if v.RangeMaximum == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RangeMaximum"))
	}
	if len(v.TimeGranularity) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TimeGranularity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTimeRangeFilter(v *types.TimeRangeFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TimeRangeFilter"}
	if v.FilterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilterId"))
	}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if v.RangeMinimumValue != nil {
		if err := validateTimeRangeFilterValue(v.RangeMinimumValue); err != nil {
			invalidParams.AddNested("RangeMinimumValue", err.(smithy.InvalidParamsError))
		}
	}
	if v.RangeMaximumValue != nil {
		if err := validateTimeRangeFilterValue(v.RangeMaximumValue); err != nil {
			invalidParams.AddNested("RangeMaximumValue", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.NullOption) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("NullOption"))
	}
	if v.ExcludePeriodConfiguration != nil {
		if err := validateExcludePeriodConfiguration(v.ExcludePeriodConfiguration); err != nil {
			invalidParams.AddNested("ExcludePeriodConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTimeRangeFilterValue(v *types.TimeRangeFilterValue) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TimeRangeFilterValue"}
	if v.RollingDate != nil {
		if err := validateRollingDateConfiguration(v.RollingDate); err != nil {
			invalidParams.AddNested("RollingDate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTooltipItem(v *types.TooltipItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TooltipItem"}
	if v.FieldTooltipItem != nil {
		if err := validateFieldTooltipItem(v.FieldTooltipItem); err != nil {
			invalidParams.AddNested("FieldTooltipItem", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnTooltipItem != nil {
		if err := validateColumnTooltipItem(v.ColumnTooltipItem); err != nil {
			invalidParams.AddNested("ColumnTooltipItem", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTooltipOptions(v *types.TooltipOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TooltipOptions"}
	if v.FieldBasedTooltip != nil {
		if err := validateFieldBasedTooltip(v.FieldBasedTooltip); err != nil {
			invalidParams.AddNested("FieldBasedTooltip", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTopBottomFilter(v *types.TopBottomFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TopBottomFilter"}
	if v.FilterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilterId"))
	}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if v.AggregationSortConfigurations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AggregationSortConfigurations"))
	} else if v.AggregationSortConfigurations != nil {
		if err := validateAggregationSortConfigurationList(v.AggregationSortConfigurations); err != nil {
			invalidParams.AddNested("AggregationSortConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTopBottomMoversComputation(v *types.TopBottomMoversComputation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TopBottomMoversComputation"}
	if v.ComputationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ComputationId"))
	}
	if v.Time == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Time"))
	} else if v.Time != nil {
		if err := validateDimensionField(v.Time); err != nil {
			invalidParams.AddNested("Time", err.(smithy.InvalidParamsError))
		}
	}
	if v.Category == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Category"))
	} else if v.Category != nil {
		if err := validateDimensionField(v.Category); err != nil {
			invalidParams.AddNested("Category", err.(smithy.InvalidParamsError))
		}
	}
	if v.Value != nil {
		if err := validateMeasureField(v.Value); err != nil {
			invalidParams.AddNested("Value", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTopBottomRankedComputation(v *types.TopBottomRankedComputation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TopBottomRankedComputation"}
	if v.ComputationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ComputationId"))
	}
	if v.Category == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Category"))
	} else if v.Category != nil {
		if err := validateDimensionField(v.Category); err != nil {
			invalidParams.AddNested("Category", err.(smithy.InvalidParamsError))
		}
	}
	if v.Value != nil {
		if err := validateMeasureField(v.Value); err != nil {
			invalidParams.AddNested("Value", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTopicCalculatedField(v *types.TopicCalculatedField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TopicCalculatedField"}
	if v.CalculatedFieldName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CalculatedFieldName"))
	}
	if v.Expression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateTopicDetails(v *types.TopicDetails) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TopicDetails"}
	if v.DataSets != nil {
		if err := validateDatasets(v.DataSets); err != nil {
			invalidParams.AddNested("DataSets", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTopicFilter(v *types.TopicFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TopicFilter"}
	if v.FilterName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilterName"))
	}
	if v.OperandFieldName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OperandFieldName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateTotalAggregationComputation(v *types.TotalAggregationComputation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TotalAggregationComputation"}
	if v.ComputationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ComputationId"))
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	} else if v.Value != nil {
		if err := validateMeasureField(v.Value); err != nil {
			invalidParams.AddNested("Value", err.(smithy.InvalidParamsError))
		}
	}
	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.TransformOperationMemberOverrideDatasetParameterOperation:
		if err := validateOverrideDatasetParameterOperation(&uv.Value); err != nil {
			invalidParams.AddNested("[OverrideDatasetParameterOperation]", 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 validateTreeMapAggregatedFieldWells(v *types.TreeMapAggregatedFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TreeMapAggregatedFieldWells"}
	if v.Groups != nil {
		if err := validateTreeMapDimensionFieldList(v.Groups); err != nil {
			invalidParams.AddNested("Groups", err.(smithy.InvalidParamsError))
		}
	}
	if v.Sizes != nil {
		if err := validateTreeMapMeasureFieldList(v.Sizes); err != nil {
			invalidParams.AddNested("Sizes", err.(smithy.InvalidParamsError))
		}
	}
	if v.Colors != nil {
		if err := validateTreeMapMeasureFieldList(v.Colors); err != nil {
			invalidParams.AddNested("Colors", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTreeMapConfiguration(v *types.TreeMapConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TreeMapConfiguration"}
	if v.FieldWells != nil {
		if err := validateTreeMapFieldWells(v.FieldWells); err != nil {
			invalidParams.AddNested("FieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortConfiguration != nil {
		if err := validateTreeMapSortConfiguration(v.SortConfiguration); err != nil {
			invalidParams.AddNested("SortConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.GroupLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.GroupLabelOptions); err != nil {
			invalidParams.AddNested("GroupLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.SizeLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.SizeLabelOptions); err != nil {
			invalidParams.AddNested("SizeLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColorLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.ColorLabelOptions); err != nil {
			invalidParams.AddNested("ColorLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColorScale != nil {
		if err := validateColorScale(v.ColorScale); err != nil {
			invalidParams.AddNested("ColorScale", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tooltip != nil {
		if err := validateTooltipOptions(v.Tooltip); err != nil {
			invalidParams.AddNested("Tooltip", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTreeMapFieldWells(v *types.TreeMapFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TreeMapFieldWells"}
	if v.TreeMapAggregatedFieldWells != nil {
		if err := validateTreeMapAggregatedFieldWells(v.TreeMapAggregatedFieldWells); err != nil {
			invalidParams.AddNested("TreeMapAggregatedFieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTreeMapSortConfiguration(v *types.TreeMapSortConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TreeMapSortConfiguration"}
	if v.TreeMapSort != nil {
		if err := validateFieldSortOptionsList(v.TreeMapSort); err != nil {
			invalidParams.AddNested("TreeMapSort", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTreeMapVisual(v *types.TreeMapVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TreeMapVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.ChartConfiguration != nil {
		if err := validateTreeMapConfiguration(v.ChartConfiguration); err != nil {
			invalidParams.AddNested("ChartConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnHierarchies != nil {
		if err := validateColumnHierarchyList(v.ColumnHierarchies); err != nil {
			invalidParams.AddNested("ColumnHierarchies", 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 validateUnaggregatedField(v *types.UnaggregatedField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UnaggregatedField"}
	if v.FieldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FieldId"))
	}
	if v.Column == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Column"))
	} else if v.Column != nil {
		if err := validateColumnIdentifier(v.Column); err != nil {
			invalidParams.AddNested("Column", err.(smithy.InvalidParamsError))
		}
	}
	if v.FormatConfiguration != nil {
		if err := validateFormatConfiguration(v.FormatConfiguration); err != nil {
			invalidParams.AddNested("FormatConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateUniqueValuesComputation(v *types.UniqueValuesComputation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UniqueValuesComputation"}
	if v.ComputationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ComputationId"))
	}
	if v.Category == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Category"))
	} else if v.Category != nil {
		if err := validateDimensionField(v.Category); err != nil {
			invalidParams.AddNested("Category", err.(smithy.InvalidParamsError))
		}
	}
	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 validateVisual(v *types.Visual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Visual"}
	if v.TableVisual != nil {
		if err := validateTableVisual(v.TableVisual); err != nil {
			invalidParams.AddNested("TableVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.PivotTableVisual != nil {
		if err := validatePivotTableVisual(v.PivotTableVisual); err != nil {
			invalidParams.AddNested("PivotTableVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.BarChartVisual != nil {
		if err := validateBarChartVisual(v.BarChartVisual); err != nil {
			invalidParams.AddNested("BarChartVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.KPIVisual != nil {
		if err := validateKPIVisual(v.KPIVisual); err != nil {
			invalidParams.AddNested("KPIVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.PieChartVisual != nil {
		if err := validatePieChartVisual(v.PieChartVisual); err != nil {
			invalidParams.AddNested("PieChartVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.GaugeChartVisual != nil {
		if err := validateGaugeChartVisual(v.GaugeChartVisual); err != nil {
			invalidParams.AddNested("GaugeChartVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.LineChartVisual != nil {
		if err := validateLineChartVisual(v.LineChartVisual); err != nil {
			invalidParams.AddNested("LineChartVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.HeatMapVisual != nil {
		if err := validateHeatMapVisual(v.HeatMapVisual); err != nil {
			invalidParams.AddNested("HeatMapVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.TreeMapVisual != nil {
		if err := validateTreeMapVisual(v.TreeMapVisual); err != nil {
			invalidParams.AddNested("TreeMapVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.GeospatialMapVisual != nil {
		if err := validateGeospatialMapVisual(v.GeospatialMapVisual); err != nil {
			invalidParams.AddNested("GeospatialMapVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.FilledMapVisual != nil {
		if err := validateFilledMapVisual(v.FilledMapVisual); err != nil {
			invalidParams.AddNested("FilledMapVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.FunnelChartVisual != nil {
		if err := validateFunnelChartVisual(v.FunnelChartVisual); err != nil {
			invalidParams.AddNested("FunnelChartVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.ScatterPlotVisual != nil {
		if err := validateScatterPlotVisual(v.ScatterPlotVisual); err != nil {
			invalidParams.AddNested("ScatterPlotVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.ComboChartVisual != nil {
		if err := validateComboChartVisual(v.ComboChartVisual); err != nil {
			invalidParams.AddNested("ComboChartVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.BoxPlotVisual != nil {
		if err := validateBoxPlotVisual(v.BoxPlotVisual); err != nil {
			invalidParams.AddNested("BoxPlotVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.WaterfallVisual != nil {
		if err := validateWaterfallVisual(v.WaterfallVisual); err != nil {
			invalidParams.AddNested("WaterfallVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.HistogramVisual != nil {
		if err := validateHistogramVisual(v.HistogramVisual); err != nil {
			invalidParams.AddNested("HistogramVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.WordCloudVisual != nil {
		if err := validateWordCloudVisual(v.WordCloudVisual); err != nil {
			invalidParams.AddNested("WordCloudVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.InsightVisual != nil {
		if err := validateInsightVisual(v.InsightVisual); err != nil {
			invalidParams.AddNested("InsightVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.SankeyDiagramVisual != nil {
		if err := validateSankeyDiagramVisual(v.SankeyDiagramVisual); err != nil {
			invalidParams.AddNested("SankeyDiagramVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomContentVisual != nil {
		if err := validateCustomContentVisual(v.CustomContentVisual); err != nil {
			invalidParams.AddNested("CustomContentVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.EmptyVisual != nil {
		if err := validateEmptyVisual(v.EmptyVisual); err != nil {
			invalidParams.AddNested("EmptyVisual", err.(smithy.InvalidParamsError))
		}
	}
	if v.RadarChartVisual != nil {
		if err := validateRadarChartVisual(v.RadarChartVisual); err != nil {
			invalidParams.AddNested("RadarChartVisual", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateVisualCustomAction(v *types.VisualCustomAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VisualCustomAction"}
	if v.CustomActionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CustomActionId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Trigger) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Trigger"))
	}
	if v.ActionOperations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActionOperations"))
	} else if v.ActionOperations != nil {
		if err := validateVisualCustomActionOperationList(v.ActionOperations); err != nil {
			invalidParams.AddNested("ActionOperations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateVisualCustomActionOperation(v *types.VisualCustomActionOperation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VisualCustomActionOperation"}
	if v.FilterOperation != nil {
		if err := validateCustomActionFilterOperation(v.FilterOperation); err != nil {
			invalidParams.AddNested("FilterOperation", err.(smithy.InvalidParamsError))
		}
	}
	if v.NavigationOperation != nil {
		if err := validateCustomActionNavigationOperation(v.NavigationOperation); err != nil {
			invalidParams.AddNested("NavigationOperation", err.(smithy.InvalidParamsError))
		}
	}
	if v.URLOperation != nil {
		if err := validateCustomActionURLOperation(v.URLOperation); err != nil {
			invalidParams.AddNested("URLOperation", err.(smithy.InvalidParamsError))
		}
	}
	if v.SetParametersOperation != nil {
		if err := validateCustomActionSetParametersOperation(v.SetParametersOperation); err != nil {
			invalidParams.AddNested("SetParametersOperation", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateVisualPalette(v *types.VisualPalette) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VisualPalette"}
	if v.ColorMap != nil {
		if err := validateDataPathColorList(v.ColorMap); err != nil {
			invalidParams.AddNested("ColorMap", 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 validateWaterfallChartAggregatedFieldWells(v *types.WaterfallChartAggregatedFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WaterfallChartAggregatedFieldWells"}
	if v.Categories != nil {
		if err := validateDimensionFieldList(v.Categories); err != nil {
			invalidParams.AddNested("Categories", err.(smithy.InvalidParamsError))
		}
	}
	if v.Values != nil {
		if err := validateMeasureFieldList(v.Values); err != nil {
			invalidParams.AddNested("Values", err.(smithy.InvalidParamsError))
		}
	}
	if v.Breakdowns != nil {
		if err := validateDimensionFieldList(v.Breakdowns); err != nil {
			invalidParams.AddNested("Breakdowns", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWaterfallChartConfiguration(v *types.WaterfallChartConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WaterfallChartConfiguration"}
	if v.FieldWells != nil {
		if err := validateWaterfallChartFieldWells(v.FieldWells); err != nil {
			invalidParams.AddNested("FieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortConfiguration != nil {
		if err := validateWaterfallChartSortConfiguration(v.SortConfiguration); err != nil {
			invalidParams.AddNested("SortConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CategoryAxisLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.CategoryAxisLabelOptions); err != nil {
			invalidParams.AddNested("CategoryAxisLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.PrimaryYAxisLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.PrimaryYAxisLabelOptions); err != nil {
			invalidParams.AddNested("PrimaryYAxisLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.VisualPalette != nil {
		if err := validateVisualPalette(v.VisualPalette); err != nil {
			invalidParams.AddNested("VisualPalette", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWaterfallChartFieldWells(v *types.WaterfallChartFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WaterfallChartFieldWells"}
	if v.WaterfallChartAggregatedFieldWells != nil {
		if err := validateWaterfallChartAggregatedFieldWells(v.WaterfallChartAggregatedFieldWells); err != nil {
			invalidParams.AddNested("WaterfallChartAggregatedFieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWaterfallChartSortConfiguration(v *types.WaterfallChartSortConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WaterfallChartSortConfiguration"}
	if v.CategorySort != nil {
		if err := validateFieldSortOptionsList(v.CategorySort); err != nil {
			invalidParams.AddNested("CategorySort", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWaterfallVisual(v *types.WaterfallVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WaterfallVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.ChartConfiguration != nil {
		if err := validateWaterfallChartConfiguration(v.ChartConfiguration); err != nil {
			invalidParams.AddNested("ChartConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnHierarchies != nil {
		if err := validateColumnHierarchyList(v.ColumnHierarchies); err != nil {
			invalidParams.AddNested("ColumnHierarchies", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateWhatIfRangeScenario(v *types.WhatIfRangeScenario) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WhatIfRangeScenario"}
	if v.StartDate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartDate"))
	}
	if v.EndDate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndDate"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWordCloudAggregatedFieldWells(v *types.WordCloudAggregatedFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WordCloudAggregatedFieldWells"}
	if v.GroupBy != nil {
		if err := validateWordCloudDimensionFieldList(v.GroupBy); err != nil {
			invalidParams.AddNested("GroupBy", err.(smithy.InvalidParamsError))
		}
	}
	if v.Size != nil {
		if err := validateWordCloudMeasureFieldList(v.Size); err != nil {
			invalidParams.AddNested("Size", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWordCloudChartConfiguration(v *types.WordCloudChartConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WordCloudChartConfiguration"}
	if v.FieldWells != nil {
		if err := validateWordCloudFieldWells(v.FieldWells); err != nil {
			invalidParams.AddNested("FieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortConfiguration != nil {
		if err := validateWordCloudSortConfiguration(v.SortConfiguration); err != nil {
			invalidParams.AddNested("SortConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.CategoryLabelOptions != nil {
		if err := validateChartAxisLabelOptions(v.CategoryLabelOptions); err != nil {
			invalidParams.AddNested("CategoryLabelOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateWordCloudFieldWells(v *types.WordCloudFieldWells) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WordCloudFieldWells"}
	if v.WordCloudAggregatedFieldWells != nil {
		if err := validateWordCloudAggregatedFieldWells(v.WordCloudAggregatedFieldWells); err != nil {
			invalidParams.AddNested("WordCloudAggregatedFieldWells", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateWordCloudSortConfiguration(v *types.WordCloudSortConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WordCloudSortConfiguration"}
	if v.CategorySort != nil {
		if err := validateFieldSortOptionsList(v.CategorySort); err != nil {
			invalidParams.AddNested("CategorySort", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWordCloudVisual(v *types.WordCloudVisual) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WordCloudVisual"}
	if v.VisualId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VisualId"))
	}
	if v.ChartConfiguration != nil {
		if err := validateWordCloudChartConfiguration(v.ChartConfiguration); err != nil {
			invalidParams.AddNested("ChartConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions != nil {
		if err := validateVisualCustomActionList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColumnHierarchies != nil {
		if err := validateColumnHierarchyList(v.ColumnHierarchies); err != nil {
			invalidParams.AddNested("ColumnHierarchies", err.(smithy.InvalidParamsError))
		}
	}
	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 {
		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 v.Definition != nil {
		if err := validateAnalysisDefinition(v.Definition); err != nil {
			invalidParams.AddNested("Definition", 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 {
		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 v.Definition != nil {
		if err := validateDashboardVersionDefinition(v.Definition); err != nil {
			invalidParams.AddNested("Definition", 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 v.DatasetParameters != nil {
		if err := validateDatasetParameterList(v.DatasetParameters); err != nil {
			invalidParams.AddNested("DatasetParameters", 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 validateOpCreateRefreshScheduleInput(v *CreateRefreshScheduleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRefreshScheduleInput"}
	if v.DataSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
	}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Schedule == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Schedule"))
	} else if v.Schedule != nil {
		if err := validateRefreshSchedule(v.Schedule); err != nil {
			invalidParams.AddNested("Schedule", 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 {
		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 v.Definition != nil {
		if err := validateTemplateVersionDefinition(v.Definition); err != nil {
			invalidParams.AddNested("Definition", 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 validateOpCreateTopicInput(v *CreateTopicInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTopicInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TopicId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopicId"))
	}
	if v.Topic == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Topic"))
	} else if v.Topic != nil {
		if err := validateTopicDetails(v.Topic); err != nil {
			invalidParams.AddNested("Topic", 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 validateOpCreateTopicRefreshScheduleInput(v *CreateTopicRefreshScheduleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTopicRefreshScheduleInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TopicId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopicId"))
	}
	if v.DatasetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatasetArn"))
	}
	if v.RefreshSchedule == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RefreshSchedule"))
	} else if v.RefreshSchedule != nil {
		if err := validateTopicRefreshSchedule(v.RefreshSchedule); err != nil {
			invalidParams.AddNested("RefreshSchedule", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateVPCConnectionInput(v *CreateVPCConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateVPCConnectionInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.VPCConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VPCConnectionId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
	}
	if v.SecurityGroupIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupIds"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	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 validateOpDeleteAccountSubscriptionInput(v *DeleteAccountSubscriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAccountSubscriptionInput"}
	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 validateOpDeleteDataSetRefreshPropertiesInput(v *DeleteDataSetRefreshPropertiesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDataSetRefreshPropertiesInput"}
	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 validateOpDeleteRefreshScheduleInput(v *DeleteRefreshScheduleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRefreshScheduleInput"}
	if v.DataSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
	}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.ScheduleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScheduleId"))
	}
	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 validateOpDeleteTopicInput(v *DeleteTopicInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTopicInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TopicId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopicId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTopicRefreshScheduleInput(v *DeleteTopicRefreshScheduleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTopicRefreshScheduleInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TopicId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopicId"))
	}
	if v.DatasetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatasetId"))
	}
	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 validateOpDeleteVPCConnectionInput(v *DeleteVPCConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVPCConnectionInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.VPCConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VPCConnectionId"))
	}
	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 validateOpDescribeAnalysisDefinitionInput(v *DescribeAnalysisDefinitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeAnalysisDefinitionInput"}
	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 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 validateOpDescribeAssetBundleExportJobInput(v *DescribeAssetBundleExportJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeAssetBundleExportJobInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.AssetBundleExportJobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetBundleExportJobId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDescribeDashboardDefinitionInput(v *DescribeDashboardDefinitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDashboardDefinitionInput"}
	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 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 validateOpDescribeDashboardSnapshotJobInput(v *DescribeDashboardSnapshotJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDashboardSnapshotJobInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DashboardId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
	}
	if v.SnapshotJobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotJobId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeDashboardSnapshotJobResultInput(v *DescribeDashboardSnapshotJobResultInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDashboardSnapshotJobResultInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DashboardId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
	}
	if v.SnapshotJobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotJobId"))
	}
	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 validateOpDescribeDataSetRefreshPropertiesInput(v *DescribeDataSetRefreshPropertiesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDataSetRefreshPropertiesInput"}
	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 validateOpDescribeRefreshScheduleInput(v *DescribeRefreshScheduleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeRefreshScheduleInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DataSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
	}
	if v.ScheduleId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScheduleId"))
	}
	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 validateOpDescribeTemplateDefinitionInput(v *DescribeTemplateDefinitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeTemplateDefinitionInput"}
	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 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 validateOpDescribeTopicInput(v *DescribeTopicInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeTopicInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TopicId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopicId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDescribeTopicRefreshScheduleInput(v *DescribeTopicRefreshScheduleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeTopicRefreshScheduleInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TopicId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopicId"))
	}
	if v.DatasetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatasetId"))
	}
	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 validateOpDescribeVPCConnectionInput(v *DescribeVPCConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeVPCConnectionInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.VPCConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VPCConnectionId"))
	}
	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 validateOpListAssetBundleExportJobsInput(v *ListAssetBundleExportJobsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAssetBundleExportJobsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListAssetBundleImportJobsInput(v *ListAssetBundleImportJobsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAssetBundleImportJobsInput"}
	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 validateOpListRefreshSchedulesInput(v *ListRefreshSchedulesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListRefreshSchedulesInput"}
	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 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 validateOpListTopicRefreshSchedulesInput(v *ListTopicRefreshSchedulesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTopicRefreshSchedulesInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TopicId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopicId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListTopicsInput(v *ListTopicsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTopicsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	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 validateOpListVPCConnectionsInput(v *ListVPCConnectionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListVPCConnectionsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutDataSetRefreshPropertiesInput(v *PutDataSetRefreshPropertiesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutDataSetRefreshPropertiesInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DataSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
	}
	if v.DataSetRefreshProperties == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetRefreshProperties"))
	} else if v.DataSetRefreshProperties != nil {
		if err := validateDataSetRefreshProperties(v.DataSetRefreshProperties); err != nil {
			invalidParams.AddNested("DataSetRefreshProperties", err.(smithy.InvalidParamsError))
		}
	}
	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 validateOpSearchDataSetsInput(v *SearchDataSetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchDataSetsInput"}
	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 := validateDataSetSearchFilterList(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchDataSourcesInput(v *SearchDataSourcesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchDataSourcesInput"}
	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 := validateDataSourceSearchFilterList(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 validateOpStartAssetBundleExportJobInput(v *StartAssetBundleExportJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartAssetBundleExportJobInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.AssetBundleExportJobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetBundleExportJobId"))
	}
	if v.ResourceArns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArns"))
	}
	if len(v.ExportFormat) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ExportFormat"))
	}
	if v.CloudFormationOverridePropertyConfiguration != nil {
		if err := validateAssetBundleCloudFormationOverridePropertyConfiguration(v.CloudFormationOverridePropertyConfiguration); err != nil {
			invalidParams.AddNested("CloudFormationOverridePropertyConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartAssetBundleImportJobInput(v *StartAssetBundleImportJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartAssetBundleImportJobInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.AssetBundleImportJobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetBundleImportJobId"))
	}
	if v.AssetBundleImportSource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetBundleImportSource"))
	}
	if v.OverrideParameters != nil {
		if err := validateAssetBundleImportJobOverrideParameters(v.OverrideParameters); err != nil {
			invalidParams.AddNested("OverrideParameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartDashboardSnapshotJobInput(v *StartDashboardSnapshotJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartDashboardSnapshotJobInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.DashboardId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
	}
	if v.SnapshotJobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotJobId"))
	}
	if v.UserConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserConfiguration"))
	} else if v.UserConfiguration != nil {
		if err := validateSnapshotUserConfiguration(v.UserConfiguration); err != nil {
			invalidParams.AddNested("UserConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.SnapshotConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotConfiguration"))
	} else if v.SnapshotConfiguration != nil {
		if err := validateSnapshotConfiguration(v.SnapshotConfiguration); err != nil {
			invalidParams.AddNested("SnapshotConfiguration", 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 {
		if err := validateAnalysisSourceEntity(v.SourceEntity); err != nil {
			invalidParams.AddNested("SourceEntity", err.(smithy.InvalidParamsError))
		}
	}
	if v.Definition != nil {
		if err := validateAnalysisDefinition(v.Definition); err != nil {
			invalidParams.AddNested("Definition", 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 {
		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 v.Definition != nil {
		if err := validateDashboardVersionDefinition(v.Definition); err != nil {
			invalidParams.AddNested("Definition", 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 v.DatasetParameters != nil {
		if err := validateDatasetParameterList(v.DatasetParameters); err != nil {
			invalidParams.AddNested("DatasetParameters", 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 validateOpUpdateRefreshScheduleInput(v *UpdateRefreshScheduleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRefreshScheduleInput"}
	if v.DataSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSetId"))
	}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.Schedule == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Schedule"))
	} else if v.Schedule != nil {
		if err := validateRefreshSchedule(v.Schedule); err != nil {
			invalidParams.AddNested("Schedule", err.(smithy.InvalidParamsError))
		}
	}
	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 {
		if err := validateTemplateSourceEntity(v.SourceEntity); err != nil {
			invalidParams.AddNested("SourceEntity", err.(smithy.InvalidParamsError))
		}
	}
	if v.Definition != nil {
		if err := validateTemplateVersionDefinition(v.Definition); err != nil {
			invalidParams.AddNested("Definition", 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 validateOpUpdateTopicInput(v *UpdateTopicInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTopicInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TopicId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopicId"))
	}
	if v.Topic == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Topic"))
	} else if v.Topic != nil {
		if err := validateTopicDetails(v.Topic); err != nil {
			invalidParams.AddNested("Topic", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateTopicPermissionsInput(v *UpdateTopicPermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTopicPermissionsInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TopicId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopicId"))
	}
	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 validateOpUpdateTopicRefreshScheduleInput(v *UpdateTopicRefreshScheduleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTopicRefreshScheduleInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.TopicId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopicId"))
	}
	if v.DatasetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatasetId"))
	}
	if v.RefreshSchedule == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RefreshSchedule"))
	} else if v.RefreshSchedule != nil {
		if err := validateTopicRefreshSchedule(v.RefreshSchedule); err != nil {
			invalidParams.AddNested("RefreshSchedule", 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
	}
}

func validateOpUpdateVPCConnectionInput(v *UpdateVPCConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateVPCConnectionInput"}
	if v.AwsAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccountId"))
	}
	if v.VPCConnectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VPCConnectionId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
	}
	if v.SecurityGroupIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupIds"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}