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

package applicationsignals

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

type validateOpBatchDeleteInstrumentationConfigurations struct {
}

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

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

type validateOpBatchGetServiceLevelObjectiveBudgetReport struct {
}

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

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

type validateOpBatchUpdateExclusionWindows struct {
}

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

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

type validateOpCreateInstrumentationConfiguration struct {
}

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

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

type validateOpCreateServiceLevelObjective struct {
}

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

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

type validateOpDeleteInstrumentationConfiguration struct {
}

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

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

type validateOpDeleteServiceLevelObjective struct {
}

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

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

type validateOpGetInstrumentationConfiguration struct {
}

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

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

type validateOpGetInstrumentationConfigurationStatus struct {
}

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

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

type validateOpGetService struct {
}

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

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

type validateOpGetServiceLevelObjective struct {
}

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

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

type validateOpListAuditFindings struct {
}

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

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

type validateOpListEntityEvents struct {
}

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

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

type validateOpListInstrumentationConfigurations struct {
}

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

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

type validateOpListServiceDependencies struct {
}

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

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

type validateOpListServiceDependents struct {
}

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

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

type validateOpListServiceLevelObjectiveExclusionWindows struct {
}

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

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

type validateOpListServiceLevelObjectives struct {
}

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

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

type validateOpListServiceOperations struct {
}

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

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

type validateOpListServices struct {
}

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

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

type validateOpListServiceStates struct {
}

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

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

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

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

type validateOpReportInstrumentationConfigurationStatus struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpReportInstrumentationConfigurationStatusValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpReportInstrumentationConfigurationStatus{}, 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 addOpUpdateServiceLevelObjectiveValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateServiceLevelObjective{}, middleware.After)
}

func validateAttributeFilter(v *types.AttributeFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttributeFilter"}
	if v.AttributeFilterName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeFilterName"))
	}
	if v.AttributeFilterValues == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeFilterValues"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateAuditTarget(v *types.AuditTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AuditTarget"}
	if v.Type == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.Data == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Data"))
	} else if v.Data != nil {
		if err := validateAuditTargetEntity(v.Data); err != nil {
			invalidParams.AddNested("Data", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAuditTargetEntity(v types.AuditTargetEntity) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AuditTargetEntity"}
	switch uv := v.(type) {
	case *types.AuditTargetEntityMemberCanary:
		if err := validateCanaryEntity(&uv.Value); err != nil {
			invalidParams.AddNested("[Canary]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateBatchDeleteByResourceArns(v *types.BatchDeleteByResourceArns) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteByResourceArns"}
	if v.ResourceArns == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArns"))
	}
	if len(v.InstrumentationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InstrumentationType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBatchDeleteDeletionTarget(v types.BatchDeleteDeletionTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteDeletionTarget"}
	switch uv := v.(type) {
	case *types.BatchDeleteDeletionTargetMemberResourceArns:
		if err := validateBatchDeleteByResourceArns(&uv.Value); err != nil {
			invalidParams.AddNested("[ResourceArns]", err.(smithy.InvalidParamsError))
		}

	case *types.BatchDeleteDeletionTargetMemberScope:
		if err := validateBatchDeleteScope(&uv.Value); err != nil {
			invalidParams.AddNested("[Scope]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBatchDeleteScope(v *types.BatchDeleteScope) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteScope"}
	if v.Service == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Service"))
	}
	if v.Environment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Environment"))
	}
	if len(v.InstrumentationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InstrumentationType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateCalendarInterval(v *types.CalendarInterval) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CalendarInterval"}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if len(v.DurationUnit) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DurationUnit"))
	}
	if v.Duration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Duration"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCaptureConfiguration(v types.CaptureConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CaptureConfiguration"}
	switch uv := v.(type) {
	case *types.CaptureConfigurationMemberCodeCapture:
		if err := validateCodeCaptureConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[CodeCapture]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCodeLocation(v *types.CodeLocation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CodeLocation"}
	if len(v.Language) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Language"))
	}
	if v.FilePath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilePath"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCompositeSliConfig(v *types.CompositeSliConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CompositeSliConfig"}
	if v.SelectionConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SelectionConfig"))
	} else if v.SelectionConfig != nil {
		if err := validateSelectionConfig(v.SelectionConfig); err != nil {
			invalidParams.AddNested("SelectionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDependencyConfig(v *types.DependencyConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DependencyConfig"}
	if v.DependencyKeyAttributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DependencyKeyAttributes"))
	}
	if v.DependencyOperationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DependencyOperationName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateExclusionWindow(v *types.ExclusionWindow) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExclusionWindow"}
	if v.Window == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Window"))
	} else if v.Window != nil {
		if err := validateWindow(v.Window); err != nil {
			invalidParams.AddNested("Window", err.(smithy.InvalidParamsError))
		}
	}
	if v.RecurrenceRule != nil {
		if err := validateRecurrenceRule(v.RecurrenceRule); err != nil {
			invalidParams.AddNested("RecurrenceRule", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateGoal(v *types.Goal) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Goal"}
	if v.Interval != nil {
		if err := validateInterval(v.Interval); err != nil {
			invalidParams.AddNested("Interval", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateInstrumentationConfigurationStatusReport(v *types.InstrumentationConfigurationStatusReport) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InstrumentationConfigurationStatusReport"}
	if len(v.InstrumentationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InstrumentationType"))
	}
	if len(v.SignalType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SignalType"))
	}
	if v.LocationHash == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocationHash"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if v.Time == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Time"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInterval(v types.Interval) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Interval"}
	switch uv := v.(type) {
	case *types.IntervalMemberCalendarInterval:
		if err := validateCalendarInterval(&uv.Value); err != nil {
			invalidParams.AddNested("[CalendarInterval]", err.(smithy.InvalidParamsError))
		}

	case *types.IntervalMemberRollingInterval:
		if err := validateRollingInterval(&uv.Value); err != nil {
			invalidParams.AddNested("[RollingInterval]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLocation(v types.Location) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Location"}
	switch uv := v.(type) {
	case *types.LocationMemberCodeLocation:
		if err := validateCodeLocation(&uv.Value); err != nil {
			invalidParams.AddNested("[CodeLocation]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLocationIdentifier(v types.LocationIdentifier) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LocationIdentifier"}
	switch uv := v.(type) {
	case *types.LocationIdentifierMemberCodeLocation:
		if err := validateCodeLocation(&uv.Value); err != nil {
			invalidParams.AddNested("[CodeLocation]", 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.Dimensions != nil {
		if err := validateDimensions(v.Dimensions); err != nil {
			invalidParams.AddNested("Dimensions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateMetricDataQuery(v *types.MetricDataQuery) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MetricDataQuery"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.MetricStat != nil {
		if err := validateMetricStat(v.MetricStat); err != nil {
			invalidParams.AddNested("MetricStat", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateMetricStat(v *types.MetricStat) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MetricStat"}
	if v.Metric == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Metric"))
	} else if v.Metric != nil {
		if err := validateMetric(v.Metric); err != nil {
			invalidParams.AddNested("Metric", err.(smithy.InvalidParamsError))
		}
	}
	if v.Period == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Period"))
	}
	if v.Stat == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Stat"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMonitoredRequestCountMetricDataQueries(v types.MonitoredRequestCountMetricDataQueries) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MonitoredRequestCountMetricDataQueries"}
	switch uv := v.(type) {
	case *types.MonitoredRequestCountMetricDataQueriesMemberBadCountMetric:
		if err := validateMetricDataQueries(uv.Value); err != nil {
			invalidParams.AddNested("[BadCountMetric]", err.(smithy.InvalidParamsError))
		}

	case *types.MonitoredRequestCountMetricDataQueriesMemberGoodCountMetric:
		if err := validateMetricDataQueries(uv.Value); err != nil {
			invalidParams.AddNested("[GoodCountMetric]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRequestBasedServiceLevelIndicatorConfig(v *types.RequestBasedServiceLevelIndicatorConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RequestBasedServiceLevelIndicatorConfig"}
	if v.RequestBasedSliMetricConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequestBasedSliMetricConfig"))
	} else if v.RequestBasedSliMetricConfig != nil {
		if err := validateRequestBasedServiceLevelIndicatorMetricConfig(v.RequestBasedSliMetricConfig); err != nil {
			invalidParams.AddNested("RequestBasedSliMetricConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRequestBasedServiceLevelIndicatorMetricConfig(v *types.RequestBasedServiceLevelIndicatorMetricConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RequestBasedServiceLevelIndicatorMetricConfig"}
	if v.TotalRequestCountMetric != nil {
		if err := validateMetricDataQueries(v.TotalRequestCountMetric); err != nil {
			invalidParams.AddNested("TotalRequestCountMetric", err.(smithy.InvalidParamsError))
		}
	}
	if v.MonitoredRequestCountMetric != nil {
		if err := validateMonitoredRequestCountMetricDataQueries(v.MonitoredRequestCountMetric); err != nil {
			invalidParams.AddNested("MonitoredRequestCountMetric", err.(smithy.InvalidParamsError))
		}
	}
	if v.DependencyConfig != nil {
		if err := validateDependencyConfig(v.DependencyConfig); err != nil {
			invalidParams.AddNested("DependencyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.MetricSource != nil {
		if err := validateMetricSource(v.MetricSource); err != nil {
			invalidParams.AddNested("MetricSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.CompositeSliConfig != nil {
		if err := validateCompositeSliConfig(v.CompositeSliConfig); err != nil {
			invalidParams.AddNested("CompositeSliConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRollingInterval(v *types.RollingInterval) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RollingInterval"}
	if len(v.DurationUnit) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DurationUnit"))
	}
	if v.Duration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Duration"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateServiceLevelIndicatorConfig(v *types.ServiceLevelIndicatorConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ServiceLevelIndicatorConfig"}
	if v.SliMetricConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SliMetricConfig"))
	} else if v.SliMetricConfig != nil {
		if err := validateServiceLevelIndicatorMetricConfig(v.SliMetricConfig); err != nil {
			invalidParams.AddNested("SliMetricConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateServiceLevelIndicatorMetricConfig(v *types.ServiceLevelIndicatorMetricConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ServiceLevelIndicatorMetricConfig"}
	if v.MetricSource != nil {
		if err := validateMetricSource(v.MetricSource); err != nil {
			invalidParams.AddNested("MetricSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.MetricDataQueries != nil {
		if err := validateMetricDataQueries(v.MetricDataQueries); err != nil {
			invalidParams.AddNested("MetricDataQueries", err.(smithy.InvalidParamsError))
		}
	}
	if v.DependencyConfig != nil {
		if err := validateDependencyConfig(v.DependencyConfig); err != nil {
			invalidParams.AddNested("DependencyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.CompositeSliConfig != nil {
		if err := validateCompositeSliConfig(v.CompositeSliConfig); err != nil {
			invalidParams.AddNested("CompositeSliConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateWindow(v *types.Window) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Window"}
	if len(v.DurationUnit) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DurationUnit"))
	}
	if v.Duration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Duration"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchDeleteInstrumentationConfigurationsInput(v *BatchDeleteInstrumentationConfigurationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteInstrumentationConfigurationsInput"}
	if v.DeletionTarget == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeletionTarget"))
	} else if v.DeletionTarget != nil {
		if err := validateBatchDeleteDeletionTarget(v.DeletionTarget); err != nil {
			invalidParams.AddNested("DeletionTarget", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchGetServiceLevelObjectiveBudgetReportInput(v *BatchGetServiceLevelObjectiveBudgetReportInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetServiceLevelObjectiveBudgetReportInput"}
	if v.Timestamp == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Timestamp"))
	}
	if v.SloIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SloIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchUpdateExclusionWindowsInput(v *BatchUpdateExclusionWindowsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchUpdateExclusionWindowsInput"}
	if v.SloIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SloIds"))
	}
	if v.AddExclusionWindows != nil {
		if err := validateExclusionWindows(v.AddExclusionWindows); err != nil {
			invalidParams.AddNested("AddExclusionWindows", err.(smithy.InvalidParamsError))
		}
	}
	if v.RemoveExclusionWindows != nil {
		if err := validateExclusionWindows(v.RemoveExclusionWindows); err != nil {
			invalidParams.AddNested("RemoveExclusionWindows", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateInstrumentationConfigurationInput(v *CreateInstrumentationConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateInstrumentationConfigurationInput"}
	if len(v.InstrumentationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InstrumentationType"))
	}
	if v.Service == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Service"))
	}
	if v.Environment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Environment"))
	}
	if len(v.SignalType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SignalType"))
	}
	if v.Location == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Location"))
	} else if v.Location != nil {
		if err := validateLocation(v.Location); err != nil {
			invalidParams.AddNested("Location", err.(smithy.InvalidParamsError))
		}
	}
	if v.CaptureConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CaptureConfiguration"))
	} else if v.CaptureConfiguration != nil {
		if err := validateCaptureConfiguration(v.CaptureConfiguration); err != nil {
			invalidParams.AddNested("CaptureConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateServiceLevelObjectiveInput(v *CreateServiceLevelObjectiveInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateServiceLevelObjectiveInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.SliConfig != nil {
		if err := validateServiceLevelIndicatorConfig(v.SliConfig); err != nil {
			invalidParams.AddNested("SliConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.RequestBasedSliConfig != nil {
		if err := validateRequestBasedServiceLevelIndicatorConfig(v.RequestBasedSliConfig); err != nil {
			invalidParams.AddNested("RequestBasedSliConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Goal != nil {
		if err := validateGoal(v.Goal); err != nil {
			invalidParams.AddNested("Goal", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.BurnRateConfigurations != nil {
		if err := validateBurnRateConfigurations(v.BurnRateConfigurations); err != nil {
			invalidParams.AddNested("BurnRateConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteInstrumentationConfigurationInput(v *DeleteInstrumentationConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteInstrumentationConfigurationInput"}
	if len(v.InstrumentationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InstrumentationType"))
	}
	if v.Service == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Service"))
	}
	if v.Environment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Environment"))
	}
	if len(v.SignalType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SignalType"))
	}
	if v.LocationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocationIdentifier"))
	} else if v.LocationIdentifier != nil {
		if err := validateLocationIdentifier(v.LocationIdentifier); err != nil {
			invalidParams.AddNested("LocationIdentifier", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetInstrumentationConfigurationInput(v *GetInstrumentationConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetInstrumentationConfigurationInput"}
	if len(v.InstrumentationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InstrumentationType"))
	}
	if v.Service == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Service"))
	}
	if v.Environment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Environment"))
	}
	if len(v.SignalType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SignalType"))
	}
	if v.LocationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocationIdentifier"))
	} else if v.LocationIdentifier != nil {
		if err := validateLocationIdentifier(v.LocationIdentifier); err != nil {
			invalidParams.AddNested("LocationIdentifier", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetInstrumentationConfigurationStatusInput(v *GetInstrumentationConfigurationStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetInstrumentationConfigurationStatusInput"}
	if len(v.InstrumentationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InstrumentationType"))
	}
	if v.Service == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Service"))
	}
	if v.Environment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Environment"))
	}
	if len(v.SignalType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SignalType"))
	}
	if v.LocationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocationIdentifier"))
	} else if v.LocationIdentifier != nil {
		if err := validateLocationIdentifier(v.LocationIdentifier); err != nil {
			invalidParams.AddNested("LocationIdentifier", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetServiceInput(v *GetServiceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetServiceInput"}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if v.KeyAttributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyAttributes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListAuditFindingsInput(v *ListAuditFindingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAuditFindingsInput"}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if v.AuditTargets == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuditTargets"))
	} else if v.AuditTargets != nil {
		if err := validateAuditTargets(v.AuditTargets); err != nil {
			invalidParams.AddNested("AuditTargets", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListEntityEventsInput(v *ListEntityEventsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListEntityEventsInput"}
	if v.Entity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Entity"))
	}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListInstrumentationConfigurationsInput(v *ListInstrumentationConfigurationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListInstrumentationConfigurationsInput"}
	if v.Service == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Service"))
	}
	if v.Environment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Environment"))
	}
	if len(v.InstrumentationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InstrumentationType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListServiceDependenciesInput(v *ListServiceDependenciesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListServiceDependenciesInput"}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if v.KeyAttributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyAttributes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListServiceDependentsInput(v *ListServiceDependentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListServiceDependentsInput"}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if v.KeyAttributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyAttributes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListServiceLevelObjectivesInput(v *ListServiceLevelObjectivesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListServiceLevelObjectivesInput"}
	if v.DependencyConfig != nil {
		if err := validateDependencyConfig(v.DependencyConfig); err != nil {
			invalidParams.AddNested("DependencyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.MetricSource != nil {
		if err := validateMetricSource(v.MetricSource); err != nil {
			invalidParams.AddNested("MetricSource", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListServiceOperationsInput(v *ListServiceOperationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListServiceOperationsInput"}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if v.KeyAttributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KeyAttributes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListServicesInput(v *ListServicesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListServicesInput"}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListServiceStatesInput(v *ListServiceStatesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListServiceStatesInput"}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if v.AttributeFilters != nil {
		if err := validateAttributeFilters(v.AttributeFilters); err != nil {
			invalidParams.AddNested("AttributeFilters", err.(smithy.InvalidParamsError))
		}
	}
	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 validateOpPutGroupingConfigurationInput(v *PutGroupingConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutGroupingConfigurationInput"}
	if v.GroupingAttributeDefinitions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupingAttributeDefinitions"))
	} else if v.GroupingAttributeDefinitions != nil {
		if err := validateGroupingAttributeDefinitions(v.GroupingAttributeDefinitions); err != nil {
			invalidParams.AddNested("GroupingAttributeDefinitions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpReportInstrumentationConfigurationStatusInput(v *ReportInstrumentationConfigurationStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReportInstrumentationConfigurationStatusInput"}
	if v.Service == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Service"))
	}
	if v.Environment == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Environment"))
	}
	if v.Configurations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Configurations"))
	} else if v.Configurations != nil {
		if err := validateInstrumentationConfigurationStatusList(v.Configurations); err != nil {
			invalidParams.AddNested("Configurations", 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"))
	} else if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	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 validateOpUpdateServiceLevelObjectiveInput(v *UpdateServiceLevelObjectiveInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateServiceLevelObjectiveInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.SliConfig != nil {
		if err := validateServiceLevelIndicatorConfig(v.SliConfig); err != nil {
			invalidParams.AddNested("SliConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.RequestBasedSliConfig != nil {
		if err := validateRequestBasedServiceLevelIndicatorConfig(v.RequestBasedSliConfig); err != nil {
			invalidParams.AddNested("RequestBasedSliConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Goal != nil {
		if err := validateGoal(v.Goal); err != nil {
			invalidParams.AddNested("Goal", err.(smithy.InvalidParamsError))
		}
	}
	if v.BurnRateConfigurations != nil {
		if err := validateBurnRateConfigurations(v.BurnRateConfigurations); err != nil {
			invalidParams.AddNested("BurnRateConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}
