service/verifiedpermissions/validators.go

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

package verifiedpermissions

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

type validateOpBatchGetPolicy struct {
}

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

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

type validateOpBatchIsAuthorized struct {
}

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

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

type validateOpBatchIsAuthorizedWithToken struct {
}

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

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

type validateOpCreateIdentitySource struct {
}

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

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

type validateOpCreatePolicy struct {
}

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

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

type validateOpCreatePolicyStore struct {
}

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

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

type validateOpCreatePolicyTemplate struct {
}

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

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

type validateOpDeleteIdentitySource struct {
}

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

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

type validateOpDeletePolicy struct {
}

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

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

type validateOpDeletePolicyStore struct {
}

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

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

type validateOpDeletePolicyTemplate struct {
}

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

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

type validateOpGetIdentitySource struct {
}

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

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

type validateOpGetPolicy struct {
}

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

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

type validateOpGetPolicyStore struct {
}

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

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

type validateOpGetPolicyTemplate struct {
}

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

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

type validateOpGetSchema struct {
}

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

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

type validateOpIsAuthorized struct {
}

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

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

type validateOpIsAuthorizedWithToken struct {
}

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

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

type validateOpListIdentitySources struct {
}

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

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

type validateOpListPolicies struct {
}

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

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

type validateOpListPolicyTemplates struct {
}

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

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

type validateOpListTagsForResource struct {
}

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

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

type validateOpPutSchema struct {
}

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

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

type validateOpTagResource struct {
}

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

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

type validateOpUntagResource struct {
}

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

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

type validateOpUpdateIdentitySource struct {
}

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

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

type validateOpUpdatePolicy struct {
}

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

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

type validateOpUpdatePolicyStore struct {
}

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

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

type validateOpUpdatePolicyTemplate struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateActionIdentifier(v *types.ActionIdentifier) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ActionIdentifier"}
	if v.ActionType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActionType"))
	}
	if v.ActionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAttributeValue(v types.AttributeValue) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttributeValue"}
	switch uv := v.(type) {
	case *types.AttributeValueMemberEntityIdentifier:
		if err := validateEntityIdentifier(&uv.Value); err != nil {
			invalidParams.AddNested("[entityIdentifier]", err.(smithy.InvalidParamsError))
		}

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

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

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

func validateBatchGetPolicyInputItem(v *types.BatchGetPolicyInputItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetPolicyInputItem"}
	if v.PolicyStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyStoreId"))
	}
	if v.PolicyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateBatchIsAuthorizedInputItem(v *types.BatchIsAuthorizedInputItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchIsAuthorizedInputItem"}
	if v.Principal != nil {
		if err := validateEntityIdentifier(v.Principal); err != nil {
			invalidParams.AddNested("Principal", err.(smithy.InvalidParamsError))
		}
	}
	if v.Action != nil {
		if err := validateActionIdentifier(v.Action); err != nil {
			invalidParams.AddNested("Action", err.(smithy.InvalidParamsError))
		}
	}
	if v.Resource != nil {
		if err := validateEntityIdentifier(v.Resource); err != nil {
			invalidParams.AddNested("Resource", err.(smithy.InvalidParamsError))
		}
	}
	if v.Context != nil {
		if err := validateContextDefinition(v.Context); err != nil {
			invalidParams.AddNested("Context", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateBatchIsAuthorizedWithTokenInputItem(v *types.BatchIsAuthorizedWithTokenInputItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchIsAuthorizedWithTokenInputItem"}
	if v.Action != nil {
		if err := validateActionIdentifier(v.Action); err != nil {
			invalidParams.AddNested("Action", err.(smithy.InvalidParamsError))
		}
	}
	if v.Resource != nil {
		if err := validateEntityIdentifier(v.Resource); err != nil {
			invalidParams.AddNested("Resource", err.(smithy.InvalidParamsError))
		}
	}
	if v.Context != nil {
		if err := validateContextDefinition(v.Context); err != nil {
			invalidParams.AddNested("Context", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateCognitoUserPoolConfiguration(v *types.CognitoUserPoolConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CognitoUserPoolConfiguration"}
	if v.UserPoolArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolArn"))
	}
	if v.GroupConfiguration != nil {
		if err := validateCognitoGroupConfiguration(v.GroupConfiguration); err != nil {
			invalidParams.AddNested("GroupConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConfiguration(v types.Configuration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Configuration"}
	switch uv := v.(type) {
	case *types.ConfigurationMemberCognitoUserPoolConfiguration:
		if err := validateCognitoUserPoolConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[cognitoUserPoolConfiguration]", err.(smithy.InvalidParamsError))
		}

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

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

func validateContextDefinition(v types.ContextDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContextDefinition"}
	switch uv := v.(type) {
	case *types.ContextDefinitionMemberContextMap:
		if err := validateContextMap(uv.Value); err != nil {
			invalidParams.AddNested("[contextMap]", err.(smithy.InvalidParamsError))
		}

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

func validateContextMap(v map[string]types.AttributeValue) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContextMap"}
	for key := range v {
		if err := validateAttributeValue(v[key]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEntitiesDefinition(v types.EntitiesDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EntitiesDefinition"}
	switch uv := v.(type) {
	case *types.EntitiesDefinitionMemberEntityList:
		if err := validateEntityList(uv.Value); err != nil {
			invalidParams.AddNested("[entityList]", err.(smithy.InvalidParamsError))
		}

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

func validateEntityAttributes(v map[string]types.AttributeValue) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EntityAttributes"}
	for key := range v {
		if err := validateAttributeValue(v[key]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEntityIdentifier(v *types.EntityIdentifier) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EntityIdentifier"}
	if v.EntityType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityType"))
	}
	if v.EntityId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEntityItem(v *types.EntityItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EntityItem"}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	} else if v.Identifier != nil {
		if err := validateEntityIdentifier(v.Identifier); err != nil {
			invalidParams.AddNested("Identifier", err.(smithy.InvalidParamsError))
		}
	}
	if v.Attributes != nil {
		if err := validateEntityAttributes(v.Attributes); err != nil {
			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.Parents != nil {
		if err := validateParentList(v.Parents); err != nil {
			invalidParams.AddNested("Parents", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateEntityReference(v types.EntityReference) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EntityReference"}
	switch uv := v.(type) {
	case *types.EntityReferenceMemberIdentifier:
		if err := validateEntityIdentifier(&uv.Value); err != nil {
			invalidParams.AddNested("[identifier]", err.(smithy.InvalidParamsError))
		}

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

func validateOpenIdConnectConfiguration(v *types.OpenIdConnectConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OpenIdConnectConfiguration"}
	if v.Issuer == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Issuer"))
	}
	if v.GroupConfiguration != nil {
		if err := validateOpenIdConnectGroupConfiguration(v.GroupConfiguration); err != nil {
			invalidParams.AddNested("GroupConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.TokenSelection == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TokenSelection"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpenIdConnectGroupConfiguration(v *types.OpenIdConnectGroupConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OpenIdConnectGroupConfiguration"}
	if v.GroupClaim == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupClaim"))
	}
	if v.GroupEntityType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupEntityType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validatePolicyDefinition(v types.PolicyDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PolicyDefinition"}
	switch uv := v.(type) {
	case *types.PolicyDefinitionMemberStatic:
		if err := validateStaticPolicyDefinition(&uv.Value); err != nil {
			invalidParams.AddNested("[static]", err.(smithy.InvalidParamsError))
		}

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

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

func validatePolicyFilter(v *types.PolicyFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PolicyFilter"}
	if v.Principal != nil {
		if err := validateEntityReference(v.Principal); err != nil {
			invalidParams.AddNested("Principal", err.(smithy.InvalidParamsError))
		}
	}
	if v.Resource != nil {
		if err := validateEntityReference(v.Resource); err != nil {
			invalidParams.AddNested("Resource", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRecordAttribute(v map[string]types.AttributeValue) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RecordAttribute"}
	for key := range v {
		if err := validateAttributeValue(v[key]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateTemplateLinkedPolicyDefinition(v *types.TemplateLinkedPolicyDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TemplateLinkedPolicyDefinition"}
	if v.PolicyTemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyTemplateId"))
	}
	if v.Principal != nil {
		if err := validateEntityIdentifier(v.Principal); err != nil {
			invalidParams.AddNested("Principal", err.(smithy.InvalidParamsError))
		}
	}
	if v.Resource != nil {
		if err := validateEntityIdentifier(v.Resource); err != nil {
			invalidParams.AddNested("Resource", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateUpdateCognitoUserPoolConfiguration(v *types.UpdateCognitoUserPoolConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCognitoUserPoolConfiguration"}
	if v.UserPoolArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolArn"))
	}
	if v.GroupConfiguration != nil {
		if err := validateUpdateCognitoGroupConfiguration(v.GroupConfiguration); err != nil {
			invalidParams.AddNested("GroupConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateUpdateConfiguration(v types.UpdateConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateConfiguration"}
	switch uv := v.(type) {
	case *types.UpdateConfigurationMemberCognitoUserPoolConfiguration:
		if err := validateUpdateCognitoUserPoolConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[cognitoUserPoolConfiguration]", err.(smithy.InvalidParamsError))
		}

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

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

func validateUpdateOpenIdConnectConfiguration(v *types.UpdateOpenIdConnectConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateOpenIdConnectConfiguration"}
	if v.Issuer == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Issuer"))
	}
	if v.GroupConfiguration != nil {
		if err := validateUpdateOpenIdConnectGroupConfiguration(v.GroupConfiguration); err != nil {
			invalidParams.AddNested("GroupConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.TokenSelection == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TokenSelection"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateUpdateOpenIdConnectGroupConfiguration(v *types.UpdateOpenIdConnectGroupConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateOpenIdConnectGroupConfiguration"}
	if v.GroupClaim == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupClaim"))
	}
	if v.GroupEntityType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupEntityType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateUpdatePolicyDefinition(v types.UpdatePolicyDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePolicyDefinition"}
	switch uv := v.(type) {
	case *types.UpdatePolicyDefinitionMemberStatic:
		if err := validateUpdateStaticPolicyDefinition(&uv.Value); err != nil {
			invalidParams.AddNested("[static]", err.(smithy.InvalidParamsError))
		}

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

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

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

func validateOpBatchGetPolicyInput(v *BatchGetPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetPolicyInput"}
	if v.Requests == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Requests"))
	} else if v.Requests != nil {
		if err := validateBatchGetPolicyInputList(v.Requests); err != nil {
			invalidParams.AddNested("Requests", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchIsAuthorizedInput(v *BatchIsAuthorizedInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchIsAuthorizedInput"}
	if v.PolicyStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyStoreId"))
	}
	if v.Entities != nil {
		if err := validateEntitiesDefinition(v.Entities); err != nil {
			invalidParams.AddNested("Entities", err.(smithy.InvalidParamsError))
		}
	}
	if v.Requests == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Requests"))
	} else if v.Requests != nil {
		if err := validateBatchIsAuthorizedInputList(v.Requests); err != nil {
			invalidParams.AddNested("Requests", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchIsAuthorizedWithTokenInput(v *BatchIsAuthorizedWithTokenInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchIsAuthorizedWithTokenInput"}
	if v.PolicyStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyStoreId"))
	}
	if v.Entities != nil {
		if err := validateEntitiesDefinition(v.Entities); err != nil {
			invalidParams.AddNested("Entities", err.(smithy.InvalidParamsError))
		}
	}
	if v.Requests == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Requests"))
	} else if v.Requests != nil {
		if err := validateBatchIsAuthorizedWithTokenInputList(v.Requests); err != nil {
			invalidParams.AddNested("Requests", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateIdentitySourceInput(v *CreateIdentitySourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateIdentitySourceInput"}
	if v.PolicyStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyStoreId"))
	}
	if v.Configuration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Configuration"))
	} else if v.Configuration != nil {
		if err := validateConfiguration(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePolicyInput(v *CreatePolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePolicyInput"}
	if v.PolicyStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyStoreId"))
	}
	if v.Definition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Definition"))
	} else if v.Definition != nil {
		if err := validatePolicyDefinition(v.Definition); err != nil {
			invalidParams.AddNested("Definition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePolicyStoreInput(v *CreatePolicyStoreInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePolicyStoreInput"}
	if v.ValidationSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ValidationSettings"))
	} else if v.ValidationSettings != nil {
		if err := validateValidationSettings(v.ValidationSettings); err != nil {
			invalidParams.AddNested("ValidationSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePolicyTemplateInput(v *CreatePolicyTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePolicyTemplateInput"}
	if v.PolicyStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyStoreId"))
	}
	if v.Statement == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Statement"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteIdentitySourceInput(v *DeleteIdentitySourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIdentitySourceInput"}
	if v.PolicyStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyStoreId"))
	}
	if v.IdentitySourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdentitySourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeletePolicyInput(v *DeletePolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeletePolicyInput"}
	if v.PolicyStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyStoreId"))
	}
	if v.PolicyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeletePolicyTemplateInput(v *DeletePolicyTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeletePolicyTemplateInput"}
	if v.PolicyStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyStoreId"))
	}
	if v.PolicyTemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyTemplateId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIdentitySourceInput(v *GetIdentitySourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIdentitySourceInput"}
	if v.PolicyStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyStoreId"))
	}
	if v.IdentitySourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdentitySourceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetPolicyInput(v *GetPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPolicyInput"}
	if v.PolicyStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyStoreId"))
	}
	if v.PolicyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetPolicyTemplateInput(v *GetPolicyTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPolicyTemplateInput"}
	if v.PolicyStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyStoreId"))
	}
	if v.PolicyTemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyTemplateId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpIsAuthorizedInput(v *IsAuthorizedInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IsAuthorizedInput"}
	if v.PolicyStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyStoreId"))
	}
	if v.Principal != nil {
		if err := validateEntityIdentifier(v.Principal); err != nil {
			invalidParams.AddNested("Principal", err.(smithy.InvalidParamsError))
		}
	}
	if v.Action != nil {
		if err := validateActionIdentifier(v.Action); err != nil {
			invalidParams.AddNested("Action", err.(smithy.InvalidParamsError))
		}
	}
	if v.Resource != nil {
		if err := validateEntityIdentifier(v.Resource); err != nil {
			invalidParams.AddNested("Resource", err.(smithy.InvalidParamsError))
		}
	}
	if v.Context != nil {
		if err := validateContextDefinition(v.Context); err != nil {
			invalidParams.AddNested("Context", err.(smithy.InvalidParamsError))
		}
	}
	if v.Entities != nil {
		if err := validateEntitiesDefinition(v.Entities); err != nil {
			invalidParams.AddNested("Entities", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpIsAuthorizedWithTokenInput(v *IsAuthorizedWithTokenInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IsAuthorizedWithTokenInput"}
	if v.PolicyStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyStoreId"))
	}
	if v.Action != nil {
		if err := validateActionIdentifier(v.Action); err != nil {
			invalidParams.AddNested("Action", err.(smithy.InvalidParamsError))
		}
	}
	if v.Resource != nil {
		if err := validateEntityIdentifier(v.Resource); err != nil {
			invalidParams.AddNested("Resource", err.(smithy.InvalidParamsError))
		}
	}
	if v.Context != nil {
		if err := validateContextDefinition(v.Context); err != nil {
			invalidParams.AddNested("Context", err.(smithy.InvalidParamsError))
		}
	}
	if v.Entities != nil {
		if err := validateEntitiesDefinition(v.Entities); err != nil {
			invalidParams.AddNested("Entities", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListPoliciesInput(v *ListPoliciesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListPoliciesInput"}
	if v.PolicyStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyStoreId"))
	}
	if v.Filter != nil {
		if err := validatePolicyFilter(v.Filter); err != nil {
			invalidParams.AddNested("Filter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpPutSchemaInput(v *PutSchemaInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutSchemaInput"}
	if v.PolicyStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyStoreId"))
	}
	if v.Definition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Definition"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpUpdateIdentitySourceInput(v *UpdateIdentitySourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateIdentitySourceInput"}
	if v.PolicyStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyStoreId"))
	}
	if v.IdentitySourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdentitySourceId"))
	}
	if v.UpdateConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UpdateConfiguration"))
	} else if v.UpdateConfiguration != nil {
		if err := validateUpdateConfiguration(v.UpdateConfiguration); err != nil {
			invalidParams.AddNested("UpdateConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdatePolicyInput(v *UpdatePolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePolicyInput"}
	if v.PolicyStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyStoreId"))
	}
	if v.PolicyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyId"))
	}
	if v.Definition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Definition"))
	} else if v.Definition != nil {
		if err := validateUpdatePolicyDefinition(v.Definition); err != nil {
			invalidParams.AddNested("Definition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdatePolicyStoreInput(v *UpdatePolicyStoreInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePolicyStoreInput"}
	if v.PolicyStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyStoreId"))
	}
	if v.ValidationSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ValidationSettings"))
	} else if v.ValidationSettings != nil {
		if err := validateValidationSettings(v.ValidationSettings); err != nil {
			invalidParams.AddNested("ValidationSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdatePolicyTemplateInput(v *UpdatePolicyTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePolicyTemplateInput"}
	if v.PolicyStoreId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyStoreId"))
	}
	if v.PolicyTemplateId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyTemplateId"))
	}
	if v.Statement == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Statement"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}