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

package iotsitewise

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

type validateOpAssociateAssets struct {
}

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

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

type validateOpAssociateTimeSeriesToAssetProperty struct {
}

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

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

type validateOpBatchAssociateProjectAssets struct {
}

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

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

type validateOpBatchDisassociateProjectAssets struct {
}

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

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

type validateOpBatchGetAssetPropertyAggregates struct {
}

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

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

type validateOpBatchGetAssetPropertyValueHistory struct {
}

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

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

type validateOpBatchGetAssetPropertyValue struct {
}

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

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

type validateOpBatchPutAssetPropertyValue struct {
}

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

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

type validateOpCreateAccessPolicy struct {
}

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

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

type validateOpCreateAsset struct {
}

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

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

type validateOpCreateAssetModel struct {
}

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

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

type validateOpCreateBulkImportJob struct {
}

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

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

type validateOpCreateDashboard struct {
}

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

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

type validateOpCreateGateway struct {
}

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

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

type validateOpCreatePortal struct {
}

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

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

type validateOpCreateProject struct {
}

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

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

type validateOpDeleteAccessPolicy struct {
}

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

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

type validateOpDeleteAsset struct {
}

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

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

type validateOpDeleteAssetModel struct {
}

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

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

type validateOpDeleteDashboard struct {
}

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

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

type validateOpDeleteGateway struct {
}

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

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

type validateOpDeletePortal struct {
}

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

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

type validateOpDeleteProject struct {
}

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

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

type validateOpDescribeAccessPolicy struct {
}

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

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

type validateOpDescribeAsset struct {
}

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

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

type validateOpDescribeAssetModel struct {
}

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

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

type validateOpDescribeAssetProperty struct {
}

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

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

type validateOpDescribeBulkImportJob struct {
}

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

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

type validateOpDescribeDashboard struct {
}

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

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

type validateOpDescribeGatewayCapabilityConfiguration struct {
}

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

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

type validateOpDescribeGateway struct {
}

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

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

type validateOpDescribePortal struct {
}

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

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

type validateOpDescribeProject struct {
}

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

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

type validateOpDisassociateAssets struct {
}

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

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

type validateOpDisassociateTimeSeriesFromAssetProperty struct {
}

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

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

type validateOpGetAssetPropertyAggregates struct {
}

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

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

type validateOpGetInterpolatedAssetPropertyValues struct {
}

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

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

type validateOpListAssetModelProperties struct {
}

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

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

type validateOpListAssetProperties struct {
}

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

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

type validateOpListAssetRelationships struct {
}

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

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

type validateOpListAssociatedAssets struct {
}

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

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

type validateOpListDashboards struct {
}

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

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

type validateOpListProjectAssets struct {
}

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

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

type validateOpListProjects struct {
}

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

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

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

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

type validateOpPutLoggingOptions struct {
}

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

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

type validateOpPutStorageConfiguration struct {
}

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

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

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

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

type validateOpUpdateAsset struct {
}

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

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

type validateOpUpdateAssetModel struct {
}

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

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

type validateOpUpdateAssetProperty struct {
}

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

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

type validateOpUpdateDashboard struct {
}

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

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

type validateOpUpdateGatewayCapabilityConfiguration struct {
}

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

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

type validateOpUpdateGateway struct {
}

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

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

type validateOpUpdatePortal struct {
}

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

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

type validateOpUpdateProject struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpPutStorageConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutStorageConfiguration{}, 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 addOpUpdateAccessPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateAccessPolicy{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

func validateAssetModelCompositeModel(v *types.AssetModelCompositeModel) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssetModelCompositeModel"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Type == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.Properties != nil {
		if err := validateAssetModelProperties(v.Properties); err != nil {
			invalidParams.AddNested("Properties", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAssetModelCompositeModelDefinition(v *types.AssetModelCompositeModelDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssetModelCompositeModelDefinition"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Type == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.Properties != nil {
		if err := validateAssetModelPropertyDefinitions(v.Properties); err != nil {
			invalidParams.AddNested("Properties", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

func validateAssetModelProperty(v *types.AssetModelProperty) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssetModelProperty"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.DataType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DataType"))
	}
	if v.Type == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	} else if v.Type != nil {
		if err := validatePropertyType(v.Type); err != nil {
			invalidParams.AddNested("Type", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAssetModelPropertyDefinition(v *types.AssetModelPropertyDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssetModelPropertyDefinition"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.DataType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DataType"))
	}
	if v.Type == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	} else if v.Type != nil {
		if err := validatePropertyType(v.Type); err != nil {
			invalidParams.AddNested("Type", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateAssetPropertyValue(v *types.AssetPropertyValue) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssetPropertyValue"}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if v.Timestamp == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Timestamp"))
	} else if v.Timestamp != nil {
		if err := validateTimeInNanos(v.Timestamp); err != nil {
			invalidParams.AddNested("Timestamp", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateBatchGetAssetPropertyAggregatesEntry(v *types.BatchGetAssetPropertyAggregatesEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetAssetPropertyAggregatesEntry"}
	if v.EntryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntryId"))
	}
	if v.AggregateTypes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AggregateTypes"))
	}
	if v.Resolution == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resolution"))
	}
	if v.StartDate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartDate"))
	}
	if v.EndDate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndDate"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateCustomerManagedS3Storage(v *types.CustomerManagedS3Storage) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomerManagedS3Storage"}
	if v.S3ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3ResourceArn"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateGatewayPlatform(v *types.GatewayPlatform) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GatewayPlatform"}
	if v.Greengrass != nil {
		if err := validateGreengrass(v.Greengrass); err != nil {
			invalidParams.AddNested("Greengrass", err.(smithy.InvalidParamsError))
		}
	}
	if v.GreengrassV2 != nil {
		if err := validateGreengrassV2(v.GreengrassV2); err != nil {
			invalidParams.AddNested("GreengrassV2", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateIdentity(v *types.Identity) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Identity"}
	if v.User != nil {
		if err := validateUserIdentity(v.User); err != nil {
			invalidParams.AddNested("User", err.(smithy.InvalidParamsError))
		}
	}
	if v.Group != nil {
		if err := validateGroupIdentity(v.Group); err != nil {
			invalidParams.AddNested("Group", err.(smithy.InvalidParamsError))
		}
	}
	if v.IamUser != nil {
		if err := validateIAMUserIdentity(v.IamUser); err != nil {
			invalidParams.AddNested("IamUser", err.(smithy.InvalidParamsError))
		}
	}
	if v.IamRole != nil {
		if err := validateIAMRoleIdentity(v.IamRole); err != nil {
			invalidParams.AddNested("IamRole", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateImage(v *types.Image) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Image"}
	if v.File != nil {
		if err := validateImageFile(v.File); err != nil {
			invalidParams.AddNested("File", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateMeasurement(v *types.Measurement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Measurement"}
	if v.ProcessingConfig != nil {
		if err := validateMeasurementProcessingConfig(v.ProcessingConfig); err != nil {
			invalidParams.AddNested("ProcessingConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMeasurementProcessingConfig(v *types.MeasurementProcessingConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MeasurementProcessingConfig"}
	if v.ForwardingConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ForwardingConfig"))
	} else if v.ForwardingConfig != nil {
		if err := validateForwardingConfig(v.ForwardingConfig); err != nil {
			invalidParams.AddNested("ForwardingConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMetric(v *types.Metric) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Metric"}
	if v.Expression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
	}
	if v.Variables == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Variables"))
	} else if v.Variables != nil {
		if err := validateExpressionVariables(v.Variables); err != nil {
			invalidParams.AddNested("Variables", err.(smithy.InvalidParamsError))
		}
	}
	if v.Window == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Window"))
	} else if v.Window != nil {
		if err := validateMetricWindow(v.Window); err != nil {
			invalidParams.AddNested("Window", err.(smithy.InvalidParamsError))
		}
	}
	if v.ProcessingConfig != nil {
		if err := validateMetricProcessingConfig(v.ProcessingConfig); err != nil {
			invalidParams.AddNested("ProcessingConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateMetricWindow(v *types.MetricWindow) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MetricWindow"}
	if v.Tumbling != nil {
		if err := validateTumblingWindow(v.Tumbling); err != nil {
			invalidParams.AddNested("Tumbling", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMultiLayerStorage(v *types.MultiLayerStorage) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MultiLayerStorage"}
	if v.CustomerManagedS3Storage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CustomerManagedS3Storage"))
	} else if v.CustomerManagedS3Storage != nil {
		if err := validateCustomerManagedS3Storage(v.CustomerManagedS3Storage); err != nil {
			invalidParams.AddNested("CustomerManagedS3Storage", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validatePropertyType(v *types.PropertyType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PropertyType"}
	if v.Measurement != nil {
		if err := validateMeasurement(v.Measurement); err != nil {
			invalidParams.AddNested("Measurement", err.(smithy.InvalidParamsError))
		}
	}
	if v.Transform != nil {
		if err := validateTransform(v.Transform); err != nil {
			invalidParams.AddNested("Transform", err.(smithy.InvalidParamsError))
		}
	}
	if v.Metric != nil {
		if err := validateMetric(v.Metric); err != nil {
			invalidParams.AddNested("Metric", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validatePutAssetPropertyValueEntry(v *types.PutAssetPropertyValueEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutAssetPropertyValueEntry"}
	if v.EntryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntryId"))
	}
	if v.PropertyValues == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PropertyValues"))
	} else if v.PropertyValues != nil {
		if err := validateAssetPropertyValues(v.PropertyValues); err != nil {
			invalidParams.AddNested("PropertyValues", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResource(v *types.Resource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Resource"}
	if v.Portal != nil {
		if err := validatePortalResource(v.Portal); err != nil {
			invalidParams.AddNested("Portal", err.(smithy.InvalidParamsError))
		}
	}
	if v.Project != nil {
		if err := validateProjectResource(v.Project); err != nil {
			invalidParams.AddNested("Project", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTransform(v *types.Transform) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Transform"}
	if v.Expression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
	}
	if v.Variables == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Variables"))
	} else if v.Variables != nil {
		if err := validateExpressionVariables(v.Variables); err != nil {
			invalidParams.AddNested("Variables", err.(smithy.InvalidParamsError))
		}
	}
	if v.ProcessingConfig != nil {
		if err := validateTransformProcessingConfig(v.ProcessingConfig); err != nil {
			invalidParams.AddNested("ProcessingConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTransformProcessingConfig(v *types.TransformProcessingConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TransformProcessingConfig"}
	if len(v.ComputeLocation) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ComputeLocation"))
	}
	if v.ForwardingConfig != nil {
		if err := validateForwardingConfig(v.ForwardingConfig); err != nil {
			invalidParams.AddNested("ForwardingConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpAssociateAssetsInput(v *AssociateAssetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateAssetsInput"}
	if v.AssetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetId"))
	}
	if v.HierarchyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HierarchyId"))
	}
	if v.ChildAssetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChildAssetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateTimeSeriesToAssetPropertyInput(v *AssociateTimeSeriesToAssetPropertyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateTimeSeriesToAssetPropertyInput"}
	if v.Alias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Alias"))
	}
	if v.AssetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetId"))
	}
	if v.PropertyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PropertyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchAssociateProjectAssetsInput(v *BatchAssociateProjectAssetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchAssociateProjectAssetsInput"}
	if v.ProjectId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProjectId"))
	}
	if v.AssetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchDisassociateProjectAssetsInput(v *BatchDisassociateProjectAssetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDisassociateProjectAssetsInput"}
	if v.ProjectId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProjectId"))
	}
	if v.AssetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchGetAssetPropertyAggregatesInput(v *BatchGetAssetPropertyAggregatesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetAssetPropertyAggregatesInput"}
	if v.Entries == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Entries"))
	} else if v.Entries != nil {
		if err := validateBatchGetAssetPropertyAggregatesEntries(v.Entries); err != nil {
			invalidParams.AddNested("Entries", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchGetAssetPropertyValueHistoryInput(v *BatchGetAssetPropertyValueHistoryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetAssetPropertyValueHistoryInput"}
	if v.Entries == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Entries"))
	} else if v.Entries != nil {
		if err := validateBatchGetAssetPropertyValueHistoryEntries(v.Entries); err != nil {
			invalidParams.AddNested("Entries", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchGetAssetPropertyValueInput(v *BatchGetAssetPropertyValueInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetAssetPropertyValueInput"}
	if v.Entries == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Entries"))
	} else if v.Entries != nil {
		if err := validateBatchGetAssetPropertyValueEntries(v.Entries); err != nil {
			invalidParams.AddNested("Entries", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchPutAssetPropertyValueInput(v *BatchPutAssetPropertyValueInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchPutAssetPropertyValueInput"}
	if v.Entries == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Entries"))
	} else if v.Entries != nil {
		if err := validatePutAssetPropertyValueEntries(v.Entries); err != nil {
			invalidParams.AddNested("Entries", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAccessPolicyInput(v *CreateAccessPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAccessPolicyInput"}
	if v.AccessPolicyIdentity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessPolicyIdentity"))
	} else if v.AccessPolicyIdentity != nil {
		if err := validateIdentity(v.AccessPolicyIdentity); err != nil {
			invalidParams.AddNested("AccessPolicyIdentity", err.(smithy.InvalidParamsError))
		}
	}
	if v.AccessPolicyResource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessPolicyResource"))
	} else if v.AccessPolicyResource != nil {
		if err := validateResource(v.AccessPolicyResource); err != nil {
			invalidParams.AddNested("AccessPolicyResource", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.AccessPolicyPermission) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AccessPolicyPermission"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAssetInput(v *CreateAssetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAssetInput"}
	if v.AssetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetName"))
	}
	if v.AssetModelId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetModelId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAssetModelInput(v *CreateAssetModelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAssetModelInput"}
	if v.AssetModelName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetModelName"))
	}
	if v.AssetModelProperties != nil {
		if err := validateAssetModelPropertyDefinitions(v.AssetModelProperties); err != nil {
			invalidParams.AddNested("AssetModelProperties", err.(smithy.InvalidParamsError))
		}
	}
	if v.AssetModelHierarchies != nil {
		if err := validateAssetModelHierarchyDefinitions(v.AssetModelHierarchies); err != nil {
			invalidParams.AddNested("AssetModelHierarchies", err.(smithy.InvalidParamsError))
		}
	}
	if v.AssetModelCompositeModels != nil {
		if err := validateAssetModelCompositeModelDefinitions(v.AssetModelCompositeModels); err != nil {
			invalidParams.AddNested("AssetModelCompositeModels", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateBulkImportJobInput(v *CreateBulkImportJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateBulkImportJobInput"}
	if v.JobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobName"))
	}
	if v.JobRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobRoleArn"))
	}
	if v.Files == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Files"))
	} else if v.Files != nil {
		if err := validateFiles(v.Files); err != nil {
			invalidParams.AddNested("Files", err.(smithy.InvalidParamsError))
		}
	}
	if v.ErrorReportLocation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ErrorReportLocation"))
	} else if v.ErrorReportLocation != nil {
		if err := validateErrorReportLocation(v.ErrorReportLocation); err != nil {
			invalidParams.AddNested("ErrorReportLocation", err.(smithy.InvalidParamsError))
		}
	}
	if v.JobConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobConfiguration"))
	} else if v.JobConfiguration != nil {
		if err := validateJobConfiguration(v.JobConfiguration); err != nil {
			invalidParams.AddNested("JobConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDashboardInput(v *CreateDashboardInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDashboardInput"}
	if v.ProjectId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProjectId"))
	}
	if v.DashboardName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DashboardName"))
	}
	if v.DashboardDefinition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DashboardDefinition"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateGatewayInput(v *CreateGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateGatewayInput"}
	if v.GatewayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayName"))
	}
	if v.GatewayPlatform == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayPlatform"))
	} else if v.GatewayPlatform != nil {
		if err := validateGatewayPlatform(v.GatewayPlatform); err != nil {
			invalidParams.AddNested("GatewayPlatform", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePortalInput(v *CreatePortalInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePortalInput"}
	if v.PortalName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortalName"))
	}
	if v.PortalContactEmail == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortalContactEmail"))
	}
	if v.PortalLogoImageFile != nil {
		if err := validateImageFile(v.PortalLogoImageFile); err != nil {
			invalidParams.AddNested("PortalLogoImageFile", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.Alarms != nil {
		if err := validateAlarms(v.Alarms); err != nil {
			invalidParams.AddNested("Alarms", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateProjectInput(v *CreateProjectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateProjectInput"}
	if v.PortalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortalId"))
	}
	if v.ProjectName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

func validateOpDescribeAssetPropertyInput(v *DescribeAssetPropertyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeAssetPropertyInput"}
	if v.AssetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetId"))
	}
	if v.PropertyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PropertyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDescribeGatewayCapabilityConfigurationInput(v *DescribeGatewayCapabilityConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeGatewayCapabilityConfigurationInput"}
	if v.GatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayId"))
	}
	if v.CapabilityNamespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapabilityNamespace"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpDisassociateAssetsInput(v *DisassociateAssetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateAssetsInput"}
	if v.AssetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetId"))
	}
	if v.HierarchyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HierarchyId"))
	}
	if v.ChildAssetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChildAssetId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateTimeSeriesFromAssetPropertyInput(v *DisassociateTimeSeriesFromAssetPropertyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateTimeSeriesFromAssetPropertyInput"}
	if v.Alias == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Alias"))
	}
	if v.AssetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetId"))
	}
	if v.PropertyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PropertyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAssetPropertyAggregatesInput(v *GetAssetPropertyAggregatesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAssetPropertyAggregatesInput"}
	if v.AggregateTypes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AggregateTypes"))
	}
	if v.Resolution == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resolution"))
	}
	if v.StartDate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartDate"))
	}
	if v.EndDate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndDate"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetInterpolatedAssetPropertyValuesInput(v *GetInterpolatedAssetPropertyValuesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetInterpolatedAssetPropertyValuesInput"}
	if v.StartTimeInSeconds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTimeInSeconds"))
	}
	if v.EndTimeInSeconds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTimeInSeconds"))
	}
	if len(v.Quality) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Quality"))
	}
	if v.IntervalInSeconds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntervalInSeconds"))
	}
	if v.Type == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListAssetRelationshipsInput(v *ListAssetRelationshipsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAssetRelationshipsInput"}
	if v.AssetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetId"))
	}
	if len(v.TraversalType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TraversalType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpListProjectsInput(v *ListProjectsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListProjectsInput"}
	if v.PortalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortalId"))
	}
	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 validateOpPutDefaultEncryptionConfigurationInput(v *PutDefaultEncryptionConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutDefaultEncryptionConfigurationInput"}
	if len(v.EncryptionType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EncryptionType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutLoggingOptionsInput(v *PutLoggingOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutLoggingOptionsInput"}
	if v.LoggingOptions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LoggingOptions"))
	} else if v.LoggingOptions != nil {
		if err := validateLoggingOptions(v.LoggingOptions); err != nil {
			invalidParams.AddNested("LoggingOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutStorageConfigurationInput(v *PutStorageConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutStorageConfigurationInput"}
	if len(v.StorageType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("StorageType"))
	}
	if v.MultiLayerStorage != nil {
		if err := validateMultiLayerStorage(v.MultiLayerStorage); err != nil {
			invalidParams.AddNested("MultiLayerStorage", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTagResourceInput(v *TagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateAccessPolicyInput(v *UpdateAccessPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAccessPolicyInput"}
	if v.AccessPolicyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessPolicyId"))
	}
	if v.AccessPolicyIdentity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessPolicyIdentity"))
	} else if v.AccessPolicyIdentity != nil {
		if err := validateIdentity(v.AccessPolicyIdentity); err != nil {
			invalidParams.AddNested("AccessPolicyIdentity", err.(smithy.InvalidParamsError))
		}
	}
	if v.AccessPolicyResource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessPolicyResource"))
	} else if v.AccessPolicyResource != nil {
		if err := validateResource(v.AccessPolicyResource); err != nil {
			invalidParams.AddNested("AccessPolicyResource", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.AccessPolicyPermission) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AccessPolicyPermission"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAssetInput(v *UpdateAssetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAssetInput"}
	if v.AssetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetId"))
	}
	if v.AssetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAssetModelInput(v *UpdateAssetModelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAssetModelInput"}
	if v.AssetModelId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetModelId"))
	}
	if v.AssetModelName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetModelName"))
	}
	if v.AssetModelProperties != nil {
		if err := validateAssetModelProperties(v.AssetModelProperties); err != nil {
			invalidParams.AddNested("AssetModelProperties", err.(smithy.InvalidParamsError))
		}
	}
	if v.AssetModelHierarchies != nil {
		if err := validateAssetModelHierarchies(v.AssetModelHierarchies); err != nil {
			invalidParams.AddNested("AssetModelHierarchies", err.(smithy.InvalidParamsError))
		}
	}
	if v.AssetModelCompositeModels != nil {
		if err := validateAssetModelCompositeModels(v.AssetModelCompositeModels); err != nil {
			invalidParams.AddNested("AssetModelCompositeModels", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAssetPropertyInput(v *UpdateAssetPropertyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAssetPropertyInput"}
	if v.AssetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetId"))
	}
	if v.PropertyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PropertyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDashboardInput(v *UpdateDashboardInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDashboardInput"}
	if v.DashboardId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DashboardId"))
	}
	if v.DashboardName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DashboardName"))
	}
	if v.DashboardDefinition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DashboardDefinition"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateGatewayCapabilityConfigurationInput(v *UpdateGatewayCapabilityConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateGatewayCapabilityConfigurationInput"}
	if v.GatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayId"))
	}
	if v.CapabilityNamespace == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapabilityNamespace"))
	}
	if v.CapabilityConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CapabilityConfiguration"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateGatewayInput(v *UpdateGatewayInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateGatewayInput"}
	if v.GatewayId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayId"))
	}
	if v.GatewayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GatewayName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdatePortalInput(v *UpdatePortalInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePortalInput"}
	if v.PortalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortalId"))
	}
	if v.PortalName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortalName"))
	}
	if v.PortalContactEmail == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortalContactEmail"))
	}
	if v.PortalLogoImage != nil {
		if err := validateImage(v.PortalLogoImage); err != nil {
			invalidParams.AddNested("PortalLogoImage", err.(smithy.InvalidParamsError))
		}
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.Alarms != nil {
		if err := validateAlarms(v.Alarms); err != nil {
			invalidParams.AddNested("Alarms", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateProjectInput(v *UpdateProjectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateProjectInput"}
	if v.ProjectId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProjectId"))
	}
	if v.ProjectName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProjectName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}