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

package servicecatalog

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

type validateOpAcceptPortfolioShare struct {
}

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

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

type validateOpAssociateBudgetWithResource struct {
}

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

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

type validateOpAssociatePrincipalWithPortfolio struct {
}

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

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

type validateOpAssociateProductWithPortfolio struct {
}

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

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

type validateOpAssociateServiceActionWithProvisioningArtifact struct {
}

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

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

type validateOpAssociateTagOptionWithResource struct {
}

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

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

type validateOpBatchAssociateServiceActionWithProvisioningArtifact struct {
}

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

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

type validateOpBatchDisassociateServiceActionFromProvisioningArtifact struct {
}

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

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

type validateOpCopyProduct struct {
}

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

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

type validateOpCreateConstraint struct {
}

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

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

type validateOpCreatePortfolio struct {
}

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

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

type validateOpCreatePortfolioShare struct {
}

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

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

type validateOpCreateProduct struct {
}

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

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

type validateOpCreateProvisionedProductPlan struct {
}

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

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

type validateOpCreateProvisioningArtifact struct {
}

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

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

type validateOpCreateServiceAction struct {
}

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

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

type validateOpCreateTagOption struct {
}

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

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

type validateOpDeleteConstraint struct {
}

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

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

type validateOpDeletePortfolio struct {
}

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

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

type validateOpDeletePortfolioShare struct {
}

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

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

type validateOpDeleteProduct struct {
}

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

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

type validateOpDeleteProvisionedProductPlan struct {
}

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

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

type validateOpDeleteProvisioningArtifact struct {
}

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

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

type validateOpDeleteServiceAction struct {
}

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

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

type validateOpDeleteTagOption struct {
}

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

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

type validateOpDescribeConstraint struct {
}

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

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

type validateOpDescribeCopyProductStatus struct {
}

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

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

type validateOpDescribePortfolio struct {
}

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

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

type validateOpDescribePortfolioShares struct {
}

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

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

type validateOpDescribePortfolioShareStatus struct {
}

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

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

type validateOpDescribeProductView struct {
}

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

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

type validateOpDescribeProvisionedProductPlan struct {
}

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

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

type validateOpDescribeRecord struct {
}

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

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

type validateOpDescribeServiceActionExecutionParameters struct {
}

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

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

type validateOpDescribeServiceAction struct {
}

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

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

type validateOpDescribeTagOption struct {
}

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

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

type validateOpDisassociateBudgetFromResource struct {
}

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

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

type validateOpDisassociatePrincipalFromPortfolio struct {
}

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

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

type validateOpDisassociateProductFromPortfolio struct {
}

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

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

type validateOpDisassociateServiceActionFromProvisioningArtifact struct {
}

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

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

type validateOpDisassociateTagOptionFromResource struct {
}

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

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

type validateOpExecuteProvisionedProductPlan struct {
}

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

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

type validateOpExecuteProvisionedProductServiceAction struct {
}

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

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

type validateOpImportAsProvisionedProduct struct {
}

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

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

type validateOpListBudgetsForResource struct {
}

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

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

type validateOpListConstraintsForPortfolio struct {
}

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

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

type validateOpListLaunchPaths struct {
}

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

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

type validateOpListOrganizationPortfolioAccess struct {
}

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

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

type validateOpListPortfolioAccess struct {
}

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

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

type validateOpListPortfoliosForProduct struct {
}

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

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

type validateOpListPrincipalsForPortfolio struct {
}

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

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

type validateOpListProvisioningArtifactsForServiceAction struct {
}

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

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

type validateOpListProvisioningArtifacts struct {
}

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

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

type validateOpListResourcesForTagOption struct {
}

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

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

type validateOpListServiceActionsForProvisioningArtifact struct {
}

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

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

type validateOpListStackInstancesForProvisionedProduct struct {
}

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

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

type validateOpNotifyProvisionProductEngineWorkflowResult struct {
}

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

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

type validateOpNotifyTerminateProvisionedProductEngineWorkflowResult struct {
}

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

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

type validateOpNotifyUpdateProvisionedProductEngineWorkflowResult struct {
}

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

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

type validateOpProvisionProduct struct {
}

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

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

type validateOpRejectPortfolioShare struct {
}

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

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

type validateOpTerminateProvisionedProduct struct {
}

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

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

type validateOpUpdateConstraint struct {
}

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

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

type validateOpUpdatePortfolio struct {
}

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

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

type validateOpUpdatePortfolioShare struct {
}

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

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

type validateOpUpdateProduct struct {
}

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

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

type validateOpUpdateProvisionedProduct struct {
}

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

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

type validateOpUpdateProvisionedProductProperties struct {
}

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

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

type validateOpUpdateProvisioningArtifact struct {
}

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

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

type validateOpUpdateServiceAction struct {
}

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

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

type validateOpUpdateTagOption struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateCodeStarParameters(v *types.CodeStarParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CodeStarParameters"}
	if v.ConnectionArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionArn"))
	}
	if v.Repository == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Repository"))
	}
	if v.Branch == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Branch"))
	}
	if v.ArtifactPath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ArtifactPath"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateServiceActionAssociation(v *types.ServiceActionAssociation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ServiceActionAssociation"}
	if v.ServiceActionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceActionId"))
	}
	if v.ProductId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProductId"))
	}
	if v.ProvisioningArtifactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProvisioningArtifactId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSourceConnection(v *types.SourceConnection) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SourceConnection"}
	if v.ConnectionParameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectionParameters"))
	} else if v.ConnectionParameters != nil {
		if err := validateSourceConnectionParameters(v.ConnectionParameters); err != nil {
			invalidParams.AddNested("ConnectionParameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSourceConnectionParameters(v *types.SourceConnectionParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SourceConnectionParameters"}
	if v.CodeStar != nil {
		if err := validateCodeStarParameters(v.CodeStar); err != nil {
			invalidParams.AddNested("CodeStar", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpAssociateBudgetWithResourceInput(v *AssociateBudgetWithResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateBudgetWithResourceInput"}
	if v.BudgetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BudgetName"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociatePrincipalWithPortfolioInput(v *AssociatePrincipalWithPortfolioInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociatePrincipalWithPortfolioInput"}
	if v.PortfolioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortfolioId"))
	}
	if v.PrincipalARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalARN"))
	}
	if len(v.PrincipalType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateProductWithPortfolioInput(v *AssociateProductWithPortfolioInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateProductWithPortfolioInput"}
	if v.ProductId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProductId"))
	}
	if v.PortfolioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortfolioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateServiceActionWithProvisioningArtifactInput(v *AssociateServiceActionWithProvisioningArtifactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateServiceActionWithProvisioningArtifactInput"}
	if v.ProductId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProductId"))
	}
	if v.ProvisioningArtifactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProvisioningArtifactId"))
	}
	if v.ServiceActionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceActionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateTagOptionWithResourceInput(v *AssociateTagOptionWithResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateTagOptionWithResourceInput"}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.TagOptionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagOptionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchAssociateServiceActionWithProvisioningArtifactInput(v *BatchAssociateServiceActionWithProvisioningArtifactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchAssociateServiceActionWithProvisioningArtifactInput"}
	if v.ServiceActionAssociations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceActionAssociations"))
	} else if v.ServiceActionAssociations != nil {
		if err := validateServiceActionAssociations(v.ServiceActionAssociations); err != nil {
			invalidParams.AddNested("ServiceActionAssociations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchDisassociateServiceActionFromProvisioningArtifactInput(v *BatchDisassociateServiceActionFromProvisioningArtifactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDisassociateServiceActionFromProvisioningArtifactInput"}
	if v.ServiceActionAssociations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceActionAssociations"))
	} else if v.ServiceActionAssociations != nil {
		if err := validateServiceActionAssociations(v.ServiceActionAssociations); err != nil {
			invalidParams.AddNested("ServiceActionAssociations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCopyProductInput(v *CopyProductInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CopyProductInput"}
	if v.SourceProductArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceProductArn"))
	}
	if v.IdempotencyToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdempotencyToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateConstraintInput(v *CreateConstraintInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateConstraintInput"}
	if v.PortfolioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortfolioId"))
	}
	if v.ProductId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProductId"))
	}
	if v.Parameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Parameters"))
	}
	if v.Type == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.IdempotencyToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdempotencyToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePortfolioInput(v *CreatePortfolioInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePortfolioInput"}
	if v.DisplayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DisplayName"))
	}
	if v.ProviderName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProviderName"))
	}
	if v.Tags != nil {
		if err := validateAddTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.IdempotencyToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdempotencyToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateProductInput(v *CreateProductInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateProductInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Owner == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Owner"))
	}
	if len(v.ProductType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ProductType"))
	}
	if v.Tags != nil {
		if err := validateAddTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.IdempotencyToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdempotencyToken"))
	}
	if v.SourceConnection != nil {
		if err := validateSourceConnection(v.SourceConnection); err != nil {
			invalidParams.AddNested("SourceConnection", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateProvisionedProductPlanInput(v *CreateProvisionedProductPlanInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateProvisionedProductPlanInput"}
	if v.PlanName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PlanName"))
	}
	if len(v.PlanType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PlanType"))
	}
	if v.ProductId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProductId"))
	}
	if v.ProvisionedProductName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProvisionedProductName"))
	}
	if v.ProvisioningArtifactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProvisioningArtifactId"))
	}
	if v.IdempotencyToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdempotencyToken"))
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateProvisioningArtifactInput(v *CreateProvisioningArtifactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateProvisioningArtifactInput"}
	if v.ProductId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProductId"))
	}
	if v.Parameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Parameters"))
	}
	if v.IdempotencyToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdempotencyToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateServiceActionInput(v *CreateServiceActionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateServiceActionInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if len(v.DefinitionType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DefinitionType"))
	}
	if v.Definition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Definition"))
	}
	if v.IdempotencyToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdempotencyToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTagOptionInput(v *CreateTagOptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTagOptionInput"}
	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 validateOpDeleteConstraintInput(v *DeleteConstraintInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteConstraintInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpDeleteProvisioningArtifactInput(v *DeleteProvisioningArtifactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteProvisioningArtifactInput"}
	if v.ProductId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProductId"))
	}
	if v.ProvisioningArtifactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProvisioningArtifactId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

func validateOpDescribeServiceActionExecutionParametersInput(v *DescribeServiceActionExecutionParametersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeServiceActionExecutionParametersInput"}
	if v.ProvisionedProductId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProvisionedProductId"))
	}
	if v.ServiceActionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceActionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDisassociateBudgetFromResourceInput(v *DisassociateBudgetFromResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateBudgetFromResourceInput"}
	if v.BudgetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BudgetName"))
	}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociatePrincipalFromPortfolioInput(v *DisassociatePrincipalFromPortfolioInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociatePrincipalFromPortfolioInput"}
	if v.PortfolioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortfolioId"))
	}
	if v.PrincipalARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalARN"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateProductFromPortfolioInput(v *DisassociateProductFromPortfolioInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateProductFromPortfolioInput"}
	if v.ProductId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProductId"))
	}
	if v.PortfolioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortfolioId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateServiceActionFromProvisioningArtifactInput(v *DisassociateServiceActionFromProvisioningArtifactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateServiceActionFromProvisioningArtifactInput"}
	if v.ProductId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProductId"))
	}
	if v.ProvisioningArtifactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProvisioningArtifactId"))
	}
	if v.ServiceActionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceActionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateTagOptionFromResourceInput(v *DisassociateTagOptionFromResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateTagOptionFromResourceInput"}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.TagOptionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagOptionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpExecuteProvisionedProductPlanInput(v *ExecuteProvisionedProductPlanInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExecuteProvisionedProductPlanInput"}
	if v.PlanId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PlanId"))
	}
	if v.IdempotencyToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdempotencyToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpExecuteProvisionedProductServiceActionInput(v *ExecuteProvisionedProductServiceActionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExecuteProvisionedProductServiceActionInput"}
	if v.ProvisionedProductId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProvisionedProductId"))
	}
	if v.ServiceActionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceActionId"))
	}
	if v.ExecuteToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExecuteToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpImportAsProvisionedProductInput(v *ImportAsProvisionedProductInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportAsProvisionedProductInput"}
	if v.ProductId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProductId"))
	}
	if v.ProvisioningArtifactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProvisioningArtifactId"))
	}
	if v.ProvisionedProductName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProvisionedProductName"))
	}
	if v.PhysicalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PhysicalId"))
	}
	if v.IdempotencyToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdempotencyToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpListOrganizationPortfolioAccessInput(v *ListOrganizationPortfolioAccessInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListOrganizationPortfolioAccessInput"}
	if v.PortfolioId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PortfolioId"))
	}
	if len(v.OrganizationNodeType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("OrganizationNodeType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateOpListServiceActionsForProvisioningArtifactInput(v *ListServiceActionsForProvisioningArtifactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListServiceActionsForProvisioningArtifactInput"}
	if v.ProductId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProductId"))
	}
	if v.ProvisioningArtifactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProvisioningArtifactId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpNotifyProvisionProductEngineWorkflowResultInput(v *NotifyProvisionProductEngineWorkflowResultInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NotifyProvisionProductEngineWorkflowResultInput"}
	if v.WorkflowToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkflowToken"))
	}
	if v.RecordId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecordId"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if v.IdempotencyToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdempotencyToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpNotifyTerminateProvisionedProductEngineWorkflowResultInput(v *NotifyTerminateProvisionedProductEngineWorkflowResultInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NotifyTerminateProvisionedProductEngineWorkflowResultInput"}
	if v.WorkflowToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkflowToken"))
	}
	if v.RecordId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecordId"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if v.IdempotencyToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdempotencyToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpNotifyUpdateProvisionedProductEngineWorkflowResultInput(v *NotifyUpdateProvisionedProductEngineWorkflowResultInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NotifyUpdateProvisionedProductEngineWorkflowResultInput"}
	if v.WorkflowToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkflowToken"))
	}
	if v.RecordId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecordId"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if v.IdempotencyToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdempotencyToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpProvisionProductInput(v *ProvisionProductInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProvisionProductInput"}
	if v.ProvisionedProductName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProvisionedProductName"))
	}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.ProvisionToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProvisionToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpUpdatePortfolioInput(v *UpdatePortfolioInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePortfolioInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.AddTags != nil {
		if err := validateAddTags(v.AddTags); err != nil {
			invalidParams.AddNested("AddTags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateProductInput(v *UpdateProductInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateProductInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.AddTags != nil {
		if err := validateAddTags(v.AddTags); err != nil {
			invalidParams.AddNested("AddTags", err.(smithy.InvalidParamsError))
		}
	}
	if v.SourceConnection != nil {
		if err := validateSourceConnection(v.SourceConnection); err != nil {
			invalidParams.AddNested("SourceConnection", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateProvisionedProductInput(v *UpdateProvisionedProductInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateProvisionedProductInput"}
	if v.Tags != nil {
		if err := validateTags(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.UpdateToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UpdateToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateProvisionedProductPropertiesInput(v *UpdateProvisionedProductPropertiesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateProvisionedProductPropertiesInput"}
	if v.ProvisionedProductId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProvisionedProductId"))
	}
	if v.ProvisionedProductProperties == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProvisionedProductProperties"))
	}
	if v.IdempotencyToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdempotencyToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateProvisioningArtifactInput(v *UpdateProvisioningArtifactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateProvisioningArtifactInput"}
	if v.ProductId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProductId"))
	}
	if v.ProvisioningArtifactId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProvisioningArtifactId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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