// 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 addOpBatchGetSchemaValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpBatchGetSchema{}, middleware.After)
}

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

func addOpCreateConfiguredTableAnalysisRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateConfiguredTableAnalysisRule{}, 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 addOpCreateMembershipValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateMembership{}, middleware.After)
}

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

func addOpDeleteConfiguredTableAnalysisRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteConfiguredTableAnalysisRule{}, 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 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 addOpGetCollaborationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetCollaboration{}, middleware.After)
}

func addOpGetConfiguredTableAnalysisRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetConfiguredTableAnalysisRule{}, 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 addOpGetMembershipValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetMembership{}, 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 addOpListConfiguredTableAssociationsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListConfiguredTableAssociations{}, middleware.After)
}

func addOpListMembersValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListMembers{}, 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 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 addOpUpdateCollaborationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateCollaboration{}, middleware.After)
}

func addOpUpdateConfiguredTableAnalysisRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateConfiguredTableAnalysisRule{}, 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 addOpUpdateMembershipValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateMembership{}, middleware.After)
}

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

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 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 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 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.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 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 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 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.DisplayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DisplayName"))
	}
	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.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 validateTableReference(v types.TableReference) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TableReference"}
	switch uv := v.(type) {
	case *types.TableReferenceMemberGlue:
		if err := validateGlueTableReference(&uv.Value); err != nil {
			invalidParams.AddNested("[glue]", 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 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.Description == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Description"))
	}
	if v.CreatorMemberAbilities == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CreatorMemberAbilities"))
	}
	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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 {
		invalidParams.Add(smithy.NewErrParamRequired("ResultConfiguration"))
	} else 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 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 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 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 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 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
	}
}