// Code generated by mockery v1.0.0. DO NOT EDIT.

package aws

import (
	context "context"

	dynamodb "github.com/aws/aws-sdk-go/service/dynamodb"
	mock "github.com/stretchr/testify/mock"

	request "github.com/aws/aws-sdk-go/aws/request"
)

// MockFakeDynamoDB is an autogenerated mock type for the FakeDynamoDB type
type MockFakeDynamoDB struct {
	mock.Mock
}

// BatchExecuteStatement provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) BatchExecuteStatement(_a0 *dynamodb.BatchExecuteStatementInput) (*dynamodb.BatchExecuteStatementOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.BatchExecuteStatementOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.BatchExecuteStatementInput) *dynamodb.BatchExecuteStatementOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.BatchExecuteStatementOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.BatchExecuteStatementInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// BatchExecuteStatementRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) BatchExecuteStatementRequest(_a0 *dynamodb.BatchExecuteStatementInput) (*request.Request, *dynamodb.BatchExecuteStatementOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.BatchExecuteStatementInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.BatchExecuteStatementOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.BatchExecuteStatementInput) *dynamodb.BatchExecuteStatementOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.BatchExecuteStatementOutput)
		}
	}

	return r0, r1
}

// BatchExecuteStatementWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) BatchExecuteStatementWithContext(_a0 context.Context, _a1 *dynamodb.BatchExecuteStatementInput, _a2 ...request.Option) (*dynamodb.BatchExecuteStatementOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.BatchExecuteStatementOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.BatchExecuteStatementInput, ...request.Option) *dynamodb.BatchExecuteStatementOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.BatchExecuteStatementOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.BatchExecuteStatementInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// BatchGetItem provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) BatchGetItem(_a0 *dynamodb.BatchGetItemInput) (*dynamodb.BatchGetItemOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.BatchGetItemOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.BatchGetItemInput) *dynamodb.BatchGetItemOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.BatchGetItemOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.BatchGetItemInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// BatchGetItemPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeDynamoDB) BatchGetItemPages(_a0 *dynamodb.BatchGetItemInput, _a1 func(*dynamodb.BatchGetItemOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*dynamodb.BatchGetItemInput, func(*dynamodb.BatchGetItemOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// BatchGetItemPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeDynamoDB) BatchGetItemPagesWithContext(_a0 context.Context, _a1 *dynamodb.BatchGetItemInput, _a2 func(*dynamodb.BatchGetItemOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.BatchGetItemInput, func(*dynamodb.BatchGetItemOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// BatchGetItemRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) BatchGetItemRequest(_a0 *dynamodb.BatchGetItemInput) (*request.Request, *dynamodb.BatchGetItemOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.BatchGetItemInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.BatchGetItemOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.BatchGetItemInput) *dynamodb.BatchGetItemOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.BatchGetItemOutput)
		}
	}

	return r0, r1
}

// BatchGetItemWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) BatchGetItemWithContext(_a0 context.Context, _a1 *dynamodb.BatchGetItemInput, _a2 ...request.Option) (*dynamodb.BatchGetItemOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.BatchGetItemOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.BatchGetItemInput, ...request.Option) *dynamodb.BatchGetItemOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.BatchGetItemOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.BatchGetItemInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// BatchWriteItem provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) BatchWriteItem(_a0 *dynamodb.BatchWriteItemInput) (*dynamodb.BatchWriteItemOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.BatchWriteItemOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.BatchWriteItemInput) *dynamodb.BatchWriteItemOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.BatchWriteItemOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.BatchWriteItemInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// BatchWriteItemRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) BatchWriteItemRequest(_a0 *dynamodb.BatchWriteItemInput) (*request.Request, *dynamodb.BatchWriteItemOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.BatchWriteItemInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.BatchWriteItemOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.BatchWriteItemInput) *dynamodb.BatchWriteItemOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.BatchWriteItemOutput)
		}
	}

	return r0, r1
}

// BatchWriteItemWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) BatchWriteItemWithContext(_a0 context.Context, _a1 *dynamodb.BatchWriteItemInput, _a2 ...request.Option) (*dynamodb.BatchWriteItemOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.BatchWriteItemOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.BatchWriteItemInput, ...request.Option) *dynamodb.BatchWriteItemOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.BatchWriteItemOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.BatchWriteItemInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateBackup provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) CreateBackup(_a0 *dynamodb.CreateBackupInput) (*dynamodb.CreateBackupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.CreateBackupOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.CreateBackupInput) *dynamodb.CreateBackupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.CreateBackupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.CreateBackupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateBackupRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) CreateBackupRequest(_a0 *dynamodb.CreateBackupInput) (*request.Request, *dynamodb.CreateBackupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.CreateBackupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.CreateBackupOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.CreateBackupInput) *dynamodb.CreateBackupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.CreateBackupOutput)
		}
	}

	return r0, r1
}

// CreateBackupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) CreateBackupWithContext(_a0 context.Context, _a1 *dynamodb.CreateBackupInput, _a2 ...request.Option) (*dynamodb.CreateBackupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.CreateBackupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.CreateBackupInput, ...request.Option) *dynamodb.CreateBackupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.CreateBackupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.CreateBackupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateGlobalTable provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) CreateGlobalTable(_a0 *dynamodb.CreateGlobalTableInput) (*dynamodb.CreateGlobalTableOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.CreateGlobalTableOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.CreateGlobalTableInput) *dynamodb.CreateGlobalTableOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.CreateGlobalTableOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.CreateGlobalTableInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateGlobalTableRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) CreateGlobalTableRequest(_a0 *dynamodb.CreateGlobalTableInput) (*request.Request, *dynamodb.CreateGlobalTableOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.CreateGlobalTableInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.CreateGlobalTableOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.CreateGlobalTableInput) *dynamodb.CreateGlobalTableOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.CreateGlobalTableOutput)
		}
	}

	return r0, r1
}

// CreateGlobalTableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) CreateGlobalTableWithContext(_a0 context.Context, _a1 *dynamodb.CreateGlobalTableInput, _a2 ...request.Option) (*dynamodb.CreateGlobalTableOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.CreateGlobalTableOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.CreateGlobalTableInput, ...request.Option) *dynamodb.CreateGlobalTableOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.CreateGlobalTableOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.CreateGlobalTableInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateTable provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) CreateTable(_a0 *dynamodb.CreateTableInput) (*dynamodb.CreateTableOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.CreateTableOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.CreateTableInput) *dynamodb.CreateTableOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.CreateTableOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.CreateTableInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateTableRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) CreateTableRequest(_a0 *dynamodb.CreateTableInput) (*request.Request, *dynamodb.CreateTableOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.CreateTableInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.CreateTableOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.CreateTableInput) *dynamodb.CreateTableOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.CreateTableOutput)
		}
	}

	return r0, r1
}

// CreateTableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) CreateTableWithContext(_a0 context.Context, _a1 *dynamodb.CreateTableInput, _a2 ...request.Option) (*dynamodb.CreateTableOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.CreateTableOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.CreateTableInput, ...request.Option) *dynamodb.CreateTableOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.CreateTableOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.CreateTableInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteBackup provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DeleteBackup(_a0 *dynamodb.DeleteBackupInput) (*dynamodb.DeleteBackupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.DeleteBackupOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.DeleteBackupInput) *dynamodb.DeleteBackupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DeleteBackupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.DeleteBackupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteBackupRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DeleteBackupRequest(_a0 *dynamodb.DeleteBackupInput) (*request.Request, *dynamodb.DeleteBackupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.DeleteBackupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.DeleteBackupOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.DeleteBackupInput) *dynamodb.DeleteBackupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.DeleteBackupOutput)
		}
	}

	return r0, r1
}

// DeleteBackupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) DeleteBackupWithContext(_a0 context.Context, _a1 *dynamodb.DeleteBackupInput, _a2 ...request.Option) (*dynamodb.DeleteBackupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.DeleteBackupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.DeleteBackupInput, ...request.Option) *dynamodb.DeleteBackupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DeleteBackupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.DeleteBackupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteItem provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DeleteItem(_a0 *dynamodb.DeleteItemInput) (*dynamodb.DeleteItemOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.DeleteItemOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.DeleteItemInput) *dynamodb.DeleteItemOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DeleteItemOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.DeleteItemInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteItemRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DeleteItemRequest(_a0 *dynamodb.DeleteItemInput) (*request.Request, *dynamodb.DeleteItemOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.DeleteItemInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.DeleteItemOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.DeleteItemInput) *dynamodb.DeleteItemOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.DeleteItemOutput)
		}
	}

	return r0, r1
}

// DeleteItemWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) DeleteItemWithContext(_a0 context.Context, _a1 *dynamodb.DeleteItemInput, _a2 ...request.Option) (*dynamodb.DeleteItemOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.DeleteItemOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.DeleteItemInput, ...request.Option) *dynamodb.DeleteItemOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DeleteItemOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.DeleteItemInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteTable provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DeleteTable(_a0 *dynamodb.DeleteTableInput) (*dynamodb.DeleteTableOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.DeleteTableOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.DeleteTableInput) *dynamodb.DeleteTableOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DeleteTableOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.DeleteTableInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteTableRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DeleteTableRequest(_a0 *dynamodb.DeleteTableInput) (*request.Request, *dynamodb.DeleteTableOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.DeleteTableInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.DeleteTableOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.DeleteTableInput) *dynamodb.DeleteTableOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.DeleteTableOutput)
		}
	}

	return r0, r1
}

// DeleteTableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) DeleteTableWithContext(_a0 context.Context, _a1 *dynamodb.DeleteTableInput, _a2 ...request.Option) (*dynamodb.DeleteTableOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.DeleteTableOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.DeleteTableInput, ...request.Option) *dynamodb.DeleteTableOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DeleteTableOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.DeleteTableInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeBackup provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeBackup(_a0 *dynamodb.DescribeBackupInput) (*dynamodb.DescribeBackupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.DescribeBackupOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeBackupInput) *dynamodb.DescribeBackupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeBackupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeBackupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeBackupRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeBackupRequest(_a0 *dynamodb.DescribeBackupInput) (*request.Request, *dynamodb.DescribeBackupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeBackupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.DescribeBackupOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeBackupInput) *dynamodb.DescribeBackupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.DescribeBackupOutput)
		}
	}

	return r0, r1
}

// DescribeBackupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) DescribeBackupWithContext(_a0 context.Context, _a1 *dynamodb.DescribeBackupInput, _a2 ...request.Option) (*dynamodb.DescribeBackupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.DescribeBackupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.DescribeBackupInput, ...request.Option) *dynamodb.DescribeBackupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeBackupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.DescribeBackupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeContinuousBackups provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeContinuousBackups(_a0 *dynamodb.DescribeContinuousBackupsInput) (*dynamodb.DescribeContinuousBackupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.DescribeContinuousBackupsOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeContinuousBackupsInput) *dynamodb.DescribeContinuousBackupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeContinuousBackupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeContinuousBackupsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeContinuousBackupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeContinuousBackupsRequest(_a0 *dynamodb.DescribeContinuousBackupsInput) (*request.Request, *dynamodb.DescribeContinuousBackupsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeContinuousBackupsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.DescribeContinuousBackupsOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeContinuousBackupsInput) *dynamodb.DescribeContinuousBackupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.DescribeContinuousBackupsOutput)
		}
	}

	return r0, r1
}

// DescribeContinuousBackupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) DescribeContinuousBackupsWithContext(_a0 context.Context, _a1 *dynamodb.DescribeContinuousBackupsInput, _a2 ...request.Option) (*dynamodb.DescribeContinuousBackupsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.DescribeContinuousBackupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.DescribeContinuousBackupsInput, ...request.Option) *dynamodb.DescribeContinuousBackupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeContinuousBackupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.DescribeContinuousBackupsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeContributorInsights provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeContributorInsights(_a0 *dynamodb.DescribeContributorInsightsInput) (*dynamodb.DescribeContributorInsightsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.DescribeContributorInsightsOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeContributorInsightsInput) *dynamodb.DescribeContributorInsightsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeContributorInsightsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeContributorInsightsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeContributorInsightsRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeContributorInsightsRequest(_a0 *dynamodb.DescribeContributorInsightsInput) (*request.Request, *dynamodb.DescribeContributorInsightsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeContributorInsightsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.DescribeContributorInsightsOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeContributorInsightsInput) *dynamodb.DescribeContributorInsightsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.DescribeContributorInsightsOutput)
		}
	}

	return r0, r1
}

// DescribeContributorInsightsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) DescribeContributorInsightsWithContext(_a0 context.Context, _a1 *dynamodb.DescribeContributorInsightsInput, _a2 ...request.Option) (*dynamodb.DescribeContributorInsightsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.DescribeContributorInsightsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.DescribeContributorInsightsInput, ...request.Option) *dynamodb.DescribeContributorInsightsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeContributorInsightsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.DescribeContributorInsightsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeEndpoints provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeEndpoints(_a0 *dynamodb.DescribeEndpointsInput) (*dynamodb.DescribeEndpointsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.DescribeEndpointsOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeEndpointsInput) *dynamodb.DescribeEndpointsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeEndpointsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeEndpointsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeEndpointsRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeEndpointsRequest(_a0 *dynamodb.DescribeEndpointsInput) (*request.Request, *dynamodb.DescribeEndpointsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeEndpointsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.DescribeEndpointsOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeEndpointsInput) *dynamodb.DescribeEndpointsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.DescribeEndpointsOutput)
		}
	}

	return r0, r1
}

// DescribeEndpointsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) DescribeEndpointsWithContext(_a0 context.Context, _a1 *dynamodb.DescribeEndpointsInput, _a2 ...request.Option) (*dynamodb.DescribeEndpointsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.DescribeEndpointsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.DescribeEndpointsInput, ...request.Option) *dynamodb.DescribeEndpointsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeEndpointsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.DescribeEndpointsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeExport provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeExport(_a0 *dynamodb.DescribeExportInput) (*dynamodb.DescribeExportOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.DescribeExportOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeExportInput) *dynamodb.DescribeExportOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeExportOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeExportInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeExportRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeExportRequest(_a0 *dynamodb.DescribeExportInput) (*request.Request, *dynamodb.DescribeExportOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeExportInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.DescribeExportOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeExportInput) *dynamodb.DescribeExportOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.DescribeExportOutput)
		}
	}

	return r0, r1
}

// DescribeExportWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) DescribeExportWithContext(_a0 context.Context, _a1 *dynamodb.DescribeExportInput, _a2 ...request.Option) (*dynamodb.DescribeExportOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.DescribeExportOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.DescribeExportInput, ...request.Option) *dynamodb.DescribeExportOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeExportOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.DescribeExportInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeGlobalTable provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeGlobalTable(_a0 *dynamodb.DescribeGlobalTableInput) (*dynamodb.DescribeGlobalTableOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.DescribeGlobalTableOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeGlobalTableInput) *dynamodb.DescribeGlobalTableOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeGlobalTableOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeGlobalTableInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeGlobalTableRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeGlobalTableRequest(_a0 *dynamodb.DescribeGlobalTableInput) (*request.Request, *dynamodb.DescribeGlobalTableOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeGlobalTableInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.DescribeGlobalTableOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeGlobalTableInput) *dynamodb.DescribeGlobalTableOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.DescribeGlobalTableOutput)
		}
	}

	return r0, r1
}

// DescribeGlobalTableSettings provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeGlobalTableSettings(_a0 *dynamodb.DescribeGlobalTableSettingsInput) (*dynamodb.DescribeGlobalTableSettingsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.DescribeGlobalTableSettingsOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeGlobalTableSettingsInput) *dynamodb.DescribeGlobalTableSettingsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeGlobalTableSettingsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeGlobalTableSettingsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeGlobalTableSettingsRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeGlobalTableSettingsRequest(_a0 *dynamodb.DescribeGlobalTableSettingsInput) (*request.Request, *dynamodb.DescribeGlobalTableSettingsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeGlobalTableSettingsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.DescribeGlobalTableSettingsOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeGlobalTableSettingsInput) *dynamodb.DescribeGlobalTableSettingsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.DescribeGlobalTableSettingsOutput)
		}
	}

	return r0, r1
}

// DescribeGlobalTableSettingsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) DescribeGlobalTableSettingsWithContext(_a0 context.Context, _a1 *dynamodb.DescribeGlobalTableSettingsInput, _a2 ...request.Option) (*dynamodb.DescribeGlobalTableSettingsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.DescribeGlobalTableSettingsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.DescribeGlobalTableSettingsInput, ...request.Option) *dynamodb.DescribeGlobalTableSettingsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeGlobalTableSettingsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.DescribeGlobalTableSettingsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeGlobalTableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) DescribeGlobalTableWithContext(_a0 context.Context, _a1 *dynamodb.DescribeGlobalTableInput, _a2 ...request.Option) (*dynamodb.DescribeGlobalTableOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.DescribeGlobalTableOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.DescribeGlobalTableInput, ...request.Option) *dynamodb.DescribeGlobalTableOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeGlobalTableOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.DescribeGlobalTableInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeKinesisStreamingDestination provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeKinesisStreamingDestination(_a0 *dynamodb.DescribeKinesisStreamingDestinationInput) (*dynamodb.DescribeKinesisStreamingDestinationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.DescribeKinesisStreamingDestinationOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeKinesisStreamingDestinationInput) *dynamodb.DescribeKinesisStreamingDestinationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeKinesisStreamingDestinationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeKinesisStreamingDestinationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeKinesisStreamingDestinationRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeKinesisStreamingDestinationRequest(_a0 *dynamodb.DescribeKinesisStreamingDestinationInput) (*request.Request, *dynamodb.DescribeKinesisStreamingDestinationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeKinesisStreamingDestinationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.DescribeKinesisStreamingDestinationOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeKinesisStreamingDestinationInput) *dynamodb.DescribeKinesisStreamingDestinationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.DescribeKinesisStreamingDestinationOutput)
		}
	}

	return r0, r1
}

// DescribeKinesisStreamingDestinationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) DescribeKinesisStreamingDestinationWithContext(_a0 context.Context, _a1 *dynamodb.DescribeKinesisStreamingDestinationInput, _a2 ...request.Option) (*dynamodb.DescribeKinesisStreamingDestinationOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.DescribeKinesisStreamingDestinationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.DescribeKinesisStreamingDestinationInput, ...request.Option) *dynamodb.DescribeKinesisStreamingDestinationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeKinesisStreamingDestinationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.DescribeKinesisStreamingDestinationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeLimits provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeLimits(_a0 *dynamodb.DescribeLimitsInput) (*dynamodb.DescribeLimitsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.DescribeLimitsOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeLimitsInput) *dynamodb.DescribeLimitsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeLimitsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeLimitsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeLimitsRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeLimitsRequest(_a0 *dynamodb.DescribeLimitsInput) (*request.Request, *dynamodb.DescribeLimitsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeLimitsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.DescribeLimitsOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeLimitsInput) *dynamodb.DescribeLimitsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.DescribeLimitsOutput)
		}
	}

	return r0, r1
}

// DescribeLimitsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) DescribeLimitsWithContext(_a0 context.Context, _a1 *dynamodb.DescribeLimitsInput, _a2 ...request.Option) (*dynamodb.DescribeLimitsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.DescribeLimitsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.DescribeLimitsInput, ...request.Option) *dynamodb.DescribeLimitsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeLimitsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.DescribeLimitsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTable provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeTable(_a0 *dynamodb.DescribeTableInput) (*dynamodb.DescribeTableOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.DescribeTableOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeTableInput) *dynamodb.DescribeTableOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeTableOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeTableInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTableReplicaAutoScaling provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeTableReplicaAutoScaling(_a0 *dynamodb.DescribeTableReplicaAutoScalingInput) (*dynamodb.DescribeTableReplicaAutoScalingOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.DescribeTableReplicaAutoScalingOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeTableReplicaAutoScalingInput) *dynamodb.DescribeTableReplicaAutoScalingOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeTableReplicaAutoScalingOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeTableReplicaAutoScalingInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTableReplicaAutoScalingRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeTableReplicaAutoScalingRequest(_a0 *dynamodb.DescribeTableReplicaAutoScalingInput) (*request.Request, *dynamodb.DescribeTableReplicaAutoScalingOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeTableReplicaAutoScalingInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.DescribeTableReplicaAutoScalingOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeTableReplicaAutoScalingInput) *dynamodb.DescribeTableReplicaAutoScalingOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.DescribeTableReplicaAutoScalingOutput)
		}
	}

	return r0, r1
}

// DescribeTableReplicaAutoScalingWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) DescribeTableReplicaAutoScalingWithContext(_a0 context.Context, _a1 *dynamodb.DescribeTableReplicaAutoScalingInput, _a2 ...request.Option) (*dynamodb.DescribeTableReplicaAutoScalingOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.DescribeTableReplicaAutoScalingOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.DescribeTableReplicaAutoScalingInput, ...request.Option) *dynamodb.DescribeTableReplicaAutoScalingOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeTableReplicaAutoScalingOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.DescribeTableReplicaAutoScalingInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTableRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeTableRequest(_a0 *dynamodb.DescribeTableInput) (*request.Request, *dynamodb.DescribeTableOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeTableInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.DescribeTableOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeTableInput) *dynamodb.DescribeTableOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.DescribeTableOutput)
		}
	}

	return r0, r1
}

// DescribeTableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) DescribeTableWithContext(_a0 context.Context, _a1 *dynamodb.DescribeTableInput, _a2 ...request.Option) (*dynamodb.DescribeTableOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.DescribeTableOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.DescribeTableInput, ...request.Option) *dynamodb.DescribeTableOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeTableOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.DescribeTableInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTimeToLive provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeTimeToLive(_a0 *dynamodb.DescribeTimeToLiveInput) (*dynamodb.DescribeTimeToLiveOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.DescribeTimeToLiveOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeTimeToLiveInput) *dynamodb.DescribeTimeToLiveOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeTimeToLiveOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeTimeToLiveInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeTimeToLiveRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DescribeTimeToLiveRequest(_a0 *dynamodb.DescribeTimeToLiveInput) (*request.Request, *dynamodb.DescribeTimeToLiveOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeTimeToLiveInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.DescribeTimeToLiveOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.DescribeTimeToLiveInput) *dynamodb.DescribeTimeToLiveOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.DescribeTimeToLiveOutput)
		}
	}

	return r0, r1
}

// DescribeTimeToLiveWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) DescribeTimeToLiveWithContext(_a0 context.Context, _a1 *dynamodb.DescribeTimeToLiveInput, _a2 ...request.Option) (*dynamodb.DescribeTimeToLiveOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.DescribeTimeToLiveOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.DescribeTimeToLiveInput, ...request.Option) *dynamodb.DescribeTimeToLiveOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DescribeTimeToLiveOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.DescribeTimeToLiveInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisableKinesisStreamingDestination provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DisableKinesisStreamingDestination(_a0 *dynamodb.DisableKinesisStreamingDestinationInput) (*dynamodb.DisableKinesisStreamingDestinationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.DisableKinesisStreamingDestinationOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.DisableKinesisStreamingDestinationInput) *dynamodb.DisableKinesisStreamingDestinationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DisableKinesisStreamingDestinationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.DisableKinesisStreamingDestinationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisableKinesisStreamingDestinationRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) DisableKinesisStreamingDestinationRequest(_a0 *dynamodb.DisableKinesisStreamingDestinationInput) (*request.Request, *dynamodb.DisableKinesisStreamingDestinationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.DisableKinesisStreamingDestinationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.DisableKinesisStreamingDestinationOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.DisableKinesisStreamingDestinationInput) *dynamodb.DisableKinesisStreamingDestinationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.DisableKinesisStreamingDestinationOutput)
		}
	}

	return r0, r1
}

// DisableKinesisStreamingDestinationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) DisableKinesisStreamingDestinationWithContext(_a0 context.Context, _a1 *dynamodb.DisableKinesisStreamingDestinationInput, _a2 ...request.Option) (*dynamodb.DisableKinesisStreamingDestinationOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.DisableKinesisStreamingDestinationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.DisableKinesisStreamingDestinationInput, ...request.Option) *dynamodb.DisableKinesisStreamingDestinationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.DisableKinesisStreamingDestinationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.DisableKinesisStreamingDestinationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableKinesisStreamingDestination provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) EnableKinesisStreamingDestination(_a0 *dynamodb.EnableKinesisStreamingDestinationInput) (*dynamodb.EnableKinesisStreamingDestinationOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.EnableKinesisStreamingDestinationOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.EnableKinesisStreamingDestinationInput) *dynamodb.EnableKinesisStreamingDestinationOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.EnableKinesisStreamingDestinationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.EnableKinesisStreamingDestinationInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// EnableKinesisStreamingDestinationRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) EnableKinesisStreamingDestinationRequest(_a0 *dynamodb.EnableKinesisStreamingDestinationInput) (*request.Request, *dynamodb.EnableKinesisStreamingDestinationOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.EnableKinesisStreamingDestinationInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.EnableKinesisStreamingDestinationOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.EnableKinesisStreamingDestinationInput) *dynamodb.EnableKinesisStreamingDestinationOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.EnableKinesisStreamingDestinationOutput)
		}
	}

	return r0, r1
}

// EnableKinesisStreamingDestinationWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) EnableKinesisStreamingDestinationWithContext(_a0 context.Context, _a1 *dynamodb.EnableKinesisStreamingDestinationInput, _a2 ...request.Option) (*dynamodb.EnableKinesisStreamingDestinationOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.EnableKinesisStreamingDestinationOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.EnableKinesisStreamingDestinationInput, ...request.Option) *dynamodb.EnableKinesisStreamingDestinationOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.EnableKinesisStreamingDestinationOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.EnableKinesisStreamingDestinationInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ExecuteStatement provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) ExecuteStatement(_a0 *dynamodb.ExecuteStatementInput) (*dynamodb.ExecuteStatementOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.ExecuteStatementOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.ExecuteStatementInput) *dynamodb.ExecuteStatementOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.ExecuteStatementOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.ExecuteStatementInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ExecuteStatementRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) ExecuteStatementRequest(_a0 *dynamodb.ExecuteStatementInput) (*request.Request, *dynamodb.ExecuteStatementOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.ExecuteStatementInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.ExecuteStatementOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.ExecuteStatementInput) *dynamodb.ExecuteStatementOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.ExecuteStatementOutput)
		}
	}

	return r0, r1
}

// ExecuteStatementWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) ExecuteStatementWithContext(_a0 context.Context, _a1 *dynamodb.ExecuteStatementInput, _a2 ...request.Option) (*dynamodb.ExecuteStatementOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.ExecuteStatementOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.ExecuteStatementInput, ...request.Option) *dynamodb.ExecuteStatementOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.ExecuteStatementOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.ExecuteStatementInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ExecuteTransaction provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) ExecuteTransaction(_a0 *dynamodb.ExecuteTransactionInput) (*dynamodb.ExecuteTransactionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.ExecuteTransactionOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.ExecuteTransactionInput) *dynamodb.ExecuteTransactionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.ExecuteTransactionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.ExecuteTransactionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ExecuteTransactionRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) ExecuteTransactionRequest(_a0 *dynamodb.ExecuteTransactionInput) (*request.Request, *dynamodb.ExecuteTransactionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.ExecuteTransactionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.ExecuteTransactionOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.ExecuteTransactionInput) *dynamodb.ExecuteTransactionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.ExecuteTransactionOutput)
		}
	}

	return r0, r1
}

// ExecuteTransactionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) ExecuteTransactionWithContext(_a0 context.Context, _a1 *dynamodb.ExecuteTransactionInput, _a2 ...request.Option) (*dynamodb.ExecuteTransactionOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.ExecuteTransactionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.ExecuteTransactionInput, ...request.Option) *dynamodb.ExecuteTransactionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.ExecuteTransactionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.ExecuteTransactionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ExportTableToPointInTime provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) ExportTableToPointInTime(_a0 *dynamodb.ExportTableToPointInTimeInput) (*dynamodb.ExportTableToPointInTimeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.ExportTableToPointInTimeOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.ExportTableToPointInTimeInput) *dynamodb.ExportTableToPointInTimeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.ExportTableToPointInTimeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.ExportTableToPointInTimeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ExportTableToPointInTimeRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) ExportTableToPointInTimeRequest(_a0 *dynamodb.ExportTableToPointInTimeInput) (*request.Request, *dynamodb.ExportTableToPointInTimeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.ExportTableToPointInTimeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.ExportTableToPointInTimeOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.ExportTableToPointInTimeInput) *dynamodb.ExportTableToPointInTimeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.ExportTableToPointInTimeOutput)
		}
	}

	return r0, r1
}

// ExportTableToPointInTimeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) ExportTableToPointInTimeWithContext(_a0 context.Context, _a1 *dynamodb.ExportTableToPointInTimeInput, _a2 ...request.Option) (*dynamodb.ExportTableToPointInTimeOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.ExportTableToPointInTimeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.ExportTableToPointInTimeInput, ...request.Option) *dynamodb.ExportTableToPointInTimeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.ExportTableToPointInTimeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.ExportTableToPointInTimeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetItem provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) GetItem(_a0 *dynamodb.GetItemInput) (*dynamodb.GetItemOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.GetItemOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.GetItemInput) *dynamodb.GetItemOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.GetItemOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.GetItemInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetItemRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) GetItemRequest(_a0 *dynamodb.GetItemInput) (*request.Request, *dynamodb.GetItemOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.GetItemInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.GetItemOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.GetItemInput) *dynamodb.GetItemOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.GetItemOutput)
		}
	}

	return r0, r1
}

// GetItemWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) GetItemWithContext(_a0 context.Context, _a1 *dynamodb.GetItemInput, _a2 ...request.Option) (*dynamodb.GetItemOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.GetItemOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.GetItemInput, ...request.Option) *dynamodb.GetItemOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.GetItemOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.GetItemInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListBackups provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) ListBackups(_a0 *dynamodb.ListBackupsInput) (*dynamodb.ListBackupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.ListBackupsOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.ListBackupsInput) *dynamodb.ListBackupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.ListBackupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.ListBackupsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListBackupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) ListBackupsRequest(_a0 *dynamodb.ListBackupsInput) (*request.Request, *dynamodb.ListBackupsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.ListBackupsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.ListBackupsOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.ListBackupsInput) *dynamodb.ListBackupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.ListBackupsOutput)
		}
	}

	return r0, r1
}

// ListBackupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) ListBackupsWithContext(_a0 context.Context, _a1 *dynamodb.ListBackupsInput, _a2 ...request.Option) (*dynamodb.ListBackupsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.ListBackupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.ListBackupsInput, ...request.Option) *dynamodb.ListBackupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.ListBackupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.ListBackupsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListContributorInsights provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) ListContributorInsights(_a0 *dynamodb.ListContributorInsightsInput) (*dynamodb.ListContributorInsightsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.ListContributorInsightsOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.ListContributorInsightsInput) *dynamodb.ListContributorInsightsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.ListContributorInsightsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.ListContributorInsightsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListContributorInsightsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeDynamoDB) ListContributorInsightsPages(_a0 *dynamodb.ListContributorInsightsInput, _a1 func(*dynamodb.ListContributorInsightsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*dynamodb.ListContributorInsightsInput, func(*dynamodb.ListContributorInsightsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListContributorInsightsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeDynamoDB) ListContributorInsightsPagesWithContext(_a0 context.Context, _a1 *dynamodb.ListContributorInsightsInput, _a2 func(*dynamodb.ListContributorInsightsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.ListContributorInsightsInput, func(*dynamodb.ListContributorInsightsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListContributorInsightsRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) ListContributorInsightsRequest(_a0 *dynamodb.ListContributorInsightsInput) (*request.Request, *dynamodb.ListContributorInsightsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.ListContributorInsightsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.ListContributorInsightsOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.ListContributorInsightsInput) *dynamodb.ListContributorInsightsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.ListContributorInsightsOutput)
		}
	}

	return r0, r1
}

// ListContributorInsightsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) ListContributorInsightsWithContext(_a0 context.Context, _a1 *dynamodb.ListContributorInsightsInput, _a2 ...request.Option) (*dynamodb.ListContributorInsightsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.ListContributorInsightsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.ListContributorInsightsInput, ...request.Option) *dynamodb.ListContributorInsightsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.ListContributorInsightsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.ListContributorInsightsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListExports provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) ListExports(_a0 *dynamodb.ListExportsInput) (*dynamodb.ListExportsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.ListExportsOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.ListExportsInput) *dynamodb.ListExportsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.ListExportsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.ListExportsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListExportsPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeDynamoDB) ListExportsPages(_a0 *dynamodb.ListExportsInput, _a1 func(*dynamodb.ListExportsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*dynamodb.ListExportsInput, func(*dynamodb.ListExportsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListExportsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeDynamoDB) ListExportsPagesWithContext(_a0 context.Context, _a1 *dynamodb.ListExportsInput, _a2 func(*dynamodb.ListExportsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.ListExportsInput, func(*dynamodb.ListExportsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListExportsRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) ListExportsRequest(_a0 *dynamodb.ListExportsInput) (*request.Request, *dynamodb.ListExportsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.ListExportsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.ListExportsOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.ListExportsInput) *dynamodb.ListExportsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.ListExportsOutput)
		}
	}

	return r0, r1
}

// ListExportsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) ListExportsWithContext(_a0 context.Context, _a1 *dynamodb.ListExportsInput, _a2 ...request.Option) (*dynamodb.ListExportsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.ListExportsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.ListExportsInput, ...request.Option) *dynamodb.ListExportsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.ListExportsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.ListExportsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListGlobalTables provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) ListGlobalTables(_a0 *dynamodb.ListGlobalTablesInput) (*dynamodb.ListGlobalTablesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.ListGlobalTablesOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.ListGlobalTablesInput) *dynamodb.ListGlobalTablesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.ListGlobalTablesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.ListGlobalTablesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListGlobalTablesRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) ListGlobalTablesRequest(_a0 *dynamodb.ListGlobalTablesInput) (*request.Request, *dynamodb.ListGlobalTablesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.ListGlobalTablesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.ListGlobalTablesOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.ListGlobalTablesInput) *dynamodb.ListGlobalTablesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.ListGlobalTablesOutput)
		}
	}

	return r0, r1
}

// ListGlobalTablesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) ListGlobalTablesWithContext(_a0 context.Context, _a1 *dynamodb.ListGlobalTablesInput, _a2 ...request.Option) (*dynamodb.ListGlobalTablesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.ListGlobalTablesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.ListGlobalTablesInput, ...request.Option) *dynamodb.ListGlobalTablesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.ListGlobalTablesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.ListGlobalTablesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTables provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) ListTables(_a0 *dynamodb.ListTablesInput) (*dynamodb.ListTablesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.ListTablesOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.ListTablesInput) *dynamodb.ListTablesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.ListTablesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.ListTablesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTablesPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeDynamoDB) ListTablesPages(_a0 *dynamodb.ListTablesInput, _a1 func(*dynamodb.ListTablesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*dynamodb.ListTablesInput, func(*dynamodb.ListTablesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListTablesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeDynamoDB) ListTablesPagesWithContext(_a0 context.Context, _a1 *dynamodb.ListTablesInput, _a2 func(*dynamodb.ListTablesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.ListTablesInput, func(*dynamodb.ListTablesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListTablesRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) ListTablesRequest(_a0 *dynamodb.ListTablesInput) (*request.Request, *dynamodb.ListTablesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.ListTablesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.ListTablesOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.ListTablesInput) *dynamodb.ListTablesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.ListTablesOutput)
		}
	}

	return r0, r1
}

// ListTablesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) ListTablesWithContext(_a0 context.Context, _a1 *dynamodb.ListTablesInput, _a2 ...request.Option) (*dynamodb.ListTablesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.ListTablesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.ListTablesInput, ...request.Option) *dynamodb.ListTablesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.ListTablesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.ListTablesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTagsOfResource provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) ListTagsOfResource(_a0 *dynamodb.ListTagsOfResourceInput) (*dynamodb.ListTagsOfResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.ListTagsOfResourceOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.ListTagsOfResourceInput) *dynamodb.ListTagsOfResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.ListTagsOfResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.ListTagsOfResourceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTagsOfResourceRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) ListTagsOfResourceRequest(_a0 *dynamodb.ListTagsOfResourceInput) (*request.Request, *dynamodb.ListTagsOfResourceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.ListTagsOfResourceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.ListTagsOfResourceOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.ListTagsOfResourceInput) *dynamodb.ListTagsOfResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.ListTagsOfResourceOutput)
		}
	}

	return r0, r1
}

// ListTagsOfResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) ListTagsOfResourceWithContext(_a0 context.Context, _a1 *dynamodb.ListTagsOfResourceInput, _a2 ...request.Option) (*dynamodb.ListTagsOfResourceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.ListTagsOfResourceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.ListTagsOfResourceInput, ...request.Option) *dynamodb.ListTagsOfResourceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.ListTagsOfResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.ListTagsOfResourceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutItem provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) PutItem(_a0 *dynamodb.PutItemInput) (*dynamodb.PutItemOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.PutItemOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.PutItemInput) *dynamodb.PutItemOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.PutItemOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.PutItemInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// PutItemRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) PutItemRequest(_a0 *dynamodb.PutItemInput) (*request.Request, *dynamodb.PutItemOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.PutItemInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.PutItemOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.PutItemInput) *dynamodb.PutItemOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.PutItemOutput)
		}
	}

	return r0, r1
}

// PutItemWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) PutItemWithContext(_a0 context.Context, _a1 *dynamodb.PutItemInput, _a2 ...request.Option) (*dynamodb.PutItemOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.PutItemOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.PutItemInput, ...request.Option) *dynamodb.PutItemOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.PutItemOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.PutItemInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Query provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) Query(_a0 *dynamodb.QueryInput) (*dynamodb.QueryOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.QueryOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.QueryInput) *dynamodb.QueryOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.QueryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.QueryInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// QueryPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeDynamoDB) QueryPages(_a0 *dynamodb.QueryInput, _a1 func(*dynamodb.QueryOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*dynamodb.QueryInput, func(*dynamodb.QueryOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// QueryPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeDynamoDB) QueryPagesWithContext(_a0 context.Context, _a1 *dynamodb.QueryInput, _a2 func(*dynamodb.QueryOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.QueryInput, func(*dynamodb.QueryOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// QueryRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) QueryRequest(_a0 *dynamodb.QueryInput) (*request.Request, *dynamodb.QueryOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.QueryInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.QueryOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.QueryInput) *dynamodb.QueryOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.QueryOutput)
		}
	}

	return r0, r1
}

// QueryWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) QueryWithContext(_a0 context.Context, _a1 *dynamodb.QueryInput, _a2 ...request.Option) (*dynamodb.QueryOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.QueryOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.QueryInput, ...request.Option) *dynamodb.QueryOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.QueryOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.QueryInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreTableFromBackup provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) RestoreTableFromBackup(_a0 *dynamodb.RestoreTableFromBackupInput) (*dynamodb.RestoreTableFromBackupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.RestoreTableFromBackupOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.RestoreTableFromBackupInput) *dynamodb.RestoreTableFromBackupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.RestoreTableFromBackupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.RestoreTableFromBackupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreTableFromBackupRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) RestoreTableFromBackupRequest(_a0 *dynamodb.RestoreTableFromBackupInput) (*request.Request, *dynamodb.RestoreTableFromBackupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.RestoreTableFromBackupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.RestoreTableFromBackupOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.RestoreTableFromBackupInput) *dynamodb.RestoreTableFromBackupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.RestoreTableFromBackupOutput)
		}
	}

	return r0, r1
}

// RestoreTableFromBackupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) RestoreTableFromBackupWithContext(_a0 context.Context, _a1 *dynamodb.RestoreTableFromBackupInput, _a2 ...request.Option) (*dynamodb.RestoreTableFromBackupOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.RestoreTableFromBackupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.RestoreTableFromBackupInput, ...request.Option) *dynamodb.RestoreTableFromBackupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.RestoreTableFromBackupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.RestoreTableFromBackupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreTableToPointInTime provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) RestoreTableToPointInTime(_a0 *dynamodb.RestoreTableToPointInTimeInput) (*dynamodb.RestoreTableToPointInTimeOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.RestoreTableToPointInTimeOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.RestoreTableToPointInTimeInput) *dynamodb.RestoreTableToPointInTimeOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.RestoreTableToPointInTimeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.RestoreTableToPointInTimeInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RestoreTableToPointInTimeRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) RestoreTableToPointInTimeRequest(_a0 *dynamodb.RestoreTableToPointInTimeInput) (*request.Request, *dynamodb.RestoreTableToPointInTimeOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.RestoreTableToPointInTimeInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.RestoreTableToPointInTimeOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.RestoreTableToPointInTimeInput) *dynamodb.RestoreTableToPointInTimeOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.RestoreTableToPointInTimeOutput)
		}
	}

	return r0, r1
}

// RestoreTableToPointInTimeWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) RestoreTableToPointInTimeWithContext(_a0 context.Context, _a1 *dynamodb.RestoreTableToPointInTimeInput, _a2 ...request.Option) (*dynamodb.RestoreTableToPointInTimeOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.RestoreTableToPointInTimeOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.RestoreTableToPointInTimeInput, ...request.Option) *dynamodb.RestoreTableToPointInTimeOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.RestoreTableToPointInTimeOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.RestoreTableToPointInTimeInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Scan provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) Scan(_a0 *dynamodb.ScanInput) (*dynamodb.ScanOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.ScanOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.ScanInput) *dynamodb.ScanOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.ScanOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.ScanInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ScanPages provides a mock function with given fields: _a0, _a1
func (_m *MockFakeDynamoDB) ScanPages(_a0 *dynamodb.ScanInput, _a1 func(*dynamodb.ScanOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*dynamodb.ScanInput, func(*dynamodb.ScanOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ScanPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *MockFakeDynamoDB) ScanPagesWithContext(_a0 context.Context, _a1 *dynamodb.ScanInput, _a2 func(*dynamodb.ScanOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.ScanInput, func(*dynamodb.ScanOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ScanRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) ScanRequest(_a0 *dynamodb.ScanInput) (*request.Request, *dynamodb.ScanOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.ScanInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.ScanOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.ScanInput) *dynamodb.ScanOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.ScanOutput)
		}
	}

	return r0, r1
}

// ScanWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) ScanWithContext(_a0 context.Context, _a1 *dynamodb.ScanInput, _a2 ...request.Option) (*dynamodb.ScanOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.ScanOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.ScanInput, ...request.Option) *dynamodb.ScanOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.ScanOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.ScanInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TagResource provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) TagResource(_a0 *dynamodb.TagResourceInput) (*dynamodb.TagResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.TagResourceOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.TagResourceInput) *dynamodb.TagResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.TagResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.TagResourceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TagResourceRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) TagResourceRequest(_a0 *dynamodb.TagResourceInput) (*request.Request, *dynamodb.TagResourceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.TagResourceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.TagResourceOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.TagResourceInput) *dynamodb.TagResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.TagResourceOutput)
		}
	}

	return r0, r1
}

// TagResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) TagResourceWithContext(_a0 context.Context, _a1 *dynamodb.TagResourceInput, _a2 ...request.Option) (*dynamodb.TagResourceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.TagResourceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.TagResourceInput, ...request.Option) *dynamodb.TagResourceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.TagResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.TagResourceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TransactGetItems provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) TransactGetItems(_a0 *dynamodb.TransactGetItemsInput) (*dynamodb.TransactGetItemsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.TransactGetItemsOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.TransactGetItemsInput) *dynamodb.TransactGetItemsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.TransactGetItemsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.TransactGetItemsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TransactGetItemsRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) TransactGetItemsRequest(_a0 *dynamodb.TransactGetItemsInput) (*request.Request, *dynamodb.TransactGetItemsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.TransactGetItemsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.TransactGetItemsOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.TransactGetItemsInput) *dynamodb.TransactGetItemsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.TransactGetItemsOutput)
		}
	}

	return r0, r1
}

// TransactGetItemsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) TransactGetItemsWithContext(_a0 context.Context, _a1 *dynamodb.TransactGetItemsInput, _a2 ...request.Option) (*dynamodb.TransactGetItemsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.TransactGetItemsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.TransactGetItemsInput, ...request.Option) *dynamodb.TransactGetItemsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.TransactGetItemsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.TransactGetItemsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TransactWriteItems provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) TransactWriteItems(_a0 *dynamodb.TransactWriteItemsInput) (*dynamodb.TransactWriteItemsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.TransactWriteItemsOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.TransactWriteItemsInput) *dynamodb.TransactWriteItemsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.TransactWriteItemsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.TransactWriteItemsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TransactWriteItemsRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) TransactWriteItemsRequest(_a0 *dynamodb.TransactWriteItemsInput) (*request.Request, *dynamodb.TransactWriteItemsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.TransactWriteItemsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.TransactWriteItemsOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.TransactWriteItemsInput) *dynamodb.TransactWriteItemsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.TransactWriteItemsOutput)
		}
	}

	return r0, r1
}

// TransactWriteItemsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) TransactWriteItemsWithContext(_a0 context.Context, _a1 *dynamodb.TransactWriteItemsInput, _a2 ...request.Option) (*dynamodb.TransactWriteItemsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.TransactWriteItemsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.TransactWriteItemsInput, ...request.Option) *dynamodb.TransactWriteItemsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.TransactWriteItemsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.TransactWriteItemsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UntagResource provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) UntagResource(_a0 *dynamodb.UntagResourceInput) (*dynamodb.UntagResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.UntagResourceOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.UntagResourceInput) *dynamodb.UntagResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.UntagResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.UntagResourceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UntagResourceRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) UntagResourceRequest(_a0 *dynamodb.UntagResourceInput) (*request.Request, *dynamodb.UntagResourceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.UntagResourceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.UntagResourceOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.UntagResourceInput) *dynamodb.UntagResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.UntagResourceOutput)
		}
	}

	return r0, r1
}

// UntagResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) UntagResourceWithContext(_a0 context.Context, _a1 *dynamodb.UntagResourceInput, _a2 ...request.Option) (*dynamodb.UntagResourceOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.UntagResourceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.UntagResourceInput, ...request.Option) *dynamodb.UntagResourceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.UntagResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.UntagResourceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateContinuousBackups provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) UpdateContinuousBackups(_a0 *dynamodb.UpdateContinuousBackupsInput) (*dynamodb.UpdateContinuousBackupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.UpdateContinuousBackupsOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.UpdateContinuousBackupsInput) *dynamodb.UpdateContinuousBackupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.UpdateContinuousBackupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.UpdateContinuousBackupsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateContinuousBackupsRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) UpdateContinuousBackupsRequest(_a0 *dynamodb.UpdateContinuousBackupsInput) (*request.Request, *dynamodb.UpdateContinuousBackupsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.UpdateContinuousBackupsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.UpdateContinuousBackupsOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.UpdateContinuousBackupsInput) *dynamodb.UpdateContinuousBackupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.UpdateContinuousBackupsOutput)
		}
	}

	return r0, r1
}

// UpdateContinuousBackupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) UpdateContinuousBackupsWithContext(_a0 context.Context, _a1 *dynamodb.UpdateContinuousBackupsInput, _a2 ...request.Option) (*dynamodb.UpdateContinuousBackupsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.UpdateContinuousBackupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.UpdateContinuousBackupsInput, ...request.Option) *dynamodb.UpdateContinuousBackupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.UpdateContinuousBackupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.UpdateContinuousBackupsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateContributorInsights provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) UpdateContributorInsights(_a0 *dynamodb.UpdateContributorInsightsInput) (*dynamodb.UpdateContributorInsightsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.UpdateContributorInsightsOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.UpdateContributorInsightsInput) *dynamodb.UpdateContributorInsightsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.UpdateContributorInsightsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.UpdateContributorInsightsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateContributorInsightsRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) UpdateContributorInsightsRequest(_a0 *dynamodb.UpdateContributorInsightsInput) (*request.Request, *dynamodb.UpdateContributorInsightsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.UpdateContributorInsightsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.UpdateContributorInsightsOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.UpdateContributorInsightsInput) *dynamodb.UpdateContributorInsightsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.UpdateContributorInsightsOutput)
		}
	}

	return r0, r1
}

// UpdateContributorInsightsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) UpdateContributorInsightsWithContext(_a0 context.Context, _a1 *dynamodb.UpdateContributorInsightsInput, _a2 ...request.Option) (*dynamodb.UpdateContributorInsightsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.UpdateContributorInsightsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.UpdateContributorInsightsInput, ...request.Option) *dynamodb.UpdateContributorInsightsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.UpdateContributorInsightsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.UpdateContributorInsightsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateGlobalTable provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) UpdateGlobalTable(_a0 *dynamodb.UpdateGlobalTableInput) (*dynamodb.UpdateGlobalTableOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.UpdateGlobalTableOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.UpdateGlobalTableInput) *dynamodb.UpdateGlobalTableOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.UpdateGlobalTableOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.UpdateGlobalTableInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateGlobalTableRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) UpdateGlobalTableRequest(_a0 *dynamodb.UpdateGlobalTableInput) (*request.Request, *dynamodb.UpdateGlobalTableOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.UpdateGlobalTableInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.UpdateGlobalTableOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.UpdateGlobalTableInput) *dynamodb.UpdateGlobalTableOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.UpdateGlobalTableOutput)
		}
	}

	return r0, r1
}

// UpdateGlobalTableSettings provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) UpdateGlobalTableSettings(_a0 *dynamodb.UpdateGlobalTableSettingsInput) (*dynamodb.UpdateGlobalTableSettingsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.UpdateGlobalTableSettingsOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.UpdateGlobalTableSettingsInput) *dynamodb.UpdateGlobalTableSettingsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.UpdateGlobalTableSettingsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.UpdateGlobalTableSettingsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateGlobalTableSettingsRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) UpdateGlobalTableSettingsRequest(_a0 *dynamodb.UpdateGlobalTableSettingsInput) (*request.Request, *dynamodb.UpdateGlobalTableSettingsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.UpdateGlobalTableSettingsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.UpdateGlobalTableSettingsOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.UpdateGlobalTableSettingsInput) *dynamodb.UpdateGlobalTableSettingsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.UpdateGlobalTableSettingsOutput)
		}
	}

	return r0, r1
}

// UpdateGlobalTableSettingsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) UpdateGlobalTableSettingsWithContext(_a0 context.Context, _a1 *dynamodb.UpdateGlobalTableSettingsInput, _a2 ...request.Option) (*dynamodb.UpdateGlobalTableSettingsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.UpdateGlobalTableSettingsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.UpdateGlobalTableSettingsInput, ...request.Option) *dynamodb.UpdateGlobalTableSettingsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.UpdateGlobalTableSettingsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.UpdateGlobalTableSettingsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateGlobalTableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) UpdateGlobalTableWithContext(_a0 context.Context, _a1 *dynamodb.UpdateGlobalTableInput, _a2 ...request.Option) (*dynamodb.UpdateGlobalTableOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.UpdateGlobalTableOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.UpdateGlobalTableInput, ...request.Option) *dynamodb.UpdateGlobalTableOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.UpdateGlobalTableOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.UpdateGlobalTableInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateItem provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) UpdateItem(_a0 *dynamodb.UpdateItemInput) (*dynamodb.UpdateItemOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.UpdateItemOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.UpdateItemInput) *dynamodb.UpdateItemOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.UpdateItemOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.UpdateItemInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateItemRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) UpdateItemRequest(_a0 *dynamodb.UpdateItemInput) (*request.Request, *dynamodb.UpdateItemOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.UpdateItemInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.UpdateItemOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.UpdateItemInput) *dynamodb.UpdateItemOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.UpdateItemOutput)
		}
	}

	return r0, r1
}

// UpdateItemWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) UpdateItemWithContext(_a0 context.Context, _a1 *dynamodb.UpdateItemInput, _a2 ...request.Option) (*dynamodb.UpdateItemOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.UpdateItemOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.UpdateItemInput, ...request.Option) *dynamodb.UpdateItemOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.UpdateItemOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.UpdateItemInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateTable provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) UpdateTable(_a0 *dynamodb.UpdateTableInput) (*dynamodb.UpdateTableOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.UpdateTableOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.UpdateTableInput) *dynamodb.UpdateTableOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.UpdateTableOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.UpdateTableInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateTableReplicaAutoScaling provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) UpdateTableReplicaAutoScaling(_a0 *dynamodb.UpdateTableReplicaAutoScalingInput) (*dynamodb.UpdateTableReplicaAutoScalingOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.UpdateTableReplicaAutoScalingOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.UpdateTableReplicaAutoScalingInput) *dynamodb.UpdateTableReplicaAutoScalingOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.UpdateTableReplicaAutoScalingOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.UpdateTableReplicaAutoScalingInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateTableReplicaAutoScalingRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) UpdateTableReplicaAutoScalingRequest(_a0 *dynamodb.UpdateTableReplicaAutoScalingInput) (*request.Request, *dynamodb.UpdateTableReplicaAutoScalingOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.UpdateTableReplicaAutoScalingInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.UpdateTableReplicaAutoScalingOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.UpdateTableReplicaAutoScalingInput) *dynamodb.UpdateTableReplicaAutoScalingOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.UpdateTableReplicaAutoScalingOutput)
		}
	}

	return r0, r1
}

// UpdateTableReplicaAutoScalingWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) UpdateTableReplicaAutoScalingWithContext(_a0 context.Context, _a1 *dynamodb.UpdateTableReplicaAutoScalingInput, _a2 ...request.Option) (*dynamodb.UpdateTableReplicaAutoScalingOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.UpdateTableReplicaAutoScalingOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.UpdateTableReplicaAutoScalingInput, ...request.Option) *dynamodb.UpdateTableReplicaAutoScalingOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.UpdateTableReplicaAutoScalingOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.UpdateTableReplicaAutoScalingInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateTableRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) UpdateTableRequest(_a0 *dynamodb.UpdateTableInput) (*request.Request, *dynamodb.UpdateTableOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.UpdateTableInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.UpdateTableOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.UpdateTableInput) *dynamodb.UpdateTableOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.UpdateTableOutput)
		}
	}

	return r0, r1
}

// UpdateTableWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) UpdateTableWithContext(_a0 context.Context, _a1 *dynamodb.UpdateTableInput, _a2 ...request.Option) (*dynamodb.UpdateTableOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.UpdateTableOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.UpdateTableInput, ...request.Option) *dynamodb.UpdateTableOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.UpdateTableOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.UpdateTableInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateTimeToLive provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) UpdateTimeToLive(_a0 *dynamodb.UpdateTimeToLiveInput) (*dynamodb.UpdateTimeToLiveOutput, error) {
	ret := _m.Called(_a0)

	var r0 *dynamodb.UpdateTimeToLiveOutput
	if rf, ok := ret.Get(0).(func(*dynamodb.UpdateTimeToLiveInput) *dynamodb.UpdateTimeToLiveOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.UpdateTimeToLiveOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*dynamodb.UpdateTimeToLiveInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateTimeToLiveRequest provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) UpdateTimeToLiveRequest(_a0 *dynamodb.UpdateTimeToLiveInput) (*request.Request, *dynamodb.UpdateTimeToLiveOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*dynamodb.UpdateTimeToLiveInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *dynamodb.UpdateTimeToLiveOutput
	if rf, ok := ret.Get(1).(func(*dynamodb.UpdateTimeToLiveInput) *dynamodb.UpdateTimeToLiveOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*dynamodb.UpdateTimeToLiveOutput)
		}
	}

	return r0, r1
}

// UpdateTimeToLiveWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) UpdateTimeToLiveWithContext(_a0 context.Context, _a1 *dynamodb.UpdateTimeToLiveInput, _a2 ...request.Option) (*dynamodb.UpdateTimeToLiveOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *dynamodb.UpdateTimeToLiveOutput
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.UpdateTimeToLiveInput, ...request.Option) *dynamodb.UpdateTimeToLiveOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dynamodb.UpdateTimeToLiveOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *dynamodb.UpdateTimeToLiveInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// WaitUntilTableExists provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) WaitUntilTableExists(_a0 *dynamodb.DescribeTableInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeTableInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilTableExistsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) WaitUntilTableExistsWithContext(_a0 context.Context, _a1 *dynamodb.DescribeTableInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.DescribeTableInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilTableNotExists provides a mock function with given fields: _a0
func (_m *MockFakeDynamoDB) WaitUntilTableNotExists(_a0 *dynamodb.DescribeTableInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*dynamodb.DescribeTableInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilTableNotExistsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockFakeDynamoDB) WaitUntilTableNotExistsWithContext(_a0 context.Context, _a1 *dynamodb.DescribeTableInput, _a2 ...request.WaiterOption) error {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *dynamodb.DescribeTableInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}
