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

package auditmanager

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

type validateOpAssociateAssessmentReportEvidenceFolder struct {
}

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

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

type validateOpBatchAssociateAssessmentReportEvidence struct {
}

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

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

type validateOpBatchCreateDelegationByAssessment struct {
}

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

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

type validateOpBatchDeleteDelegationByAssessment struct {
}

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

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

type validateOpBatchDisassociateAssessmentReportEvidence struct {
}

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

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

type validateOpBatchImportEvidenceToAssessmentControl struct {
}

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

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

type validateOpCreateAssessmentFramework struct {
}

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

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

type validateOpCreateAssessment struct {
}

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

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

type validateOpCreateAssessmentReport struct {
}

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

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

type validateOpCreateControl struct {
}

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

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

type validateOpDeleteAssessmentFramework struct {
}

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

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

type validateOpDeleteAssessmentFrameworkShare struct {
}

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

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

type validateOpDeleteAssessment struct {
}

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

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

type validateOpDeleteAssessmentReport struct {
}

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

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

type validateOpDeleteControl struct {
}

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

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

type validateOpDisassociateAssessmentReportEvidenceFolder struct {
}

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

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

type validateOpGetAssessmentFramework struct {
}

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

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

type validateOpGetAssessment struct {
}

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

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

type validateOpGetAssessmentReportUrl struct {
}

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

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

type validateOpGetChangeLogs struct {
}

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

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

type validateOpGetControl struct {
}

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

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

type validateOpGetEvidenceByEvidenceFolder struct {
}

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

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

type validateOpGetEvidenceFileUploadUrl struct {
}

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

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

type validateOpGetEvidenceFolder struct {
}

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

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

type validateOpGetEvidenceFoldersByAssessmentControl struct {
}

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

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

type validateOpGetEvidenceFoldersByAssessment struct {
}

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

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

type validateOpGetEvidence struct {
}

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

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

type validateOpGetInsightsByAssessment struct {
}

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

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

type validateOpGetSettings struct {
}

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

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

type validateOpListAssessmentControlInsightsByControlDomain struct {
}

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

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

type validateOpListAssessmentFrameworkShareRequests struct {
}

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

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

type validateOpListAssessmentFrameworks struct {
}

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

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

type validateOpListControlDomainInsightsByAssessment struct {
}

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

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

type validateOpListControlInsightsByControlDomain struct {
}

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

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

type validateOpListControls struct {
}

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

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

type validateOpListKeywordsForDataSource struct {
}

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

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

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

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

type validateOpStartAssessmentFrameworkShare struct {
}

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

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

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

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

type validateOpUpdateAssessmentControlSetStatus struct {
}

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

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

type validateOpUpdateAssessmentFramework struct {
}

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

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

type validateOpUpdateAssessmentFrameworkShare struct {
}

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

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

type validateOpUpdateAssessment struct {
}

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

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

type validateOpUpdateAssessmentStatus struct {
}

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

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

type validateOpUpdateControl struct {
}

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

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

type validateOpUpdateSettings struct {
}

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

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

type validateOpValidateAssessmentReportIntegrity struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpStartAssessmentFrameworkShareValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartAssessmentFrameworkShare{}, 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 addOpUpdateAssessmentControlValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateAssessmentControl{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

func validateCreateAssessmentFrameworkControlSet(v *types.CreateAssessmentFrameworkControlSet) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAssessmentFrameworkControlSet"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Controls != nil {
		if err := validateCreateAssessmentFrameworkControls(v.Controls); err != nil {
			invalidParams.AddNested("Controls", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRole(v *types.Role) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Role"}
	if len(v.RoleType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RoleType"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateUpdateAssessmentFrameworkControlSet(v *types.UpdateAssessmentFrameworkControlSet) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAssessmentFrameworkControlSet"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Controls == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Controls"))
	} else if v.Controls != nil {
		if err := validateCreateAssessmentFrameworkControls(v.Controls); err != nil {
			invalidParams.AddNested("Controls", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpAssociateAssessmentReportEvidenceFolderInput(v *AssociateAssessmentReportEvidenceFolderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateAssessmentReportEvidenceFolderInput"}
	if v.AssessmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentId"))
	}
	if v.EvidenceFolderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvidenceFolderId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchAssociateAssessmentReportEvidenceInput(v *BatchAssociateAssessmentReportEvidenceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchAssociateAssessmentReportEvidenceInput"}
	if v.AssessmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentId"))
	}
	if v.EvidenceFolderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvidenceFolderId"))
	}
	if v.EvidenceIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvidenceIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchCreateDelegationByAssessmentInput(v *BatchCreateDelegationByAssessmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchCreateDelegationByAssessmentInput"}
	if v.CreateDelegationRequests == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CreateDelegationRequests"))
	}
	if v.AssessmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchDeleteDelegationByAssessmentInput(v *BatchDeleteDelegationByAssessmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteDelegationByAssessmentInput"}
	if v.DelegationIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DelegationIds"))
	}
	if v.AssessmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchDisassociateAssessmentReportEvidenceInput(v *BatchDisassociateAssessmentReportEvidenceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDisassociateAssessmentReportEvidenceInput"}
	if v.AssessmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentId"))
	}
	if v.EvidenceFolderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvidenceFolderId"))
	}
	if v.EvidenceIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvidenceIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchImportEvidenceToAssessmentControlInput(v *BatchImportEvidenceToAssessmentControlInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchImportEvidenceToAssessmentControlInput"}
	if v.AssessmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentId"))
	}
	if v.ControlSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ControlSetId"))
	}
	if v.ControlId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ControlId"))
	}
	if v.ManualEvidence == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ManualEvidence"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAssessmentFrameworkInput(v *CreateAssessmentFrameworkInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAssessmentFrameworkInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ControlSets == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ControlSets"))
	} else if v.ControlSets != nil {
		if err := validateCreateAssessmentFrameworkControlSets(v.ControlSets); err != nil {
			invalidParams.AddNested("ControlSets", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAssessmentInput(v *CreateAssessmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAssessmentInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.AssessmentReportsDestination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentReportsDestination"))
	}
	if v.Scope == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.Roles == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Roles"))
	} else if v.Roles != nil {
		if err := validateRoles(v.Roles); err != nil {
			invalidParams.AddNested("Roles", err.(smithy.InvalidParamsError))
		}
	}
	if v.FrameworkId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FrameworkId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpDeleteAssessmentFrameworkShareInput(v *DeleteAssessmentFrameworkShareInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAssessmentFrameworkShareInput"}
	if v.RequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequestId"))
	}
	if len(v.RequestType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RequestType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteAssessmentReportInput(v *DeleteAssessmentReportInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAssessmentReportInput"}
	if v.AssessmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentId"))
	}
	if v.AssessmentReportId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentReportId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDisassociateAssessmentReportEvidenceFolderInput(v *DisassociateAssessmentReportEvidenceFolderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateAssessmentReportEvidenceFolderInput"}
	if v.AssessmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentId"))
	}
	if v.EvidenceFolderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvidenceFolderId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpGetAssessmentReportUrlInput(v *GetAssessmentReportUrlInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAssessmentReportUrlInput"}
	if v.AssessmentReportId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentReportId"))
	}
	if v.AssessmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpGetEvidenceByEvidenceFolderInput(v *GetEvidenceByEvidenceFolderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetEvidenceByEvidenceFolderInput"}
	if v.AssessmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentId"))
	}
	if v.ControlSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ControlSetId"))
	}
	if v.EvidenceFolderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvidenceFolderId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetEvidenceFolderInput(v *GetEvidenceFolderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetEvidenceFolderInput"}
	if v.AssessmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentId"))
	}
	if v.ControlSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ControlSetId"))
	}
	if v.EvidenceFolderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvidenceFolderId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetEvidenceFoldersByAssessmentControlInput(v *GetEvidenceFoldersByAssessmentControlInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetEvidenceFoldersByAssessmentControlInput"}
	if v.AssessmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentId"))
	}
	if v.ControlSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ControlSetId"))
	}
	if v.ControlId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ControlId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetEvidenceInput(v *GetEvidenceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetEvidenceInput"}
	if v.AssessmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentId"))
	}
	if v.ControlSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ControlSetId"))
	}
	if v.EvidenceFolderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvidenceFolderId"))
	}
	if v.EvidenceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvidenceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetSettingsInput(v *GetSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSettingsInput"}
	if len(v.Attribute) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListAssessmentControlInsightsByControlDomainInput(v *ListAssessmentControlInsightsByControlDomainInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAssessmentControlInsightsByControlDomainInput"}
	if v.ControlDomainId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ControlDomainId"))
	}
	if v.AssessmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListAssessmentFrameworkShareRequestsInput(v *ListAssessmentFrameworkShareRequestsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAssessmentFrameworkShareRequestsInput"}
	if len(v.RequestType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RequestType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListAssessmentFrameworksInput(v *ListAssessmentFrameworksInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAssessmentFrameworksInput"}
	if len(v.FrameworkType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("FrameworkType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListControlsInput(v *ListControlsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListControlsInput"}
	if len(v.ControlType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ControlType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListKeywordsForDataSourceInput(v *ListKeywordsForDataSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListKeywordsForDataSourceInput"}
	if len(v.Source) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	}
	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 validateOpRegisterOrganizationAdminAccountInput(v *RegisterOrganizationAdminAccountInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterOrganizationAdminAccountInput"}
	if v.AdminAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AdminAccountId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartAssessmentFrameworkShareInput(v *StartAssessmentFrameworkShareInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartAssessmentFrameworkShareInput"}
	if v.FrameworkId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FrameworkId"))
	}
	if v.DestinationAccount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationAccount"))
	}
	if v.DestinationRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationRegion"))
	}
	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 validateOpUpdateAssessmentControlInput(v *UpdateAssessmentControlInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAssessmentControlInput"}
	if v.AssessmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentId"))
	}
	if v.ControlSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ControlSetId"))
	}
	if v.ControlId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ControlId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAssessmentControlSetStatusInput(v *UpdateAssessmentControlSetStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAssessmentControlSetStatusInput"}
	if v.AssessmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentId"))
	}
	if v.ControlSetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ControlSetId"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if v.Comment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Comment"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAssessmentFrameworkInput(v *UpdateAssessmentFrameworkInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAssessmentFrameworkInput"}
	if v.FrameworkId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FrameworkId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ControlSets == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ControlSets"))
	} else if v.ControlSets != nil {
		if err := validateUpdateAssessmentFrameworkControlSets(v.ControlSets); err != nil {
			invalidParams.AddNested("ControlSets", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAssessmentFrameworkShareInput(v *UpdateAssessmentFrameworkShareInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAssessmentFrameworkShareInput"}
	if v.RequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequestId"))
	}
	if len(v.RequestType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RequestType"))
	}
	if len(v.Action) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAssessmentInput(v *UpdateAssessmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAssessmentInput"}
	if v.AssessmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentId"))
	}
	if v.Scope == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if v.Roles != nil {
		if err := validateRoles(v.Roles); err != nil {
			invalidParams.AddNested("Roles", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAssessmentStatusInput(v *UpdateAssessmentStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAssessmentStatusInput"}
	if v.AssessmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssessmentId"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateControlInput(v *UpdateControlInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateControlInput"}
	if v.ControlId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ControlId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ControlMappingSources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ControlMappingSources"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateSettingsInput(v *UpdateSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSettingsInput"}
	if v.DefaultProcessOwners != nil {
		if err := validateRoles(v.DefaultProcessOwners); err != nil {
			invalidParams.AddNested("DefaultProcessOwners", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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