validators.go

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

package worklink

import (
	"context"
	"fmt"
	smithy "github.com/aws/smithy-go"
	"github.com/aws/smithy-go/middleware"
)

type validateOpAssociateDomain struct {
}

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

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

type validateOpAssociateWebsiteAuthorizationProvider struct {
}

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

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

type validateOpAssociateWebsiteCertificateAuthority struct {
}

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

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

type validateOpCreateFleet struct {
}

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

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

type validateOpDeleteFleet struct {
}

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

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

type validateOpDescribeAuditStreamConfiguration struct {
}

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

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

type validateOpDescribeCompanyNetworkConfiguration struct {
}

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

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

type validateOpDescribeDevice struct {
}

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

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

type validateOpDescribeDevicePolicyConfiguration struct {
}

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

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

type validateOpDescribeDomain struct {
}

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

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

type validateOpDescribeFleetMetadata struct {
}

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

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

type validateOpDescribeIdentityProviderConfiguration struct {
}

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

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

type validateOpDescribeWebsiteCertificateAuthority struct {
}

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

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

type validateOpDisassociateDomain struct {
}

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

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

type validateOpDisassociateWebsiteAuthorizationProvider struct {
}

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

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

type validateOpDisassociateWebsiteCertificateAuthority struct {
}

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

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

type validateOpListDevices struct {
}

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

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

type validateOpListDomains struct {
}

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

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

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

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

type validateOpListWebsiteCertificateAuthorities struct {
}

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

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

type validateOpRestoreDomainAccess struct {
}

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

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

type validateOpRevokeDomainAccess struct {
}

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

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

type validateOpSignOutUser struct {
}

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

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

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

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

type validateOpUpdateCompanyNetworkConfiguration struct {
}

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

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

type validateOpUpdateDevicePolicyConfiguration struct {
}

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

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

type validateOpUpdateDomainMetadata struct {
}

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

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

type validateOpUpdateFleetMetadata struct {
}

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

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

type validateOpUpdateIdentityProviderConfiguration struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpSignOutUserValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSignOutUser{}, 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 addOpUpdateAuditStreamConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateAuditStreamConfiguration{}, middleware.After)
}

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

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

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

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

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

func validateOpAssociateDomainInput(v *AssociateDomainInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateDomainInput"}
	if v.FleetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
	}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if v.AcmCertificateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AcmCertificateArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateWebsiteAuthorizationProviderInput(v *AssociateWebsiteAuthorizationProviderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateWebsiteAuthorizationProviderInput"}
	if v.FleetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
	}
	if len(v.AuthorizationProviderType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AuthorizationProviderType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateWebsiteCertificateAuthorityInput(v *AssociateWebsiteCertificateAuthorityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateWebsiteCertificateAuthorityInput"}
	if v.FleetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
	}
	if v.Certificate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Certificate"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpDescribeDeviceInput(v *DescribeDeviceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDeviceInput"}
	if v.FleetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
	}
	if v.DeviceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDescribeDomainInput(v *DescribeDomainInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeDomainInput"}
	if v.FleetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
	}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDescribeWebsiteCertificateAuthorityInput(v *DescribeWebsiteCertificateAuthorityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeWebsiteCertificateAuthorityInput"}
	if v.FleetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
	}
	if v.WebsiteCaId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WebsiteCaId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateDomainInput(v *DisassociateDomainInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateDomainInput"}
	if v.FleetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
	}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateWebsiteAuthorizationProviderInput(v *DisassociateWebsiteAuthorizationProviderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateWebsiteAuthorizationProviderInput"}
	if v.FleetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
	}
	if v.AuthorizationProviderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthorizationProviderId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateWebsiteCertificateAuthorityInput(v *DisassociateWebsiteCertificateAuthorityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateWebsiteCertificateAuthorityInput"}
	if v.FleetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
	}
	if v.WebsiteCaId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WebsiteCaId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListDomainsInput(v *ListDomainsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDomainsInput"}
	if v.FleetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
	}
	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 validateOpListWebsiteAuthorizationProvidersInput(v *ListWebsiteAuthorizationProvidersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListWebsiteAuthorizationProvidersInput"}
	if v.FleetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpRestoreDomainAccessInput(v *RestoreDomainAccessInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RestoreDomainAccessInput"}
	if v.FleetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
	}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRevokeDomainAccessInput(v *RevokeDomainAccessInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RevokeDomainAccessInput"}
	if v.FleetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
	}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSignOutUserInput(v *SignOutUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SignOutUserInput"}
	if v.FleetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	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 validateOpUpdateAuditStreamConfigurationInput(v *UpdateAuditStreamConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAuditStreamConfigurationInput"}
	if v.FleetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateCompanyNetworkConfigurationInput(v *UpdateCompanyNetworkConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCompanyNetworkConfigurationInput"}
	if v.FleetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
	}
	if v.VpcId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcId"))
	}
	if v.SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
	}
	if v.SecurityGroupIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecurityGroupIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateDomainMetadataInput(v *UpdateDomainMetadataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDomainMetadataInput"}
	if v.FleetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
	}
	if v.DomainName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateIdentityProviderConfigurationInput(v *UpdateIdentityProviderConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateIdentityProviderConfigurationInput"}
	if v.FleetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FleetArn"))
	}
	if len(v.IdentityProviderType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("IdentityProviderType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}