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

package costexplorer

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

type validateOpCreateAnomalyMonitor struct {
}

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

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

type validateOpCreateAnomalySubscription struct {
}

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

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

type validateOpCreateCostCategoryDefinition struct {
}

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

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

type validateOpDeleteAnomalyMonitor struct {
}

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

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

type validateOpDeleteAnomalySubscription struct {
}

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

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

type validateOpDeleteCostCategoryDefinition struct {
}

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

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

type validateOpDescribeCostCategoryDefinition struct {
}

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

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

type validateOpGetAnomalies struct {
}

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

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

type validateOpGetCostAndUsage struct {
}

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

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

type validateOpGetCostAndUsageWithResources struct {
}

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

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

type validateOpGetCostCategories struct {
}

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

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

type validateOpGetCostForecast struct {
}

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

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

type validateOpGetDimensionValues struct {
}

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

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

type validateOpGetReservationCoverage struct {
}

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

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

type validateOpGetReservationPurchaseRecommendation struct {
}

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

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

type validateOpGetReservationUtilization struct {
}

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

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

type validateOpGetRightsizingRecommendation struct {
}

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

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

type validateOpGetSavingsPlanPurchaseRecommendationDetails struct {
}

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

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

type validateOpGetSavingsPlansCoverage struct {
}

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

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

type validateOpGetSavingsPlansPurchaseRecommendation struct {
}

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

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

type validateOpGetSavingsPlansUtilizationDetails struct {
}

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

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

type validateOpGetSavingsPlansUtilization struct {
}

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

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

type validateOpGetTags struct {
}

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

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

type validateOpGetUsageForecast struct {
}

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

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

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

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

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

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

type validateOpUpdateAnomalySubscription struct {
}

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

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

type validateOpUpdateCostAllocationTagsStatus struct {
}

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

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

type validateOpUpdateCostCategoryDefinition struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpProvideAnomalyFeedbackValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpProvideAnomalyFeedback{}, 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 addOpUpdateAnomalyMonitorValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateAnomalyMonitor{}, middleware.After)
}

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

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

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

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

func validateAnomalyMonitor(v *types.AnomalyMonitor) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AnomalyMonitor"}
	if v.MonitorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MonitorName"))
	}
	if len(v.MonitorType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MonitorType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAnomalySubscription(v *types.AnomalySubscription) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AnomalySubscription"}
	if v.MonitorArnList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MonitorArnList"))
	}
	if v.Subscribers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Subscribers"))
	}
	if len(v.Frequency) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Frequency"))
	}
	if v.SubscriptionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubscriptionName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCostAllocationTagStatusEntry(v *types.CostAllocationTagStatusEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CostAllocationTagStatusEntry"}
	if v.TagKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKey"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCostCategorySplitChargeRule(v *types.CostCategorySplitChargeRule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CostCategorySplitChargeRule"}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	}
	if v.Targets == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Targets"))
	}
	if len(v.Method) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Method"))
	}
	if v.Parameters != nil {
		if err := validateCostCategorySplitChargeRuleParametersList(v.Parameters); err != nil {
			invalidParams.AddNested("Parameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateDateInterval(v *types.DateInterval) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DateInterval"}
	if v.Start == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Start"))
	}
	if v.End == nil {
		invalidParams.Add(smithy.NewErrParamRequired("End"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateOpCreateAnomalyMonitorInput(v *CreateAnomalyMonitorInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAnomalyMonitorInput"}
	if v.AnomalyMonitor == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnomalyMonitor"))
	} else if v.AnomalyMonitor != nil {
		if err := validateAnomalyMonitor(v.AnomalyMonitor); err != nil {
			invalidParams.AddNested("AnomalyMonitor", err.(smithy.InvalidParamsError))
		}
	}
	if v.ResourceTags != nil {
		if err := validateResourceTagList(v.ResourceTags); err != nil {
			invalidParams.AddNested("ResourceTags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAnomalySubscriptionInput(v *CreateAnomalySubscriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAnomalySubscriptionInput"}
	if v.AnomalySubscription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnomalySubscription"))
	} else if v.AnomalySubscription != nil {
		if err := validateAnomalySubscription(v.AnomalySubscription); err != nil {
			invalidParams.AddNested("AnomalySubscription", err.(smithy.InvalidParamsError))
		}
	}
	if v.ResourceTags != nil {
		if err := validateResourceTagList(v.ResourceTags); err != nil {
			invalidParams.AddNested("ResourceTags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCostCategoryDefinitionInput(v *CreateCostCategoryDefinitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCostCategoryDefinitionInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.RuleVersion) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RuleVersion"))
	}
	if v.Rules == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Rules"))
	}
	if v.SplitChargeRules != nil {
		if err := validateCostCategorySplitChargeRulesList(v.SplitChargeRules); err != nil {
			invalidParams.AddNested("SplitChargeRules", err.(smithy.InvalidParamsError))
		}
	}
	if v.ResourceTags != nil {
		if err := validateResourceTagList(v.ResourceTags); err != nil {
			invalidParams.AddNested("ResourceTags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpGetAnomaliesInput(v *GetAnomaliesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAnomaliesInput"}
	if v.DateInterval == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DateInterval"))
	} else if v.DateInterval != nil {
		if err := validateAnomalyDateInterval(v.DateInterval); err != nil {
			invalidParams.AddNested("DateInterval", err.(smithy.InvalidParamsError))
		}
	}
	if v.TotalImpact != nil {
		if err := validateTotalImpactFilter(v.TotalImpact); err != nil {
			invalidParams.AddNested("TotalImpact", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCostAndUsageInput(v *GetCostAndUsageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCostAndUsageInput"}
	if v.TimePeriod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimePeriod"))
	} else if v.TimePeriod != nil {
		if err := validateDateInterval(v.TimePeriod); err != nil {
			invalidParams.AddNested("TimePeriod", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.Granularity) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Granularity"))
	}
	if v.Metrics == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Metrics"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCostAndUsageWithResourcesInput(v *GetCostAndUsageWithResourcesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCostAndUsageWithResourcesInput"}
	if v.TimePeriod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimePeriod"))
	} else if v.TimePeriod != nil {
		if err := validateDateInterval(v.TimePeriod); err != nil {
			invalidParams.AddNested("TimePeriod", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.Granularity) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Granularity"))
	}
	if v.Filter == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Filter"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCostCategoriesInput(v *GetCostCategoriesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCostCategoriesInput"}
	if v.TimePeriod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimePeriod"))
	} else if v.TimePeriod != nil {
		if err := validateDateInterval(v.TimePeriod); err != nil {
			invalidParams.AddNested("TimePeriod", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortBy != nil {
		if err := validateSortDefinitions(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCostForecastInput(v *GetCostForecastInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCostForecastInput"}
	if v.TimePeriod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimePeriod"))
	} else if v.TimePeriod != nil {
		if err := validateDateInterval(v.TimePeriod); err != nil {
			invalidParams.AddNested("TimePeriod", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.Metric) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Metric"))
	}
	if len(v.Granularity) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Granularity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDimensionValuesInput(v *GetDimensionValuesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDimensionValuesInput"}
	if v.TimePeriod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimePeriod"))
	} else if v.TimePeriod != nil {
		if err := validateDateInterval(v.TimePeriod); err != nil {
			invalidParams.AddNested("TimePeriod", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.Dimension) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Dimension"))
	}
	if v.SortBy != nil {
		if err := validateSortDefinitions(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetReservationCoverageInput(v *GetReservationCoverageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetReservationCoverageInput"}
	if v.TimePeriod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimePeriod"))
	} else if v.TimePeriod != nil {
		if err := validateDateInterval(v.TimePeriod); err != nil {
			invalidParams.AddNested("TimePeriod", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortBy != nil {
		if err := validateSortDefinition(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetReservationUtilizationInput(v *GetReservationUtilizationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetReservationUtilizationInput"}
	if v.TimePeriod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimePeriod"))
	} else if v.TimePeriod != nil {
		if err := validateDateInterval(v.TimePeriod); err != nil {
			invalidParams.AddNested("TimePeriod", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortBy != nil {
		if err := validateSortDefinition(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetRightsizingRecommendationInput(v *GetRightsizingRecommendationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRightsizingRecommendationInput"}
	if v.Configuration != nil {
		if err := validateRightsizingRecommendationConfiguration(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Service == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Service"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetSavingsPlansCoverageInput(v *GetSavingsPlansCoverageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSavingsPlansCoverageInput"}
	if v.TimePeriod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimePeriod"))
	} else if v.TimePeriod != nil {
		if err := validateDateInterval(v.TimePeriod); err != nil {
			invalidParams.AddNested("TimePeriod", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortBy != nil {
		if err := validateSortDefinition(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSavingsPlansPurchaseRecommendationInput(v *GetSavingsPlansPurchaseRecommendationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSavingsPlansPurchaseRecommendationInput"}
	if len(v.SavingsPlansType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SavingsPlansType"))
	}
	if len(v.TermInYears) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TermInYears"))
	}
	if len(v.PaymentOption) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PaymentOption"))
	}
	if len(v.LookbackPeriodInDays) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LookbackPeriodInDays"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSavingsPlansUtilizationDetailsInput(v *GetSavingsPlansUtilizationDetailsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSavingsPlansUtilizationDetailsInput"}
	if v.TimePeriod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimePeriod"))
	} else if v.TimePeriod != nil {
		if err := validateDateInterval(v.TimePeriod); err != nil {
			invalidParams.AddNested("TimePeriod", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortBy != nil {
		if err := validateSortDefinition(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSavingsPlansUtilizationInput(v *GetSavingsPlansUtilizationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSavingsPlansUtilizationInput"}
	if v.TimePeriod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimePeriod"))
	} else if v.TimePeriod != nil {
		if err := validateDateInterval(v.TimePeriod); err != nil {
			invalidParams.AddNested("TimePeriod", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortBy != nil {
		if err := validateSortDefinition(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetTagsInput(v *GetTagsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTagsInput"}
	if v.TimePeriod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimePeriod"))
	} else if v.TimePeriod != nil {
		if err := validateDateInterval(v.TimePeriod); err != nil {
			invalidParams.AddNested("TimePeriod", err.(smithy.InvalidParamsError))
		}
	}
	if v.SortBy != nil {
		if err := validateSortDefinitions(v.SortBy); err != nil {
			invalidParams.AddNested("SortBy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetUsageForecastInput(v *GetUsageForecastInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetUsageForecastInput"}
	if v.TimePeriod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimePeriod"))
	} else if v.TimePeriod != nil {
		if err := validateDateInterval(v.TimePeriod); err != nil {
			invalidParams.AddNested("TimePeriod", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.Metric) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Metric"))
	}
	if len(v.Granularity) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Granularity"))
	}
	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 validateOpProvideAnomalyFeedbackInput(v *ProvideAnomalyFeedbackInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProvideAnomalyFeedbackInput"}
	if v.AnomalyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AnomalyId"))
	}
	if len(v.Feedback) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Feedback"))
	}
	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.ResourceTags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceTags"))
	} else if v.ResourceTags != nil {
		if err := validateResourceTagList(v.ResourceTags); err != nil {
			invalidParams.AddNested("ResourceTags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpUpdateCostAllocationTagsStatusInput(v *UpdateCostAllocationTagsStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCostAllocationTagsStatusInput"}
	if v.CostAllocationTagsStatus == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CostAllocationTagsStatus"))
	} else if v.CostAllocationTagsStatus != nil {
		if err := validateCostAllocationTagStatusList(v.CostAllocationTagsStatus); err != nil {
			invalidParams.AddNested("CostAllocationTagsStatus", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateCostCategoryDefinitionInput(v *UpdateCostCategoryDefinitionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCostCategoryDefinitionInput"}
	if v.CostCategoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CostCategoryArn"))
	}
	if len(v.RuleVersion) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RuleVersion"))
	}
	if v.Rules == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Rules"))
	}
	if v.SplitChargeRules != nil {
		if err := validateCostCategorySplitChargeRulesList(v.SplitChargeRules); err != nil {
			invalidParams.AddNested("SplitChargeRules", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}