diff --git a/mocks/mock_dynamodbiface/mock.go b/mocks/mock_dynamodbiface/mock.go
new file mode 100644
index 00000000..8bfe43cf
--- /dev/null
+++ b/mocks/mock_dynamodbiface/mock.go
@@ -0,0 +1,3184 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: /Users/ekristen/go/pkg/mod/github.com/aws/aws-sdk-go@v1.54.19/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...)
+}
diff --git a/resources/dynamodb-backup.go b/resources/dynamodb-backup.go
new file mode 100644
index 00000000..1161e939
--- /dev/null
+++ b/resources/dynamodb-backup.go
@@ -0,0 +1,102 @@
+package resources
+
+import (
+	"context"
+	"time"
+
+	"github.com/gotidy/ptr"
+
+	"github.com/ekristen/libnuke/pkg/registry"
+	"github.com/ekristen/libnuke/pkg/resource"
+	"github.com/ekristen/libnuke/pkg/types"
+
+	"github.com/aws/aws-sdk-go/service/dynamodb"
+	"github.com/aws/aws-sdk-go/service/dynamodb/dynamodbiface"
+
+	"github.com/ekristen/aws-nuke/v3/pkg/nuke"
+)
+
+const DynamoDBBackupResource = "DynamoDBBackup"
+
+func init() {
+	registry.Register(&registry.Registration{
+		Name:   DynamoDBBackupResource,
+		Scope:  nuke.Account,
+		Lister: &DynamoDBBackupLister{},
+	})
+}
+
+type DynamoDBBackupLister struct {
+	mockSvc dynamodbiface.DynamoDBAPI
+}
+
+func (l *DynamoDBBackupLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) {
+	opts := o.(*nuke.ListerOpts)
+
+	var svc dynamodbiface.DynamoDBAPI
+	if l.mockSvc != nil {
+		svc = l.mockSvc
+	} else {
+		svc = dynamodb.New(opts.Session)
+	}
+
+	resources := make([]resource.Resource, 0)
+
+	var lastEvaluatedBackupArn *string
+
+	for {
+		backupsResp, err := svc.ListBackups(&dynamodb.ListBackupsInput{
+			ExclusiveStartBackupArn: lastEvaluatedBackupArn,
+		})
+		if err != nil {
+			return nil, err
+		}
+
+		for _, backup := range backupsResp.BackupSummaries {
+			resources = append(resources, &DynamoDBBackup{
+				svc:        svc,
+				arn:        backup.BackupArn,
+				Name:       backup.BackupName,
+				CreateDate: backup.BackupCreationDateTime,
+				TableName:  backup.TableName,
+			})
+		}
+
+		if backupsResp.LastEvaluatedBackupArn == nil {
+			break
+		}
+
+		lastEvaluatedBackupArn = backupsResp.LastEvaluatedBackupArn
+	}
+
+	return resources, nil
+}
+
+type DynamoDBBackup struct {
+	svc        dynamodbiface.DynamoDBAPI
+	arn        *string
+	Name       *string
+	CreateDate *time.Time
+	TableName  *string
+}
+
+func (r *DynamoDBBackup) Remove(_ context.Context) error {
+	params := &dynamodb.DeleteBackupInput{
+		BackupArn: r.arn,
+	}
+
+	_, err := r.svc.DeleteBackup(params)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (r *DynamoDBBackup) Properties() types.Properties {
+	return types.NewPropertiesFromStruct(r)
+}
+
+func (r *DynamoDBBackup) String() string {
+	return ptr.ToString(r.Name)
+}
diff --git a/resources/dynamodb-backup_mock_test.go b/resources/dynamodb-backup_mock_test.go
new file mode 100644
index 00000000..dfcb0c59
--- /dev/null
+++ b/resources/dynamodb-backup_mock_test.go
@@ -0,0 +1,81 @@
+package resources
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/golang/mock/gomock"
+	"github.com/gotidy/ptr"
+	"github.com/stretchr/testify/assert"
+
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/service/dynamodb"
+
+	"github.com/ekristen/aws-nuke/v3/mocks/mock_dynamodbiface"
+	"github.com/ekristen/aws-nuke/v3/pkg/nuke"
+)
+
+func Test_Mock_DynamoDBBackup_List(t *testing.T) {
+	a := assert.New(t)
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	mockSvc := mock_dynamodbiface.NewMockDynamoDBAPI(ctrl)
+
+	mockSvc.EXPECT().ListBackups(&dynamodb.ListBackupsInput{
+		ExclusiveStartBackupArn: nil,
+	}).Return(&dynamodb.ListBackupsOutput{
+		BackupSummaries: []*dynamodb.BackupSummary{
+			{
+				BackupArn:              ptr.String("arn:aws:dynamodb:us-west-2:123456789012:table/ExampleTable/backup/1234567890123"),
+				BackupName:             ptr.String("ExampleBackup"),
+				BackupCreationDateTime: ptr.Time(time.Now()),
+				TableName:              ptr.String("ExampleTable"),
+				TableArn:               ptr.String("arn:aws:dynamodb:us-west-2:123456789012:table/ExampleTable"),
+			},
+		},
+	}, nil)
+
+	lister := &DynamoDBBackupLister{
+		mockSvc: mockSvc,
+	}
+
+	resources, err := lister.List(context.TODO(), &nuke.ListerOpts{
+		Region: &nuke.Region{
+			Name: "us-east-2",
+		},
+		Session: session.Must(session.NewSession()),
+	})
+	a.Nil(err)
+	a.Len(resources, 1)
+}
+
+func Test_Mock_DynamoDBBackup_Remove(t *testing.T) {
+	a := assert.New(t)
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	mockSvc := mock_dynamodbiface.NewMockDynamoDBAPI(ctrl)
+
+	mockSvc.EXPECT().DeleteBackup(&dynamodb.DeleteBackupInput{
+		BackupArn: ptr.String("arn:aws:dynamodb:us-west-2:123456789012:table/ExampleTable/backup/1234567890123"),
+	}).Return(&dynamodb.DeleteBackupOutput{}, nil)
+
+	now := time.Now()
+
+	resource := &DynamoDBBackup{
+		svc:        mockSvc,
+		arn:        ptr.String("arn:aws:dynamodb:us-west-2:123456789012:table/ExampleTable/backup/1234567890123"),
+		Name:       ptr.String("ExampleBackup"),
+		CreateDate: ptr.Time(now),
+		TableName:  ptr.String("ExampleTable"),
+	}
+
+	a.Equal(now.Format(time.RFC3339), resource.Properties().Get("CreateDate"))
+	a.Equal("ExampleBackup", resource.Properties().Get("Name"))
+	a.Equal("ExampleTable", resource.Properties().Get("TableName"))
+
+	err := resource.Remove(context.TODO())
+	a.Nil(err)
+}
diff --git a/resources/dynamodb_mock_test.go b/resources/dynamodb_mock_test.go
new file mode 100644
index 00000000..299889fe
--- /dev/null
+++ b/resources/dynamodb_mock_test.go
@@ -0,0 +1,2 @@
+//go:generate ../mocks/generate_mocks.sh dynamodb dynamodbiface
+package resources