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

package directoryservice

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

type validateOpAcceptSharedDirectory struct {
}

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

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

type validateOpAddIpRoutes struct {
}

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

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

type validateOpAddRegion struct {
}

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

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

type validateOpAddTagsToResource struct {
}

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

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

type validateOpCancelSchemaExtension struct {
}

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

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

type validateOpConnectDirectory struct {
}

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

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

type validateOpCreateAlias struct {
}

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

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

type validateOpCreateComputer struct {
}

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

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

type validateOpCreateConditionalForwarder struct {
}

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

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

type validateOpCreateDirectory struct {
}

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

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

type validateOpCreateLogSubscription struct {
}

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

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

type validateOpCreateMicrosoftAD struct {
}

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

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

type validateOpCreateSnapshot struct {
}

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

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

type validateOpCreateTrust struct {
}

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

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

type validateOpDeleteConditionalForwarder struct {
}

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

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

type validateOpDeleteDirectory struct {
}

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

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

type validateOpDeleteLogSubscription struct {
}

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

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

type validateOpDeleteSnapshot struct {
}

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

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

type validateOpDeleteTrust struct {
}

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

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

type validateOpDeregisterCertificate struct {
}

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

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

type validateOpDeregisterEventTopic struct {
}

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

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

type validateOpDescribeCertificate struct {
}

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

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

type validateOpDescribeClientAuthenticationSettings struct {
}

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

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

type validateOpDescribeConditionalForwarders struct {
}

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

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

type validateOpDescribeDomainControllers struct {
}

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

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

type validateOpDescribeLDAPSSettings struct {
}

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

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

type validateOpDescribeRegions struct {
}

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

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

type validateOpDescribeSettings struct {
}

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

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

type validateOpDescribeSharedDirectories struct {
}

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

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

type validateOpDescribeUpdateDirectory struct {
}

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

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

type validateOpDisableClientAuthentication struct {
}

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

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

type validateOpDisableLDAPS struct {
}

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

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

type validateOpDisableRadius struct {
}

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

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

type validateOpDisableSso struct {
}

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

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

type validateOpEnableClientAuthentication struct {
}

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

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

type validateOpEnableLDAPS struct {
}

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

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

type validateOpEnableRadius struct {
}

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

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

type validateOpEnableSso struct {
}

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

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

type validateOpGetSnapshotLimits struct {
}

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

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

type validateOpListCertificates struct {
}

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

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

type validateOpListIpRoutes struct {
}

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

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

type validateOpListSchemaExtensions struct {
}

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

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

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

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

type validateOpRegisterEventTopic struct {
}

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

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

type validateOpRejectSharedDirectory struct {
}

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

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

type validateOpRemoveIpRoutes struct {
}

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

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

type validateOpRemoveRegion struct {
}

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

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

type validateOpRemoveTagsFromResource struct {
}

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

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

type validateOpResetUserPassword struct {
}

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

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

type validateOpRestoreFromSnapshot struct {
}

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

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

type validateOpShareDirectory struct {
}

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

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

type validateOpStartSchemaExtension struct {
}

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

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

type validateOpUnshareDirectory struct {
}

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

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

type validateOpUpdateConditionalForwarder struct {
}

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

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

type validateOpUpdateDirectorySetup struct {
}

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

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

type validateOpUpdateNumberOfDomainControllers struct {
}

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

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

type validateOpUpdateRadius struct {
}

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

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

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

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

type validateOpVerifyTrust struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateDirectoryConnectSettings(v *types.DirectoryConnectSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DirectoryConnectSettings"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if v.SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
	}
	if v.CustomerDnsIps == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CustomerDnsIps"))
	}
	if v.CustomerUserName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CustomerUserName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDirectoryVpcSettings(v *types.DirectoryVpcSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DirectoryVpcSettings"}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if v.SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

func validateOpAddIpRoutesInput(v *AddIpRoutesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddIpRoutesInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.IpRoutes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpRoutes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddRegionInput(v *AddRegionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddRegionInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.RegionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RegionName"))
	}
	if v.VPCSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VPCSettings"))
	} else if v.VPCSettings != nil {
		if err := validateDirectoryVpcSettings(v.VPCSettings); err != nil {
			invalidParams.AddNested("VPCSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddTagsToResourceInput(v *AddTagsToResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddTagsToResourceInput"}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	} else if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCancelSchemaExtensionInput(v *CancelSchemaExtensionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelSchemaExtensionInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.SchemaExtensionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaExtensionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpConnectDirectoryInput(v *ConnectDirectoryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConnectDirectoryInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Password == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Password"))
	}
	if len(v.Size) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Size"))
	}
	if v.ConnectSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectSettings"))
	} else if v.ConnectSettings != nil {
		if err := validateDirectoryConnectSettings(v.ConnectSettings); err != nil {
			invalidParams.AddNested("ConnectSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAliasInput(v *CreateAliasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAliasInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.Alias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Alias"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateComputerInput(v *CreateComputerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateComputerInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.ComputerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ComputerName"))
	}
	if v.Password == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Password"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateConditionalForwarderInput(v *CreateConditionalForwarderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateConditionalForwarderInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.RemoteDomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RemoteDomainName"))
	}
	if v.DnsIpAddrs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DnsIpAddrs"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDirectoryInput(v *CreateDirectoryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDirectoryInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Password == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Password"))
	}
	if len(v.Size) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Size"))
	}
	if v.VpcSettings != nil {
		if err := validateDirectoryVpcSettings(v.VpcSettings); err != nil {
			invalidParams.AddNested("VpcSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLogSubscriptionInput(v *CreateLogSubscriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLogSubscriptionInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.LogGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LogGroupName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMicrosoftADInput(v *CreateMicrosoftADInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMicrosoftADInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Password == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Password"))
	}
	if v.VpcSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcSettings"))
	} else if v.VpcSettings != nil {
		if err := validateDirectoryVpcSettings(v.VpcSettings); err != nil {
			invalidParams.AddNested("VpcSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateTrustInput(v *CreateTrustInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTrustInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.RemoteDomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RemoteDomainName"))
	}
	if v.TrustPassword == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrustPassword"))
	}
	if len(v.TrustDirection) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TrustDirection"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteConditionalForwarderInput(v *DeleteConditionalForwarderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteConditionalForwarderInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.RemoteDomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RemoteDomainName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpDeregisterCertificateInput(v *DeregisterCertificateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeregisterCertificateInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.CertificateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CertificateId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeregisterEventTopicInput(v *DeregisterEventTopicInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeregisterEventTopicInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.TopicName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopicName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeCertificateInput(v *DescribeCertificateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeCertificateInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.CertificateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CertificateId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

func validateOpDescribeUpdateDirectoryInput(v *DescribeUpdateDirectoryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeUpdateDirectoryInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if len(v.UpdateType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("UpdateType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateOpEnableRadiusInput(v *EnableRadiusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableRadiusInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.RadiusSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RadiusSettings"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpListSchemaExtensionsInput(v *ListSchemaExtensionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListSchemaExtensionsInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	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.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRegisterCertificateInput(v *RegisterCertificateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterCertificateInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.CertificateData == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CertificateData"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRegisterEventTopicInput(v *RegisterEventTopicInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegisterEventTopicInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.TopicName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopicName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpRemoveIpRoutesInput(v *RemoveIpRoutesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveIpRoutesInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.CidrIps == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CidrIps"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpRemoveTagsFromResourceInput(v *RemoveTagsFromResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveTagsFromResourceInput"}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.TagKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpResetUserPasswordInput(v *ResetUserPasswordInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResetUserPasswordInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.UserName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
	}
	if v.NewPassword == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NewPassword"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpShareDirectoryInput(v *ShareDirectoryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ShareDirectoryInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.ShareTarget == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ShareTarget"))
	} else if v.ShareTarget != nil {
		if err := validateShareTarget(v.ShareTarget); err != nil {
			invalidParams.AddNested("ShareTarget", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.ShareMethod) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ShareMethod"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartSchemaExtensionInput(v *StartSchemaExtensionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartSchemaExtensionInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.LdifContent == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LdifContent"))
	}
	if v.Description == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Description"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUnshareDirectoryInput(v *UnshareDirectoryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UnshareDirectoryInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.UnshareTarget == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UnshareTarget"))
	} else if v.UnshareTarget != nil {
		if err := validateUnshareTarget(v.UnshareTarget); err != nil {
			invalidParams.AddNested("UnshareTarget", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateConditionalForwarderInput(v *UpdateConditionalForwarderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateConditionalForwarderInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.RemoteDomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RemoteDomainName"))
	}
	if v.DnsIpAddrs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DnsIpAddrs"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDirectorySetupInput(v *UpdateDirectorySetupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDirectorySetupInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if len(v.UpdateType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("UpdateType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateRadiusInput(v *UpdateRadiusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRadiusInput"}
	if v.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.RadiusSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RadiusSettings"))
	}
	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.DirectoryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryId"))
	}
	if v.Settings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Settings"))
	} else if v.Settings != nil {
		if err := validateSettings(v.Settings); err != nil {
			invalidParams.AddNested("Settings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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