service/networkflowmonitor/validators.go

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

package networkflowmonitor

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

type validateOpCreateMonitor struct {
}

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

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

type validateOpCreateScope struct {
}

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

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

type validateOpDeleteMonitor struct {
}

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

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

type validateOpDeleteScope struct {
}

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

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

type validateOpGetMonitor struct {
}

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

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

type validateOpGetQueryResultsMonitorTopContributors struct {
}

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

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

type validateOpGetQueryResultsWorkloadInsightsTopContributorsData struct {
}

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

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

type validateOpGetQueryResultsWorkloadInsightsTopContributors struct {
}

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

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

type validateOpGetQueryStatusMonitorTopContributors struct {
}

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

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

type validateOpGetQueryStatusWorkloadInsightsTopContributorsData struct {
}

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

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

type validateOpGetQueryStatusWorkloadInsightsTopContributors struct {
}

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

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

type validateOpGetScope struct {
}

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

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

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

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

type validateOpStartQueryWorkloadInsightsTopContributorsData struct {
}

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

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

type validateOpStartQueryWorkloadInsightsTopContributors struct {
}

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

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

type validateOpStopQueryMonitorTopContributors struct {
}

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

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

type validateOpStopQueryWorkloadInsightsTopContributorsData struct {
}

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

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

type validateOpStopQueryWorkloadInsightsTopContributors struct {
}

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

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

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

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

type validateOpUpdateScope struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpStopQueryWorkloadInsightsTopContributorsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStopQueryWorkloadInsightsTopContributors{}, 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 addOpUpdateMonitorValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateMonitor{}, middleware.After)
}

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

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

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

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

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

func validateTargetIdentifier(v *types.TargetIdentifier) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TargetIdentifier"}
	if v.TargetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetId"))
	}
	if len(v.TargetType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TargetType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTargetResource(v *types.TargetResource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TargetResource"}
	if v.TargetIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetIdentifier"))
	} else if v.TargetIdentifier != nil {
		if err := validateTargetIdentifier(v.TargetIdentifier); err != nil {
			invalidParams.AddNested("TargetIdentifier", err.(smithy.InvalidParamsError))
		}
	}
	if v.Region == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Region"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateMonitorInput(v *CreateMonitorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMonitorInput"}
	if v.MonitorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MonitorName"))
	}
	if v.LocalResources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocalResources"))
	} else if v.LocalResources != nil {
		if err := validateMonitorLocalResources(v.LocalResources); err != nil {
			invalidParams.AddNested("LocalResources", err.(smithy.InvalidParamsError))
		}
	}
	if v.RemoteResources != nil {
		if err := validateMonitorRemoteResources(v.RemoteResources); err != nil {
			invalidParams.AddNested("RemoteResources", err.(smithy.InvalidParamsError))
		}
	}
	if v.ScopeArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScopeArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateScopeInput(v *CreateScopeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateScopeInput"}
	if v.Targets == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Targets"))
	} else if v.Targets != nil {
		if err := validateTargetResourceList(v.Targets); err != nil {
			invalidParams.AddNested("Targets", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpGetQueryResultsMonitorTopContributorsInput(v *GetQueryResultsMonitorTopContributorsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetQueryResultsMonitorTopContributorsInput"}
	if v.MonitorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MonitorName"))
	}
	if v.QueryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetQueryResultsWorkloadInsightsTopContributorsDataInput(v *GetQueryResultsWorkloadInsightsTopContributorsDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetQueryResultsWorkloadInsightsTopContributorsDataInput"}
	if v.ScopeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScopeId"))
	}
	if v.QueryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetQueryResultsWorkloadInsightsTopContributorsInput(v *GetQueryResultsWorkloadInsightsTopContributorsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetQueryResultsWorkloadInsightsTopContributorsInput"}
	if v.ScopeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScopeId"))
	}
	if v.QueryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetQueryStatusMonitorTopContributorsInput(v *GetQueryStatusMonitorTopContributorsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetQueryStatusMonitorTopContributorsInput"}
	if v.MonitorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MonitorName"))
	}
	if v.QueryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetQueryStatusWorkloadInsightsTopContributorsDataInput(v *GetQueryStatusWorkloadInsightsTopContributorsDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetQueryStatusWorkloadInsightsTopContributorsDataInput"}
	if v.ScopeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScopeId"))
	}
	if v.QueryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetQueryStatusWorkloadInsightsTopContributorsInput(v *GetQueryStatusWorkloadInsightsTopContributorsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetQueryStatusWorkloadInsightsTopContributorsInput"}
	if v.ScopeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScopeId"))
	}
	if v.QueryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetScopeInput(v *GetScopeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetScopeInput"}
	if v.ScopeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScopeId"))
	}
	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 validateOpStartQueryMonitorTopContributorsInput(v *StartQueryMonitorTopContributorsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartQueryMonitorTopContributorsInput"}
	if v.MonitorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MonitorName"))
	}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if len(v.MetricName) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
	}
	if len(v.DestinationCategory) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCategory"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartQueryWorkloadInsightsTopContributorsDataInput(v *StartQueryWorkloadInsightsTopContributorsDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartQueryWorkloadInsightsTopContributorsDataInput"}
	if v.ScopeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScopeId"))
	}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if len(v.MetricName) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
	}
	if len(v.DestinationCategory) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCategory"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartQueryWorkloadInsightsTopContributorsInput(v *StartQueryWorkloadInsightsTopContributorsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartQueryWorkloadInsightsTopContributorsInput"}
	if v.ScopeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScopeId"))
	}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if len(v.MetricName) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
	}
	if len(v.DestinationCategory) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationCategory"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopQueryMonitorTopContributorsInput(v *StopQueryMonitorTopContributorsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopQueryMonitorTopContributorsInput"}
	if v.MonitorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MonitorName"))
	}
	if v.QueryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopQueryWorkloadInsightsTopContributorsDataInput(v *StopQueryWorkloadInsightsTopContributorsDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopQueryWorkloadInsightsTopContributorsDataInput"}
	if v.ScopeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScopeId"))
	}
	if v.QueryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopQueryWorkloadInsightsTopContributorsInput(v *StopQueryWorkloadInsightsTopContributorsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopQueryWorkloadInsightsTopContributorsInput"}
	if v.ScopeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScopeId"))
	}
	if v.QueryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryId"))
	}
	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 validateOpUpdateMonitorInput(v *UpdateMonitorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateMonitorInput"}
	if v.MonitorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MonitorName"))
	}
	if v.LocalResourcesToAdd != nil {
		if err := validateMonitorLocalResources(v.LocalResourcesToAdd); err != nil {
			invalidParams.AddNested("LocalResourcesToAdd", err.(smithy.InvalidParamsError))
		}
	}
	if v.LocalResourcesToRemove != nil {
		if err := validateMonitorLocalResources(v.LocalResourcesToRemove); err != nil {
			invalidParams.AddNested("LocalResourcesToRemove", err.(smithy.InvalidParamsError))
		}
	}
	if v.RemoteResourcesToAdd != nil {
		if err := validateMonitorRemoteResources(v.RemoteResourcesToAdd); err != nil {
			invalidParams.AddNested("RemoteResourcesToAdd", err.(smithy.InvalidParamsError))
		}
	}
	if v.RemoteResourcesToRemove != nil {
		if err := validateMonitorRemoteResources(v.RemoteResourcesToRemove); err != nil {
			invalidParams.AddNested("RemoteResourcesToRemove", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateScopeInput(v *UpdateScopeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateScopeInput"}
	if v.ScopeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScopeId"))
	}
	if v.ResourcesToAdd != nil {
		if err := validateTargetResourceList(v.ResourcesToAdd); err != nil {
			invalidParams.AddNested("ResourcesToAdd", err.(smithy.InvalidParamsError))
		}
	}
	if v.ResourcesToDelete != nil {
		if err := validateTargetResourceList(v.ResourcesToDelete); err != nil {
			invalidParams.AddNested("ResourcesToDelete", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}