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
}
DescribeTable mocks base method
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)
}