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

package lakeformation

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

type validateOpAddLFTagsToResource struct {
}

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

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

type validateOpAssumeDecoratedRoleWithSAML struct {
}

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

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

type validateOpBatchGrantPermissions struct {
}

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

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

type validateOpBatchRevokePermissions struct {
}

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

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

type validateOpCancelTransaction struct {
}

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

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

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

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

type validateOpCreateLFTag struct {
}

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

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

type validateOpDeleteLFTag struct {
}

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

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

type validateOpDeleteObjectsOnCancel struct {
}

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

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

type validateOpDeregisterResource struct {
}

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

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

type validateOpDescribeResource struct {
}

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

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

type validateOpDescribeTransaction struct {
}

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

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

type validateOpGetDataCellsFilter struct {
}

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

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

type validateOpGetEffectivePermissionsForPath struct {
}

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

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

type validateOpGetLFTag struct {
}

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

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

type validateOpGetQueryState struct {
}

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

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

type validateOpGetQueryStatistics struct {
}

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

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

type validateOpGetResourceLFTags struct {
}

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

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

type validateOpGetTableObjects struct {
}

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

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

type validateOpGetTemporaryGluePartitionCredentials struct {
}

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

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

type validateOpGetTemporaryGlueTableCredentials struct {
}

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

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

type validateOpGetWorkUnitResults struct {
}

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

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

type validateOpGetWorkUnits struct {
}

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

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

type validateOpGrantPermissions struct {
}

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

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

type validateOpListDataCellsFilter struct {
}

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

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

type validateOpListPermissions struct {
}

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

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

type validateOpListTableStorageOptimizers struct {
}

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

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

type validateOpPutDataLakeSettings struct {
}

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

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

type validateOpRegisterResource struct {
}

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

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

type validateOpRemoveLFTagsFromResource struct {
}

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

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

type validateOpRevokePermissions struct {
}

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

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

type validateOpSearchDatabasesByLFTags struct {
}

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

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

type validateOpSearchTablesByLFTags struct {
}

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

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

type validateOpStartQueryPlanning struct {
}

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

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

type validateOpUpdateDataCellsFilter struct {
}

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

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

type validateOpUpdateLFTag struct {
}

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

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

type validateOpUpdateResource struct {
}

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

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

type validateOpUpdateTableObjects struct {
}

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

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

type validateOpUpdateTableStorageOptimizer struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateAddObjectInput(v *types.AddObjectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddObjectInput"}
	if v.Uri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Uri"))
	}
	if v.ETag == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ETag"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBatchPermissionsRequestEntry(v *types.BatchPermissionsRequestEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchPermissionsRequestEntry"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.Resource != nil {
		if err := validateResource(v.Resource); err != nil {
			invalidParams.AddNested("Resource", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateDataCellsFilter(v *types.DataCellsFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataCellsFilter"}
	if v.TableCatalogId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableCatalogId"))
	}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateLFTag(v *types.LFTag) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LFTag"}
	if v.TagKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKey"))
	}
	if v.TagValues == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagValues"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLFTagKeyResource(v *types.LFTagKeyResource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LFTagKeyResource"}
	if v.TagKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKey"))
	}
	if v.TagValues == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagValues"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLFTagPair(v *types.LFTagPair) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LFTagPair"}
	if v.TagKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKey"))
	}
	if v.TagValues == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagValues"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLFTagPolicyResource(v *types.LFTagPolicyResource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LFTagPolicyResource"}
	if len(v.ResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if v.Expression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
	} else if v.Expression != nil {
		if err := validateExpression(v.Expression); err != nil {
			invalidParams.AddNested("Expression", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateResource(v *types.Resource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Resource"}
	if v.Database != nil {
		if err := validateDatabaseResource(v.Database); err != nil {
			invalidParams.AddNested("Database", err.(smithy.InvalidParamsError))
		}
	}
	if v.Table != nil {
		if err := validateTableResource(v.Table); err != nil {
			invalidParams.AddNested("Table", err.(smithy.InvalidParamsError))
		}
	}
	if v.TableWithColumns != nil {
		if err := validateTableWithColumnsResource(v.TableWithColumns); err != nil {
			invalidParams.AddNested("TableWithColumns", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataLocation != nil {
		if err := validateDataLocationResource(v.DataLocation); err != nil {
			invalidParams.AddNested("DataLocation", err.(smithy.InvalidParamsError))
		}
	}
	if v.LFTag != nil {
		if err := validateLFTagKeyResource(v.LFTag); err != nil {
			invalidParams.AddNested("LFTag", err.(smithy.InvalidParamsError))
		}
	}
	if v.LFTagPolicy != nil {
		if err := validateLFTagPolicyResource(v.LFTagPolicy); err != nil {
			invalidParams.AddNested("LFTagPolicy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateWriteOperation(v *types.WriteOperation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WriteOperation"}
	if v.AddObject != nil {
		if err := validateAddObjectInput(v.AddObject); err != nil {
			invalidParams.AddNested("AddObject", err.(smithy.InvalidParamsError))
		}
	}
	if v.DeleteObject != nil {
		if err := validateDeleteObjectInput(v.DeleteObject); err != nil {
			invalidParams.AddNested("DeleteObject", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpAddLFTagsToResourceInput(v *AddLFTagsToResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddLFTagsToResourceInput"}
	if v.Resource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resource"))
	} else if v.Resource != nil {
		if err := validateResource(v.Resource); err != nil {
			invalidParams.AddNested("Resource", err.(smithy.InvalidParamsError))
		}
	}
	if v.LFTags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LFTags"))
	} else if v.LFTags != nil {
		if err := validateLFTagsList(v.LFTags); err != nil {
			invalidParams.AddNested("LFTags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssumeDecoratedRoleWithSAMLInput(v *AssumeDecoratedRoleWithSAMLInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssumeDecoratedRoleWithSAMLInput"}
	if v.SAMLAssertion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SAMLAssertion"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.PrincipalArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrincipalArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchGrantPermissionsInput(v *BatchGrantPermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGrantPermissionsInput"}
	if v.Entries == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Entries"))
	} else if v.Entries != nil {
		if err := validateBatchPermissionsRequestEntryList(v.Entries); err != nil {
			invalidParams.AddNested("Entries", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchRevokePermissionsInput(v *BatchRevokePermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchRevokePermissionsInput"}
	if v.Entries == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Entries"))
	} else if v.Entries != nil {
		if err := validateBatchPermissionsRequestEntryList(v.Entries); err != nil {
			invalidParams.AddNested("Entries", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateDataCellsFilterInput(v *CreateDataCellsFilterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDataCellsFilterInput"}
	if v.TableData == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableData"))
	} else if v.TableData != nil {
		if err := validateDataCellsFilter(v.TableData); err != nil {
			invalidParams.AddNested("TableData", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLFTagInput(v *CreateLFTagInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLFTagInput"}
	if v.TagKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKey"))
	}
	if v.TagValues == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagValues"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteObjectsOnCancelInput(v *DeleteObjectsOnCancelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteObjectsOnCancelInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.TransactionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransactionId"))
	}
	if v.Objects == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Objects"))
	} else if v.Objects != nil {
		if err := validateVirtualObjectList(v.Objects); err != nil {
			invalidParams.AddNested("Objects", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpGetDataCellsFilterInput(v *GetDataCellsFilterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDataCellsFilterInput"}
	if v.TableCatalogId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableCatalogId"))
	}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpGetResourceLFTagsInput(v *GetResourceLFTagsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetResourceLFTagsInput"}
	if v.Resource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resource"))
	} else if v.Resource != nil {
		if err := validateResource(v.Resource); err != nil {
			invalidParams.AddNested("Resource", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetTableObjectsInput(v *GetTableObjectsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTableObjectsInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetTemporaryGluePartitionCredentialsInput(v *GetTemporaryGluePartitionCredentialsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTemporaryGluePartitionCredentialsInput"}
	if v.TableArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableArn"))
	}
	if v.Partition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Partition"))
	} else if v.Partition != nil {
		if err := validatePartitionValueList(v.Partition); err != nil {
			invalidParams.AddNested("Partition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetWorkUnitResultsInput(v *GetWorkUnitResultsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetWorkUnitResultsInput"}
	if v.QueryId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryId"))
	}
	if v.WorkUnitToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WorkUnitToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGrantPermissionsInput(v *GrantPermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GrantPermissionsInput"}
	if v.Principal == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Principal"))
	}
	if v.Resource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resource"))
	} else if v.Resource != nil {
		if err := validateResource(v.Resource); err != nil {
			invalidParams.AddNested("Resource", err.(smithy.InvalidParamsError))
		}
	}
	if v.Permissions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Permissions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDataCellsFilterInput(v *ListDataCellsFilterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDataCellsFilterInput"}
	if v.Table != nil {
		if err := validateTableResource(v.Table); err != nil {
			invalidParams.AddNested("Table", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListPermissionsInput(v *ListPermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListPermissionsInput"}
	if v.Resource != nil {
		if err := validateResource(v.Resource); err != nil {
			invalidParams.AddNested("Resource", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListTableStorageOptimizersInput(v *ListTableStorageOptimizersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTableStorageOptimizersInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpRemoveLFTagsFromResourceInput(v *RemoveLFTagsFromResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveLFTagsFromResourceInput"}
	if v.Resource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resource"))
	} else if v.Resource != nil {
		if err := validateResource(v.Resource); err != nil {
			invalidParams.AddNested("Resource", err.(smithy.InvalidParamsError))
		}
	}
	if v.LFTags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LFTags"))
	} else if v.LFTags != nil {
		if err := validateLFTagsList(v.LFTags); err != nil {
			invalidParams.AddNested("LFTags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRevokePermissionsInput(v *RevokePermissionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RevokePermissionsInput"}
	if v.Principal == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Principal"))
	}
	if v.Resource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resource"))
	} else if v.Resource != nil {
		if err := validateResource(v.Resource); err != nil {
			invalidParams.AddNested("Resource", err.(smithy.InvalidParamsError))
		}
	}
	if v.Permissions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Permissions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchDatabasesByLFTagsInput(v *SearchDatabasesByLFTagsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchDatabasesByLFTagsInput"}
	if v.Expression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
	} else if v.Expression != nil {
		if err := validateExpression(v.Expression); err != nil {
			invalidParams.AddNested("Expression", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchTablesByLFTagsInput(v *SearchTablesByLFTagsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchTablesByLFTagsInput"}
	if v.Expression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Expression"))
	} else if v.Expression != nil {
		if err := validateExpression(v.Expression); err != nil {
			invalidParams.AddNested("Expression", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartQueryPlanningInput(v *StartQueryPlanningInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartQueryPlanningInput"}
	if v.QueryPlanningContext == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryPlanningContext"))
	} else if v.QueryPlanningContext != nil {
		if err := validateQueryPlanningContext(v.QueryPlanningContext); err != nil {
			invalidParams.AddNested("QueryPlanningContext", err.(smithy.InvalidParamsError))
		}
	}
	if v.QueryString == nil {
		invalidParams.Add(smithy.NewErrParamRequired("QueryString"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDataCellsFilterInput(v *UpdateDataCellsFilterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDataCellsFilterInput"}
	if v.TableData == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableData"))
	} else if v.TableData != nil {
		if err := validateDataCellsFilter(v.TableData); err != nil {
			invalidParams.AddNested("TableData", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpUpdateTableObjectsInput(v *UpdateTableObjectsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTableObjectsInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.WriteOperations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WriteOperations"))
	} else if v.WriteOperations != nil {
		if err := validateWriteOperationList(v.WriteOperations); err != nil {
			invalidParams.AddNested("WriteOperations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateTableStorageOptimizerInput(v *UpdateTableStorageOptimizerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTableStorageOptimizerInput"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.TableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TableName"))
	}
	if v.StorageOptimizerConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StorageOptimizerConfig"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}