func (_mr *MockDynamoDBAPIMockRecorder) UntagResourceRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UntagResourceRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UntagResourceRequest), arg0)
}
UntagResourceRequest indicates an expected call of UntagResourceRequest
package mockaws
import (
	aws "github.com/aws/aws-sdk-go/aws"
	request "github.com/aws/aws-sdk-go/aws/request"
	dynamodb "github.com/aws/aws-sdk-go/service/dynamodb"
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
)
type MockDynamoDBAPI struct {
	ctrl     *gomock.Controller
	recorder *MockDynamoDBAPIMockRecorder
}
type MockDynamoDBAPIMockRecorder struct {
	mock *MockDynamoDBAPI
}
func NewMockDynamoDBAPI(ctrl *gomock.Controller) *MockDynamoDBAPI {
	mock := &MockDynamoDBAPI{ctrl: ctrl}
	mock.recorder = &MockDynamoDBAPIMockRecorder{mock}
	return mock
}
func (_m *MockDynamoDBAPI) EXPECT() *MockDynamoDBAPIMockRecorder {
	return _m.recorder
}
func (_m *MockDynamoDBAPI) BatchGetItem(_param0 *dynamodb.BatchGetItemInput) (*dynamodb.BatchGetItemOutput, error) {
	ret := _m.ctrl.Call(_m, "BatchGetItem", _param0)
	ret0, _ := ret[0].(*dynamodb.BatchGetItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) BatchGetItem(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchGetItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchGetItem), arg0)
}
func (_m *MockDynamoDBAPI) BatchGetItemWithContext(_param0 aws.Context, _param1 *dynamodb.BatchGetItemInput, _param2 ...request.Option) (*dynamodb.BatchGetItemOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "BatchGetItemWithContext", _s...)
	ret0, _ := ret[0].(*dynamodb.BatchGetItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) BatchGetItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchGetItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchGetItemWithContext), _s...)
}
func (_m *MockDynamoDBAPI) BatchGetItemRequest(_param0 *dynamodb.BatchGetItemInput) (*request.Request, *dynamodb.BatchGetItemOutput) {
	ret := _m.ctrl.Call(_m, "BatchGetItemRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.BatchGetItemOutput)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) BatchGetItemRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchGetItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchGetItemRequest), arg0)
}
func (_m *MockDynamoDBAPI) BatchGetItemPages(_param0 *dynamodb.BatchGetItemInput, _param1 func(*dynamodb.BatchGetItemOutput, bool) bool) error {
	ret := _m.ctrl.Call(_m, "BatchGetItemPages", _param0, _param1)
	ret0, _ := ret[0].(error)
	return ret0
}
func (_mr *MockDynamoDBAPIMockRecorder) BatchGetItemPages(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchGetItemPages", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchGetItemPages), arg0, arg1)
}
func (_m *MockDynamoDBAPI) BatchGetItemPagesWithContext(_param0 aws.Context, _param1 *dynamodb.BatchGetItemInput, _param2 func(*dynamodb.BatchGetItemOutput, bool) bool, _param3 ...request.Option) error {
	_s := []interface{}{_param0, _param1, _param2}
	for _, _x := range _param3 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "BatchGetItemPagesWithContext", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (_mr *MockDynamoDBAPIMockRecorder) BatchGetItemPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchGetItemPagesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchGetItemPagesWithContext), _s...)
}
func (_m *MockDynamoDBAPI) BatchWriteItem(_param0 *dynamodb.BatchWriteItemInput) (*dynamodb.BatchWriteItemOutput, error) {
	ret := _m.ctrl.Call(_m, "BatchWriteItem", _param0)
	ret0, _ := ret[0].(*dynamodb.BatchWriteItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) BatchWriteItem(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchWriteItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchWriteItem), arg0)
}
func (_m *MockDynamoDBAPI) BatchWriteItemWithContext(_param0 aws.Context, _param1 *dynamodb.BatchWriteItemInput, _param2 ...request.Option) (*dynamodb.BatchWriteItemOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "BatchWriteItemWithContext", _s...)
	ret0, _ := ret[0].(*dynamodb.BatchWriteItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) BatchWriteItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchWriteItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchWriteItemWithContext), _s...)
}
func (_m *MockDynamoDBAPI) BatchWriteItemRequest(_param0 *dynamodb.BatchWriteItemInput) (*request.Request, *dynamodb.BatchWriteItemOutput) {
	ret := _m.ctrl.Call(_m, "BatchWriteItemRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.BatchWriteItemOutput)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) BatchWriteItemRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchWriteItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchWriteItemRequest), arg0)
}
func (_m *MockDynamoDBAPI) CreateTable(_param0 *dynamodb.CreateTableInput) (*dynamodb.CreateTableOutput, error) {
	ret := _m.ctrl.Call(_m, "CreateTable", _param0)
	ret0, _ := ret[0].(*dynamodb.CreateTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) CreateTable(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateTable), arg0)
}
func (_m *MockDynamoDBAPI) CreateTableWithContext(_param0 aws.Context, _param1 *dynamodb.CreateTableInput, _param2 ...request.Option) (*dynamodb.CreateTableOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "CreateTableWithContext", _s...)
	ret0, _ := ret[0].(*dynamodb.CreateTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) CreateTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateTableWithContext), _s...)
}
func (_m *MockDynamoDBAPI) CreateTableRequest(_param0 *dynamodb.CreateTableInput) (*request.Request, *dynamodb.CreateTableOutput) {
	ret := _m.ctrl.Call(_m, "CreateTableRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.CreateTableOutput)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) CreateTableRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateTableRequest), arg0)
}
func (_m *MockDynamoDBAPI) DeleteItem(_param0 *dynamodb.DeleteItemInput) (*dynamodb.DeleteItemOutput, error) {
	ret := _m.ctrl.Call(_m, "DeleteItem", _param0)
	ret0, _ := ret[0].(*dynamodb.DeleteItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) DeleteItem(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteItem), arg0)
}
func (_m *MockDynamoDBAPI) DeleteItemWithContext(_param0 aws.Context, _param1 *dynamodb.DeleteItemInput, _param2 ...request.Option) (*dynamodb.DeleteItemOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteItemWithContext", _s...)
	ret0, _ := ret[0].(*dynamodb.DeleteItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) DeleteItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteItemWithContext), _s...)
}
func (_m *MockDynamoDBAPI) DeleteItemRequest(_param0 *dynamodb.DeleteItemInput) (*request.Request, *dynamodb.DeleteItemOutput) {
	ret := _m.ctrl.Call(_m, "DeleteItemRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DeleteItemOutput)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) DeleteItemRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteItemRequest), arg0)
}
func (_m *MockDynamoDBAPI) DeleteTable(_param0 *dynamodb.DeleteTableInput) (*dynamodb.DeleteTableOutput, error) {
	ret := _m.ctrl.Call(_m, "DeleteTable", _param0)
	ret0, _ := ret[0].(*dynamodb.DeleteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) DeleteTable(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteTable), arg0)
}
func (_m *MockDynamoDBAPI) DeleteTableWithContext(_param0 aws.Context, _param1 *dynamodb.DeleteTableInput, _param2 ...request.Option) (*dynamodb.DeleteTableOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteTableWithContext", _s...)
	ret0, _ := ret[0].(*dynamodb.DeleteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) DeleteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteTableWithContext), _s...)
}
func (_m *MockDynamoDBAPI) DeleteTableRequest(_param0 *dynamodb.DeleteTableInput) (*request.Request, *dynamodb.DeleteTableOutput) {
	ret := _m.ctrl.Call(_m, "DeleteTableRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DeleteTableOutput)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) DeleteTableRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteTableRequest), arg0)
}
func (_m *MockDynamoDBAPI) DescribeLimits(_param0 *dynamodb.DescribeLimitsInput) (*dynamodb.DescribeLimitsOutput, error) {
	ret := _m.ctrl.Call(_m, "DescribeLimits", _param0)
	ret0, _ := ret[0].(*dynamodb.DescribeLimitsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) DescribeLimits(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeLimits", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeLimits), arg0)
}
func (_m *MockDynamoDBAPI) DescribeLimitsWithContext(_param0 aws.Context, _param1 *dynamodb.DescribeLimitsInput, _param2 ...request.Option) (*dynamodb.DescribeLimitsOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DescribeLimitsWithContext", _s...)
	ret0, _ := ret[0].(*dynamodb.DescribeLimitsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) DescribeLimitsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeLimitsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeLimitsWithContext), _s...)
}
func (_m *MockDynamoDBAPI) DescribeLimitsRequest(_param0 *dynamodb.DescribeLimitsInput) (*request.Request, *dynamodb.DescribeLimitsOutput) {
	ret := _m.ctrl.Call(_m, "DescribeLimitsRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DescribeLimitsOutput)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) DescribeLimitsRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeLimitsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeLimitsRequest), arg0)
}
func (_m *MockDynamoDBAPI) DescribeTable(_param0 *dynamodb.DescribeTableInput) (*dynamodb.DescribeTableOutput, error) {
	ret := _m.ctrl.Call(_m, "DescribeTable", _param0)
	ret0, _ := ret[0].(*dynamodb.DescribeTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) DescribeTable(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTable), arg0)
}
func (_m *MockDynamoDBAPI) DescribeTableWithContext(_param0 aws.Context, _param1 *dynamodb.DescribeTableInput, _param2 ...request.Option) (*dynamodb.DescribeTableOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DescribeTableWithContext", _s...)
	ret0, _ := ret[0].(*dynamodb.DescribeTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) DescribeTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTableWithContext), _s...)
}
func (_m *MockDynamoDBAPI) DescribeTableRequest(_param0 *dynamodb.DescribeTableInput) (*request.Request, *dynamodb.DescribeTableOutput) {
	ret := _m.ctrl.Call(_m, "DescribeTableRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DescribeTableOutput)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) DescribeTableRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTableRequest), arg0)
}
func (_m *MockDynamoDBAPI) DescribeTimeToLive(_param0 *dynamodb.DescribeTimeToLiveInput) (*dynamodb.DescribeTimeToLiveOutput, error) {
	ret := _m.ctrl.Call(_m, "DescribeTimeToLive", _param0)
	ret0, _ := ret[0].(*dynamodb.DescribeTimeToLiveOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) DescribeTimeToLive(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeTimeToLive", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTimeToLive), arg0)
}
func (_m *MockDynamoDBAPI) DescribeTimeToLiveWithContext(_param0 aws.Context, _param1 *dynamodb.DescribeTimeToLiveInput, _param2 ...request.Option) (*dynamodb.DescribeTimeToLiveOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DescribeTimeToLiveWithContext", _s...)
	ret0, _ := ret[0].(*dynamodb.DescribeTimeToLiveOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) DescribeTimeToLiveWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeTimeToLiveWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTimeToLiveWithContext), _s...)
}
func (_m *MockDynamoDBAPI) DescribeTimeToLiveRequest(_param0 *dynamodb.DescribeTimeToLiveInput) (*request.Request, *dynamodb.DescribeTimeToLiveOutput) {
	ret := _m.ctrl.Call(_m, "DescribeTimeToLiveRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DescribeTimeToLiveOutput)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) DescribeTimeToLiveRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DescribeTimeToLiveRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTimeToLiveRequest), arg0)
}
func (_m *MockDynamoDBAPI) GetItem(_param0 *dynamodb.GetItemInput) (*dynamodb.GetItemOutput, error) {
	ret := _m.ctrl.Call(_m, "GetItem", _param0)
	ret0, _ := ret[0].(*dynamodb.GetItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) GetItem(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).GetItem), arg0)
}
func (_m *MockDynamoDBAPI) GetItemWithContext(_param0 aws.Context, _param1 *dynamodb.GetItemInput, _param2 ...request.Option) (*dynamodb.GetItemOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "GetItemWithContext", _s...)
	ret0, _ := ret[0].(*dynamodb.GetItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) GetItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).GetItemWithContext), _s...)
}
func (_m *MockDynamoDBAPI) GetItemRequest(_param0 *dynamodb.GetItemInput) (*request.Request, *dynamodb.GetItemOutput) {
	ret := _m.ctrl.Call(_m, "GetItemRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.GetItemOutput)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) GetItemRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).GetItemRequest), arg0)
}
func (_m *MockDynamoDBAPI) ListTables(_param0 *dynamodb.ListTablesInput) (*dynamodb.ListTablesOutput, error) {
	ret := _m.ctrl.Call(_m, "ListTables", _param0)
	ret0, _ := ret[0].(*dynamodb.ListTablesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) ListTables(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTables", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTables), arg0)
}
func (_m *MockDynamoDBAPI) ListTablesWithContext(_param0 aws.Context, _param1 *dynamodb.ListTablesInput, _param2 ...request.Option) (*dynamodb.ListTablesOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "ListTablesWithContext", _s...)
	ret0, _ := ret[0].(*dynamodb.ListTablesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) ListTablesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTablesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTablesWithContext), _s...)
}
func (_m *MockDynamoDBAPI) ListTablesRequest(_param0 *dynamodb.ListTablesInput) (*request.Request, *dynamodb.ListTablesOutput) {
	ret := _m.ctrl.Call(_m, "ListTablesRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.ListTablesOutput)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) ListTablesRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTablesRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTablesRequest), arg0)
}
func (_m *MockDynamoDBAPI) ListTablesPages(_param0 *dynamodb.ListTablesInput, _param1 func(*dynamodb.ListTablesOutput, bool) bool) error {
	ret := _m.ctrl.Call(_m, "ListTablesPages", _param0, _param1)
	ret0, _ := ret[0].(error)
	return ret0
}
func (_mr *MockDynamoDBAPIMockRecorder) ListTablesPages(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTablesPages", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTablesPages), arg0, arg1)
}
func (_m *MockDynamoDBAPI) ListTablesPagesWithContext(_param0 aws.Context, _param1 *dynamodb.ListTablesInput, _param2 func(*dynamodb.ListTablesOutput, bool) bool, _param3 ...request.Option) error {
	_s := []interface{}{_param0, _param1, _param2}
	for _, _x := range _param3 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "ListTablesPagesWithContext", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (_mr *MockDynamoDBAPIMockRecorder) ListTablesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTablesPagesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTablesPagesWithContext), _s...)
}
func (_m *MockDynamoDBAPI) ListTagsOfResource(_param0 *dynamodb.ListTagsOfResourceInput) (*dynamodb.ListTagsOfResourceOutput, error) {
	ret := _m.ctrl.Call(_m, "ListTagsOfResource", _param0)
	ret0, _ := ret[0].(*dynamodb.ListTagsOfResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) ListTagsOfResource(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTagsOfResource", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTagsOfResource), arg0)
}
func (_m *MockDynamoDBAPI) ListTagsOfResourceWithContext(_param0 aws.Context, _param1 *dynamodb.ListTagsOfResourceInput, _param2 ...request.Option) (*dynamodb.ListTagsOfResourceOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "ListTagsOfResourceWithContext", _s...)
	ret0, _ := ret[0].(*dynamodb.ListTagsOfResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) ListTagsOfResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTagsOfResourceWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTagsOfResourceWithContext), _s...)
}
func (_m *MockDynamoDBAPI) ListTagsOfResourceRequest(_param0 *dynamodb.ListTagsOfResourceInput) (*request.Request, *dynamodb.ListTagsOfResourceOutput) {
	ret := _m.ctrl.Call(_m, "ListTagsOfResourceRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.ListTagsOfResourceOutput)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) ListTagsOfResourceRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListTagsOfResourceRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTagsOfResourceRequest), arg0)
}
func (_m *MockDynamoDBAPI) PutItem(_param0 *dynamodb.PutItemInput) (*dynamodb.PutItemOutput, error) {
	ret := _m.ctrl.Call(_m, "PutItem", _param0)
	ret0, _ := ret[0].(*dynamodb.PutItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) PutItem(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).PutItem), arg0)
}
func (_m *MockDynamoDBAPI) PutItemWithContext(_param0 aws.Context, _param1 *dynamodb.PutItemInput, _param2 ...request.Option) (*dynamodb.PutItemOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "PutItemWithContext", _s...)
	ret0, _ := ret[0].(*dynamodb.PutItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) PutItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).PutItemWithContext), _s...)
}
func (_m *MockDynamoDBAPI) PutItemRequest(_param0 *dynamodb.PutItemInput) (*request.Request, *dynamodb.PutItemOutput) {
	ret := _m.ctrl.Call(_m, "PutItemRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.PutItemOutput)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) PutItemRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PutItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).PutItemRequest), arg0)
}
func (_m *MockDynamoDBAPI) Query(_param0 *dynamodb.QueryInput) (*dynamodb.QueryOutput, error) {
	ret := _m.ctrl.Call(_m, "Query", _param0)
	ret0, _ := ret[0].(*dynamodb.QueryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) Query(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Query", reflect.TypeOf((*MockDynamoDBAPI)(nil).Query), arg0)
}
func (_m *MockDynamoDBAPI) QueryWithContext(_param0 aws.Context, _param1 *dynamodb.QueryInput, _param2 ...request.Option) (*dynamodb.QueryOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "QueryWithContext", _s...)
	ret0, _ := ret[0].(*dynamodb.QueryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) QueryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "QueryWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).QueryWithContext), _s...)
}
func (_m *MockDynamoDBAPI) QueryRequest(_param0 *dynamodb.QueryInput) (*request.Request, *dynamodb.QueryOutput) {
	ret := _m.ctrl.Call(_m, "QueryRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.QueryOutput)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) QueryRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "QueryRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).QueryRequest), arg0)
}
func (_m *MockDynamoDBAPI) QueryPages(_param0 *dynamodb.QueryInput, _param1 func(*dynamodb.QueryOutput, bool) bool) error {
	ret := _m.ctrl.Call(_m, "QueryPages", _param0, _param1)
	ret0, _ := ret[0].(error)
	return ret0
}
func (_mr *MockDynamoDBAPIMockRecorder) QueryPages(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "QueryPages", reflect.TypeOf((*MockDynamoDBAPI)(nil).QueryPages), arg0, arg1)
}
func (_m *MockDynamoDBAPI) QueryPagesWithContext(_param0 aws.Context, _param1 *dynamodb.QueryInput, _param2 func(*dynamodb.QueryOutput, bool) bool, _param3 ...request.Option) error {
	_s := []interface{}{_param0, _param1, _param2}
	for _, _x := range _param3 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "QueryPagesWithContext", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (_mr *MockDynamoDBAPIMockRecorder) QueryPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "QueryPagesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).QueryPagesWithContext), _s...)
}
func (_m *MockDynamoDBAPI) Scan(_param0 *dynamodb.ScanInput) (*dynamodb.ScanOutput, error) {
	ret := _m.ctrl.Call(_m, "Scan", _param0)
	ret0, _ := ret[0].(*dynamodb.ScanOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) Scan(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Scan", reflect.TypeOf((*MockDynamoDBAPI)(nil).Scan), arg0)
}
func (_m *MockDynamoDBAPI) ScanWithContext(_param0 aws.Context, _param1 *dynamodb.ScanInput, _param2 ...request.Option) (*dynamodb.ScanOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "ScanWithContext", _s...)
	ret0, _ := ret[0].(*dynamodb.ScanOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) ScanWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ScanWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ScanWithContext), _s...)
}
func (_m *MockDynamoDBAPI) ScanRequest(_param0 *dynamodb.ScanInput) (*request.Request, *dynamodb.ScanOutput) {
	ret := _m.ctrl.Call(_m, "ScanRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.ScanOutput)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) ScanRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ScanRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ScanRequest), arg0)
}
func (_m *MockDynamoDBAPI) ScanPages(_param0 *dynamodb.ScanInput, _param1 func(*dynamodb.ScanOutput, bool) bool) error {
	ret := _m.ctrl.Call(_m, "ScanPages", _param0, _param1)
	ret0, _ := ret[0].(error)
	return ret0
}
func (_mr *MockDynamoDBAPIMockRecorder) ScanPages(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ScanPages", reflect.TypeOf((*MockDynamoDBAPI)(nil).ScanPages), arg0, arg1)
}
func (_m *MockDynamoDBAPI) ScanPagesWithContext(_param0 aws.Context, _param1 *dynamodb.ScanInput, _param2 func(*dynamodb.ScanOutput, bool) bool, _param3 ...request.Option) error {
	_s := []interface{}{_param0, _param1, _param2}
	for _, _x := range _param3 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "ScanPagesWithContext", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (_mr *MockDynamoDBAPIMockRecorder) ScanPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ScanPagesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ScanPagesWithContext), _s...)
}
func (_m *MockDynamoDBAPI) TagResource(_param0 *dynamodb.TagResourceInput) (*dynamodb.TagResourceOutput, error) {
	ret := _m.ctrl.Call(_m, "TagResource", _param0)
	ret0, _ := ret[0].(*dynamodb.TagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) TagResource(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "TagResource", reflect.TypeOf((*MockDynamoDBAPI)(nil).TagResource), arg0)
}
func (_m *MockDynamoDBAPI) TagResourceWithContext(_param0 aws.Context, _param1 *dynamodb.TagResourceInput, _param2 ...request.Option) (*dynamodb.TagResourceOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "TagResourceWithContext", _s...)
	ret0, _ := ret[0].(*dynamodb.TagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) TagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "TagResourceWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).TagResourceWithContext), _s...)
}
func (_m *MockDynamoDBAPI) TagResourceRequest(_param0 *dynamodb.TagResourceInput) (*request.Request, *dynamodb.TagResourceOutput) {
	ret := _m.ctrl.Call(_m, "TagResourceRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.TagResourceOutput)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) TagResourceRequest(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "TagResourceRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).TagResourceRequest), arg0)
}
func (_m *MockDynamoDBAPI) UntagResource(_param0 *dynamodb.UntagResourceInput) (*dynamodb.UntagResourceOutput, error) {
	ret := _m.ctrl.Call(_m, "UntagResource", _param0)
	ret0, _ := ret[0].(*dynamodb.UntagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) UntagResource(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UntagResource", reflect.TypeOf((*MockDynamoDBAPI)(nil).UntagResource), arg0)
}
func (_m *MockDynamoDBAPI) UntagResourceWithContext(_param0 aws.Context, _param1 *dynamodb.UntagResourceInput, _param2 ...request.Option) (*dynamodb.UntagResourceOutput, error) {
	_s := []interface{}{_param0, _param1}
	for _, _x := range _param2 {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "UntagResourceWithContext", _s...)
	ret0, _ := ret[0].(*dynamodb.UntagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (_mr *MockDynamoDBAPIMockRecorder) UntagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1}, arg2...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UntagResourceWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UntagResourceWithContext), _s...)
}
func (_m *MockDynamoDBAPI) UntagResourceRequest(_param0 *dynamodb.UntagResourceInput) (*request.Request, *dynamodb.UntagResourceOutput) {
	ret := _m.ctrl.Call(_m, "UntagResourceRequest", _param0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.UntagResourceOutput)
	return ret0, ret1
}