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

package cleanrooms

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

type validateOpBatchGetCollaborationAnalysisTemplate struct {
}

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

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

type validateOpBatchGetSchemaAnalysisRule struct {
}

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

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

type validateOpBatchGetSchema struct {
}

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

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

type validateOpCreateAnalysisTemplate struct {
}

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

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

type validateOpCreateCollaborationChangeRequest struct {
}

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

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

type validateOpCreateCollaboration struct {
}

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

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

type validateOpCreateConfiguredAudienceModelAssociation struct {
}

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

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

type validateOpCreateConfiguredTableAnalysisRule struct {
}

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

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

type validateOpCreateConfiguredTableAssociationAnalysisRule struct {
}

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

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

type validateOpCreateConfiguredTableAssociation struct {
}

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

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

type validateOpCreateConfiguredTable struct {
}

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

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

type validateOpCreateIdMappingTable struct {
}

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

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

type validateOpCreateIdNamespaceAssociation struct {
}

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

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

type validateOpCreateIntermediateTableAnalysisRule struct {
}

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

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

type validateOpCreateIntermediateTable struct {
}

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

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

type validateOpCreateMembership struct {
}

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

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

type validateOpCreatePrivacyBudgetTemplate struct {
}

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

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

type validateOpDeleteAnalysisTemplate struct {
}

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

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

type validateOpDeleteCollaboration struct {
}

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

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

type validateOpDeleteConfiguredAudienceModelAssociation struct {
}

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

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

type validateOpDeleteConfiguredTableAnalysisRule struct {
}

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

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

type validateOpDeleteConfiguredTableAssociationAnalysisRule struct {
}

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

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

type validateOpDeleteConfiguredTableAssociation struct {
}

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

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

type validateOpDeleteConfiguredTable struct {
}

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

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

type validateOpDeleteIdMappingTable struct {
}

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

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

type validateOpDeleteIdNamespaceAssociation struct {
}

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

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

type validateOpDeleteIntermediateTableAnalysisRule struct {
}

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

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

type validateOpDeleteIntermediateTable struct {
}

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

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

type validateOpDeleteMember struct {
}

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

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

type validateOpDeleteMembership struct {
}

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

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

type validateOpDeletePrivacyBudgetTemplate struct {
}

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

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

type validateOpDisallowIntermediateTable struct {
}

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

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

type validateOpGetAnalysisTemplate struct {
}

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

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

type validateOpGetCollaborationAnalysisTemplate struct {
}

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

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

type validateOpGetCollaborationChangeRequest struct {
}

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

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

type validateOpGetCollaborationConfiguredAudienceModelAssociation struct {
}

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

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

type validateOpGetCollaborationIdNamespaceAssociation struct {
}

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

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

type validateOpGetCollaboration struct {
}

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

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

type validateOpGetCollaborationPrivacyBudgetTemplate struct {
}

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

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

type validateOpGetConfiguredAudienceModelAssociation struct {
}

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

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

type validateOpGetConfiguredTableAnalysisRule struct {
}

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

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

type validateOpGetConfiguredTableAssociationAnalysisRule struct {
}

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

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

type validateOpGetConfiguredTableAssociation struct {
}

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

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

type validateOpGetConfiguredTable struct {
}

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

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

type validateOpGetIdMappingTable struct {
}

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

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

type validateOpGetIdNamespaceAssociation struct {
}

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

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

type validateOpGetIntermediateTableAnalysisRule struct {
}

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

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

type validateOpGetIntermediateTable struct {
}

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

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

type validateOpGetMembership struct {
}

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

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

type validateOpGetPrivacyBudgetTemplate struct {
}

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

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

type validateOpGetProtectedJob struct {
}

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

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

type validateOpGetProtectedQuery struct {
}

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

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

type validateOpGetSchemaAnalysisRule struct {
}

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

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

type validateOpGetSchema struct {
}

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

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

type validateOpListAnalysisTemplates struct {
}

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

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

type validateOpListCollaborationAnalysisTemplates struct {
}

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

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

type validateOpListCollaborationChangeRequests struct {
}

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

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

type validateOpListCollaborationConfiguredAudienceModelAssociations struct {
}

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

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

type validateOpListCollaborationIdNamespaceAssociations struct {
}

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

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

type validateOpListCollaborationPrivacyBudgets struct {
}

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

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

type validateOpListCollaborationPrivacyBudgetTemplates struct {
}

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

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

type validateOpListConfiguredAudienceModelAssociations struct {
}

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

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

type validateOpListConfiguredTableAssociations struct {
}

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

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

type validateOpListIdMappingTables struct {
}

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

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

type validateOpListIdNamespaceAssociations struct {
}

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

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

type validateOpListIntermediateTables struct {
}

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

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

type validateOpListIntermediateTableVersions struct {
}

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

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

type validateOpListMembers struct {
}

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

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

type validateOpListPrivacyBudgets struct {
}

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

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

type validateOpListPrivacyBudgetTemplates struct {
}

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

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

type validateOpListProtectedJobs struct {
}

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

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

type validateOpListProtectedQueries struct {
}

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

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

type validateOpListSchemas struct {
}

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

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

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

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

type validateOpPopulateIntermediateTable struct {
}

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

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

type validateOpPreviewPrivacyImpact struct {
}

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

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

type validateOpStartProtectedJob struct {
}

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

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

type validateOpStartProtectedQuery struct {
}

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

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

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

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

type validateOpUpdateCollaborationChangeRequest struct {
}

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

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

type validateOpUpdateCollaboration struct {
}

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

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

type validateOpUpdateConfiguredAudienceModelAssociation struct {
}

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

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

type validateOpUpdateConfiguredTableAnalysisRule struct {
}

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

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

type validateOpUpdateConfiguredTableAssociationAnalysisRule struct {
}

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

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

type validateOpUpdateConfiguredTableAssociation struct {
}

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

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

type validateOpUpdateConfiguredTable struct {
}

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

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

type validateOpUpdateIdMappingTable struct {
}

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

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

type validateOpUpdateIdNamespaceAssociation struct {
}

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

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

type validateOpUpdateIntermediateTableAnalysisRule struct {
}

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

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

type validateOpUpdateIntermediateTable struct {
}

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

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

type validateOpUpdateMembership struct {
}

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

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

type validateOpUpdatePrivacyBudgetTemplate struct {
}

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

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

type validateOpUpdateProtectedJob struct {
}

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

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

type validateOpUpdateProtectedQuery struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpStartProtectedQueryValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartProtectedQuery{}, 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 addOpUpdateAnalysisTemplateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateAnalysisTemplate{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateAccessBudgetsPrivacyTemplateParametersInput(v *types.AccessBudgetsPrivacyTemplateParametersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AccessBudgetsPrivacyTemplateParametersInput"}
	if v.BudgetParameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BudgetParameters"))
	} else if v.BudgetParameters != nil {
		if err := validateBudgetParameters(v.BudgetParameters); err != nil {
			invalidParams.AddNested("BudgetParameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAccessBudgetsPrivacyTemplateUpdateParameters(v *types.AccessBudgetsPrivacyTemplateUpdateParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AccessBudgetsPrivacyTemplateUpdateParameters"}
	if v.BudgetParameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BudgetParameters"))
	} else if v.BudgetParameters != nil {
		if err := validateBudgetParameters(v.BudgetParameters); err != nil {
			invalidParams.AddNested("BudgetParameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAggregateColumn(v *types.AggregateColumn) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AggregateColumn"}
	if v.ColumnNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnNames"))
	}
	if len(v.Function) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Function"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateAnalysisRuleAggregation(v *types.AnalysisRuleAggregation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AnalysisRuleAggregation"}
	if v.AggregateColumns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AggregateColumns"))
	} else if v.AggregateColumns != nil {
		if err := validateAggregateColumnList(v.AggregateColumns); err != nil {
			invalidParams.AddNested("AggregateColumns", err.(smithy.InvalidParamsError))
		}
	}
	if v.JoinColumns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JoinColumns"))
	}
	if v.DimensionColumns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DimensionColumns"))
	}
	if v.ScalarFunctions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScalarFunctions"))
	}
	if v.OutputConstraints == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputConstraints"))
	} else if v.OutputConstraints != nil {
		if err := validateAggregationConstraints(v.OutputConstraints); err != nil {
			invalidParams.AddNested("OutputConstraints", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAnalysisRuleCustom(v *types.AnalysisRuleCustom) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AnalysisRuleCustom"}
	if v.AllowedAnalyses == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AllowedAnalyses"))
	}
	if v.DifferentialPrivacy != nil {
		if err := validateDifferentialPrivacyConfiguration(v.DifferentialPrivacy); err != nil {
			invalidParams.AddNested("DifferentialPrivacy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAnalysisRuleList(v *types.AnalysisRuleList) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AnalysisRuleList"}
	if v.JoinColumns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JoinColumns"))
	}
	if v.ListColumns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ListColumns"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAnalysisSource(v types.AnalysisSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AnalysisSource"}
	switch uv := v.(type) {
	case *types.AnalysisSourceMemberArtifacts:
		if err := validateAnalysisTemplateArtifacts(&uv.Value); err != nil {
			invalidParams.AddNested("[artifacts]", err.(smithy.InvalidParamsError))
		}

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

func validateAnalysisTemplateArtifact(v *types.AnalysisTemplateArtifact) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AnalysisTemplateArtifact"}
	if v.Location == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Location"))
	} else if v.Location != nil {
		if err := validateS3Location(v.Location); err != nil {
			invalidParams.AddNested("Location", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateAnalysisTemplateArtifacts(v *types.AnalysisTemplateArtifacts) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AnalysisTemplateArtifacts"}
	if v.EntryPoint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntryPoint"))
	} else if v.EntryPoint != nil {
		if err := validateAnalysisTemplateArtifact(v.EntryPoint); err != nil {
			invalidParams.AddNested("EntryPoint", err.(smithy.InvalidParamsError))
		}
	}
	if v.AdditionalArtifacts != nil {
		if err := validateAnalysisTemplateArtifactList(v.AdditionalArtifacts); err != nil {
			invalidParams.AddNested("AdditionalArtifacts", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAthenaTableReference(v *types.AthenaTableReference) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AthenaTableReference"}
	if v.WorkGroup == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkGroup"))
	}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateChangeInput(v *types.ChangeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChangeInput"}
	if len(v.SpecificationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SpecificationType"))
	}
	if v.Specification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Specification"))
	} else if v.Specification != nil {
		if err := validateChangeSpecification(v.Specification); err != nil {
			invalidParams.AddNested("Specification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateChangeSpecification(v types.ChangeSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChangeSpecification"}
	switch uv := v.(type) {
	case *types.ChangeSpecificationMemberMember:
		if err := validateMemberChangeSpecification(&uv.Value); err != nil {
			invalidParams.AddNested("[member]", err.(smithy.InvalidParamsError))
		}

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

func validateColumnClassificationDetails(v *types.ColumnClassificationDetails) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ColumnClassificationDetails"}
	if v.ColumnMapping == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnMapping"))
	} else if v.ColumnMapping != nil {
		if err := validateColumnMappingList(v.ColumnMapping); err != nil {
			invalidParams.AddNested("ColumnMapping", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateConfiguredTableAnalysisRulePolicy(v types.ConfiguredTableAnalysisRulePolicy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConfiguredTableAnalysisRulePolicy"}
	switch uv := v.(type) {
	case *types.ConfiguredTableAnalysisRulePolicyMemberV1:
		if err := validateConfiguredTableAnalysisRulePolicyV1(uv.Value); err != nil {
			invalidParams.AddNested("[v1]", err.(smithy.InvalidParamsError))
		}

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

func validateConfiguredTableAnalysisRulePolicyV1(v types.ConfiguredTableAnalysisRulePolicyV1) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConfiguredTableAnalysisRulePolicyV1"}
	switch uv := v.(type) {
	case *types.ConfiguredTableAnalysisRulePolicyV1MemberAggregation:
		if err := validateAnalysisRuleAggregation(&uv.Value); err != nil {
			invalidParams.AddNested("[aggregation]", err.(smithy.InvalidParamsError))
		}

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

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

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

func validateDataEncryptionMetadata(v *types.DataEncryptionMetadata) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataEncryptionMetadata"}
	if v.AllowCleartext == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AllowCleartext"))
	}
	if v.AllowDuplicates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AllowDuplicates"))
	}
	if v.AllowJoinsOnColumnsWithDifferentNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AllowJoinsOnColumnsWithDifferentNames"))
	}
	if v.PreserveNulls == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PreserveNulls"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateDifferentialPrivacyPreviewParametersInput(v *types.DifferentialPrivacyPreviewParametersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DifferentialPrivacyPreviewParametersInput"}
	if v.Epsilon == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Epsilon"))
	}
	if v.UsersNoisePerQuery == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsersNoisePerQuery"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDifferentialPrivacyTemplateParametersInput(v *types.DifferentialPrivacyTemplateParametersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DifferentialPrivacyTemplateParametersInput"}
	if v.Epsilon == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Epsilon"))
	}
	if v.UsersNoisePerQuery == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsersNoisePerQuery"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateGlueTableReference(v *types.GlueTableReference) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GlueTableReference"}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateIdMappingTableInputReferenceConfig(v *types.IdMappingTableInputReferenceConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IdMappingTableInputReferenceConfig"}
	if v.InputReferenceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputReferenceArn"))
	}
	if v.ManageResourcePolicies == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ManageResourcePolicies"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateIdNamespaceAssociationInputReferenceConfig(v *types.IdNamespaceAssociationInputReferenceConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IdNamespaceAssociationInputReferenceConfig"}
	if v.InputReferenceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputReferenceArn"))
	}
	if v.ManageResourcePolicies == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ManageResourcePolicies"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateIntermediateTableAnalysisRuleCustom(v *types.IntermediateTableAnalysisRuleCustom) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IntermediateTableAnalysisRuleCustom"}
	if v.DifferentialPrivacy != nil {
		if err := validateDifferentialPrivacyConfiguration(v.DifferentialPrivacy); err != nil {
			invalidParams.AddNested("DifferentialPrivacy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateIntermediateTableAnalysisRulePolicy(v types.IntermediateTableAnalysisRulePolicy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IntermediateTableAnalysisRulePolicy"}
	switch uv := v.(type) {
	case *types.IntermediateTableAnalysisRulePolicyMemberV1:
		if err := validateIntermediateTableAnalysisRulePolicyV1(uv.Value); err != nil {
			invalidParams.AddNested("[v1]", err.(smithy.InvalidParamsError))
		}

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

func validateIntermediateTableAnalysisRulePolicyV1(v types.IntermediateTableAnalysisRulePolicyV1) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IntermediateTableAnalysisRulePolicyV1"}
	switch uv := v.(type) {
	case *types.IntermediateTableAnalysisRulePolicyV1MemberCustom:
		if err := validateIntermediateTableAnalysisRuleCustom(&uv.Value); err != nil {
			invalidParams.AddNested("[custom]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

func validateMemberChangeSpecification(v *types.MemberChangeSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MemberChangeSpecification"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.MemberAbilities == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemberAbilities"))
	}
	if v.MlMemberAbilities != nil {
		if err := validateMLMemberAbilities(v.MlMemberAbilities); err != nil {
			invalidParams.AddNested("MlMemberAbilities", err.(smithy.InvalidParamsError))
		}
	}
	if v.PaymentConfiguration != nil {
		if err := validatePaymentConfiguration(v.PaymentConfiguration); err != nil {
			invalidParams.AddNested("PaymentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateMembershipMLPaymentConfig(v *types.MembershipMLPaymentConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MembershipMLPaymentConfig"}
	if v.ModelTraining != nil {
		if err := validateMembershipModelTrainingPaymentConfig(v.ModelTraining); err != nil {
			invalidParams.AddNested("ModelTraining", err.(smithy.InvalidParamsError))
		}
	}
	if v.ModelInference != nil {
		if err := validateMembershipModelInferencePaymentConfig(v.ModelInference); err != nil {
			invalidParams.AddNested("ModelInference", err.(smithy.InvalidParamsError))
		}
	}
	if v.SyntheticDataGeneration != nil {
		if err := validateMembershipSyntheticDataGenerationPaymentConfig(v.SyntheticDataGeneration); err != nil {
			invalidParams.AddNested("SyntheticDataGeneration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateMembershipPaymentConfiguration(v *types.MembershipPaymentConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MembershipPaymentConfiguration"}
	if v.QueryCompute == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryCompute"))
	} else if v.QueryCompute != nil {
		if err := validateMembershipQueryComputePaymentConfig(v.QueryCompute); err != nil {
			invalidParams.AddNested("QueryCompute", err.(smithy.InvalidParamsError))
		}
	}
	if v.MachineLearning != nil {
		if err := validateMembershipMLPaymentConfig(v.MachineLearning); err != nil {
			invalidParams.AddNested("MachineLearning", err.(smithy.InvalidParamsError))
		}
	}
	if v.JobCompute != nil {
		if err := validateMembershipJobComputePaymentConfig(v.JobCompute); err != nil {
			invalidParams.AddNested("JobCompute", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMembershipProtectedJobOutputConfiguration(v types.MembershipProtectedJobOutputConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MembershipProtectedJobOutputConfiguration"}
	switch uv := v.(type) {
	case *types.MembershipProtectedJobOutputConfigurationMemberS3:
		if err := validateProtectedJobS3OutputConfigurationInput(&uv.Value); err != nil {
			invalidParams.AddNested("[s3]", err.(smithy.InvalidParamsError))
		}

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

func validateMembershipProtectedJobResultConfiguration(v *types.MembershipProtectedJobResultConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MembershipProtectedJobResultConfiguration"}
	if v.OutputConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputConfiguration"))
	} else if v.OutputConfiguration != nil {
		if err := validateMembershipProtectedJobOutputConfiguration(v.OutputConfiguration); err != nil {
			invalidParams.AddNested("OutputConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMembershipProtectedQueryOutputConfiguration(v types.MembershipProtectedQueryOutputConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MembershipProtectedQueryOutputConfiguration"}
	switch uv := v.(type) {
	case *types.MembershipProtectedQueryOutputConfigurationMemberS3:
		if err := validateProtectedQueryS3OutputConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[s3]", err.(smithy.InvalidParamsError))
		}

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

func validateMembershipProtectedQueryResultConfiguration(v *types.MembershipProtectedQueryResultConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MembershipProtectedQueryResultConfiguration"}
	if v.OutputConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputConfiguration"))
	} else if v.OutputConfiguration != nil {
		if err := validateMembershipProtectedQueryOutputConfiguration(v.OutputConfiguration); err != nil {
			invalidParams.AddNested("OutputConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateMemberSpecification(v *types.MemberSpecification) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MemberSpecification"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.MemberAbilities == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MemberAbilities"))
	}
	if v.MlMemberAbilities != nil {
		if err := validateMLMemberAbilities(v.MlMemberAbilities); err != nil {
			invalidParams.AddNested("MlMemberAbilities", err.(smithy.InvalidParamsError))
		}
	}
	if v.DisplayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DisplayName"))
	}
	if v.PaymentConfiguration != nil {
		if err := validatePaymentConfiguration(v.PaymentConfiguration); err != nil {
			invalidParams.AddNested("PaymentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateMLPaymentConfig(v *types.MLPaymentConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MLPaymentConfig"}
	if v.ModelTraining != nil {
		if err := validateModelTrainingPaymentConfig(v.ModelTraining); err != nil {
			invalidParams.AddNested("ModelTraining", err.(smithy.InvalidParamsError))
		}
	}
	if v.ModelInference != nil {
		if err := validateModelInferencePaymentConfig(v.ModelInference); err != nil {
			invalidParams.AddNested("ModelInference", err.(smithy.InvalidParamsError))
		}
	}
	if v.SyntheticDataGeneration != nil {
		if err := validateSyntheticDataGenerationPaymentConfig(v.SyntheticDataGeneration); err != nil {
			invalidParams.AddNested("SyntheticDataGeneration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMLSyntheticDataParameters(v *types.MLSyntheticDataParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MLSyntheticDataParameters"}
	if v.Epsilon == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Epsilon"))
	}
	if v.MaxMembershipInferenceAttackScore == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxMembershipInferenceAttackScore"))
	}
	if v.ColumnClassification == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnClassification"))
	} else if v.ColumnClassification != nil {
		if err := validateColumnClassificationDetails(v.ColumnClassification); err != nil {
			invalidParams.AddNested("ColumnClassification", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validatePaymentConfiguration(v *types.PaymentConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PaymentConfiguration"}
	if v.QueryCompute == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryCompute"))
	} else if v.QueryCompute != nil {
		if err := validateQueryComputePaymentConfig(v.QueryCompute); err != nil {
			invalidParams.AddNested("QueryCompute", err.(smithy.InvalidParamsError))
		}
	}
	if v.MachineLearning != nil {
		if err := validateMLPaymentConfig(v.MachineLearning); err != nil {
			invalidParams.AddNested("MachineLearning", err.(smithy.InvalidParamsError))
		}
	}
	if v.JobCompute != nil {
		if err := validateJobComputePaymentConfig(v.JobCompute); err != nil {
			invalidParams.AddNested("JobCompute", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePreviewPrivacyImpactParametersInput(v types.PreviewPrivacyImpactParametersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PreviewPrivacyImpactParametersInput"}
	switch uv := v.(type) {
	case *types.PreviewPrivacyImpactParametersInputMemberDifferentialPrivacy:
		if err := validateDifferentialPrivacyPreviewParametersInput(&uv.Value); err != nil {
			invalidParams.AddNested("[differentialPrivacy]", err.(smithy.InvalidParamsError))
		}

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

func validatePrivacyBudgetTemplateParametersInput(v types.PrivacyBudgetTemplateParametersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PrivacyBudgetTemplateParametersInput"}
	switch uv := v.(type) {
	case *types.PrivacyBudgetTemplateParametersInputMemberAccessBudget:
		if err := validateAccessBudgetsPrivacyTemplateParametersInput(&uv.Value); err != nil {
			invalidParams.AddNested("[accessBudget]", err.(smithy.InvalidParamsError))
		}

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

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

func validatePrivacyBudgetTemplateUpdateParameters(v types.PrivacyBudgetTemplateUpdateParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PrivacyBudgetTemplateUpdateParameters"}
	switch uv := v.(type) {
	case *types.PrivacyBudgetTemplateUpdateParametersMemberAccessBudget:
		if err := validateAccessBudgetsPrivacyTemplateUpdateParameters(&uv.Value); err != nil {
			invalidParams.AddNested("[accessBudget]", err.(smithy.InvalidParamsError))
		}

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

func validateProtectedJobComputeConfiguration(v types.ProtectedJobComputeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProtectedJobComputeConfiguration"}
	switch uv := v.(type) {
	case *types.ProtectedJobComputeConfigurationMemberWorker:
		if err := validateProtectedJobWorkerComputeConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[worker]", err.(smithy.InvalidParamsError))
		}

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

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

func validateProtectedJobOutputConfigurationInput(v types.ProtectedJobOutputConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProtectedJobOutputConfigurationInput"}
	switch uv := v.(type) {
	case *types.ProtectedJobOutputConfigurationInputMemberMember:
		if err := validateProtectedJobMemberOutputConfigurationInput(&uv.Value); err != nil {
			invalidParams.AddNested("[member]", err.(smithy.InvalidParamsError))
		}

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

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

func validateProtectedJobResultConfigurationInput(v *types.ProtectedJobResultConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProtectedJobResultConfigurationInput"}
	if v.OutputConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputConfiguration"))
	} else if v.OutputConfiguration != nil {
		if err := validateProtectedJobOutputConfigurationInput(v.OutputConfiguration); err != nil {
			invalidParams.AddNested("OutputConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateProtectedQueryDistributeOutputConfiguration(v *types.ProtectedQueryDistributeOutputConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProtectedQueryDistributeOutputConfiguration"}
	if v.Locations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Locations"))
	} else if v.Locations != nil {
		if err := validateProtectedQueryDistributeOutputConfigurationLocations(v.Locations); err != nil {
			invalidParams.AddNested("Locations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateProtectedQueryDistributeOutputConfigurationLocation(v types.ProtectedQueryDistributeOutputConfigurationLocation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProtectedQueryDistributeOutputConfigurationLocation"}
	switch uv := v.(type) {
	case *types.ProtectedQueryDistributeOutputConfigurationLocationMemberMember:
		if err := validateProtectedQueryMemberOutputConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[member]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

func validateProtectedQueryOutputConfiguration(v types.ProtectedQueryOutputConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProtectedQueryOutputConfiguration"}
	switch uv := v.(type) {
	case *types.ProtectedQueryOutputConfigurationMemberDistribute:
		if err := validateProtectedQueryDistributeOutputConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[distribute]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

func validateProtectedQueryResultConfiguration(v *types.ProtectedQueryResultConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProtectedQueryResultConfiguration"}
	if v.OutputConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputConfiguration"))
	} else if v.OutputConfiguration != nil {
		if err := validateProtectedQueryOutputConfiguration(v.OutputConfiguration); err != nil {
			invalidParams.AddNested("OutputConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateProtectedQueryS3OutputConfiguration(v *types.ProtectedQueryS3OutputConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProtectedQueryS3OutputConfiguration"}
	if len(v.ResultFormat) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResultFormat"))
	}
	if v.Bucket == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Bucket"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateSnowflakeTableReference(v *types.SnowflakeTableReference) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SnowflakeTableReference"}
	if v.SecretArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecretArn"))
	}
	if v.AccountIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountIdentifier"))
	}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.SchemaName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaName"))
	}
	if v.TableSchema == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableSchema"))
	} else if v.TableSchema != nil {
		if err := validateSnowflakeTableSchema(v.TableSchema); err != nil {
			invalidParams.AddNested("TableSchema", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSnowflakeTableSchema(v types.SnowflakeTableSchema) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SnowflakeTableSchema"}
	switch uv := v.(type) {
	case *types.SnowflakeTableSchemaMemberV1:
		if err := validateSnowflakeTableSchemaList(uv.Value); err != nil {
			invalidParams.AddNested("[v1]", err.(smithy.InvalidParamsError))
		}

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

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

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

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

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

func validateSyntheticDataParameters(v types.SyntheticDataParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SyntheticDataParameters"}
	switch uv := v.(type) {
	case *types.SyntheticDataParametersMemberMlSyntheticDataParameters:
		if err := validateMLSyntheticDataParameters(&uv.Value); err != nil {
			invalidParams.AddNested("[mlSyntheticDataParameters]", err.(smithy.InvalidParamsError))
		}

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

func validateTableReference(v types.TableReference) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TableReference"}
	switch uv := v.(type) {
	case *types.TableReferenceMemberAthena:
		if err := validateAthenaTableReference(&uv.Value); err != nil {
			invalidParams.AddNested("[athena]", err.(smithy.InvalidParamsError))
		}

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

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

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

func validateUpdateMembershipPaymentConfiguration(v *types.UpdateMembershipPaymentConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateMembershipPaymentConfiguration"}
	if v.QueryCompute != nil {
		if err := validateMembershipQueryComputePaymentConfig(v.QueryCompute); err != nil {
			invalidParams.AddNested("QueryCompute", err.(smithy.InvalidParamsError))
		}
	}
	if v.MachineLearning != nil {
		if err := validateMembershipMLPaymentConfig(v.MachineLearning); err != nil {
			invalidParams.AddNested("MachineLearning", err.(smithy.InvalidParamsError))
		}
	}
	if v.JobCompute != nil {
		if err := validateMembershipJobComputePaymentConfig(v.JobCompute); err != nil {
			invalidParams.AddNested("JobCompute", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchGetCollaborationAnalysisTemplateInput(v *BatchGetCollaborationAnalysisTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetCollaborationAnalysisTemplateInput"}
	if v.CollaborationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaborationIdentifier"))
	}
	if v.AnalysisTemplateArns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisTemplateArns"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchGetSchemaAnalysisRuleInput(v *BatchGetSchemaAnalysisRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetSchemaAnalysisRuleInput"}
	if v.CollaborationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaborationIdentifier"))
	}
	if v.SchemaAnalysisRuleRequests == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaAnalysisRuleRequests"))
	} else if v.SchemaAnalysisRuleRequests != nil {
		if err := validateSchemaAnalysisRuleRequestList(v.SchemaAnalysisRuleRequests); err != nil {
			invalidParams.AddNested("SchemaAnalysisRuleRequests", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchGetSchemaInput(v *BatchGetSchemaInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetSchemaInput"}
	if v.CollaborationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaborationIdentifier"))
	}
	if v.Names == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Names"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAnalysisTemplateInput(v *CreateAnalysisTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAnalysisTemplateInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.Format) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Format"))
	}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	} else if v.Source != nil {
		if err := validateAnalysisSource(v.Source); err != nil {
			invalidParams.AddNested("Source", err.(smithy.InvalidParamsError))
		}
	}
	if v.AnalysisParameters != nil {
		if err := validateAnalysisParameterList(v.AnalysisParameters); err != nil {
			invalidParams.AddNested("AnalysisParameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.ErrorMessageConfiguration != nil {
		if err := validateErrorMessageConfiguration(v.ErrorMessageConfiguration); err != nil {
			invalidParams.AddNested("ErrorMessageConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.SyntheticDataParameters != nil {
		if err := validateSyntheticDataParameters(v.SyntheticDataParameters); err != nil {
			invalidParams.AddNested("SyntheticDataParameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCollaborationChangeRequestInput(v *CreateCollaborationChangeRequestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCollaborationChangeRequestInput"}
	if v.CollaborationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaborationIdentifier"))
	}
	if v.Changes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Changes"))
	} else if v.Changes != nil {
		if err := validateChangeInputList(v.Changes); err != nil {
			invalidParams.AddNested("Changes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCollaborationInput(v *CreateCollaborationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCollaborationInput"}
	if v.Members == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Members"))
	} else if v.Members != nil {
		if err := validateMemberList(v.Members); err != nil {
			invalidParams.AddNested("Members", err.(smithy.InvalidParamsError))
		}
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.CreatorMemberAbilities == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CreatorMemberAbilities"))
	}
	if v.CreatorMLMemberAbilities != nil {
		if err := validateMLMemberAbilities(v.CreatorMLMemberAbilities); err != nil {
			invalidParams.AddNested("CreatorMLMemberAbilities", err.(smithy.InvalidParamsError))
		}
	}
	if v.CreatorDisplayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CreatorDisplayName"))
	}
	if v.DataEncryptionMetadata != nil {
		if err := validateDataEncryptionMetadata(v.DataEncryptionMetadata); err != nil {
			invalidParams.AddNested("DataEncryptionMetadata", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.QueryLogStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("QueryLogStatus"))
	}
	if v.CreatorPaymentConfiguration != nil {
		if err := validatePaymentConfiguration(v.CreatorPaymentConfiguration); err != nil {
			invalidParams.AddNested("CreatorPaymentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateConfiguredAudienceModelAssociationInput(v *CreateConfiguredAudienceModelAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateConfiguredAudienceModelAssociationInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.ConfiguredAudienceModelArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfiguredAudienceModelArn"))
	}
	if v.ConfiguredAudienceModelAssociationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfiguredAudienceModelAssociationName"))
	}
	if v.ManageResourcePolicies == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ManageResourcePolicies"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateConfiguredTableAnalysisRuleInput(v *CreateConfiguredTableAnalysisRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateConfiguredTableAnalysisRuleInput"}
	if v.ConfiguredTableIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfiguredTableIdentifier"))
	}
	if len(v.AnalysisRuleType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisRuleType"))
	}
	if v.AnalysisRulePolicy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisRulePolicy"))
	} else if v.AnalysisRulePolicy != nil {
		if err := validateConfiguredTableAnalysisRulePolicy(v.AnalysisRulePolicy); err != nil {
			invalidParams.AddNested("AnalysisRulePolicy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateConfiguredTableAssociationAnalysisRuleInput(v *CreateConfiguredTableAssociationAnalysisRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateConfiguredTableAssociationAnalysisRuleInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.ConfiguredTableAssociationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfiguredTableAssociationIdentifier"))
	}
	if len(v.AnalysisRuleType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisRuleType"))
	}
	if v.AnalysisRulePolicy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisRulePolicy"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateConfiguredTableAssociationInput(v *CreateConfiguredTableAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateConfiguredTableAssociationInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.ConfiguredTableIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfiguredTableIdentifier"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateConfiguredTableInput(v *CreateConfiguredTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateConfiguredTableInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.TableReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableReference"))
	} else if v.TableReference != nil {
		if err := validateTableReference(v.TableReference); err != nil {
			invalidParams.AddNested("TableReference", err.(smithy.InvalidParamsError))
		}
	}
	if v.AllowedColumns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AllowedColumns"))
	}
	if len(v.AnalysisMethod) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisMethod"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateIdMappingTableInput(v *CreateIdMappingTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateIdMappingTableInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.InputReferenceConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputReferenceConfig"))
	} else if v.InputReferenceConfig != nil {
		if err := validateIdMappingTableInputReferenceConfig(v.InputReferenceConfig); err != nil {
			invalidParams.AddNested("InputReferenceConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateIdNamespaceAssociationInput(v *CreateIdNamespaceAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateIdNamespaceAssociationInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.InputReferenceConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputReferenceConfig"))
	} else if v.InputReferenceConfig != nil {
		if err := validateIdNamespaceAssociationInputReferenceConfig(v.InputReferenceConfig); err != nil {
			invalidParams.AddNested("InputReferenceConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.IdMappingConfig != nil {
		if err := validateIdMappingConfig(v.IdMappingConfig); err != nil {
			invalidParams.AddNested("IdMappingConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateIntermediateTableAnalysisRuleInput(v *CreateIntermediateTableAnalysisRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateIntermediateTableAnalysisRuleInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.IntermediateTableIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntermediateTableIdentifier"))
	}
	if len(v.AnalysisRuleType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisRuleType"))
	}
	if v.AnalysisRulePolicy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisRulePolicy"))
	} else if v.AnalysisRulePolicy != nil {
		if err := validateIntermediateTableAnalysisRulePolicy(v.AnalysisRulePolicy); err != nil {
			invalidParams.AddNested("AnalysisRulePolicy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateMembershipInput(v *CreateMembershipInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMembershipInput"}
	if v.CollaborationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaborationIdentifier"))
	}
	if len(v.QueryLogStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("QueryLogStatus"))
	}
	if v.DefaultResultConfiguration != nil {
		if err := validateMembershipProtectedQueryResultConfiguration(v.DefaultResultConfiguration); err != nil {
			invalidParams.AddNested("DefaultResultConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.DefaultJobResultConfiguration != nil {
		if err := validateMembershipProtectedJobResultConfiguration(v.DefaultJobResultConfiguration); err != nil {
			invalidParams.AddNested("DefaultJobResultConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.PaymentConfiguration != nil {
		if err := validateMembershipPaymentConfiguration(v.PaymentConfiguration); err != nil {
			invalidParams.AddNested("PaymentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePrivacyBudgetTemplateInput(v *CreatePrivacyBudgetTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePrivacyBudgetTemplateInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if len(v.PrivacyBudgetType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PrivacyBudgetType"))
	}
	if v.Parameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Parameters"))
	} else if v.Parameters != nil {
		if err := validatePrivacyBudgetTemplateParametersInput(v.Parameters); err != nil {
			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteAnalysisTemplateInput(v *DeleteAnalysisTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAnalysisTemplateInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.AnalysisTemplateIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisTemplateIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteConfiguredAudienceModelAssociationInput(v *DeleteConfiguredAudienceModelAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteConfiguredAudienceModelAssociationInput"}
	if v.ConfiguredAudienceModelAssociationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfiguredAudienceModelAssociationIdentifier"))
	}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteConfiguredTableAnalysisRuleInput(v *DeleteConfiguredTableAnalysisRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteConfiguredTableAnalysisRuleInput"}
	if v.ConfiguredTableIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfiguredTableIdentifier"))
	}
	if len(v.AnalysisRuleType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisRuleType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteConfiguredTableAssociationAnalysisRuleInput(v *DeleteConfiguredTableAssociationAnalysisRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteConfiguredTableAssociationAnalysisRuleInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.ConfiguredTableAssociationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfiguredTableAssociationIdentifier"))
	}
	if len(v.AnalysisRuleType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisRuleType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteConfiguredTableAssociationInput(v *DeleteConfiguredTableAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteConfiguredTableAssociationInput"}
	if v.ConfiguredTableAssociationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfiguredTableAssociationIdentifier"))
	}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteIdMappingTableInput(v *DeleteIdMappingTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIdMappingTableInput"}
	if v.IdMappingTableIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdMappingTableIdentifier"))
	}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteIdNamespaceAssociationInput(v *DeleteIdNamespaceAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIdNamespaceAssociationInput"}
	if v.IdNamespaceAssociationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdNamespaceAssociationIdentifier"))
	}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteIntermediateTableAnalysisRuleInput(v *DeleteIntermediateTableAnalysisRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIntermediateTableAnalysisRuleInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.IntermediateTableIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntermediateTableIdentifier"))
	}
	if len(v.AnalysisRuleType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisRuleType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteIntermediateTableInput(v *DeleteIntermediateTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIntermediateTableInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.IntermediateTableIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntermediateTableIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteMemberInput(v *DeleteMemberInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteMemberInput"}
	if v.CollaborationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaborationIdentifier"))
	}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeletePrivacyBudgetTemplateInput(v *DeletePrivacyBudgetTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeletePrivacyBudgetTemplateInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.PrivacyBudgetTemplateIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrivacyBudgetTemplateIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisallowIntermediateTableInput(v *DisallowIntermediateTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisallowIntermediateTableInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.IntermediateTableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntermediateTableName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAnalysisTemplateInput(v *GetAnalysisTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAnalysisTemplateInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.AnalysisTemplateIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisTemplateIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCollaborationAnalysisTemplateInput(v *GetCollaborationAnalysisTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCollaborationAnalysisTemplateInput"}
	if v.CollaborationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaborationIdentifier"))
	}
	if v.AnalysisTemplateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisTemplateArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCollaborationChangeRequestInput(v *GetCollaborationChangeRequestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCollaborationChangeRequestInput"}
	if v.CollaborationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaborationIdentifier"))
	}
	if v.ChangeRequestIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeRequestIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCollaborationConfiguredAudienceModelAssociationInput(v *GetCollaborationConfiguredAudienceModelAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCollaborationConfiguredAudienceModelAssociationInput"}
	if v.CollaborationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaborationIdentifier"))
	}
	if v.ConfiguredAudienceModelAssociationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfiguredAudienceModelAssociationIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCollaborationIdNamespaceAssociationInput(v *GetCollaborationIdNamespaceAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCollaborationIdNamespaceAssociationInput"}
	if v.CollaborationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaborationIdentifier"))
	}
	if v.IdNamespaceAssociationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdNamespaceAssociationIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetCollaborationPrivacyBudgetTemplateInput(v *GetCollaborationPrivacyBudgetTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCollaborationPrivacyBudgetTemplateInput"}
	if v.CollaborationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaborationIdentifier"))
	}
	if v.PrivacyBudgetTemplateIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrivacyBudgetTemplateIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetConfiguredAudienceModelAssociationInput(v *GetConfiguredAudienceModelAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetConfiguredAudienceModelAssociationInput"}
	if v.ConfiguredAudienceModelAssociationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfiguredAudienceModelAssociationIdentifier"))
	}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetConfiguredTableAnalysisRuleInput(v *GetConfiguredTableAnalysisRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetConfiguredTableAnalysisRuleInput"}
	if v.ConfiguredTableIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfiguredTableIdentifier"))
	}
	if len(v.AnalysisRuleType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisRuleType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetConfiguredTableAssociationAnalysisRuleInput(v *GetConfiguredTableAssociationAnalysisRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetConfiguredTableAssociationAnalysisRuleInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.ConfiguredTableAssociationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfiguredTableAssociationIdentifier"))
	}
	if len(v.AnalysisRuleType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisRuleType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetConfiguredTableAssociationInput(v *GetConfiguredTableAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetConfiguredTableAssociationInput"}
	if v.ConfiguredTableAssociationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfiguredTableAssociationIdentifier"))
	}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetIdMappingTableInput(v *GetIdMappingTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIdMappingTableInput"}
	if v.IdMappingTableIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdMappingTableIdentifier"))
	}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIdNamespaceAssociationInput(v *GetIdNamespaceAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIdNamespaceAssociationInput"}
	if v.IdNamespaceAssociationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdNamespaceAssociationIdentifier"))
	}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIntermediateTableAnalysisRuleInput(v *GetIntermediateTableAnalysisRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIntermediateTableAnalysisRuleInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.IntermediateTableIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntermediateTableIdentifier"))
	}
	if len(v.AnalysisRuleType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisRuleType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIntermediateTableInput(v *GetIntermediateTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIntermediateTableInput"}
	if v.IntermediateTableIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntermediateTableIdentifier"))
	}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetPrivacyBudgetTemplateInput(v *GetPrivacyBudgetTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPrivacyBudgetTemplateInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.PrivacyBudgetTemplateIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrivacyBudgetTemplateIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetProtectedJobInput(v *GetProtectedJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetProtectedJobInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.ProtectedJobIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProtectedJobIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetProtectedQueryInput(v *GetProtectedQueryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetProtectedQueryInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.ProtectedQueryIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProtectedQueryIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateOpListCollaborationPrivacyBudgetsInput(v *ListCollaborationPrivacyBudgetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListCollaborationPrivacyBudgetsInput"}
	if v.CollaborationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaborationIdentifier"))
	}
	if len(v.PrivacyBudgetType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PrivacyBudgetType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateOpListIntermediateTableVersionsInput(v *ListIntermediateTableVersionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListIntermediateTableVersionsInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.IntermediateTableIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntermediateTableIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListPrivacyBudgetsInput(v *ListPrivacyBudgetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListPrivacyBudgetsInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if len(v.PrivacyBudgetType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PrivacyBudgetType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpListSchemasInput(v *ListSchemasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListSchemasInput"}
	if v.CollaborationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaborationIdentifier"))
	}
	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 validateOpPopulateIdMappingTableInput(v *PopulateIdMappingTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PopulateIdMappingTableInput"}
	if v.IdMappingTableIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdMappingTableIdentifier"))
	}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPopulateIntermediateTableInput(v *PopulateIntermediateTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PopulateIntermediateTableInput"}
	if v.IntermediateTableIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntermediateTableIdentifier"))
	}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPreviewPrivacyImpactInput(v *PreviewPrivacyImpactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PreviewPrivacyImpactInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.Parameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Parameters"))
	} else if v.Parameters != nil {
		if err := validatePreviewPrivacyImpactParametersInput(v.Parameters); err != nil {
			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartProtectedJobInput(v *StartProtectedJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartProtectedJobInput"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.JobParameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobParameters"))
	} else if v.JobParameters != nil {
		if err := validateProtectedJobParameters(v.JobParameters); err != nil {
			invalidParams.AddNested("JobParameters", err.(smithy.InvalidParamsError))
		}
	}
	if v.ResultConfiguration != nil {
		if err := validateProtectedJobResultConfigurationInput(v.ResultConfiguration); err != nil {
			invalidParams.AddNested("ResultConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ComputeConfiguration != nil {
		if err := validateProtectedJobComputeConfiguration(v.ComputeConfiguration); err != nil {
			invalidParams.AddNested("ComputeConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartProtectedQueryInput(v *StartProtectedQueryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartProtectedQueryInput"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.SqlParameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SqlParameters"))
	}
	if v.ResultConfiguration != nil {
		if err := validateProtectedQueryResultConfiguration(v.ResultConfiguration); err != nil {
			invalidParams.AddNested("ResultConfiguration", 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"))
	}
	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 validateOpUpdateAnalysisTemplateInput(v *UpdateAnalysisTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAnalysisTemplateInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.AnalysisTemplateIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisTemplateIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateCollaborationChangeRequestInput(v *UpdateCollaborationChangeRequestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCollaborationChangeRequestInput"}
	if v.CollaborationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CollaborationIdentifier"))
	}
	if v.ChangeRequestIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChangeRequestIdentifier"))
	}
	if len(v.Action) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateConfiguredAudienceModelAssociationInput(v *UpdateConfiguredAudienceModelAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateConfiguredAudienceModelAssociationInput"}
	if v.ConfiguredAudienceModelAssociationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfiguredAudienceModelAssociationIdentifier"))
	}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateConfiguredTableAnalysisRuleInput(v *UpdateConfiguredTableAnalysisRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateConfiguredTableAnalysisRuleInput"}
	if v.ConfiguredTableIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfiguredTableIdentifier"))
	}
	if len(v.AnalysisRuleType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisRuleType"))
	}
	if v.AnalysisRulePolicy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisRulePolicy"))
	} else if v.AnalysisRulePolicy != nil {
		if err := validateConfiguredTableAnalysisRulePolicy(v.AnalysisRulePolicy); err != nil {
			invalidParams.AddNested("AnalysisRulePolicy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateConfiguredTableAssociationAnalysisRuleInput(v *UpdateConfiguredTableAssociationAnalysisRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateConfiguredTableAssociationAnalysisRuleInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.ConfiguredTableAssociationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfiguredTableAssociationIdentifier"))
	}
	if len(v.AnalysisRuleType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisRuleType"))
	}
	if v.AnalysisRulePolicy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisRulePolicy"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateConfiguredTableAssociationInput(v *UpdateConfiguredTableAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateConfiguredTableAssociationInput"}
	if v.ConfiguredTableAssociationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfiguredTableAssociationIdentifier"))
	}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateConfiguredTableInput(v *UpdateConfiguredTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateConfiguredTableInput"}
	if v.ConfiguredTableIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfiguredTableIdentifier"))
	}
	if v.TableReference != nil {
		if err := validateTableReference(v.TableReference); err != nil {
			invalidParams.AddNested("TableReference", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateIdMappingTableInput(v *UpdateIdMappingTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateIdMappingTableInput"}
	if v.IdMappingTableIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdMappingTableIdentifier"))
	}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateIdNamespaceAssociationInput(v *UpdateIdNamespaceAssociationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateIdNamespaceAssociationInput"}
	if v.IdNamespaceAssociationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdNamespaceAssociationIdentifier"))
	}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.IdMappingConfig != nil {
		if err := validateIdMappingConfig(v.IdMappingConfig); err != nil {
			invalidParams.AddNested("IdMappingConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateIntermediateTableAnalysisRuleInput(v *UpdateIntermediateTableAnalysisRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateIntermediateTableAnalysisRuleInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.IntermediateTableIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntermediateTableIdentifier"))
	}
	if len(v.AnalysisRuleType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisRuleType"))
	}
	if v.AnalysisRulePolicy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnalysisRulePolicy"))
	} else if v.AnalysisRulePolicy != nil {
		if err := validateIntermediateTableAnalysisRulePolicy(v.AnalysisRulePolicy); err != nil {
			invalidParams.AddNested("AnalysisRulePolicy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateIntermediateTableInput(v *UpdateIntermediateTableInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateIntermediateTableInput"}
	if v.IntermediateTableIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntermediateTableIdentifier"))
	}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.Columns != nil {
		if err := validateIntermediateTableColumnList(v.Columns); err != nil {
			invalidParams.AddNested("Columns", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateMembershipInput(v *UpdateMembershipInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateMembershipInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.DefaultResultConfiguration != nil {
		if err := validateMembershipProtectedQueryResultConfiguration(v.DefaultResultConfiguration); err != nil {
			invalidParams.AddNested("DefaultResultConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.DefaultJobResultConfiguration != nil {
		if err := validateMembershipProtectedJobResultConfiguration(v.DefaultJobResultConfiguration); err != nil {
			invalidParams.AddNested("DefaultJobResultConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.MembershipPaymentConfiguration != nil {
		if err := validateUpdateMembershipPaymentConfiguration(v.MembershipPaymentConfiguration); err != nil {
			invalidParams.AddNested("MembershipPaymentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdatePrivacyBudgetTemplateInput(v *UpdatePrivacyBudgetTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePrivacyBudgetTemplateInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.PrivacyBudgetTemplateIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrivacyBudgetTemplateIdentifier"))
	}
	if len(v.PrivacyBudgetType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PrivacyBudgetType"))
	}
	if v.Parameters != nil {
		if err := validatePrivacyBudgetTemplateUpdateParameters(v.Parameters); err != nil {
			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateProtectedJobInput(v *UpdateProtectedJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateProtectedJobInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.ProtectedJobIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProtectedJobIdentifier"))
	}
	if len(v.TargetStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TargetStatus"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateProtectedQueryInput(v *UpdateProtectedQueryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateProtectedQueryInput"}
	if v.MembershipIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MembershipIdentifier"))
	}
	if v.ProtectedQueryIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProtectedQueryIdentifier"))
	}
	if len(v.TargetStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TargetStatus"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}
