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

package rdsdata

import (
	"context"
	"fmt"
	smithy "github.com/aws/smithy-go"
	"github.com/aws/smithy-go/middleware"
)

type validateOpBatchExecuteStatement struct {
}

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

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

type validateOpBeginTransaction struct {
}

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

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

type validateOpCommitTransaction struct {
}

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

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

type validateOpExecuteSql struct {
}

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

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

type validateOpExecuteStatement struct {
}

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

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

type validateOpRollbackTransaction struct {
}

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

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

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

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

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

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

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

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

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

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

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

func validateOpExecuteSqlInput(v *ExecuteSqlInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExecuteSqlInput"}
	if v.DbClusterOrInstanceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DbClusterOrInstanceArn"))
	}
	if v.AwsSecretStoreArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsSecretStoreArn"))
	}
	if v.SqlStatements == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SqlStatements"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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