service/bcmpricingcalculator/validators.go

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

package bcmpricingcalculator

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

type validateOpBatchCreateBillScenarioCommitmentModification struct {
}

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

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

type validateOpBatchCreateBillScenarioUsageModification struct {
}

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

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

type validateOpBatchCreateWorkloadEstimateUsage struct {
}

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

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

type validateOpBatchDeleteBillScenarioCommitmentModification struct {
}

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

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

type validateOpBatchDeleteBillScenarioUsageModification struct {
}

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

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

type validateOpBatchDeleteWorkloadEstimateUsage struct {
}

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

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

type validateOpBatchUpdateBillScenarioCommitmentModification struct {
}

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

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

type validateOpBatchUpdateBillScenarioUsageModification struct {
}

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

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

type validateOpBatchUpdateWorkloadEstimateUsage struct {
}

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

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

type validateOpCreateBillEstimate struct {
}

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

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

type validateOpCreateBillScenario struct {
}

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

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

type validateOpCreateWorkloadEstimate struct {
}

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

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

type validateOpDeleteBillEstimate struct {
}

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

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

type validateOpDeleteBillScenario struct {
}

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

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

type validateOpDeleteWorkloadEstimate struct {
}

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

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

type validateOpGetBillEstimate struct {
}

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

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

type validateOpGetBillScenario struct {
}

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

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

type validateOpGetWorkloadEstimate struct {
}

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

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

type validateOpListBillEstimateCommitments struct {
}

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

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

type validateOpListBillEstimateInputCommitmentModifications struct {
}

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

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

type validateOpListBillEstimateInputUsageModifications struct {
}

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

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

type validateOpListBillEstimateLineItems struct {
}

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

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

type validateOpListBillEstimates struct {
}

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

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

type validateOpListBillScenarioCommitmentModifications struct {
}

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

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

type validateOpListBillScenarios struct {
}

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

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

type validateOpListBillScenarioUsageModifications struct {
}

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

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

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

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

type validateOpListWorkloadEstimateUsage struct {
}

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

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

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

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

type validateOpUpdateBillScenario struct {
}

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

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

type validateOpUpdateWorkloadEstimate struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpListWorkloadEstimateUsageValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListWorkloadEstimateUsage{}, 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 addOpUpdateBillEstimateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateBillEstimate{}, middleware.After)
}

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

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

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

func validateBatchCreateBillScenarioCommitmentModificationEntry(v *types.BatchCreateBillScenarioCommitmentModificationEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchCreateBillScenarioCommitmentModificationEntry"}
	if v.Key == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Key"))
	}
	if v.UsageAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsageAccountId"))
	}
	if v.CommitmentAction == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CommitmentAction"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateBatchCreateBillScenarioUsageModificationEntry(v *types.BatchCreateBillScenarioUsageModificationEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchCreateBillScenarioUsageModificationEntry"}
	if v.ServiceCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceCode"))
	}
	if v.UsageType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsageType"))
	}
	if v.Operation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Operation"))
	}
	if v.Key == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Key"))
	}
	if v.UsageAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsageAccountId"))
	}
	if v.Amounts != nil {
		if err := validateUsageAmounts(v.Amounts); err != nil {
			invalidParams.AddNested("Amounts", err.(smithy.InvalidParamsError))
		}
	}
	if v.HistoricalUsage != nil {
		if err := validateHistoricalUsageEntity(v.HistoricalUsage); err != nil {
			invalidParams.AddNested("HistoricalUsage", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateBatchCreateWorkloadEstimateUsageEntry(v *types.BatchCreateWorkloadEstimateUsageEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchCreateWorkloadEstimateUsageEntry"}
	if v.ServiceCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceCode"))
	}
	if v.UsageType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsageType"))
	}
	if v.Operation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Operation"))
	}
	if v.Key == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Key"))
	}
	if v.UsageAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsageAccountId"))
	}
	if v.Amount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Amount"))
	}
	if v.HistoricalUsage != nil {
		if err := validateHistoricalUsageEntity(v.HistoricalUsage); err != nil {
			invalidParams.AddNested("HistoricalUsage", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateHistoricalUsageEntity(v *types.HistoricalUsageEntity) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HistoricalUsageEntity"}
	if v.ServiceCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceCode"))
	}
	if v.UsageType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsageType"))
	}
	if v.Operation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Operation"))
	}
	if v.UsageAccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsageAccountId"))
	}
	if v.BillInterval == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BillInterval"))
	}
	if v.FilterExpression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilterExpression"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateListBillEstimateLineItemsFilter(v *types.ListBillEstimateLineItemsFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListBillEstimateLineItemsFilter"}
	if len(v.Name) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Values == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Values"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateListBillEstimatesFilter(v *types.ListBillEstimatesFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListBillEstimatesFilter"}
	if len(v.Name) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Values == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Values"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateListBillScenariosFilter(v *types.ListBillScenariosFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListBillScenariosFilter"}
	if len(v.Name) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Values == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Values"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateListUsageFilter(v *types.ListUsageFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListUsageFilter"}
	if len(v.Name) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Values == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Values"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateListWorkloadEstimatesFilter(v *types.ListWorkloadEstimatesFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListWorkloadEstimatesFilter"}
	if len(v.Name) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Values == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Values"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateUsageAmount(v *types.UsageAmount) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UsageAmount"}
	if v.StartHour == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartHour"))
	}
	if v.Amount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Amount"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpBatchCreateBillScenarioCommitmentModificationInput(v *BatchCreateBillScenarioCommitmentModificationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchCreateBillScenarioCommitmentModificationInput"}
	if v.BillScenarioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BillScenarioId"))
	}
	if v.CommitmentModifications == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CommitmentModifications"))
	} else if v.CommitmentModifications != nil {
		if err := validateBatchCreateBillScenarioCommitmentModificationEntries(v.CommitmentModifications); err != nil {
			invalidParams.AddNested("CommitmentModifications", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchCreateBillScenarioUsageModificationInput(v *BatchCreateBillScenarioUsageModificationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchCreateBillScenarioUsageModificationInput"}
	if v.BillScenarioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BillScenarioId"))
	}
	if v.UsageModifications == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsageModifications"))
	} else if v.UsageModifications != nil {
		if err := validateBatchCreateBillScenarioUsageModificationEntries(v.UsageModifications); err != nil {
			invalidParams.AddNested("UsageModifications", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchCreateWorkloadEstimateUsageInput(v *BatchCreateWorkloadEstimateUsageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchCreateWorkloadEstimateUsageInput"}
	if v.WorkloadEstimateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadEstimateId"))
	}
	if v.Usage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Usage"))
	} else if v.Usage != nil {
		if err := validateBatchCreateWorkloadEstimateUsageEntries(v.Usage); err != nil {
			invalidParams.AddNested("Usage", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchDeleteBillScenarioCommitmentModificationInput(v *BatchDeleteBillScenarioCommitmentModificationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteBillScenarioCommitmentModificationInput"}
	if v.BillScenarioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BillScenarioId"))
	}
	if v.Ids == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Ids"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchDeleteBillScenarioUsageModificationInput(v *BatchDeleteBillScenarioUsageModificationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteBillScenarioUsageModificationInput"}
	if v.BillScenarioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BillScenarioId"))
	}
	if v.Ids == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Ids"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchDeleteWorkloadEstimateUsageInput(v *BatchDeleteWorkloadEstimateUsageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteWorkloadEstimateUsageInput"}
	if v.WorkloadEstimateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadEstimateId"))
	}
	if v.Ids == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Ids"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchUpdateBillScenarioCommitmentModificationInput(v *BatchUpdateBillScenarioCommitmentModificationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchUpdateBillScenarioCommitmentModificationInput"}
	if v.BillScenarioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BillScenarioId"))
	}
	if v.CommitmentModifications == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CommitmentModifications"))
	} else if v.CommitmentModifications != nil {
		if err := validateBatchUpdateBillScenarioCommitmentModificationEntries(v.CommitmentModifications); err != nil {
			invalidParams.AddNested("CommitmentModifications", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchUpdateBillScenarioUsageModificationInput(v *BatchUpdateBillScenarioUsageModificationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchUpdateBillScenarioUsageModificationInput"}
	if v.BillScenarioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BillScenarioId"))
	}
	if v.UsageModifications == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UsageModifications"))
	} else if v.UsageModifications != nil {
		if err := validateBatchUpdateBillScenarioUsageModificationEntries(v.UsageModifications); err != nil {
			invalidParams.AddNested("UsageModifications", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchUpdateWorkloadEstimateUsageInput(v *BatchUpdateWorkloadEstimateUsageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchUpdateWorkloadEstimateUsageInput"}
	if v.WorkloadEstimateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadEstimateId"))
	}
	if v.Usage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Usage"))
	} else if v.Usage != nil {
		if err := validateBatchUpdateWorkloadEstimateUsageEntries(v.Usage); err != nil {
			invalidParams.AddNested("Usage", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateBillEstimateInput(v *CreateBillEstimateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateBillEstimateInput"}
	if v.BillScenarioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BillScenarioId"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

func validateOpListBillEstimateInputUsageModificationsInput(v *ListBillEstimateInputUsageModificationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListBillEstimateInputUsageModificationsInput"}
	if v.BillEstimateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BillEstimateId"))
	}
	if v.Filters != nil {
		if err := validateListUsageFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListBillEstimateLineItemsInput(v *ListBillEstimateLineItemsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListBillEstimateLineItemsInput"}
	if v.BillEstimateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BillEstimateId"))
	}
	if v.Filters != nil {
		if err := validateListBillEstimateLineItemsFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListBillEstimatesInput(v *ListBillEstimatesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListBillEstimatesInput"}
	if v.Filters != nil {
		if err := validateListBillEstimatesFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListBillScenariosInput(v *ListBillScenariosInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListBillScenariosInput"}
	if v.Filters != nil {
		if err := validateListBillScenariosFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListBillScenarioUsageModificationsInput(v *ListBillScenarioUsageModificationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListBillScenarioUsageModificationsInput"}
	if v.BillScenarioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BillScenarioId"))
	}
	if v.Filters != nil {
		if err := validateListUsageFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", 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.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListWorkloadEstimatesInput(v *ListWorkloadEstimatesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListWorkloadEstimatesInput"}
	if v.Filters != nil {
		if err := validateListWorkloadEstimatesFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListWorkloadEstimateUsageInput(v *ListWorkloadEstimateUsageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListWorkloadEstimateUsageInput"}
	if v.WorkloadEstimateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkloadEstimateId"))
	}
	if v.Filters != nil {
		if err := validateListUsageFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", 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.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	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.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	if v.TagKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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