// Code generated by MockGen. DO NOT EDIT.
// Source: /home/runner/go/pkg/mod/github.com/aws/aws-sdk-go@v1.55.5/service/dynamodb/dynamodbiface/interface.go

// Package mock_dynamodbiface is a generated GoMock package.
package mock_dynamodbiface

import (
	reflect "reflect"

	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"
)

// MockDynamoDBAPI is a mock of DynamoDBAPI interface.
type MockDynamoDBAPI struct {
	ctrl     *gomock.Controller
	recorder *MockDynamoDBAPIMockRecorder
}

// MockDynamoDBAPIMockRecorder is the mock recorder for MockDynamoDBAPI.
type MockDynamoDBAPIMockRecorder struct {
	mock *MockDynamoDBAPI
}

// NewMockDynamoDBAPI creates a new mock instance.
func NewMockDynamoDBAPI(ctrl *gomock.Controller) *MockDynamoDBAPI {
	mock := &MockDynamoDBAPI{ctrl: ctrl}
	mock.recorder = &MockDynamoDBAPIMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockDynamoDBAPI) EXPECT() *MockDynamoDBAPIMockRecorder {
	return m.recorder
}

// BatchExecuteStatement mocks base method.
func (m *MockDynamoDBAPI) BatchExecuteStatement(arg0 *dynamodb.BatchExecuteStatementInput) (*dynamodb.BatchExecuteStatementOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchExecuteStatement", arg0)
	ret0, _ := ret[0].(*dynamodb.BatchExecuteStatementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchExecuteStatement indicates an expected call of BatchExecuteStatement.
func (mr *MockDynamoDBAPIMockRecorder) BatchExecuteStatement(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchExecuteStatement", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchExecuteStatement), arg0)
}

// BatchExecuteStatementRequest mocks base method.
func (m *MockDynamoDBAPI) BatchExecuteStatementRequest(arg0 *dynamodb.BatchExecuteStatementInput) (*request.Request, *dynamodb.BatchExecuteStatementOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchExecuteStatementRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.BatchExecuteStatementOutput)
	return ret0, ret1
}

// BatchExecuteStatementRequest indicates an expected call of BatchExecuteStatementRequest.
func (mr *MockDynamoDBAPIMockRecorder) BatchExecuteStatementRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchExecuteStatementRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchExecuteStatementRequest), arg0)
}

// BatchExecuteStatementWithContext mocks base method.
func (m *MockDynamoDBAPI) BatchExecuteStatementWithContext(arg0 aws.Context, arg1 *dynamodb.BatchExecuteStatementInput, arg2 ...request.Option) (*dynamodb.BatchExecuteStatementOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchExecuteStatementWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.BatchExecuteStatementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchExecuteStatementWithContext indicates an expected call of BatchExecuteStatementWithContext.
func (mr *MockDynamoDBAPIMockRecorder) BatchExecuteStatementWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchExecuteStatementWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchExecuteStatementWithContext), varargs...)
}

// BatchGetItem mocks base method.
func (m *MockDynamoDBAPI) BatchGetItem(arg0 *dynamodb.BatchGetItemInput) (*dynamodb.BatchGetItemOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchGetItem", arg0)
	ret0, _ := ret[0].(*dynamodb.BatchGetItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchGetItem indicates an expected call of BatchGetItem.
func (mr *MockDynamoDBAPIMockRecorder) BatchGetItem(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchGetItem), arg0)
}

// BatchGetItemPages mocks base method.
func (m *MockDynamoDBAPI) BatchGetItemPages(arg0 *dynamodb.BatchGetItemInput, arg1 func(*dynamodb.BatchGetItemOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchGetItemPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchGetItemPages indicates an expected call of BatchGetItemPages.
func (mr *MockDynamoDBAPIMockRecorder) BatchGetItemPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetItemPages", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchGetItemPages), arg0, arg1)
}

// BatchGetItemPagesWithContext mocks base method.
func (m *MockDynamoDBAPI) BatchGetItemPagesWithContext(arg0 aws.Context, arg1 *dynamodb.BatchGetItemInput, arg2 func(*dynamodb.BatchGetItemOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchGetItemPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchGetItemPagesWithContext indicates an expected call of BatchGetItemPagesWithContext.
func (mr *MockDynamoDBAPIMockRecorder) BatchGetItemPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetItemPagesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchGetItemPagesWithContext), varargs...)
}

// BatchGetItemRequest mocks base method.
func (m *MockDynamoDBAPI) BatchGetItemRequest(arg0 *dynamodb.BatchGetItemInput) (*request.Request, *dynamodb.BatchGetItemOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchGetItemRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.BatchGetItemOutput)
	return ret0, ret1
}

// BatchGetItemRequest indicates an expected call of BatchGetItemRequest.
func (mr *MockDynamoDBAPIMockRecorder) BatchGetItemRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchGetItemRequest), arg0)
}

// BatchGetItemWithContext mocks base method.
func (m *MockDynamoDBAPI) BatchGetItemWithContext(arg0 aws.Context, arg1 *dynamodb.BatchGetItemInput, arg2 ...request.Option) (*dynamodb.BatchGetItemOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchGetItemWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.BatchGetItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchGetItemWithContext indicates an expected call of BatchGetItemWithContext.
func (mr *MockDynamoDBAPIMockRecorder) BatchGetItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchGetItemWithContext), varargs...)
}

// BatchWriteItem mocks base method.
func (m *MockDynamoDBAPI) BatchWriteItem(arg0 *dynamodb.BatchWriteItemInput) (*dynamodb.BatchWriteItemOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchWriteItem", arg0)
	ret0, _ := ret[0].(*dynamodb.BatchWriteItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchWriteItem indicates an expected call of BatchWriteItem.
func (mr *MockDynamoDBAPIMockRecorder) BatchWriteItem(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchWriteItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchWriteItem), arg0)
}

// BatchWriteItemRequest mocks base method.
func (m *MockDynamoDBAPI) BatchWriteItemRequest(arg0 *dynamodb.BatchWriteItemInput) (*request.Request, *dynamodb.BatchWriteItemOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchWriteItemRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.BatchWriteItemOutput)
	return ret0, ret1
}

// BatchWriteItemRequest indicates an expected call of BatchWriteItemRequest.
func (mr *MockDynamoDBAPIMockRecorder) BatchWriteItemRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchWriteItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchWriteItemRequest), arg0)
}

// BatchWriteItemWithContext mocks base method.
func (m *MockDynamoDBAPI) BatchWriteItemWithContext(arg0 aws.Context, arg1 *dynamodb.BatchWriteItemInput, arg2 ...request.Option) (*dynamodb.BatchWriteItemOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchWriteItemWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.BatchWriteItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchWriteItemWithContext indicates an expected call of BatchWriteItemWithContext.
func (mr *MockDynamoDBAPIMockRecorder) BatchWriteItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchWriteItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).BatchWriteItemWithContext), varargs...)
}

// CreateBackup mocks base method.
func (m *MockDynamoDBAPI) CreateBackup(arg0 *dynamodb.CreateBackupInput) (*dynamodb.CreateBackupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBackup", arg0)
	ret0, _ := ret[0].(*dynamodb.CreateBackupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateBackup indicates an expected call of CreateBackup.
func (mr *MockDynamoDBAPIMockRecorder) CreateBackup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBackup", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateBackup), arg0)
}

// CreateBackupRequest mocks base method.
func (m *MockDynamoDBAPI) CreateBackupRequest(arg0 *dynamodb.CreateBackupInput) (*request.Request, *dynamodb.CreateBackupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBackupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.CreateBackupOutput)
	return ret0, ret1
}

// CreateBackupRequest indicates an expected call of CreateBackupRequest.
func (mr *MockDynamoDBAPIMockRecorder) CreateBackupRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBackupRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateBackupRequest), arg0)
}

// CreateBackupWithContext mocks base method.
func (m *MockDynamoDBAPI) CreateBackupWithContext(arg0 aws.Context, arg1 *dynamodb.CreateBackupInput, arg2 ...request.Option) (*dynamodb.CreateBackupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateBackupWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.CreateBackupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateBackupWithContext indicates an expected call of CreateBackupWithContext.
func (mr *MockDynamoDBAPIMockRecorder) CreateBackupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBackupWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateBackupWithContext), varargs...)
}

// CreateGlobalTable mocks base method.
func (m *MockDynamoDBAPI) CreateGlobalTable(arg0 *dynamodb.CreateGlobalTableInput) (*dynamodb.CreateGlobalTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGlobalTable", arg0)
	ret0, _ := ret[0].(*dynamodb.CreateGlobalTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateGlobalTable indicates an expected call of CreateGlobalTable.
func (mr *MockDynamoDBAPIMockRecorder) CreateGlobalTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGlobalTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateGlobalTable), arg0)
}

// CreateGlobalTableRequest mocks base method.
func (m *MockDynamoDBAPI) CreateGlobalTableRequest(arg0 *dynamodb.CreateGlobalTableInput) (*request.Request, *dynamodb.CreateGlobalTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGlobalTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.CreateGlobalTableOutput)
	return ret0, ret1
}

// CreateGlobalTableRequest indicates an expected call of CreateGlobalTableRequest.
func (mr *MockDynamoDBAPIMockRecorder) CreateGlobalTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGlobalTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateGlobalTableRequest), arg0)
}

// CreateGlobalTableWithContext mocks base method.
func (m *MockDynamoDBAPI) CreateGlobalTableWithContext(arg0 aws.Context, arg1 *dynamodb.CreateGlobalTableInput, arg2 ...request.Option) (*dynamodb.CreateGlobalTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateGlobalTableWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.CreateGlobalTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateGlobalTableWithContext indicates an expected call of CreateGlobalTableWithContext.
func (mr *MockDynamoDBAPIMockRecorder) CreateGlobalTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGlobalTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateGlobalTableWithContext), varargs...)
}

// CreateTable mocks base method.
func (m *MockDynamoDBAPI) CreateTable(arg0 *dynamodb.CreateTableInput) (*dynamodb.CreateTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTable", arg0)
	ret0, _ := ret[0].(*dynamodb.CreateTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTable indicates an expected call of CreateTable.
func (mr *MockDynamoDBAPIMockRecorder) CreateTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateTable), arg0)
}

// CreateTableRequest mocks base method.
func (m *MockDynamoDBAPI) CreateTableRequest(arg0 *dynamodb.CreateTableInput) (*request.Request, *dynamodb.CreateTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.CreateTableOutput)
	return ret0, ret1
}

// CreateTableRequest indicates an expected call of CreateTableRequest.
func (mr *MockDynamoDBAPIMockRecorder) CreateTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateTableRequest), arg0)
}

// CreateTableWithContext mocks base method.
func (m *MockDynamoDBAPI) CreateTableWithContext(arg0 aws.Context, arg1 *dynamodb.CreateTableInput, arg2 ...request.Option) (*dynamodb.CreateTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTableWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.CreateTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTableWithContext indicates an expected call of CreateTableWithContext.
func (mr *MockDynamoDBAPIMockRecorder) CreateTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).CreateTableWithContext), varargs...)
}

// DeleteBackup mocks base method.
func (m *MockDynamoDBAPI) DeleteBackup(arg0 *dynamodb.DeleteBackupInput) (*dynamodb.DeleteBackupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBackup", arg0)
	ret0, _ := ret[0].(*dynamodb.DeleteBackupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBackup indicates an expected call of DeleteBackup.
func (mr *MockDynamoDBAPIMockRecorder) DeleteBackup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBackup", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteBackup), arg0)
}

// DeleteBackupRequest mocks base method.
func (m *MockDynamoDBAPI) DeleteBackupRequest(arg0 *dynamodb.DeleteBackupInput) (*request.Request, *dynamodb.DeleteBackupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBackupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DeleteBackupOutput)
	return ret0, ret1
}

// DeleteBackupRequest indicates an expected call of DeleteBackupRequest.
func (mr *MockDynamoDBAPIMockRecorder) DeleteBackupRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBackupRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteBackupRequest), arg0)
}

// DeleteBackupWithContext mocks base method.
func (m *MockDynamoDBAPI) DeleteBackupWithContext(arg0 aws.Context, arg1 *dynamodb.DeleteBackupInput, arg2 ...request.Option) (*dynamodb.DeleteBackupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteBackupWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.DeleteBackupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteBackupWithContext indicates an expected call of DeleteBackupWithContext.
func (mr *MockDynamoDBAPIMockRecorder) DeleteBackupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBackupWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteBackupWithContext), varargs...)
}

// DeleteItem mocks base method.
func (m *MockDynamoDBAPI) DeleteItem(arg0 *dynamodb.DeleteItemInput) (*dynamodb.DeleteItemOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteItem", arg0)
	ret0, _ := ret[0].(*dynamodb.DeleteItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteItem indicates an expected call of DeleteItem.
func (mr *MockDynamoDBAPIMockRecorder) DeleteItem(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteItem), arg0)
}

// DeleteItemRequest mocks base method.
func (m *MockDynamoDBAPI) DeleteItemRequest(arg0 *dynamodb.DeleteItemInput) (*request.Request, *dynamodb.DeleteItemOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteItemRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DeleteItemOutput)
	return ret0, ret1
}

// DeleteItemRequest indicates an expected call of DeleteItemRequest.
func (mr *MockDynamoDBAPIMockRecorder) DeleteItemRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteItemRequest), arg0)
}

// DeleteItemWithContext mocks base method.
func (m *MockDynamoDBAPI) DeleteItemWithContext(arg0 aws.Context, arg1 *dynamodb.DeleteItemInput, arg2 ...request.Option) (*dynamodb.DeleteItemOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteItemWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.DeleteItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteItemWithContext indicates an expected call of DeleteItemWithContext.
func (mr *MockDynamoDBAPIMockRecorder) DeleteItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteItemWithContext), varargs...)
}

// DeleteResourcePolicy mocks base method.
func (m *MockDynamoDBAPI) DeleteResourcePolicy(arg0 *dynamodb.DeleteResourcePolicyInput) (*dynamodb.DeleteResourcePolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteResourcePolicy", arg0)
	ret0, _ := ret[0].(*dynamodb.DeleteResourcePolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteResourcePolicy indicates an expected call of DeleteResourcePolicy.
func (mr *MockDynamoDBAPIMockRecorder) DeleteResourcePolicy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourcePolicy", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteResourcePolicy), arg0)
}

// DeleteResourcePolicyRequest mocks base method.
func (m *MockDynamoDBAPI) DeleteResourcePolicyRequest(arg0 *dynamodb.DeleteResourcePolicyInput) (*request.Request, *dynamodb.DeleteResourcePolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteResourcePolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DeleteResourcePolicyOutput)
	return ret0, ret1
}

// DeleteResourcePolicyRequest indicates an expected call of DeleteResourcePolicyRequest.
func (mr *MockDynamoDBAPIMockRecorder) DeleteResourcePolicyRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourcePolicyRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteResourcePolicyRequest), arg0)
}

// DeleteResourcePolicyWithContext mocks base method.
func (m *MockDynamoDBAPI) DeleteResourcePolicyWithContext(arg0 aws.Context, arg1 *dynamodb.DeleteResourcePolicyInput, arg2 ...request.Option) (*dynamodb.DeleteResourcePolicyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteResourcePolicyWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.DeleteResourcePolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteResourcePolicyWithContext indicates an expected call of DeleteResourcePolicyWithContext.
func (mr *MockDynamoDBAPIMockRecorder) DeleteResourcePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourcePolicyWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteResourcePolicyWithContext), varargs...)
}

// DeleteTable mocks base method.
func (m *MockDynamoDBAPI) DeleteTable(arg0 *dynamodb.DeleteTableInput) (*dynamodb.DeleteTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTable", arg0)
	ret0, _ := ret[0].(*dynamodb.DeleteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTable indicates an expected call of DeleteTable.
func (mr *MockDynamoDBAPIMockRecorder) DeleteTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteTable), arg0)
}

// DeleteTableRequest mocks base method.
func (m *MockDynamoDBAPI) DeleteTableRequest(arg0 *dynamodb.DeleteTableInput) (*request.Request, *dynamodb.DeleteTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DeleteTableOutput)
	return ret0, ret1
}

// DeleteTableRequest indicates an expected call of DeleteTableRequest.
func (mr *MockDynamoDBAPIMockRecorder) DeleteTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteTableRequest), arg0)
}

// DeleteTableWithContext mocks base method.
func (m *MockDynamoDBAPI) DeleteTableWithContext(arg0 aws.Context, arg1 *dynamodb.DeleteTableInput, arg2 ...request.Option) (*dynamodb.DeleteTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTableWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.DeleteTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTableWithContext indicates an expected call of DeleteTableWithContext.
func (mr *MockDynamoDBAPIMockRecorder) DeleteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DeleteTableWithContext), varargs...)
}

// DescribeBackup mocks base method.
func (m *MockDynamoDBAPI) DescribeBackup(arg0 *dynamodb.DescribeBackupInput) (*dynamodb.DescribeBackupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBackup", arg0)
	ret0, _ := ret[0].(*dynamodb.DescribeBackupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeBackup indicates an expected call of DescribeBackup.
func (mr *MockDynamoDBAPIMockRecorder) DescribeBackup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBackup", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeBackup), arg0)
}

// DescribeBackupRequest mocks base method.
func (m *MockDynamoDBAPI) DescribeBackupRequest(arg0 *dynamodb.DescribeBackupInput) (*request.Request, *dynamodb.DescribeBackupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeBackupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DescribeBackupOutput)
	return ret0, ret1
}

// DescribeBackupRequest indicates an expected call of DescribeBackupRequest.
func (mr *MockDynamoDBAPIMockRecorder) DescribeBackupRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBackupRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeBackupRequest), arg0)
}

// DescribeBackupWithContext mocks base method.
func (m *MockDynamoDBAPI) DescribeBackupWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeBackupInput, arg2 ...request.Option) (*dynamodb.DescribeBackupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeBackupWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.DescribeBackupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeBackupWithContext indicates an expected call of DescribeBackupWithContext.
func (mr *MockDynamoDBAPIMockRecorder) DescribeBackupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBackupWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeBackupWithContext), varargs...)
}

// DescribeContinuousBackups mocks base method.
func (m *MockDynamoDBAPI) DescribeContinuousBackups(arg0 *dynamodb.DescribeContinuousBackupsInput) (*dynamodb.DescribeContinuousBackupsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeContinuousBackups", arg0)
	ret0, _ := ret[0].(*dynamodb.DescribeContinuousBackupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeContinuousBackups indicates an expected call of DescribeContinuousBackups.
func (mr *MockDynamoDBAPIMockRecorder) DescribeContinuousBackups(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeContinuousBackups", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeContinuousBackups), arg0)
}

// DescribeContinuousBackupsRequest mocks base method.
func (m *MockDynamoDBAPI) DescribeContinuousBackupsRequest(arg0 *dynamodb.DescribeContinuousBackupsInput) (*request.Request, *dynamodb.DescribeContinuousBackupsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeContinuousBackupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DescribeContinuousBackupsOutput)
	return ret0, ret1
}

// DescribeContinuousBackupsRequest indicates an expected call of DescribeContinuousBackupsRequest.
func (mr *MockDynamoDBAPIMockRecorder) DescribeContinuousBackupsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeContinuousBackupsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeContinuousBackupsRequest), arg0)
}

// DescribeContinuousBackupsWithContext mocks base method.
func (m *MockDynamoDBAPI) DescribeContinuousBackupsWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeContinuousBackupsInput, arg2 ...request.Option) (*dynamodb.DescribeContinuousBackupsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeContinuousBackupsWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.DescribeContinuousBackupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeContinuousBackupsWithContext indicates an expected call of DescribeContinuousBackupsWithContext.
func (mr *MockDynamoDBAPIMockRecorder) DescribeContinuousBackupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeContinuousBackupsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeContinuousBackupsWithContext), varargs...)
}

// DescribeContributorInsights mocks base method.
func (m *MockDynamoDBAPI) DescribeContributorInsights(arg0 *dynamodb.DescribeContributorInsightsInput) (*dynamodb.DescribeContributorInsightsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeContributorInsights", arg0)
	ret0, _ := ret[0].(*dynamodb.DescribeContributorInsightsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeContributorInsights indicates an expected call of DescribeContributorInsights.
func (mr *MockDynamoDBAPIMockRecorder) DescribeContributorInsights(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeContributorInsights", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeContributorInsights), arg0)
}

// DescribeContributorInsightsRequest mocks base method.
func (m *MockDynamoDBAPI) DescribeContributorInsightsRequest(arg0 *dynamodb.DescribeContributorInsightsInput) (*request.Request, *dynamodb.DescribeContributorInsightsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeContributorInsightsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DescribeContributorInsightsOutput)
	return ret0, ret1
}

// DescribeContributorInsightsRequest indicates an expected call of DescribeContributorInsightsRequest.
func (mr *MockDynamoDBAPIMockRecorder) DescribeContributorInsightsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeContributorInsightsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeContributorInsightsRequest), arg0)
}

// DescribeContributorInsightsWithContext mocks base method.
func (m *MockDynamoDBAPI) DescribeContributorInsightsWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeContributorInsightsInput, arg2 ...request.Option) (*dynamodb.DescribeContributorInsightsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeContributorInsightsWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.DescribeContributorInsightsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeContributorInsightsWithContext indicates an expected call of DescribeContributorInsightsWithContext.
func (mr *MockDynamoDBAPIMockRecorder) DescribeContributorInsightsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeContributorInsightsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeContributorInsightsWithContext), varargs...)
}

// DescribeEndpoints mocks base method.
func (m *MockDynamoDBAPI) DescribeEndpoints(arg0 *dynamodb.DescribeEndpointsInput) (*dynamodb.DescribeEndpointsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEndpoints", arg0)
	ret0, _ := ret[0].(*dynamodb.DescribeEndpointsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeEndpoints indicates an expected call of DescribeEndpoints.
func (mr *MockDynamoDBAPIMockRecorder) DescribeEndpoints(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEndpoints", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeEndpoints), arg0)
}

// DescribeEndpointsRequest mocks base method.
func (m *MockDynamoDBAPI) DescribeEndpointsRequest(arg0 *dynamodb.DescribeEndpointsInput) (*request.Request, *dynamodb.DescribeEndpointsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeEndpointsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DescribeEndpointsOutput)
	return ret0, ret1
}

// DescribeEndpointsRequest indicates an expected call of DescribeEndpointsRequest.
func (mr *MockDynamoDBAPIMockRecorder) DescribeEndpointsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEndpointsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeEndpointsRequest), arg0)
}

// DescribeEndpointsWithContext mocks base method.
func (m *MockDynamoDBAPI) DescribeEndpointsWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeEndpointsInput, arg2 ...request.Option) (*dynamodb.DescribeEndpointsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeEndpointsWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.DescribeEndpointsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeEndpointsWithContext indicates an expected call of DescribeEndpointsWithContext.
func (mr *MockDynamoDBAPIMockRecorder) DescribeEndpointsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEndpointsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeEndpointsWithContext), varargs...)
}

// DescribeExport mocks base method.
func (m *MockDynamoDBAPI) DescribeExport(arg0 *dynamodb.DescribeExportInput) (*dynamodb.DescribeExportOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeExport", arg0)
	ret0, _ := ret[0].(*dynamodb.DescribeExportOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeExport indicates an expected call of DescribeExport.
func (mr *MockDynamoDBAPIMockRecorder) DescribeExport(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExport", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeExport), arg0)
}

// DescribeExportRequest mocks base method.
func (m *MockDynamoDBAPI) DescribeExportRequest(arg0 *dynamodb.DescribeExportInput) (*request.Request, *dynamodb.DescribeExportOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeExportRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DescribeExportOutput)
	return ret0, ret1
}

// DescribeExportRequest indicates an expected call of DescribeExportRequest.
func (mr *MockDynamoDBAPIMockRecorder) DescribeExportRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeExportRequest), arg0)
}

// DescribeExportWithContext mocks base method.
func (m *MockDynamoDBAPI) DescribeExportWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeExportInput, arg2 ...request.Option) (*dynamodb.DescribeExportOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeExportWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.DescribeExportOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeExportWithContext indicates an expected call of DescribeExportWithContext.
func (mr *MockDynamoDBAPIMockRecorder) DescribeExportWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeExportWithContext), varargs...)
}

// DescribeGlobalTable mocks base method.
func (m *MockDynamoDBAPI) DescribeGlobalTable(arg0 *dynamodb.DescribeGlobalTableInput) (*dynamodb.DescribeGlobalTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGlobalTable", arg0)
	ret0, _ := ret[0].(*dynamodb.DescribeGlobalTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeGlobalTable indicates an expected call of DescribeGlobalTable.
func (mr *MockDynamoDBAPIMockRecorder) DescribeGlobalTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGlobalTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeGlobalTable), arg0)
}

// DescribeGlobalTableRequest mocks base method.
func (m *MockDynamoDBAPI) DescribeGlobalTableRequest(arg0 *dynamodb.DescribeGlobalTableInput) (*request.Request, *dynamodb.DescribeGlobalTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGlobalTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DescribeGlobalTableOutput)
	return ret0, ret1
}

// DescribeGlobalTableRequest indicates an expected call of DescribeGlobalTableRequest.
func (mr *MockDynamoDBAPIMockRecorder) DescribeGlobalTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGlobalTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeGlobalTableRequest), arg0)
}

// DescribeGlobalTableSettings mocks base method.
func (m *MockDynamoDBAPI) DescribeGlobalTableSettings(arg0 *dynamodb.DescribeGlobalTableSettingsInput) (*dynamodb.DescribeGlobalTableSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGlobalTableSettings", arg0)
	ret0, _ := ret[0].(*dynamodb.DescribeGlobalTableSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeGlobalTableSettings indicates an expected call of DescribeGlobalTableSettings.
func (mr *MockDynamoDBAPIMockRecorder) DescribeGlobalTableSettings(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGlobalTableSettings", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeGlobalTableSettings), arg0)
}

// DescribeGlobalTableSettingsRequest mocks base method.
func (m *MockDynamoDBAPI) DescribeGlobalTableSettingsRequest(arg0 *dynamodb.DescribeGlobalTableSettingsInput) (*request.Request, *dynamodb.DescribeGlobalTableSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeGlobalTableSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DescribeGlobalTableSettingsOutput)
	return ret0, ret1
}

// DescribeGlobalTableSettingsRequest indicates an expected call of DescribeGlobalTableSettingsRequest.
func (mr *MockDynamoDBAPIMockRecorder) DescribeGlobalTableSettingsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGlobalTableSettingsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeGlobalTableSettingsRequest), arg0)
}

// DescribeGlobalTableSettingsWithContext mocks base method.
func (m *MockDynamoDBAPI) DescribeGlobalTableSettingsWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeGlobalTableSettingsInput, arg2 ...request.Option) (*dynamodb.DescribeGlobalTableSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeGlobalTableSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.DescribeGlobalTableSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeGlobalTableSettingsWithContext indicates an expected call of DescribeGlobalTableSettingsWithContext.
func (mr *MockDynamoDBAPIMockRecorder) DescribeGlobalTableSettingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGlobalTableSettingsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeGlobalTableSettingsWithContext), varargs...)
}

// DescribeGlobalTableWithContext mocks base method.
func (m *MockDynamoDBAPI) DescribeGlobalTableWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeGlobalTableInput, arg2 ...request.Option) (*dynamodb.DescribeGlobalTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeGlobalTableWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.DescribeGlobalTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeGlobalTableWithContext indicates an expected call of DescribeGlobalTableWithContext.
func (mr *MockDynamoDBAPIMockRecorder) DescribeGlobalTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeGlobalTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeGlobalTableWithContext), varargs...)
}

// DescribeImport mocks base method.
func (m *MockDynamoDBAPI) DescribeImport(arg0 *dynamodb.DescribeImportInput) (*dynamodb.DescribeImportOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeImport", arg0)
	ret0, _ := ret[0].(*dynamodb.DescribeImportOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeImport indicates an expected call of DescribeImport.
func (mr *MockDynamoDBAPIMockRecorder) DescribeImport(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImport", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeImport), arg0)
}

// DescribeImportRequest mocks base method.
func (m *MockDynamoDBAPI) DescribeImportRequest(arg0 *dynamodb.DescribeImportInput) (*request.Request, *dynamodb.DescribeImportOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeImportRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DescribeImportOutput)
	return ret0, ret1
}

// DescribeImportRequest indicates an expected call of DescribeImportRequest.
func (mr *MockDynamoDBAPIMockRecorder) DescribeImportRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeImportRequest), arg0)
}

// DescribeImportWithContext mocks base method.
func (m *MockDynamoDBAPI) DescribeImportWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeImportInput, arg2 ...request.Option) (*dynamodb.DescribeImportOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeImportWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.DescribeImportOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeImportWithContext indicates an expected call of DescribeImportWithContext.
func (mr *MockDynamoDBAPIMockRecorder) DescribeImportWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeImportWithContext), varargs...)
}

// DescribeKinesisStreamingDestination mocks base method.
func (m *MockDynamoDBAPI) DescribeKinesisStreamingDestination(arg0 *dynamodb.DescribeKinesisStreamingDestinationInput) (*dynamodb.DescribeKinesisStreamingDestinationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeKinesisStreamingDestination", arg0)
	ret0, _ := ret[0].(*dynamodb.DescribeKinesisStreamingDestinationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeKinesisStreamingDestination indicates an expected call of DescribeKinesisStreamingDestination.
func (mr *MockDynamoDBAPIMockRecorder) DescribeKinesisStreamingDestination(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKinesisStreamingDestination", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeKinesisStreamingDestination), arg0)
}

// DescribeKinesisStreamingDestinationRequest mocks base method.
func (m *MockDynamoDBAPI) DescribeKinesisStreamingDestinationRequest(arg0 *dynamodb.DescribeKinesisStreamingDestinationInput) (*request.Request, *dynamodb.DescribeKinesisStreamingDestinationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeKinesisStreamingDestinationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DescribeKinesisStreamingDestinationOutput)
	return ret0, ret1
}

// DescribeKinesisStreamingDestinationRequest indicates an expected call of DescribeKinesisStreamingDestinationRequest.
func (mr *MockDynamoDBAPIMockRecorder) DescribeKinesisStreamingDestinationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKinesisStreamingDestinationRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeKinesisStreamingDestinationRequest), arg0)
}

// DescribeKinesisStreamingDestinationWithContext mocks base method.
func (m *MockDynamoDBAPI) DescribeKinesisStreamingDestinationWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeKinesisStreamingDestinationInput, arg2 ...request.Option) (*dynamodb.DescribeKinesisStreamingDestinationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeKinesisStreamingDestinationWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.DescribeKinesisStreamingDestinationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeKinesisStreamingDestinationWithContext indicates an expected call of DescribeKinesisStreamingDestinationWithContext.
func (mr *MockDynamoDBAPIMockRecorder) DescribeKinesisStreamingDestinationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKinesisStreamingDestinationWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeKinesisStreamingDestinationWithContext), varargs...)
}

// DescribeLimits mocks base method.
func (m *MockDynamoDBAPI) DescribeLimits(arg0 *dynamodb.DescribeLimitsInput) (*dynamodb.DescribeLimitsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLimits", arg0)
	ret0, _ := ret[0].(*dynamodb.DescribeLimitsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeLimits indicates an expected call of DescribeLimits.
func (mr *MockDynamoDBAPIMockRecorder) DescribeLimits(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLimits", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeLimits), arg0)
}

// DescribeLimitsRequest mocks base method.
func (m *MockDynamoDBAPI) DescribeLimitsRequest(arg0 *dynamodb.DescribeLimitsInput) (*request.Request, *dynamodb.DescribeLimitsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLimitsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DescribeLimitsOutput)
	return ret0, ret1
}

// DescribeLimitsRequest indicates an expected call of DescribeLimitsRequest.
func (mr *MockDynamoDBAPIMockRecorder) DescribeLimitsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLimitsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeLimitsRequest), arg0)
}

// DescribeLimitsWithContext mocks base method.
func (m *MockDynamoDBAPI) DescribeLimitsWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeLimitsInput, arg2 ...request.Option) (*dynamodb.DescribeLimitsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeLimitsWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.DescribeLimitsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeLimitsWithContext indicates an expected call of DescribeLimitsWithContext.
func (mr *MockDynamoDBAPIMockRecorder) DescribeLimitsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLimitsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeLimitsWithContext), varargs...)
}

// DescribeTable mocks base method.
func (m *MockDynamoDBAPI) DescribeTable(arg0 *dynamodb.DescribeTableInput) (*dynamodb.DescribeTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTable", arg0)
	ret0, _ := ret[0].(*dynamodb.DescribeTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTable indicates an expected call of DescribeTable.
func (mr *MockDynamoDBAPIMockRecorder) DescribeTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTable), arg0)
}

// DescribeTableReplicaAutoScaling mocks base method.
func (m *MockDynamoDBAPI) DescribeTableReplicaAutoScaling(arg0 *dynamodb.DescribeTableReplicaAutoScalingInput) (*dynamodb.DescribeTableReplicaAutoScalingOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTableReplicaAutoScaling", arg0)
	ret0, _ := ret[0].(*dynamodb.DescribeTableReplicaAutoScalingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTableReplicaAutoScaling indicates an expected call of DescribeTableReplicaAutoScaling.
func (mr *MockDynamoDBAPIMockRecorder) DescribeTableReplicaAutoScaling(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTableReplicaAutoScaling", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTableReplicaAutoScaling), arg0)
}

// DescribeTableReplicaAutoScalingRequest mocks base method.
func (m *MockDynamoDBAPI) DescribeTableReplicaAutoScalingRequest(arg0 *dynamodb.DescribeTableReplicaAutoScalingInput) (*request.Request, *dynamodb.DescribeTableReplicaAutoScalingOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTableReplicaAutoScalingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DescribeTableReplicaAutoScalingOutput)
	return ret0, ret1
}

// DescribeTableReplicaAutoScalingRequest indicates an expected call of DescribeTableReplicaAutoScalingRequest.
func (mr *MockDynamoDBAPIMockRecorder) DescribeTableReplicaAutoScalingRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTableReplicaAutoScalingRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTableReplicaAutoScalingRequest), arg0)
}

// DescribeTableReplicaAutoScalingWithContext mocks base method.
func (m *MockDynamoDBAPI) DescribeTableReplicaAutoScalingWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeTableReplicaAutoScalingInput, arg2 ...request.Option) (*dynamodb.DescribeTableReplicaAutoScalingOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTableReplicaAutoScalingWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.DescribeTableReplicaAutoScalingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTableReplicaAutoScalingWithContext indicates an expected call of DescribeTableReplicaAutoScalingWithContext.
func (mr *MockDynamoDBAPIMockRecorder) DescribeTableReplicaAutoScalingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTableReplicaAutoScalingWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTableReplicaAutoScalingWithContext), varargs...)
}

// DescribeTableRequest mocks base method.
func (m *MockDynamoDBAPI) DescribeTableRequest(arg0 *dynamodb.DescribeTableInput) (*request.Request, *dynamodb.DescribeTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DescribeTableOutput)
	return ret0, ret1
}

// DescribeTableRequest indicates an expected call of DescribeTableRequest.
func (mr *MockDynamoDBAPIMockRecorder) DescribeTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTableRequest), arg0)
}

// DescribeTableWithContext mocks base method.
func (m *MockDynamoDBAPI) DescribeTableWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeTableInput, arg2 ...request.Option) (*dynamodb.DescribeTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTableWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.DescribeTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTableWithContext indicates an expected call of DescribeTableWithContext.
func (mr *MockDynamoDBAPIMockRecorder) DescribeTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTableWithContext), varargs...)
}

// DescribeTimeToLive mocks base method.
func (m *MockDynamoDBAPI) DescribeTimeToLive(arg0 *dynamodb.DescribeTimeToLiveInput) (*dynamodb.DescribeTimeToLiveOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTimeToLive", arg0)
	ret0, _ := ret[0].(*dynamodb.DescribeTimeToLiveOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTimeToLive indicates an expected call of DescribeTimeToLive.
func (mr *MockDynamoDBAPIMockRecorder) DescribeTimeToLive(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTimeToLive", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTimeToLive), arg0)
}

// DescribeTimeToLiveRequest mocks base method.
func (m *MockDynamoDBAPI) DescribeTimeToLiveRequest(arg0 *dynamodb.DescribeTimeToLiveInput) (*request.Request, *dynamodb.DescribeTimeToLiveOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTimeToLiveRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DescribeTimeToLiveOutput)
	return ret0, ret1
}

// DescribeTimeToLiveRequest indicates an expected call of DescribeTimeToLiveRequest.
func (mr *MockDynamoDBAPIMockRecorder) DescribeTimeToLiveRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTimeToLiveRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTimeToLiveRequest), arg0)
}

// DescribeTimeToLiveWithContext mocks base method.
func (m *MockDynamoDBAPI) DescribeTimeToLiveWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeTimeToLiveInput, arg2 ...request.Option) (*dynamodb.DescribeTimeToLiveOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTimeToLiveWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.DescribeTimeToLiveOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTimeToLiveWithContext indicates an expected call of DescribeTimeToLiveWithContext.
func (mr *MockDynamoDBAPIMockRecorder) DescribeTimeToLiveWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTimeToLiveWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DescribeTimeToLiveWithContext), varargs...)
}

// DisableKinesisStreamingDestination mocks base method.
func (m *MockDynamoDBAPI) DisableKinesisStreamingDestination(arg0 *dynamodb.DisableKinesisStreamingDestinationInput) (*dynamodb.DisableKinesisStreamingDestinationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableKinesisStreamingDestination", arg0)
	ret0, _ := ret[0].(*dynamodb.DisableKinesisStreamingDestinationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableKinesisStreamingDestination indicates an expected call of DisableKinesisStreamingDestination.
func (mr *MockDynamoDBAPIMockRecorder) DisableKinesisStreamingDestination(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableKinesisStreamingDestination", reflect.TypeOf((*MockDynamoDBAPI)(nil).DisableKinesisStreamingDestination), arg0)
}

// DisableKinesisStreamingDestinationRequest mocks base method.
func (m *MockDynamoDBAPI) DisableKinesisStreamingDestinationRequest(arg0 *dynamodb.DisableKinesisStreamingDestinationInput) (*request.Request, *dynamodb.DisableKinesisStreamingDestinationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableKinesisStreamingDestinationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.DisableKinesisStreamingDestinationOutput)
	return ret0, ret1
}

// DisableKinesisStreamingDestinationRequest indicates an expected call of DisableKinesisStreamingDestinationRequest.
func (mr *MockDynamoDBAPIMockRecorder) DisableKinesisStreamingDestinationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableKinesisStreamingDestinationRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).DisableKinesisStreamingDestinationRequest), arg0)
}

// DisableKinesisStreamingDestinationWithContext mocks base method.
func (m *MockDynamoDBAPI) DisableKinesisStreamingDestinationWithContext(arg0 aws.Context, arg1 *dynamodb.DisableKinesisStreamingDestinationInput, arg2 ...request.Option) (*dynamodb.DisableKinesisStreamingDestinationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisableKinesisStreamingDestinationWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.DisableKinesisStreamingDestinationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableKinesisStreamingDestinationWithContext indicates an expected call of DisableKinesisStreamingDestinationWithContext.
func (mr *MockDynamoDBAPIMockRecorder) DisableKinesisStreamingDestinationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableKinesisStreamingDestinationWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).DisableKinesisStreamingDestinationWithContext), varargs...)
}

// EnableKinesisStreamingDestination mocks base method.
func (m *MockDynamoDBAPI) EnableKinesisStreamingDestination(arg0 *dynamodb.EnableKinesisStreamingDestinationInput) (*dynamodb.EnableKinesisStreamingDestinationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableKinesisStreamingDestination", arg0)
	ret0, _ := ret[0].(*dynamodb.EnableKinesisStreamingDestinationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableKinesisStreamingDestination indicates an expected call of EnableKinesisStreamingDestination.
func (mr *MockDynamoDBAPIMockRecorder) EnableKinesisStreamingDestination(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableKinesisStreamingDestination", reflect.TypeOf((*MockDynamoDBAPI)(nil).EnableKinesisStreamingDestination), arg0)
}

// EnableKinesisStreamingDestinationRequest mocks base method.
func (m *MockDynamoDBAPI) EnableKinesisStreamingDestinationRequest(arg0 *dynamodb.EnableKinesisStreamingDestinationInput) (*request.Request, *dynamodb.EnableKinesisStreamingDestinationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableKinesisStreamingDestinationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.EnableKinesisStreamingDestinationOutput)
	return ret0, ret1
}

// EnableKinesisStreamingDestinationRequest indicates an expected call of EnableKinesisStreamingDestinationRequest.
func (mr *MockDynamoDBAPIMockRecorder) EnableKinesisStreamingDestinationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableKinesisStreamingDestinationRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).EnableKinesisStreamingDestinationRequest), arg0)
}

// EnableKinesisStreamingDestinationWithContext mocks base method.
func (m *MockDynamoDBAPI) EnableKinesisStreamingDestinationWithContext(arg0 aws.Context, arg1 *dynamodb.EnableKinesisStreamingDestinationInput, arg2 ...request.Option) (*dynamodb.EnableKinesisStreamingDestinationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableKinesisStreamingDestinationWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.EnableKinesisStreamingDestinationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableKinesisStreamingDestinationWithContext indicates an expected call of EnableKinesisStreamingDestinationWithContext.
func (mr *MockDynamoDBAPIMockRecorder) EnableKinesisStreamingDestinationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableKinesisStreamingDestinationWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).EnableKinesisStreamingDestinationWithContext), varargs...)
}

// ExecuteStatement mocks base method.
func (m *MockDynamoDBAPI) ExecuteStatement(arg0 *dynamodb.ExecuteStatementInput) (*dynamodb.ExecuteStatementOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecuteStatement", arg0)
	ret0, _ := ret[0].(*dynamodb.ExecuteStatementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExecuteStatement indicates an expected call of ExecuteStatement.
func (mr *MockDynamoDBAPIMockRecorder) ExecuteStatement(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteStatement", reflect.TypeOf((*MockDynamoDBAPI)(nil).ExecuteStatement), arg0)
}

// ExecuteStatementRequest mocks base method.
func (m *MockDynamoDBAPI) ExecuteStatementRequest(arg0 *dynamodb.ExecuteStatementInput) (*request.Request, *dynamodb.ExecuteStatementOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecuteStatementRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.ExecuteStatementOutput)
	return ret0, ret1
}

// ExecuteStatementRequest indicates an expected call of ExecuteStatementRequest.
func (mr *MockDynamoDBAPIMockRecorder) ExecuteStatementRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteStatementRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ExecuteStatementRequest), arg0)
}

// ExecuteStatementWithContext mocks base method.
func (m *MockDynamoDBAPI) ExecuteStatementWithContext(arg0 aws.Context, arg1 *dynamodb.ExecuteStatementInput, arg2 ...request.Option) (*dynamodb.ExecuteStatementOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ExecuteStatementWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.ExecuteStatementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExecuteStatementWithContext indicates an expected call of ExecuteStatementWithContext.
func (mr *MockDynamoDBAPIMockRecorder) ExecuteStatementWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteStatementWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ExecuteStatementWithContext), varargs...)
}

// ExecuteTransaction mocks base method.
func (m *MockDynamoDBAPI) ExecuteTransaction(arg0 *dynamodb.ExecuteTransactionInput) (*dynamodb.ExecuteTransactionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecuteTransaction", arg0)
	ret0, _ := ret[0].(*dynamodb.ExecuteTransactionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExecuteTransaction indicates an expected call of ExecuteTransaction.
func (mr *MockDynamoDBAPIMockRecorder) ExecuteTransaction(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteTransaction", reflect.TypeOf((*MockDynamoDBAPI)(nil).ExecuteTransaction), arg0)
}

// ExecuteTransactionRequest mocks base method.
func (m *MockDynamoDBAPI) ExecuteTransactionRequest(arg0 *dynamodb.ExecuteTransactionInput) (*request.Request, *dynamodb.ExecuteTransactionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecuteTransactionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.ExecuteTransactionOutput)
	return ret0, ret1
}

// ExecuteTransactionRequest indicates an expected call of ExecuteTransactionRequest.
func (mr *MockDynamoDBAPIMockRecorder) ExecuteTransactionRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteTransactionRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ExecuteTransactionRequest), arg0)
}

// ExecuteTransactionWithContext mocks base method.
func (m *MockDynamoDBAPI) ExecuteTransactionWithContext(arg0 aws.Context, arg1 *dynamodb.ExecuteTransactionInput, arg2 ...request.Option) (*dynamodb.ExecuteTransactionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ExecuteTransactionWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.ExecuteTransactionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExecuteTransactionWithContext indicates an expected call of ExecuteTransactionWithContext.
func (mr *MockDynamoDBAPIMockRecorder) ExecuteTransactionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteTransactionWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ExecuteTransactionWithContext), varargs...)
}

// ExportTableToPointInTime mocks base method.
func (m *MockDynamoDBAPI) ExportTableToPointInTime(arg0 *dynamodb.ExportTableToPointInTimeInput) (*dynamodb.ExportTableToPointInTimeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExportTableToPointInTime", arg0)
	ret0, _ := ret[0].(*dynamodb.ExportTableToPointInTimeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExportTableToPointInTime indicates an expected call of ExportTableToPointInTime.
func (mr *MockDynamoDBAPIMockRecorder) ExportTableToPointInTime(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTableToPointInTime", reflect.TypeOf((*MockDynamoDBAPI)(nil).ExportTableToPointInTime), arg0)
}

// ExportTableToPointInTimeRequest mocks base method.
func (m *MockDynamoDBAPI) ExportTableToPointInTimeRequest(arg0 *dynamodb.ExportTableToPointInTimeInput) (*request.Request, *dynamodb.ExportTableToPointInTimeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExportTableToPointInTimeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.ExportTableToPointInTimeOutput)
	return ret0, ret1
}

// ExportTableToPointInTimeRequest indicates an expected call of ExportTableToPointInTimeRequest.
func (mr *MockDynamoDBAPIMockRecorder) ExportTableToPointInTimeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTableToPointInTimeRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ExportTableToPointInTimeRequest), arg0)
}

// ExportTableToPointInTimeWithContext mocks base method.
func (m *MockDynamoDBAPI) ExportTableToPointInTimeWithContext(arg0 aws.Context, arg1 *dynamodb.ExportTableToPointInTimeInput, arg2 ...request.Option) (*dynamodb.ExportTableToPointInTimeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ExportTableToPointInTimeWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.ExportTableToPointInTimeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExportTableToPointInTimeWithContext indicates an expected call of ExportTableToPointInTimeWithContext.
func (mr *MockDynamoDBAPIMockRecorder) ExportTableToPointInTimeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTableToPointInTimeWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ExportTableToPointInTimeWithContext), varargs...)
}

// GetItem mocks base method.
func (m *MockDynamoDBAPI) GetItem(arg0 *dynamodb.GetItemInput) (*dynamodb.GetItemOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetItem", arg0)
	ret0, _ := ret[0].(*dynamodb.GetItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetItem indicates an expected call of GetItem.
func (mr *MockDynamoDBAPIMockRecorder) GetItem(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).GetItem), arg0)
}

// GetItemRequest mocks base method.
func (m *MockDynamoDBAPI) GetItemRequest(arg0 *dynamodb.GetItemInput) (*request.Request, *dynamodb.GetItemOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetItemRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.GetItemOutput)
	return ret0, ret1
}

// GetItemRequest indicates an expected call of GetItemRequest.
func (mr *MockDynamoDBAPIMockRecorder) GetItemRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).GetItemRequest), arg0)
}

// GetItemWithContext mocks base method.
func (m *MockDynamoDBAPI) GetItemWithContext(arg0 aws.Context, arg1 *dynamodb.GetItemInput, arg2 ...request.Option) (*dynamodb.GetItemOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetItemWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.GetItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetItemWithContext indicates an expected call of GetItemWithContext.
func (mr *MockDynamoDBAPIMockRecorder) GetItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).GetItemWithContext), varargs...)
}

// GetResourcePolicy mocks base method.
func (m *MockDynamoDBAPI) GetResourcePolicy(arg0 *dynamodb.GetResourcePolicyInput) (*dynamodb.GetResourcePolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetResourcePolicy", arg0)
	ret0, _ := ret[0].(*dynamodb.GetResourcePolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetResourcePolicy indicates an expected call of GetResourcePolicy.
func (mr *MockDynamoDBAPIMockRecorder) GetResourcePolicy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcePolicy", reflect.TypeOf((*MockDynamoDBAPI)(nil).GetResourcePolicy), arg0)
}

// GetResourcePolicyRequest mocks base method.
func (m *MockDynamoDBAPI) GetResourcePolicyRequest(arg0 *dynamodb.GetResourcePolicyInput) (*request.Request, *dynamodb.GetResourcePolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetResourcePolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.GetResourcePolicyOutput)
	return ret0, ret1
}

// GetResourcePolicyRequest indicates an expected call of GetResourcePolicyRequest.
func (mr *MockDynamoDBAPIMockRecorder) GetResourcePolicyRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcePolicyRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).GetResourcePolicyRequest), arg0)
}

// GetResourcePolicyWithContext mocks base method.
func (m *MockDynamoDBAPI) GetResourcePolicyWithContext(arg0 aws.Context, arg1 *dynamodb.GetResourcePolicyInput, arg2 ...request.Option) (*dynamodb.GetResourcePolicyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetResourcePolicyWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.GetResourcePolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetResourcePolicyWithContext indicates an expected call of GetResourcePolicyWithContext.
func (mr *MockDynamoDBAPIMockRecorder) GetResourcePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcePolicyWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).GetResourcePolicyWithContext), varargs...)
}

// ImportTable mocks base method.
func (m *MockDynamoDBAPI) ImportTable(arg0 *dynamodb.ImportTableInput) (*dynamodb.ImportTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportTable", arg0)
	ret0, _ := ret[0].(*dynamodb.ImportTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImportTable indicates an expected call of ImportTable.
func (mr *MockDynamoDBAPIMockRecorder) ImportTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).ImportTable), arg0)
}

// ImportTableRequest mocks base method.
func (m *MockDynamoDBAPI) ImportTableRequest(arg0 *dynamodb.ImportTableInput) (*request.Request, *dynamodb.ImportTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.ImportTableOutput)
	return ret0, ret1
}

// ImportTableRequest indicates an expected call of ImportTableRequest.
func (mr *MockDynamoDBAPIMockRecorder) ImportTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ImportTableRequest), arg0)
}

// ImportTableWithContext mocks base method.
func (m *MockDynamoDBAPI) ImportTableWithContext(arg0 aws.Context, arg1 *dynamodb.ImportTableInput, arg2 ...request.Option) (*dynamodb.ImportTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ImportTableWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.ImportTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImportTableWithContext indicates an expected call of ImportTableWithContext.
func (mr *MockDynamoDBAPIMockRecorder) ImportTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ImportTableWithContext), varargs...)
}

// ListBackups mocks base method.
func (m *MockDynamoDBAPI) ListBackups(arg0 *dynamodb.ListBackupsInput) (*dynamodb.ListBackupsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBackups", arg0)
	ret0, _ := ret[0].(*dynamodb.ListBackupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBackups indicates an expected call of ListBackups.
func (mr *MockDynamoDBAPIMockRecorder) ListBackups(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBackups", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListBackups), arg0)
}

// ListBackupsRequest mocks base method.
func (m *MockDynamoDBAPI) ListBackupsRequest(arg0 *dynamodb.ListBackupsInput) (*request.Request, *dynamodb.ListBackupsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBackupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.ListBackupsOutput)
	return ret0, ret1
}

// ListBackupsRequest indicates an expected call of ListBackupsRequest.
func (mr *MockDynamoDBAPIMockRecorder) ListBackupsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBackupsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListBackupsRequest), arg0)
}

// ListBackupsWithContext mocks base method.
func (m *MockDynamoDBAPI) ListBackupsWithContext(arg0 aws.Context, arg1 *dynamodb.ListBackupsInput, arg2 ...request.Option) (*dynamodb.ListBackupsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListBackupsWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.ListBackupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBackupsWithContext indicates an expected call of ListBackupsWithContext.
func (mr *MockDynamoDBAPIMockRecorder) ListBackupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBackupsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListBackupsWithContext), varargs...)
}

// ListContributorInsights mocks base method.
func (m *MockDynamoDBAPI) ListContributorInsights(arg0 *dynamodb.ListContributorInsightsInput) (*dynamodb.ListContributorInsightsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListContributorInsights", arg0)
	ret0, _ := ret[0].(*dynamodb.ListContributorInsightsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListContributorInsights indicates an expected call of ListContributorInsights.
func (mr *MockDynamoDBAPIMockRecorder) ListContributorInsights(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContributorInsights", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListContributorInsights), arg0)
}

// ListContributorInsightsPages mocks base method.
func (m *MockDynamoDBAPI) ListContributorInsightsPages(arg0 *dynamodb.ListContributorInsightsInput, arg1 func(*dynamodb.ListContributorInsightsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListContributorInsightsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListContributorInsightsPages indicates an expected call of ListContributorInsightsPages.
func (mr *MockDynamoDBAPIMockRecorder) ListContributorInsightsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContributorInsightsPages", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListContributorInsightsPages), arg0, arg1)
}

// ListContributorInsightsPagesWithContext mocks base method.
func (m *MockDynamoDBAPI) ListContributorInsightsPagesWithContext(arg0 aws.Context, arg1 *dynamodb.ListContributorInsightsInput, arg2 func(*dynamodb.ListContributorInsightsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListContributorInsightsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListContributorInsightsPagesWithContext indicates an expected call of ListContributorInsightsPagesWithContext.
func (mr *MockDynamoDBAPIMockRecorder) ListContributorInsightsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContributorInsightsPagesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListContributorInsightsPagesWithContext), varargs...)
}

// ListContributorInsightsRequest mocks base method.
func (m *MockDynamoDBAPI) ListContributorInsightsRequest(arg0 *dynamodb.ListContributorInsightsInput) (*request.Request, *dynamodb.ListContributorInsightsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListContributorInsightsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.ListContributorInsightsOutput)
	return ret0, ret1
}

// ListContributorInsightsRequest indicates an expected call of ListContributorInsightsRequest.
func (mr *MockDynamoDBAPIMockRecorder) ListContributorInsightsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContributorInsightsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListContributorInsightsRequest), arg0)
}

// ListContributorInsightsWithContext mocks base method.
func (m *MockDynamoDBAPI) ListContributorInsightsWithContext(arg0 aws.Context, arg1 *dynamodb.ListContributorInsightsInput, arg2 ...request.Option) (*dynamodb.ListContributorInsightsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListContributorInsightsWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.ListContributorInsightsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListContributorInsightsWithContext indicates an expected call of ListContributorInsightsWithContext.
func (mr *MockDynamoDBAPIMockRecorder) ListContributorInsightsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContributorInsightsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListContributorInsightsWithContext), varargs...)
}

// ListExports mocks base method.
func (m *MockDynamoDBAPI) ListExports(arg0 *dynamodb.ListExportsInput) (*dynamodb.ListExportsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListExports", arg0)
	ret0, _ := ret[0].(*dynamodb.ListExportsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListExports indicates an expected call of ListExports.
func (mr *MockDynamoDBAPIMockRecorder) ListExports(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExports", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListExports), arg0)
}

// ListExportsPages mocks base method.
func (m *MockDynamoDBAPI) ListExportsPages(arg0 *dynamodb.ListExportsInput, arg1 func(*dynamodb.ListExportsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListExportsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListExportsPages indicates an expected call of ListExportsPages.
func (mr *MockDynamoDBAPIMockRecorder) ListExportsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExportsPages", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListExportsPages), arg0, arg1)
}

// ListExportsPagesWithContext mocks base method.
func (m *MockDynamoDBAPI) ListExportsPagesWithContext(arg0 aws.Context, arg1 *dynamodb.ListExportsInput, arg2 func(*dynamodb.ListExportsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListExportsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListExportsPagesWithContext indicates an expected call of ListExportsPagesWithContext.
func (mr *MockDynamoDBAPIMockRecorder) ListExportsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExportsPagesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListExportsPagesWithContext), varargs...)
}

// ListExportsRequest mocks base method.
func (m *MockDynamoDBAPI) ListExportsRequest(arg0 *dynamodb.ListExportsInput) (*request.Request, *dynamodb.ListExportsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListExportsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.ListExportsOutput)
	return ret0, ret1
}

// ListExportsRequest indicates an expected call of ListExportsRequest.
func (mr *MockDynamoDBAPIMockRecorder) ListExportsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExportsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListExportsRequest), arg0)
}

// ListExportsWithContext mocks base method.
func (m *MockDynamoDBAPI) ListExportsWithContext(arg0 aws.Context, arg1 *dynamodb.ListExportsInput, arg2 ...request.Option) (*dynamodb.ListExportsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListExportsWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.ListExportsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListExportsWithContext indicates an expected call of ListExportsWithContext.
func (mr *MockDynamoDBAPIMockRecorder) ListExportsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExportsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListExportsWithContext), varargs...)
}

// ListGlobalTables mocks base method.
func (m *MockDynamoDBAPI) ListGlobalTables(arg0 *dynamodb.ListGlobalTablesInput) (*dynamodb.ListGlobalTablesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGlobalTables", arg0)
	ret0, _ := ret[0].(*dynamodb.ListGlobalTablesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListGlobalTables indicates an expected call of ListGlobalTables.
func (mr *MockDynamoDBAPIMockRecorder) ListGlobalTables(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGlobalTables", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListGlobalTables), arg0)
}

// ListGlobalTablesRequest mocks base method.
func (m *MockDynamoDBAPI) ListGlobalTablesRequest(arg0 *dynamodb.ListGlobalTablesInput) (*request.Request, *dynamodb.ListGlobalTablesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListGlobalTablesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.ListGlobalTablesOutput)
	return ret0, ret1
}

// ListGlobalTablesRequest indicates an expected call of ListGlobalTablesRequest.
func (mr *MockDynamoDBAPIMockRecorder) ListGlobalTablesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGlobalTablesRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListGlobalTablesRequest), arg0)
}

// ListGlobalTablesWithContext mocks base method.
func (m *MockDynamoDBAPI) ListGlobalTablesWithContext(arg0 aws.Context, arg1 *dynamodb.ListGlobalTablesInput, arg2 ...request.Option) (*dynamodb.ListGlobalTablesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListGlobalTablesWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.ListGlobalTablesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListGlobalTablesWithContext indicates an expected call of ListGlobalTablesWithContext.
func (mr *MockDynamoDBAPIMockRecorder) ListGlobalTablesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGlobalTablesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListGlobalTablesWithContext), varargs...)
}

// ListImports mocks base method.
func (m *MockDynamoDBAPI) ListImports(arg0 *dynamodb.ListImportsInput) (*dynamodb.ListImportsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListImports", arg0)
	ret0, _ := ret[0].(*dynamodb.ListImportsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListImports indicates an expected call of ListImports.
func (mr *MockDynamoDBAPIMockRecorder) ListImports(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImports", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListImports), arg0)
}

// ListImportsPages mocks base method.
func (m *MockDynamoDBAPI) ListImportsPages(arg0 *dynamodb.ListImportsInput, arg1 func(*dynamodb.ListImportsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListImportsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListImportsPages indicates an expected call of ListImportsPages.
func (mr *MockDynamoDBAPIMockRecorder) ListImportsPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImportsPages", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListImportsPages), arg0, arg1)
}

// ListImportsPagesWithContext mocks base method.
func (m *MockDynamoDBAPI) ListImportsPagesWithContext(arg0 aws.Context, arg1 *dynamodb.ListImportsInput, arg2 func(*dynamodb.ListImportsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListImportsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListImportsPagesWithContext indicates an expected call of ListImportsPagesWithContext.
func (mr *MockDynamoDBAPIMockRecorder) ListImportsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImportsPagesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListImportsPagesWithContext), varargs...)
}

// ListImportsRequest mocks base method.
func (m *MockDynamoDBAPI) ListImportsRequest(arg0 *dynamodb.ListImportsInput) (*request.Request, *dynamodb.ListImportsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListImportsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.ListImportsOutput)
	return ret0, ret1
}

// ListImportsRequest indicates an expected call of ListImportsRequest.
func (mr *MockDynamoDBAPIMockRecorder) ListImportsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImportsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListImportsRequest), arg0)
}

// ListImportsWithContext mocks base method.
func (m *MockDynamoDBAPI) ListImportsWithContext(arg0 aws.Context, arg1 *dynamodb.ListImportsInput, arg2 ...request.Option) (*dynamodb.ListImportsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListImportsWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.ListImportsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListImportsWithContext indicates an expected call of ListImportsWithContext.
func (mr *MockDynamoDBAPIMockRecorder) ListImportsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImportsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListImportsWithContext), varargs...)
}

// ListTables mocks base method.
func (m *MockDynamoDBAPI) ListTables(arg0 *dynamodb.ListTablesInput) (*dynamodb.ListTablesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTables", arg0)
	ret0, _ := ret[0].(*dynamodb.ListTablesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTables indicates an expected call of ListTables.
func (mr *MockDynamoDBAPIMockRecorder) ListTables(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTables", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTables), arg0)
}

// ListTablesPages mocks base method.
func (m *MockDynamoDBAPI) ListTablesPages(arg0 *dynamodb.ListTablesInput, arg1 func(*dynamodb.ListTablesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTablesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTablesPages indicates an expected call of ListTablesPages.
func (mr *MockDynamoDBAPIMockRecorder) ListTablesPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTablesPages", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTablesPages), arg0, arg1)
}

// ListTablesPagesWithContext mocks base method.
func (m *MockDynamoDBAPI) ListTablesPagesWithContext(arg0 aws.Context, arg1 *dynamodb.ListTablesInput, arg2 func(*dynamodb.ListTablesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTablesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTablesPagesWithContext indicates an expected call of ListTablesPagesWithContext.
func (mr *MockDynamoDBAPIMockRecorder) ListTablesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTablesPagesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTablesPagesWithContext), varargs...)
}

// ListTablesRequest mocks base method.
func (m *MockDynamoDBAPI) ListTablesRequest(arg0 *dynamodb.ListTablesInput) (*request.Request, *dynamodb.ListTablesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTablesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.ListTablesOutput)
	return ret0, ret1
}

// ListTablesRequest indicates an expected call of ListTablesRequest.
func (mr *MockDynamoDBAPIMockRecorder) ListTablesRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTablesRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTablesRequest), arg0)
}

// ListTablesWithContext mocks base method.
func (m *MockDynamoDBAPI) ListTablesWithContext(arg0 aws.Context, arg1 *dynamodb.ListTablesInput, arg2 ...request.Option) (*dynamodb.ListTablesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTablesWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.ListTablesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTablesWithContext indicates an expected call of ListTablesWithContext.
func (mr *MockDynamoDBAPIMockRecorder) ListTablesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTablesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTablesWithContext), varargs...)
}

// ListTagsOfResource mocks base method.
func (m *MockDynamoDBAPI) ListTagsOfResource(arg0 *dynamodb.ListTagsOfResourceInput) (*dynamodb.ListTagsOfResourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsOfResource", arg0)
	ret0, _ := ret[0].(*dynamodb.ListTagsOfResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTagsOfResource indicates an expected call of ListTagsOfResource.
func (mr *MockDynamoDBAPIMockRecorder) ListTagsOfResource(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsOfResource", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTagsOfResource), arg0)
}

// ListTagsOfResourceRequest mocks base method.
func (m *MockDynamoDBAPI) ListTagsOfResourceRequest(arg0 *dynamodb.ListTagsOfResourceInput) (*request.Request, *dynamodb.ListTagsOfResourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsOfResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.ListTagsOfResourceOutput)
	return ret0, ret1
}

// ListTagsOfResourceRequest indicates an expected call of ListTagsOfResourceRequest.
func (mr *MockDynamoDBAPIMockRecorder) ListTagsOfResourceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsOfResourceRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTagsOfResourceRequest), arg0)
}

// ListTagsOfResourceWithContext mocks base method.
func (m *MockDynamoDBAPI) ListTagsOfResourceWithContext(arg0 aws.Context, arg1 *dynamodb.ListTagsOfResourceInput, arg2 ...request.Option) (*dynamodb.ListTagsOfResourceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTagsOfResourceWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.ListTagsOfResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTagsOfResourceWithContext indicates an expected call of ListTagsOfResourceWithContext.
func (mr *MockDynamoDBAPIMockRecorder) ListTagsOfResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsOfResourceWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ListTagsOfResourceWithContext), varargs...)
}

// PutItem mocks base method.
func (m *MockDynamoDBAPI) PutItem(arg0 *dynamodb.PutItemInput) (*dynamodb.PutItemOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutItem", arg0)
	ret0, _ := ret[0].(*dynamodb.PutItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutItem indicates an expected call of PutItem.
func (mr *MockDynamoDBAPIMockRecorder) PutItem(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).PutItem), arg0)
}

// PutItemRequest mocks base method.
func (m *MockDynamoDBAPI) PutItemRequest(arg0 *dynamodb.PutItemInput) (*request.Request, *dynamodb.PutItemOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutItemRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.PutItemOutput)
	return ret0, ret1
}

// PutItemRequest indicates an expected call of PutItemRequest.
func (mr *MockDynamoDBAPIMockRecorder) PutItemRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).PutItemRequest), arg0)
}

// PutItemWithContext mocks base method.
func (m *MockDynamoDBAPI) PutItemWithContext(arg0 aws.Context, arg1 *dynamodb.PutItemInput, arg2 ...request.Option) (*dynamodb.PutItemOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutItemWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.PutItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutItemWithContext indicates an expected call of PutItemWithContext.
func (mr *MockDynamoDBAPIMockRecorder) PutItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).PutItemWithContext), varargs...)
}

// PutResourcePolicy mocks base method.
func (m *MockDynamoDBAPI) PutResourcePolicy(arg0 *dynamodb.PutResourcePolicyInput) (*dynamodb.PutResourcePolicyOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutResourcePolicy", arg0)
	ret0, _ := ret[0].(*dynamodb.PutResourcePolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutResourcePolicy indicates an expected call of PutResourcePolicy.
func (mr *MockDynamoDBAPIMockRecorder) PutResourcePolicy(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResourcePolicy", reflect.TypeOf((*MockDynamoDBAPI)(nil).PutResourcePolicy), arg0)
}

// PutResourcePolicyRequest mocks base method.
func (m *MockDynamoDBAPI) PutResourcePolicyRequest(arg0 *dynamodb.PutResourcePolicyInput) (*request.Request, *dynamodb.PutResourcePolicyOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutResourcePolicyRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.PutResourcePolicyOutput)
	return ret0, ret1
}

// PutResourcePolicyRequest indicates an expected call of PutResourcePolicyRequest.
func (mr *MockDynamoDBAPIMockRecorder) PutResourcePolicyRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResourcePolicyRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).PutResourcePolicyRequest), arg0)
}

// PutResourcePolicyWithContext mocks base method.
func (m *MockDynamoDBAPI) PutResourcePolicyWithContext(arg0 aws.Context, arg1 *dynamodb.PutResourcePolicyInput, arg2 ...request.Option) (*dynamodb.PutResourcePolicyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutResourcePolicyWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.PutResourcePolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutResourcePolicyWithContext indicates an expected call of PutResourcePolicyWithContext.
func (mr *MockDynamoDBAPIMockRecorder) PutResourcePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResourcePolicyWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).PutResourcePolicyWithContext), varargs...)
}

// Query mocks base method.
func (m *MockDynamoDBAPI) Query(arg0 *dynamodb.QueryInput) (*dynamodb.QueryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Query", arg0)
	ret0, _ := ret[0].(*dynamodb.QueryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Query indicates an expected call of Query.
func (mr *MockDynamoDBAPIMockRecorder) Query(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockDynamoDBAPI)(nil).Query), arg0)
}

// QueryPages mocks base method.
func (m *MockDynamoDBAPI) QueryPages(arg0 *dynamodb.QueryInput, arg1 func(*dynamodb.QueryOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// QueryPages indicates an expected call of QueryPages.
func (mr *MockDynamoDBAPIMockRecorder) QueryPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryPages", reflect.TypeOf((*MockDynamoDBAPI)(nil).QueryPages), arg0, arg1)
}

// QueryPagesWithContext mocks base method.
func (m *MockDynamoDBAPI) QueryPagesWithContext(arg0 aws.Context, arg1 *dynamodb.QueryInput, arg2 func(*dynamodb.QueryOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// QueryPagesWithContext indicates an expected call of QueryPagesWithContext.
func (mr *MockDynamoDBAPIMockRecorder) QueryPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryPagesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).QueryPagesWithContext), varargs...)
}

// QueryRequest mocks base method.
func (m *MockDynamoDBAPI) QueryRequest(arg0 *dynamodb.QueryInput) (*request.Request, *dynamodb.QueryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.QueryOutput)
	return ret0, ret1
}

// QueryRequest indicates an expected call of QueryRequest.
func (mr *MockDynamoDBAPIMockRecorder) QueryRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).QueryRequest), arg0)
}

// QueryWithContext mocks base method.
func (m *MockDynamoDBAPI) QueryWithContext(arg0 aws.Context, arg1 *dynamodb.QueryInput, arg2 ...request.Option) (*dynamodb.QueryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.QueryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryWithContext indicates an expected call of QueryWithContext.
func (mr *MockDynamoDBAPIMockRecorder) QueryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).QueryWithContext), varargs...)
}

// RestoreTableFromBackup mocks base method.
func (m *MockDynamoDBAPI) RestoreTableFromBackup(arg0 *dynamodb.RestoreTableFromBackupInput) (*dynamodb.RestoreTableFromBackupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreTableFromBackup", arg0)
	ret0, _ := ret[0].(*dynamodb.RestoreTableFromBackupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RestoreTableFromBackup indicates an expected call of RestoreTableFromBackup.
func (mr *MockDynamoDBAPIMockRecorder) RestoreTableFromBackup(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreTableFromBackup", reflect.TypeOf((*MockDynamoDBAPI)(nil).RestoreTableFromBackup), arg0)
}

// RestoreTableFromBackupRequest mocks base method.
func (m *MockDynamoDBAPI) RestoreTableFromBackupRequest(arg0 *dynamodb.RestoreTableFromBackupInput) (*request.Request, *dynamodb.RestoreTableFromBackupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreTableFromBackupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.RestoreTableFromBackupOutput)
	return ret0, ret1
}

// RestoreTableFromBackupRequest indicates an expected call of RestoreTableFromBackupRequest.
func (mr *MockDynamoDBAPIMockRecorder) RestoreTableFromBackupRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreTableFromBackupRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).RestoreTableFromBackupRequest), arg0)
}

// RestoreTableFromBackupWithContext mocks base method.
func (m *MockDynamoDBAPI) RestoreTableFromBackupWithContext(arg0 aws.Context, arg1 *dynamodb.RestoreTableFromBackupInput, arg2 ...request.Option) (*dynamodb.RestoreTableFromBackupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RestoreTableFromBackupWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.RestoreTableFromBackupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RestoreTableFromBackupWithContext indicates an expected call of RestoreTableFromBackupWithContext.
func (mr *MockDynamoDBAPIMockRecorder) RestoreTableFromBackupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreTableFromBackupWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).RestoreTableFromBackupWithContext), varargs...)
}

// RestoreTableToPointInTime mocks base method.
func (m *MockDynamoDBAPI) RestoreTableToPointInTime(arg0 *dynamodb.RestoreTableToPointInTimeInput) (*dynamodb.RestoreTableToPointInTimeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreTableToPointInTime", arg0)
	ret0, _ := ret[0].(*dynamodb.RestoreTableToPointInTimeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RestoreTableToPointInTime indicates an expected call of RestoreTableToPointInTime.
func (mr *MockDynamoDBAPIMockRecorder) RestoreTableToPointInTime(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreTableToPointInTime", reflect.TypeOf((*MockDynamoDBAPI)(nil).RestoreTableToPointInTime), arg0)
}

// RestoreTableToPointInTimeRequest mocks base method.
func (m *MockDynamoDBAPI) RestoreTableToPointInTimeRequest(arg0 *dynamodb.RestoreTableToPointInTimeInput) (*request.Request, *dynamodb.RestoreTableToPointInTimeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreTableToPointInTimeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.RestoreTableToPointInTimeOutput)
	return ret0, ret1
}

// RestoreTableToPointInTimeRequest indicates an expected call of RestoreTableToPointInTimeRequest.
func (mr *MockDynamoDBAPIMockRecorder) RestoreTableToPointInTimeRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreTableToPointInTimeRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).RestoreTableToPointInTimeRequest), arg0)
}

// RestoreTableToPointInTimeWithContext mocks base method.
func (m *MockDynamoDBAPI) RestoreTableToPointInTimeWithContext(arg0 aws.Context, arg1 *dynamodb.RestoreTableToPointInTimeInput, arg2 ...request.Option) (*dynamodb.RestoreTableToPointInTimeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RestoreTableToPointInTimeWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.RestoreTableToPointInTimeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RestoreTableToPointInTimeWithContext indicates an expected call of RestoreTableToPointInTimeWithContext.
func (mr *MockDynamoDBAPIMockRecorder) RestoreTableToPointInTimeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreTableToPointInTimeWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).RestoreTableToPointInTimeWithContext), varargs...)
}

// Scan mocks base method.
func (m *MockDynamoDBAPI) Scan(arg0 *dynamodb.ScanInput) (*dynamodb.ScanOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Scan", arg0)
	ret0, _ := ret[0].(*dynamodb.ScanOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Scan indicates an expected call of Scan.
func (mr *MockDynamoDBAPIMockRecorder) Scan(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockDynamoDBAPI)(nil).Scan), arg0)
}

// ScanPages mocks base method.
func (m *MockDynamoDBAPI) ScanPages(arg0 *dynamodb.ScanInput, arg1 func(*dynamodb.ScanOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanPages indicates an expected call of ScanPages.
func (mr *MockDynamoDBAPIMockRecorder) ScanPages(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanPages", reflect.TypeOf((*MockDynamoDBAPI)(nil).ScanPages), arg0, arg1)
}

// ScanPagesWithContext mocks base method.
func (m *MockDynamoDBAPI) ScanPagesWithContext(arg0 aws.Context, arg1 *dynamodb.ScanInput, arg2 func(*dynamodb.ScanOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ScanPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ScanPagesWithContext indicates an expected call of ScanPagesWithContext.
func (mr *MockDynamoDBAPIMockRecorder) ScanPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanPagesWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ScanPagesWithContext), varargs...)
}

// ScanRequest mocks base method.
func (m *MockDynamoDBAPI) ScanRequest(arg0 *dynamodb.ScanInput) (*request.Request, *dynamodb.ScanOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.ScanOutput)
	return ret0, ret1
}

// ScanRequest indicates an expected call of ScanRequest.
func (mr *MockDynamoDBAPIMockRecorder) ScanRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).ScanRequest), arg0)
}

// ScanWithContext mocks base method.
func (m *MockDynamoDBAPI) ScanWithContext(arg0 aws.Context, arg1 *dynamodb.ScanInput, arg2 ...request.Option) (*dynamodb.ScanOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ScanWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.ScanOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ScanWithContext indicates an expected call of ScanWithContext.
func (mr *MockDynamoDBAPIMockRecorder) ScanWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).ScanWithContext), varargs...)
}

// TagResource mocks base method.
func (m *MockDynamoDBAPI) TagResource(arg0 *dynamodb.TagResourceInput) (*dynamodb.TagResourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TagResource", arg0)
	ret0, _ := ret[0].(*dynamodb.TagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TagResource indicates an expected call of TagResource.
func (mr *MockDynamoDBAPIMockRecorder) TagResource(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResource", reflect.TypeOf((*MockDynamoDBAPI)(nil).TagResource), arg0)
}

// TagResourceRequest mocks base method.
func (m *MockDynamoDBAPI) TagResourceRequest(arg0 *dynamodb.TagResourceInput) (*request.Request, *dynamodb.TagResourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TagResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.TagResourceOutput)
	return ret0, ret1
}

// TagResourceRequest indicates an expected call of TagResourceRequest.
func (mr *MockDynamoDBAPIMockRecorder) TagResourceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).TagResourceRequest), arg0)
}

// TagResourceWithContext mocks base method.
func (m *MockDynamoDBAPI) TagResourceWithContext(arg0 aws.Context, arg1 *dynamodb.TagResourceInput, arg2 ...request.Option) (*dynamodb.TagResourceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TagResourceWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.TagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TagResourceWithContext indicates an expected call of TagResourceWithContext.
func (mr *MockDynamoDBAPIMockRecorder) TagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).TagResourceWithContext), varargs...)
}

// TransactGetItems mocks base method.
func (m *MockDynamoDBAPI) TransactGetItems(arg0 *dynamodb.TransactGetItemsInput) (*dynamodb.TransactGetItemsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransactGetItems", arg0)
	ret0, _ := ret[0].(*dynamodb.TransactGetItemsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TransactGetItems indicates an expected call of TransactGetItems.
func (mr *MockDynamoDBAPIMockRecorder) TransactGetItems(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactGetItems", reflect.TypeOf((*MockDynamoDBAPI)(nil).TransactGetItems), arg0)
}

// TransactGetItemsRequest mocks base method.
func (m *MockDynamoDBAPI) TransactGetItemsRequest(arg0 *dynamodb.TransactGetItemsInput) (*request.Request, *dynamodb.TransactGetItemsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransactGetItemsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.TransactGetItemsOutput)
	return ret0, ret1
}

// TransactGetItemsRequest indicates an expected call of TransactGetItemsRequest.
func (mr *MockDynamoDBAPIMockRecorder) TransactGetItemsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactGetItemsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).TransactGetItemsRequest), arg0)
}

// TransactGetItemsWithContext mocks base method.
func (m *MockDynamoDBAPI) TransactGetItemsWithContext(arg0 aws.Context, arg1 *dynamodb.TransactGetItemsInput, arg2 ...request.Option) (*dynamodb.TransactGetItemsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TransactGetItemsWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.TransactGetItemsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TransactGetItemsWithContext indicates an expected call of TransactGetItemsWithContext.
func (mr *MockDynamoDBAPIMockRecorder) TransactGetItemsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactGetItemsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).TransactGetItemsWithContext), varargs...)
}

// TransactWriteItems mocks base method.
func (m *MockDynamoDBAPI) TransactWriteItems(arg0 *dynamodb.TransactWriteItemsInput) (*dynamodb.TransactWriteItemsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransactWriteItems", arg0)
	ret0, _ := ret[0].(*dynamodb.TransactWriteItemsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TransactWriteItems indicates an expected call of TransactWriteItems.
func (mr *MockDynamoDBAPIMockRecorder) TransactWriteItems(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactWriteItems", reflect.TypeOf((*MockDynamoDBAPI)(nil).TransactWriteItems), arg0)
}

// TransactWriteItemsRequest mocks base method.
func (m *MockDynamoDBAPI) TransactWriteItemsRequest(arg0 *dynamodb.TransactWriteItemsInput) (*request.Request, *dynamodb.TransactWriteItemsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransactWriteItemsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.TransactWriteItemsOutput)
	return ret0, ret1
}

// TransactWriteItemsRequest indicates an expected call of TransactWriteItemsRequest.
func (mr *MockDynamoDBAPIMockRecorder) TransactWriteItemsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactWriteItemsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).TransactWriteItemsRequest), arg0)
}

// TransactWriteItemsWithContext mocks base method.
func (m *MockDynamoDBAPI) TransactWriteItemsWithContext(arg0 aws.Context, arg1 *dynamodb.TransactWriteItemsInput, arg2 ...request.Option) (*dynamodb.TransactWriteItemsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TransactWriteItemsWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.TransactWriteItemsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TransactWriteItemsWithContext indicates an expected call of TransactWriteItemsWithContext.
func (mr *MockDynamoDBAPIMockRecorder) TransactWriteItemsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactWriteItemsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).TransactWriteItemsWithContext), varargs...)
}

// UntagResource mocks base method.
func (m *MockDynamoDBAPI) UntagResource(arg0 *dynamodb.UntagResourceInput) (*dynamodb.UntagResourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UntagResource", arg0)
	ret0, _ := ret[0].(*dynamodb.UntagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UntagResource indicates an expected call of UntagResource.
func (mr *MockDynamoDBAPIMockRecorder) UntagResource(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResource", reflect.TypeOf((*MockDynamoDBAPI)(nil).UntagResource), arg0)
}

// UntagResourceRequest mocks base method.
func (m *MockDynamoDBAPI) UntagResourceRequest(arg0 *dynamodb.UntagResourceInput) (*request.Request, *dynamodb.UntagResourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UntagResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.UntagResourceOutput)
	return ret0, ret1
}

// UntagResourceRequest indicates an expected call of UntagResourceRequest.
func (mr *MockDynamoDBAPIMockRecorder) UntagResourceRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UntagResourceRequest), arg0)
}

// UntagResourceWithContext mocks base method.
func (m *MockDynamoDBAPI) UntagResourceWithContext(arg0 aws.Context, arg1 *dynamodb.UntagResourceInput, arg2 ...request.Option) (*dynamodb.UntagResourceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UntagResourceWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.UntagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UntagResourceWithContext indicates an expected call of UntagResourceWithContext.
func (mr *MockDynamoDBAPIMockRecorder) UntagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UntagResourceWithContext), varargs...)
}

// UpdateContinuousBackups mocks base method.
func (m *MockDynamoDBAPI) UpdateContinuousBackups(arg0 *dynamodb.UpdateContinuousBackupsInput) (*dynamodb.UpdateContinuousBackupsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateContinuousBackups", arg0)
	ret0, _ := ret[0].(*dynamodb.UpdateContinuousBackupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateContinuousBackups indicates an expected call of UpdateContinuousBackups.
func (mr *MockDynamoDBAPIMockRecorder) UpdateContinuousBackups(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContinuousBackups", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateContinuousBackups), arg0)
}

// UpdateContinuousBackupsRequest mocks base method.
func (m *MockDynamoDBAPI) UpdateContinuousBackupsRequest(arg0 *dynamodb.UpdateContinuousBackupsInput) (*request.Request, *dynamodb.UpdateContinuousBackupsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateContinuousBackupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.UpdateContinuousBackupsOutput)
	return ret0, ret1
}

// UpdateContinuousBackupsRequest indicates an expected call of UpdateContinuousBackupsRequest.
func (mr *MockDynamoDBAPIMockRecorder) UpdateContinuousBackupsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContinuousBackupsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateContinuousBackupsRequest), arg0)
}

// UpdateContinuousBackupsWithContext mocks base method.
func (m *MockDynamoDBAPI) UpdateContinuousBackupsWithContext(arg0 aws.Context, arg1 *dynamodb.UpdateContinuousBackupsInput, arg2 ...request.Option) (*dynamodb.UpdateContinuousBackupsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateContinuousBackupsWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.UpdateContinuousBackupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateContinuousBackupsWithContext indicates an expected call of UpdateContinuousBackupsWithContext.
func (mr *MockDynamoDBAPIMockRecorder) UpdateContinuousBackupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContinuousBackupsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateContinuousBackupsWithContext), varargs...)
}

// UpdateContributorInsights mocks base method.
func (m *MockDynamoDBAPI) UpdateContributorInsights(arg0 *dynamodb.UpdateContributorInsightsInput) (*dynamodb.UpdateContributorInsightsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateContributorInsights", arg0)
	ret0, _ := ret[0].(*dynamodb.UpdateContributorInsightsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateContributorInsights indicates an expected call of UpdateContributorInsights.
func (mr *MockDynamoDBAPIMockRecorder) UpdateContributorInsights(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContributorInsights", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateContributorInsights), arg0)
}

// UpdateContributorInsightsRequest mocks base method.
func (m *MockDynamoDBAPI) UpdateContributorInsightsRequest(arg0 *dynamodb.UpdateContributorInsightsInput) (*request.Request, *dynamodb.UpdateContributorInsightsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateContributorInsightsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.UpdateContributorInsightsOutput)
	return ret0, ret1
}

// UpdateContributorInsightsRequest indicates an expected call of UpdateContributorInsightsRequest.
func (mr *MockDynamoDBAPIMockRecorder) UpdateContributorInsightsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContributorInsightsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateContributorInsightsRequest), arg0)
}

// UpdateContributorInsightsWithContext mocks base method.
func (m *MockDynamoDBAPI) UpdateContributorInsightsWithContext(arg0 aws.Context, arg1 *dynamodb.UpdateContributorInsightsInput, arg2 ...request.Option) (*dynamodb.UpdateContributorInsightsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateContributorInsightsWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.UpdateContributorInsightsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateContributorInsightsWithContext indicates an expected call of UpdateContributorInsightsWithContext.
func (mr *MockDynamoDBAPIMockRecorder) UpdateContributorInsightsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateContributorInsightsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateContributorInsightsWithContext), varargs...)
}

// UpdateGlobalTable mocks base method.
func (m *MockDynamoDBAPI) UpdateGlobalTable(arg0 *dynamodb.UpdateGlobalTableInput) (*dynamodb.UpdateGlobalTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGlobalTable", arg0)
	ret0, _ := ret[0].(*dynamodb.UpdateGlobalTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateGlobalTable indicates an expected call of UpdateGlobalTable.
func (mr *MockDynamoDBAPIMockRecorder) UpdateGlobalTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGlobalTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateGlobalTable), arg0)
}

// UpdateGlobalTableRequest mocks base method.
func (m *MockDynamoDBAPI) UpdateGlobalTableRequest(arg0 *dynamodb.UpdateGlobalTableInput) (*request.Request, *dynamodb.UpdateGlobalTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGlobalTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.UpdateGlobalTableOutput)
	return ret0, ret1
}

// UpdateGlobalTableRequest indicates an expected call of UpdateGlobalTableRequest.
func (mr *MockDynamoDBAPIMockRecorder) UpdateGlobalTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGlobalTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateGlobalTableRequest), arg0)
}

// UpdateGlobalTableSettings mocks base method.
func (m *MockDynamoDBAPI) UpdateGlobalTableSettings(arg0 *dynamodb.UpdateGlobalTableSettingsInput) (*dynamodb.UpdateGlobalTableSettingsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGlobalTableSettings", arg0)
	ret0, _ := ret[0].(*dynamodb.UpdateGlobalTableSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateGlobalTableSettings indicates an expected call of UpdateGlobalTableSettings.
func (mr *MockDynamoDBAPIMockRecorder) UpdateGlobalTableSettings(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGlobalTableSettings", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateGlobalTableSettings), arg0)
}

// UpdateGlobalTableSettingsRequest mocks base method.
func (m *MockDynamoDBAPI) UpdateGlobalTableSettingsRequest(arg0 *dynamodb.UpdateGlobalTableSettingsInput) (*request.Request, *dynamodb.UpdateGlobalTableSettingsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGlobalTableSettingsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.UpdateGlobalTableSettingsOutput)
	return ret0, ret1
}

// UpdateGlobalTableSettingsRequest indicates an expected call of UpdateGlobalTableSettingsRequest.
func (mr *MockDynamoDBAPIMockRecorder) UpdateGlobalTableSettingsRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGlobalTableSettingsRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateGlobalTableSettingsRequest), arg0)
}

// UpdateGlobalTableSettingsWithContext mocks base method.
func (m *MockDynamoDBAPI) UpdateGlobalTableSettingsWithContext(arg0 aws.Context, arg1 *dynamodb.UpdateGlobalTableSettingsInput, arg2 ...request.Option) (*dynamodb.UpdateGlobalTableSettingsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateGlobalTableSettingsWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.UpdateGlobalTableSettingsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateGlobalTableSettingsWithContext indicates an expected call of UpdateGlobalTableSettingsWithContext.
func (mr *MockDynamoDBAPIMockRecorder) UpdateGlobalTableSettingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGlobalTableSettingsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateGlobalTableSettingsWithContext), varargs...)
}

// UpdateGlobalTableWithContext mocks base method.
func (m *MockDynamoDBAPI) UpdateGlobalTableWithContext(arg0 aws.Context, arg1 *dynamodb.UpdateGlobalTableInput, arg2 ...request.Option) (*dynamodb.UpdateGlobalTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateGlobalTableWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.UpdateGlobalTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateGlobalTableWithContext indicates an expected call of UpdateGlobalTableWithContext.
func (mr *MockDynamoDBAPIMockRecorder) UpdateGlobalTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGlobalTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateGlobalTableWithContext), varargs...)
}

// UpdateItem mocks base method.
func (m *MockDynamoDBAPI) UpdateItem(arg0 *dynamodb.UpdateItemInput) (*dynamodb.UpdateItemOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateItem", arg0)
	ret0, _ := ret[0].(*dynamodb.UpdateItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateItem indicates an expected call of UpdateItem.
func (mr *MockDynamoDBAPIMockRecorder) UpdateItem(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateItem", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateItem), arg0)
}

// UpdateItemRequest mocks base method.
func (m *MockDynamoDBAPI) UpdateItemRequest(arg0 *dynamodb.UpdateItemInput) (*request.Request, *dynamodb.UpdateItemOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateItemRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.UpdateItemOutput)
	return ret0, ret1
}

// UpdateItemRequest indicates an expected call of UpdateItemRequest.
func (mr *MockDynamoDBAPIMockRecorder) UpdateItemRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateItemRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateItemRequest), arg0)
}

// UpdateItemWithContext mocks base method.
func (m *MockDynamoDBAPI) UpdateItemWithContext(arg0 aws.Context, arg1 *dynamodb.UpdateItemInput, arg2 ...request.Option) (*dynamodb.UpdateItemOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateItemWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.UpdateItemOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateItemWithContext indicates an expected call of UpdateItemWithContext.
func (mr *MockDynamoDBAPIMockRecorder) UpdateItemWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateItemWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateItemWithContext), varargs...)
}

// UpdateKinesisStreamingDestination mocks base method.
func (m *MockDynamoDBAPI) UpdateKinesisStreamingDestination(arg0 *dynamodb.UpdateKinesisStreamingDestinationInput) (*dynamodb.UpdateKinesisStreamingDestinationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateKinesisStreamingDestination", arg0)
	ret0, _ := ret[0].(*dynamodb.UpdateKinesisStreamingDestinationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateKinesisStreamingDestination indicates an expected call of UpdateKinesisStreamingDestination.
func (mr *MockDynamoDBAPIMockRecorder) UpdateKinesisStreamingDestination(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateKinesisStreamingDestination", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateKinesisStreamingDestination), arg0)
}

// UpdateKinesisStreamingDestinationRequest mocks base method.
func (m *MockDynamoDBAPI) UpdateKinesisStreamingDestinationRequest(arg0 *dynamodb.UpdateKinesisStreamingDestinationInput) (*request.Request, *dynamodb.UpdateKinesisStreamingDestinationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateKinesisStreamingDestinationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.UpdateKinesisStreamingDestinationOutput)
	return ret0, ret1
}

// UpdateKinesisStreamingDestinationRequest indicates an expected call of UpdateKinesisStreamingDestinationRequest.
func (mr *MockDynamoDBAPIMockRecorder) UpdateKinesisStreamingDestinationRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateKinesisStreamingDestinationRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateKinesisStreamingDestinationRequest), arg0)
}

// UpdateKinesisStreamingDestinationWithContext mocks base method.
func (m *MockDynamoDBAPI) UpdateKinesisStreamingDestinationWithContext(arg0 aws.Context, arg1 *dynamodb.UpdateKinesisStreamingDestinationInput, arg2 ...request.Option) (*dynamodb.UpdateKinesisStreamingDestinationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateKinesisStreamingDestinationWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.UpdateKinesisStreamingDestinationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateKinesisStreamingDestinationWithContext indicates an expected call of UpdateKinesisStreamingDestinationWithContext.
func (mr *MockDynamoDBAPIMockRecorder) UpdateKinesisStreamingDestinationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateKinesisStreamingDestinationWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateKinesisStreamingDestinationWithContext), varargs...)
}

// UpdateTable mocks base method.
func (m *MockDynamoDBAPI) UpdateTable(arg0 *dynamodb.UpdateTableInput) (*dynamodb.UpdateTableOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTable", arg0)
	ret0, _ := ret[0].(*dynamodb.UpdateTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTable indicates an expected call of UpdateTable.
func (mr *MockDynamoDBAPIMockRecorder) UpdateTable(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTable", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTable), arg0)
}

// UpdateTableReplicaAutoScaling mocks base method.
func (m *MockDynamoDBAPI) UpdateTableReplicaAutoScaling(arg0 *dynamodb.UpdateTableReplicaAutoScalingInput) (*dynamodb.UpdateTableReplicaAutoScalingOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTableReplicaAutoScaling", arg0)
	ret0, _ := ret[0].(*dynamodb.UpdateTableReplicaAutoScalingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTableReplicaAutoScaling indicates an expected call of UpdateTableReplicaAutoScaling.
func (mr *MockDynamoDBAPIMockRecorder) UpdateTableReplicaAutoScaling(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTableReplicaAutoScaling", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTableReplicaAutoScaling), arg0)
}

// UpdateTableReplicaAutoScalingRequest mocks base method.
func (m *MockDynamoDBAPI) UpdateTableReplicaAutoScalingRequest(arg0 *dynamodb.UpdateTableReplicaAutoScalingInput) (*request.Request, *dynamodb.UpdateTableReplicaAutoScalingOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTableReplicaAutoScalingRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.UpdateTableReplicaAutoScalingOutput)
	return ret0, ret1
}

// UpdateTableReplicaAutoScalingRequest indicates an expected call of UpdateTableReplicaAutoScalingRequest.
func (mr *MockDynamoDBAPIMockRecorder) UpdateTableReplicaAutoScalingRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTableReplicaAutoScalingRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTableReplicaAutoScalingRequest), arg0)
}

// UpdateTableReplicaAutoScalingWithContext mocks base method.
func (m *MockDynamoDBAPI) UpdateTableReplicaAutoScalingWithContext(arg0 aws.Context, arg1 *dynamodb.UpdateTableReplicaAutoScalingInput, arg2 ...request.Option) (*dynamodb.UpdateTableReplicaAutoScalingOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateTableReplicaAutoScalingWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.UpdateTableReplicaAutoScalingOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTableReplicaAutoScalingWithContext indicates an expected call of UpdateTableReplicaAutoScalingWithContext.
func (mr *MockDynamoDBAPIMockRecorder) UpdateTableReplicaAutoScalingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTableReplicaAutoScalingWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTableReplicaAutoScalingWithContext), varargs...)
}

// UpdateTableRequest mocks base method.
func (m *MockDynamoDBAPI) UpdateTableRequest(arg0 *dynamodb.UpdateTableInput) (*request.Request, *dynamodb.UpdateTableOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTableRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.UpdateTableOutput)
	return ret0, ret1
}

// UpdateTableRequest indicates an expected call of UpdateTableRequest.
func (mr *MockDynamoDBAPIMockRecorder) UpdateTableRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTableRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTableRequest), arg0)
}

// UpdateTableWithContext mocks base method.
func (m *MockDynamoDBAPI) UpdateTableWithContext(arg0 aws.Context, arg1 *dynamodb.UpdateTableInput, arg2 ...request.Option) (*dynamodb.UpdateTableOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateTableWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.UpdateTableOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTableWithContext indicates an expected call of UpdateTableWithContext.
func (mr *MockDynamoDBAPIMockRecorder) UpdateTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTableWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTableWithContext), varargs...)
}

// UpdateTimeToLive mocks base method.
func (m *MockDynamoDBAPI) UpdateTimeToLive(arg0 *dynamodb.UpdateTimeToLiveInput) (*dynamodb.UpdateTimeToLiveOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTimeToLive", arg0)
	ret0, _ := ret[0].(*dynamodb.UpdateTimeToLiveOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTimeToLive indicates an expected call of UpdateTimeToLive.
func (mr *MockDynamoDBAPIMockRecorder) UpdateTimeToLive(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTimeToLive", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTimeToLive), arg0)
}

// UpdateTimeToLiveRequest mocks base method.
func (m *MockDynamoDBAPI) UpdateTimeToLiveRequest(arg0 *dynamodb.UpdateTimeToLiveInput) (*request.Request, *dynamodb.UpdateTimeToLiveOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTimeToLiveRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*dynamodb.UpdateTimeToLiveOutput)
	return ret0, ret1
}

// UpdateTimeToLiveRequest indicates an expected call of UpdateTimeToLiveRequest.
func (mr *MockDynamoDBAPIMockRecorder) UpdateTimeToLiveRequest(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTimeToLiveRequest", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTimeToLiveRequest), arg0)
}

// UpdateTimeToLiveWithContext mocks base method.
func (m *MockDynamoDBAPI) UpdateTimeToLiveWithContext(arg0 aws.Context, arg1 *dynamodb.UpdateTimeToLiveInput, arg2 ...request.Option) (*dynamodb.UpdateTimeToLiveOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateTimeToLiveWithContext", varargs...)
	ret0, _ := ret[0].(*dynamodb.UpdateTimeToLiveOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTimeToLiveWithContext indicates an expected call of UpdateTimeToLiveWithContext.
func (mr *MockDynamoDBAPIMockRecorder) UpdateTimeToLiveWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTimeToLiveWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).UpdateTimeToLiveWithContext), varargs...)
}

// WaitUntilTableExists mocks base method.
func (m *MockDynamoDBAPI) WaitUntilTableExists(arg0 *dynamodb.DescribeTableInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilTableExists", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilTableExists indicates an expected call of WaitUntilTableExists.
func (mr *MockDynamoDBAPIMockRecorder) WaitUntilTableExists(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTableExists", reflect.TypeOf((*MockDynamoDBAPI)(nil).WaitUntilTableExists), arg0)
}

// WaitUntilTableExistsWithContext mocks base method.
func (m *MockDynamoDBAPI) WaitUntilTableExistsWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeTableInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilTableExistsWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilTableExistsWithContext indicates an expected call of WaitUntilTableExistsWithContext.
func (mr *MockDynamoDBAPIMockRecorder) WaitUntilTableExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTableExistsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).WaitUntilTableExistsWithContext), varargs...)
}

// WaitUntilTableNotExists mocks base method.
func (m *MockDynamoDBAPI) WaitUntilTableNotExists(arg0 *dynamodb.DescribeTableInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilTableNotExists", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilTableNotExists indicates an expected call of WaitUntilTableNotExists.
func (mr *MockDynamoDBAPIMockRecorder) WaitUntilTableNotExists(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTableNotExists", reflect.TypeOf((*MockDynamoDBAPI)(nil).WaitUntilTableNotExists), arg0)
}

// WaitUntilTableNotExistsWithContext mocks base method.
func (m *MockDynamoDBAPI) WaitUntilTableNotExistsWithContext(arg0 aws.Context, arg1 *dynamodb.DescribeTableInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilTableNotExistsWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitUntilTableNotExistsWithContext indicates an expected call of WaitUntilTableNotExistsWithContext.
func (mr *MockDynamoDBAPIMockRecorder) WaitUntilTableNotExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTableNotExistsWithContext", reflect.TypeOf((*MockDynamoDBAPI)(nil).WaitUntilTableNotExistsWithContext), varargs...)
}
