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

package ssoadmin

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

type validateOpAttachCustomerManagedPolicyReferenceToPermissionSet struct {
}

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

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

type validateOpAttachManagedPolicyToPermissionSet struct {
}

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

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

type validateOpCreateAccountAssignment struct {
}

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

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

type validateOpCreateInstanceAccessControlAttributeConfiguration struct {
}

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

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

type validateOpCreatePermissionSet struct {
}

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

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

type validateOpDeleteAccountAssignment struct {
}

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

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

type validateOpDeleteInlinePolicyFromPermissionSet struct {
}

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

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

type validateOpDeleteInstanceAccessControlAttributeConfiguration struct {
}

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

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

type validateOpDeletePermissionsBoundaryFromPermissionSet struct {
}

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

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

type validateOpDeletePermissionSet struct {
}

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

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

type validateOpDescribeAccountAssignmentCreationStatus struct {
}

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

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

type validateOpDescribeAccountAssignmentDeletionStatus struct {
}

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

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

type validateOpDescribeInstanceAccessControlAttributeConfiguration struct {
}

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

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

type validateOpDescribePermissionSet struct {
}

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

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

type validateOpDescribePermissionSetProvisioningStatus struct {
}

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

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

type validateOpDetachCustomerManagedPolicyReferenceFromPermissionSet struct {
}

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

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

type validateOpDetachManagedPolicyFromPermissionSet struct {
}

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

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

type validateOpGetInlinePolicyForPermissionSet struct {
}

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

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

type validateOpGetPermissionsBoundaryForPermissionSet struct {
}

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

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

type validateOpListAccountAssignmentCreationStatus struct {
}

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

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

type validateOpListAccountAssignmentDeletionStatus struct {
}

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

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

type validateOpListAccountAssignments struct {
}

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

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

type validateOpListAccountsForProvisionedPermissionSet struct {
}

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

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

type validateOpListCustomerManagedPolicyReferencesInPermissionSet struct {
}

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

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

type validateOpListManagedPoliciesInPermissionSet struct {
}

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

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

type validateOpListPermissionSetProvisioningStatus struct {
}

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

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

type validateOpListPermissionSets struct {
}

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

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

type validateOpListPermissionSetsProvisionedToAccount struct {
}

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

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

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

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

type validateOpPutInlinePolicyToPermissionSet struct {
}

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

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

type validateOpPutPermissionsBoundaryToPermissionSet struct {
}

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

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

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

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

type validateOpUpdatePermissionSet struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpPutPermissionsBoundaryToPermissionSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutPermissionsBoundaryToPermissionSet{}, 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 addOpUpdateInstanceAccessControlAttributeConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateInstanceAccessControlAttributeConfiguration{}, middleware.After)
}

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

func validateAccessControlAttribute(v *types.AccessControlAttribute) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AccessControlAttribute"}
	if v.Key == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Key"))
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	} else if v.Value != nil {
		if err := validateAccessControlAttributeValue(v.Value); err != nil {
			invalidParams.AddNested("Value", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateInstanceAccessControlAttributeConfiguration(v *types.InstanceAccessControlAttributeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InstanceAccessControlAttributeConfiguration"}
	if v.AccessControlAttributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessControlAttributes"))
	} else if v.AccessControlAttributes != nil {
		if err := validateAccessControlAttributeList(v.AccessControlAttributes); err != nil {
			invalidParams.AddNested("AccessControlAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePermissionsBoundary(v *types.PermissionsBoundary) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PermissionsBoundary"}
	if v.CustomerManagedPolicyReference != nil {
		if err := validateCustomerManagedPolicyReference(v.CustomerManagedPolicyReference); err != nil {
			invalidParams.AddNested("CustomerManagedPolicyReference", 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 validateTagList(v []types.Tag) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
	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 validateOpAttachCustomerManagedPolicyReferenceToPermissionSetInput(v *AttachCustomerManagedPolicyReferenceToPermissionSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachCustomerManagedPolicyReferenceToPermissionSetInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.PermissionSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionSetArn"))
	}
	if v.CustomerManagedPolicyReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CustomerManagedPolicyReference"))
	} else if v.CustomerManagedPolicyReference != nil {
		if err := validateCustomerManagedPolicyReference(v.CustomerManagedPolicyReference); err != nil {
			invalidParams.AddNested("CustomerManagedPolicyReference", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAttachManagedPolicyToPermissionSetInput(v *AttachManagedPolicyToPermissionSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachManagedPolicyToPermissionSetInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.PermissionSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionSetArn"))
	}
	if v.ManagedPolicyArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ManagedPolicyArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAccountAssignmentInput(v *CreateAccountAssignmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAccountAssignmentInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.TargetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetId"))
	}
	if len(v.TargetType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TargetType"))
	}
	if v.PermissionSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionSetArn"))
	}
	if len(v.PrincipalType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalType"))
	}
	if v.PrincipalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateInstanceAccessControlAttributeConfigurationInput(v *CreateInstanceAccessControlAttributeConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateInstanceAccessControlAttributeConfigurationInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.InstanceAccessControlAttributeConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceAccessControlAttributeConfiguration"))
	} else if v.InstanceAccessControlAttributeConfiguration != nil {
		if err := validateInstanceAccessControlAttributeConfiguration(v.InstanceAccessControlAttributeConfiguration); err != nil {
			invalidParams.AddNested("InstanceAccessControlAttributeConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreatePermissionSetInput(v *CreatePermissionSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreatePermissionSetInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteAccountAssignmentInput(v *DeleteAccountAssignmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAccountAssignmentInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.TargetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetId"))
	}
	if len(v.TargetType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TargetType"))
	}
	if v.PermissionSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionSetArn"))
	}
	if len(v.PrincipalType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalType"))
	}
	if v.PrincipalId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteInlinePolicyFromPermissionSetInput(v *DeleteInlinePolicyFromPermissionSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteInlinePolicyFromPermissionSetInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.PermissionSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionSetArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeletePermissionsBoundaryFromPermissionSetInput(v *DeletePermissionsBoundaryFromPermissionSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeletePermissionsBoundaryFromPermissionSetInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.PermissionSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionSetArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeletePermissionSetInput(v *DeletePermissionSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeletePermissionSetInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.PermissionSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionSetArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeAccountAssignmentCreationStatusInput(v *DescribeAccountAssignmentCreationStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeAccountAssignmentCreationStatusInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.AccountAssignmentCreationRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountAssignmentCreationRequestId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeAccountAssignmentDeletionStatusInput(v *DescribeAccountAssignmentDeletionStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeAccountAssignmentDeletionStatusInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.AccountAssignmentDeletionRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountAssignmentDeletionRequestId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDescribePermissionSetInput(v *DescribePermissionSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribePermissionSetInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.PermissionSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionSetArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribePermissionSetProvisioningStatusInput(v *DescribePermissionSetProvisioningStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribePermissionSetProvisioningStatusInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.ProvisionPermissionSetRequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProvisionPermissionSetRequestId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDetachCustomerManagedPolicyReferenceFromPermissionSetInput(v *DetachCustomerManagedPolicyReferenceFromPermissionSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DetachCustomerManagedPolicyReferenceFromPermissionSetInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.PermissionSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionSetArn"))
	}
	if v.CustomerManagedPolicyReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CustomerManagedPolicyReference"))
	} else if v.CustomerManagedPolicyReference != nil {
		if err := validateCustomerManagedPolicyReference(v.CustomerManagedPolicyReference); err != nil {
			invalidParams.AddNested("CustomerManagedPolicyReference", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDetachManagedPolicyFromPermissionSetInput(v *DetachManagedPolicyFromPermissionSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DetachManagedPolicyFromPermissionSetInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.PermissionSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionSetArn"))
	}
	if v.ManagedPolicyArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ManagedPolicyArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetInlinePolicyForPermissionSetInput(v *GetInlinePolicyForPermissionSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetInlinePolicyForPermissionSetInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.PermissionSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionSetArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetPermissionsBoundaryForPermissionSetInput(v *GetPermissionsBoundaryForPermissionSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetPermissionsBoundaryForPermissionSetInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.PermissionSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionSetArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListAccountAssignmentsInput(v *ListAccountAssignmentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAccountAssignmentsInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.PermissionSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionSetArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListAccountsForProvisionedPermissionSetInput(v *ListAccountsForProvisionedPermissionSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAccountsForProvisionedPermissionSetInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.PermissionSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionSetArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListCustomerManagedPolicyReferencesInPermissionSetInput(v *ListCustomerManagedPolicyReferencesInPermissionSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListCustomerManagedPolicyReferencesInPermissionSetInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.PermissionSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionSetArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListManagedPoliciesInPermissionSetInput(v *ListManagedPoliciesInPermissionSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListManagedPoliciesInPermissionSetInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.PermissionSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionSetArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListPermissionSetsProvisionedToAccountInput(v *ListPermissionSetsProvisionedToAccountInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListPermissionSetsProvisionedToAccountInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	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.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpProvisionPermissionSetInput(v *ProvisionPermissionSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProvisionPermissionSetInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.PermissionSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionSetArn"))
	}
	if len(v.TargetType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TargetType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutInlinePolicyToPermissionSetInput(v *PutInlinePolicyToPermissionSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutInlinePolicyToPermissionSetInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.PermissionSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionSetArn"))
	}
	if v.InlinePolicy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InlinePolicy"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutPermissionsBoundaryToPermissionSetInput(v *PutPermissionsBoundaryToPermissionSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutPermissionsBoundaryToPermissionSetInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.PermissionSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionSetArn"))
	}
	if v.PermissionsBoundary == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionsBoundary"))
	} else if v.PermissionsBoundary != nil {
		if err := validatePermissionsBoundary(v.PermissionsBoundary); err != nil {
			invalidParams.AddNested("PermissionsBoundary", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUntagResourceInput(v *UntagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	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 validateOpUpdateInstanceAccessControlAttributeConfigurationInput(v *UpdateInstanceAccessControlAttributeConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateInstanceAccessControlAttributeConfigurationInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.InstanceAccessControlAttributeConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceAccessControlAttributeConfiguration"))
	} else if v.InstanceAccessControlAttributeConfiguration != nil {
		if err := validateInstanceAccessControlAttributeConfiguration(v.InstanceAccessControlAttributeConfiguration); err != nil {
			invalidParams.AddNested("InstanceAccessControlAttributeConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdatePermissionSetInput(v *UpdatePermissionSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePermissionSetInput"}
	if v.InstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InstanceArn"))
	}
	if v.PermissionSetArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PermissionSetArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}