mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/aws/aws-sdk-go/service/athena/athenaiface (interfaces: AthenaAPI)

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

import (
	context "context"
	request "github.com/aws/aws-sdk-go/aws/request"
	athena "github.com/aws/aws-sdk-go/service/athena"
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
)

// MockAthenaAPI is a mock of AthenaAPI interface
type MockAthenaAPI struct {
	ctrl     *gomock.Controller
	recorder *MockAthenaAPIMockRecorder
}

// MockAthenaAPIMockRecorder is the mock recorder for MockAthenaAPI
type MockAthenaAPIMockRecorder struct {
	mock *MockAthenaAPI
}

// NewMockAthenaAPI creates a new mock instance
func NewMockAthenaAPI(ctrl *gomock.Controller) *MockAthenaAPI {
	mock := &MockAthenaAPI{ctrl: ctrl}
	mock.recorder = &MockAthenaAPIMockRecorder{mock}
	return mock
}

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

// BatchGetNamedQuery mocks base method
func (m *MockAthenaAPI) BatchGetNamedQuery(arg0 *athena.BatchGetNamedQueryInput) (*athena.BatchGetNamedQueryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchGetNamedQuery", arg0)
	ret0, _ := ret[0].(*athena.BatchGetNamedQueryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BatchGetNamedQueryRequest mocks base method
func (m *MockAthenaAPI) BatchGetNamedQueryRequest(arg0 *athena.BatchGetNamedQueryInput) (*request.Request, *athena.BatchGetNamedQueryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchGetNamedQueryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.BatchGetNamedQueryOutput)
	return ret0, ret1
}

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

// BatchGetNamedQueryWithContext mocks base method
func (m *MockAthenaAPI) BatchGetNamedQueryWithContext(arg0 context.Context, arg1 *athena.BatchGetNamedQueryInput, arg2 ...request.Option) (*athena.BatchGetNamedQueryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchGetNamedQueryWithContext", varargs...)
	ret0, _ := ret[0].(*athena.BatchGetNamedQueryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchGetNamedQueryWithContext indicates an expected call of BatchGetNamedQueryWithContext
func (mr *MockAthenaAPIMockRecorder) BatchGetNamedQueryWithContext(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, "BatchGetNamedQueryWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).BatchGetNamedQueryWithContext), varargs...)
}

// BatchGetPreparedStatement mocks base method
func (m *MockAthenaAPI) BatchGetPreparedStatement(arg0 *athena.BatchGetPreparedStatementInput) (*athena.BatchGetPreparedStatementOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchGetPreparedStatement", arg0)
	ret0, _ := ret[0].(*athena.BatchGetPreparedStatementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BatchGetPreparedStatementRequest mocks base method
func (m *MockAthenaAPI) BatchGetPreparedStatementRequest(arg0 *athena.BatchGetPreparedStatementInput) (*request.Request, *athena.BatchGetPreparedStatementOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchGetPreparedStatementRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.BatchGetPreparedStatementOutput)
	return ret0, ret1
}

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

// BatchGetPreparedStatementWithContext mocks base method
func (m *MockAthenaAPI) BatchGetPreparedStatementWithContext(arg0 context.Context, arg1 *athena.BatchGetPreparedStatementInput, arg2 ...request.Option) (*athena.BatchGetPreparedStatementOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchGetPreparedStatementWithContext", varargs...)
	ret0, _ := ret[0].(*athena.BatchGetPreparedStatementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchGetPreparedStatementWithContext indicates an expected call of BatchGetPreparedStatementWithContext
func (mr *MockAthenaAPIMockRecorder) BatchGetPreparedStatementWithContext(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, "BatchGetPreparedStatementWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).BatchGetPreparedStatementWithContext), varargs...)
}

// BatchGetQueryExecution mocks base method
func (m *MockAthenaAPI) BatchGetQueryExecution(arg0 *athena.BatchGetQueryExecutionInput) (*athena.BatchGetQueryExecutionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchGetQueryExecution", arg0)
	ret0, _ := ret[0].(*athena.BatchGetQueryExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BatchGetQueryExecutionRequest mocks base method
func (m *MockAthenaAPI) BatchGetQueryExecutionRequest(arg0 *athena.BatchGetQueryExecutionInput) (*request.Request, *athena.BatchGetQueryExecutionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchGetQueryExecutionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.BatchGetQueryExecutionOutput)
	return ret0, ret1
}

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

// BatchGetQueryExecutionWithContext mocks base method
func (m *MockAthenaAPI) BatchGetQueryExecutionWithContext(arg0 context.Context, arg1 *athena.BatchGetQueryExecutionInput, arg2 ...request.Option) (*athena.BatchGetQueryExecutionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchGetQueryExecutionWithContext", varargs...)
	ret0, _ := ret[0].(*athena.BatchGetQueryExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchGetQueryExecutionWithContext indicates an expected call of BatchGetQueryExecutionWithContext
func (mr *MockAthenaAPIMockRecorder) BatchGetQueryExecutionWithContext(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, "BatchGetQueryExecutionWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).BatchGetQueryExecutionWithContext), varargs...)
}

// CancelCapacityReservation mocks base method
func (m *MockAthenaAPI) CancelCapacityReservation(arg0 *athena.CancelCapacityReservationInput) (*athena.CancelCapacityReservationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelCapacityReservation", arg0)
	ret0, _ := ret[0].(*athena.CancelCapacityReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CancelCapacityReservationRequest mocks base method
func (m *MockAthenaAPI) CancelCapacityReservationRequest(arg0 *athena.CancelCapacityReservationInput) (*request.Request, *athena.CancelCapacityReservationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelCapacityReservationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.CancelCapacityReservationOutput)
	return ret0, ret1
}

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

// CancelCapacityReservationWithContext mocks base method
func (m *MockAthenaAPI) CancelCapacityReservationWithContext(arg0 context.Context, arg1 *athena.CancelCapacityReservationInput, arg2 ...request.Option) (*athena.CancelCapacityReservationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CancelCapacityReservationWithContext", varargs...)
	ret0, _ := ret[0].(*athena.CancelCapacityReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelCapacityReservationWithContext indicates an expected call of CancelCapacityReservationWithContext
func (mr *MockAthenaAPIMockRecorder) CancelCapacityReservationWithContext(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, "CancelCapacityReservationWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).CancelCapacityReservationWithContext), varargs...)
}

// CreateCapacityReservation mocks base method
func (m *MockAthenaAPI) CreateCapacityReservation(arg0 *athena.CreateCapacityReservationInput) (*athena.CreateCapacityReservationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCapacityReservation", arg0)
	ret0, _ := ret[0].(*athena.CreateCapacityReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateCapacityReservationRequest mocks base method
func (m *MockAthenaAPI) CreateCapacityReservationRequest(arg0 *athena.CreateCapacityReservationInput) (*request.Request, *athena.CreateCapacityReservationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCapacityReservationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.CreateCapacityReservationOutput)
	return ret0, ret1
}

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

// CreateCapacityReservationWithContext mocks base method
func (m *MockAthenaAPI) CreateCapacityReservationWithContext(arg0 context.Context, arg1 *athena.CreateCapacityReservationInput, arg2 ...request.Option) (*athena.CreateCapacityReservationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateCapacityReservationWithContext", varargs...)
	ret0, _ := ret[0].(*athena.CreateCapacityReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCapacityReservationWithContext indicates an expected call of CreateCapacityReservationWithContext
func (mr *MockAthenaAPIMockRecorder) CreateCapacityReservationWithContext(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, "CreateCapacityReservationWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).CreateCapacityReservationWithContext), varargs...)
}

// CreateDataCatalog mocks base method
func (m *MockAthenaAPI) CreateDataCatalog(arg0 *athena.CreateDataCatalogInput) (*athena.CreateDataCatalogOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDataCatalog", arg0)
	ret0, _ := ret[0].(*athena.CreateDataCatalogOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateDataCatalogRequest mocks base method
func (m *MockAthenaAPI) CreateDataCatalogRequest(arg0 *athena.CreateDataCatalogInput) (*request.Request, *athena.CreateDataCatalogOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDataCatalogRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.CreateDataCatalogOutput)
	return ret0, ret1
}

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

// CreateDataCatalogWithContext mocks base method
func (m *MockAthenaAPI) CreateDataCatalogWithContext(arg0 context.Context, arg1 *athena.CreateDataCatalogInput, arg2 ...request.Option) (*athena.CreateDataCatalogOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateDataCatalogWithContext", varargs...)
	ret0, _ := ret[0].(*athena.CreateDataCatalogOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateDataCatalogWithContext indicates an expected call of CreateDataCatalogWithContext
func (mr *MockAthenaAPIMockRecorder) CreateDataCatalogWithContext(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, "CreateDataCatalogWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).CreateDataCatalogWithContext), varargs...)
}

// CreateNamedQuery mocks base method
func (m *MockAthenaAPI) CreateNamedQuery(arg0 *athena.CreateNamedQueryInput) (*athena.CreateNamedQueryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNamedQuery", arg0)
	ret0, _ := ret[0].(*athena.CreateNamedQueryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNamedQueryRequest mocks base method
func (m *MockAthenaAPI) CreateNamedQueryRequest(arg0 *athena.CreateNamedQueryInput) (*request.Request, *athena.CreateNamedQueryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNamedQueryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.CreateNamedQueryOutput)
	return ret0, ret1
}

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

// CreateNamedQueryWithContext mocks base method
func (m *MockAthenaAPI) CreateNamedQueryWithContext(arg0 context.Context, arg1 *athena.CreateNamedQueryInput, arg2 ...request.Option) (*athena.CreateNamedQueryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateNamedQueryWithContext", varargs...)
	ret0, _ := ret[0].(*athena.CreateNamedQueryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateNamedQueryWithContext indicates an expected call of CreateNamedQueryWithContext
func (mr *MockAthenaAPIMockRecorder) CreateNamedQueryWithContext(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, "CreateNamedQueryWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).CreateNamedQueryWithContext), varargs...)
}

// CreateNotebook mocks base method
func (m *MockAthenaAPI) CreateNotebook(arg0 *athena.CreateNotebookInput) (*athena.CreateNotebookOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNotebook", arg0)
	ret0, _ := ret[0].(*athena.CreateNotebookOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNotebookRequest mocks base method
func (m *MockAthenaAPI) CreateNotebookRequest(arg0 *athena.CreateNotebookInput) (*request.Request, *athena.CreateNotebookOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNotebookRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.CreateNotebookOutput)
	return ret0, ret1
}

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

// CreateNotebookWithContext mocks base method
func (m *MockAthenaAPI) CreateNotebookWithContext(arg0 context.Context, arg1 *athena.CreateNotebookInput, arg2 ...request.Option) (*athena.CreateNotebookOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateNotebookWithContext", varargs...)
	ret0, _ := ret[0].(*athena.CreateNotebookOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateNotebookWithContext indicates an expected call of CreateNotebookWithContext
func (mr *MockAthenaAPIMockRecorder) CreateNotebookWithContext(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, "CreateNotebookWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).CreateNotebookWithContext), varargs...)
}

// CreatePreparedStatement mocks base method
func (m *MockAthenaAPI) CreatePreparedStatement(arg0 *athena.CreatePreparedStatementInput) (*athena.CreatePreparedStatementOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePreparedStatement", arg0)
	ret0, _ := ret[0].(*athena.CreatePreparedStatementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePreparedStatementRequest mocks base method
func (m *MockAthenaAPI) CreatePreparedStatementRequest(arg0 *athena.CreatePreparedStatementInput) (*request.Request, *athena.CreatePreparedStatementOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePreparedStatementRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.CreatePreparedStatementOutput)
	return ret0, ret1
}

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

// CreatePreparedStatementWithContext mocks base method
func (m *MockAthenaAPI) CreatePreparedStatementWithContext(arg0 context.Context, arg1 *athena.CreatePreparedStatementInput, arg2 ...request.Option) (*athena.CreatePreparedStatementOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreatePreparedStatementWithContext", varargs...)
	ret0, _ := ret[0].(*athena.CreatePreparedStatementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePreparedStatementWithContext indicates an expected call of CreatePreparedStatementWithContext
func (mr *MockAthenaAPIMockRecorder) CreatePreparedStatementWithContext(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, "CreatePreparedStatementWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).CreatePreparedStatementWithContext), varargs...)
}

// CreatePresignedNotebookUrl mocks base method
func (m *MockAthenaAPI) CreatePresignedNotebookUrl(arg0 *athena.CreatePresignedNotebookUrlInput) (*athena.CreatePresignedNotebookUrlOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePresignedNotebookUrl", arg0)
	ret0, _ := ret[0].(*athena.CreatePresignedNotebookUrlOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePresignedNotebookUrlRequest mocks base method
func (m *MockAthenaAPI) CreatePresignedNotebookUrlRequest(arg0 *athena.CreatePresignedNotebookUrlInput) (*request.Request, *athena.CreatePresignedNotebookUrlOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePresignedNotebookUrlRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.CreatePresignedNotebookUrlOutput)
	return ret0, ret1
}

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

// CreatePresignedNotebookUrlWithContext mocks base method
func (m *MockAthenaAPI) CreatePresignedNotebookUrlWithContext(arg0 context.Context, arg1 *athena.CreatePresignedNotebookUrlInput, arg2 ...request.Option) (*athena.CreatePresignedNotebookUrlOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreatePresignedNotebookUrlWithContext", varargs...)
	ret0, _ := ret[0].(*athena.CreatePresignedNotebookUrlOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePresignedNotebookUrlWithContext indicates an expected call of CreatePresignedNotebookUrlWithContext
func (mr *MockAthenaAPIMockRecorder) CreatePresignedNotebookUrlWithContext(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, "CreatePresignedNotebookUrlWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).CreatePresignedNotebookUrlWithContext), varargs...)
}

// CreateWorkGroup mocks base method
func (m *MockAthenaAPI) CreateWorkGroup(arg0 *athena.CreateWorkGroupInput) (*athena.CreateWorkGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateWorkGroup", arg0)
	ret0, _ := ret[0].(*athena.CreateWorkGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateWorkGroupRequest mocks base method
func (m *MockAthenaAPI) CreateWorkGroupRequest(arg0 *athena.CreateWorkGroupInput) (*request.Request, *athena.CreateWorkGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateWorkGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.CreateWorkGroupOutput)
	return ret0, ret1
}

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

// CreateWorkGroupWithContext mocks base method
func (m *MockAthenaAPI) CreateWorkGroupWithContext(arg0 context.Context, arg1 *athena.CreateWorkGroupInput, arg2 ...request.Option) (*athena.CreateWorkGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateWorkGroupWithContext", varargs...)
	ret0, _ := ret[0].(*athena.CreateWorkGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateWorkGroupWithContext indicates an expected call of CreateWorkGroupWithContext
func (mr *MockAthenaAPIMockRecorder) CreateWorkGroupWithContext(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, "CreateWorkGroupWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).CreateWorkGroupWithContext), varargs...)
}

// DeleteCapacityReservation mocks base method
func (m *MockAthenaAPI) DeleteCapacityReservation(arg0 *athena.DeleteCapacityReservationInput) (*athena.DeleteCapacityReservationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCapacityReservation", arg0)
	ret0, _ := ret[0].(*athena.DeleteCapacityReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteCapacityReservationRequest mocks base method
func (m *MockAthenaAPI) DeleteCapacityReservationRequest(arg0 *athena.DeleteCapacityReservationInput) (*request.Request, *athena.DeleteCapacityReservationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCapacityReservationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.DeleteCapacityReservationOutput)
	return ret0, ret1
}

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

// DeleteCapacityReservationWithContext mocks base method
func (m *MockAthenaAPI) DeleteCapacityReservationWithContext(arg0 context.Context, arg1 *athena.DeleteCapacityReservationInput, arg2 ...request.Option) (*athena.DeleteCapacityReservationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteCapacityReservationWithContext", varargs...)
	ret0, _ := ret[0].(*athena.DeleteCapacityReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCapacityReservationWithContext indicates an expected call of DeleteCapacityReservationWithContext
func (mr *MockAthenaAPIMockRecorder) DeleteCapacityReservationWithContext(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, "DeleteCapacityReservationWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).DeleteCapacityReservationWithContext), varargs...)
}

// DeleteDataCatalog mocks base method
func (m *MockAthenaAPI) DeleteDataCatalog(arg0 *athena.DeleteDataCatalogInput) (*athena.DeleteDataCatalogOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDataCatalog", arg0)
	ret0, _ := ret[0].(*athena.DeleteDataCatalogOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteDataCatalogRequest mocks base method
func (m *MockAthenaAPI) DeleteDataCatalogRequest(arg0 *athena.DeleteDataCatalogInput) (*request.Request, *athena.DeleteDataCatalogOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDataCatalogRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.DeleteDataCatalogOutput)
	return ret0, ret1
}

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

// DeleteDataCatalogWithContext mocks base method
func (m *MockAthenaAPI) DeleteDataCatalogWithContext(arg0 context.Context, arg1 *athena.DeleteDataCatalogInput, arg2 ...request.Option) (*athena.DeleteDataCatalogOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteDataCatalogWithContext", varargs...)
	ret0, _ := ret[0].(*athena.DeleteDataCatalogOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteDataCatalogWithContext indicates an expected call of DeleteDataCatalogWithContext
func (mr *MockAthenaAPIMockRecorder) DeleteDataCatalogWithContext(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, "DeleteDataCatalogWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).DeleteDataCatalogWithContext), varargs...)
}

// DeleteNamedQuery mocks base method
func (m *MockAthenaAPI) DeleteNamedQuery(arg0 *athena.DeleteNamedQueryInput) (*athena.DeleteNamedQueryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNamedQuery", arg0)
	ret0, _ := ret[0].(*athena.DeleteNamedQueryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNamedQueryRequest mocks base method
func (m *MockAthenaAPI) DeleteNamedQueryRequest(arg0 *athena.DeleteNamedQueryInput) (*request.Request, *athena.DeleteNamedQueryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNamedQueryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.DeleteNamedQueryOutput)
	return ret0, ret1
}

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

// DeleteNamedQueryWithContext mocks base method
func (m *MockAthenaAPI) DeleteNamedQueryWithContext(arg0 context.Context, arg1 *athena.DeleteNamedQueryInput, arg2 ...request.Option) (*athena.DeleteNamedQueryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteNamedQueryWithContext", varargs...)
	ret0, _ := ret[0].(*athena.DeleteNamedQueryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteNamedQueryWithContext indicates an expected call of DeleteNamedQueryWithContext
func (mr *MockAthenaAPIMockRecorder) DeleteNamedQueryWithContext(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, "DeleteNamedQueryWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).DeleteNamedQueryWithContext), varargs...)
}

// DeleteNotebook mocks base method
func (m *MockAthenaAPI) DeleteNotebook(arg0 *athena.DeleteNotebookInput) (*athena.DeleteNotebookOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNotebook", arg0)
	ret0, _ := ret[0].(*athena.DeleteNotebookOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNotebookRequest mocks base method
func (m *MockAthenaAPI) DeleteNotebookRequest(arg0 *athena.DeleteNotebookInput) (*request.Request, *athena.DeleteNotebookOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNotebookRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.DeleteNotebookOutput)
	return ret0, ret1
}

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

// DeleteNotebookWithContext mocks base method
func (m *MockAthenaAPI) DeleteNotebookWithContext(arg0 context.Context, arg1 *athena.DeleteNotebookInput, arg2 ...request.Option) (*athena.DeleteNotebookOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteNotebookWithContext", varargs...)
	ret0, _ := ret[0].(*athena.DeleteNotebookOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteNotebookWithContext indicates an expected call of DeleteNotebookWithContext
func (mr *MockAthenaAPIMockRecorder) DeleteNotebookWithContext(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, "DeleteNotebookWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).DeleteNotebookWithContext), varargs...)
}

// DeletePreparedStatement mocks base method
func (m *MockAthenaAPI) DeletePreparedStatement(arg0 *athena.DeletePreparedStatementInput) (*athena.DeletePreparedStatementOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePreparedStatement", arg0)
	ret0, _ := ret[0].(*athena.DeletePreparedStatementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeletePreparedStatementRequest mocks base method
func (m *MockAthenaAPI) DeletePreparedStatementRequest(arg0 *athena.DeletePreparedStatementInput) (*request.Request, *athena.DeletePreparedStatementOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePreparedStatementRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.DeletePreparedStatementOutput)
	return ret0, ret1
}

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

// DeletePreparedStatementWithContext mocks base method
func (m *MockAthenaAPI) DeletePreparedStatementWithContext(arg0 context.Context, arg1 *athena.DeletePreparedStatementInput, arg2 ...request.Option) (*athena.DeletePreparedStatementOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePreparedStatementWithContext", varargs...)
	ret0, _ := ret[0].(*athena.DeletePreparedStatementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePreparedStatementWithContext indicates an expected call of DeletePreparedStatementWithContext
func (mr *MockAthenaAPIMockRecorder) DeletePreparedStatementWithContext(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, "DeletePreparedStatementWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).DeletePreparedStatementWithContext), varargs...)
}

// DeleteWorkGroup mocks base method
func (m *MockAthenaAPI) DeleteWorkGroup(arg0 *athena.DeleteWorkGroupInput) (*athena.DeleteWorkGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkGroup", arg0)
	ret0, _ := ret[0].(*athena.DeleteWorkGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteWorkGroupRequest mocks base method
func (m *MockAthenaAPI) DeleteWorkGroupRequest(arg0 *athena.DeleteWorkGroupInput) (*request.Request, *athena.DeleteWorkGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.DeleteWorkGroupOutput)
	return ret0, ret1
}

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

// DeleteWorkGroupWithContext mocks base method
func (m *MockAthenaAPI) DeleteWorkGroupWithContext(arg0 context.Context, arg1 *athena.DeleteWorkGroupInput, arg2 ...request.Option) (*athena.DeleteWorkGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteWorkGroupWithContext", varargs...)
	ret0, _ := ret[0].(*athena.DeleteWorkGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteWorkGroupWithContext indicates an expected call of DeleteWorkGroupWithContext
func (mr *MockAthenaAPIMockRecorder) DeleteWorkGroupWithContext(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, "DeleteWorkGroupWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).DeleteWorkGroupWithContext), varargs...)
}

// ExportNotebook mocks base method
func (m *MockAthenaAPI) ExportNotebook(arg0 *athena.ExportNotebookInput) (*athena.ExportNotebookOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExportNotebook", arg0)
	ret0, _ := ret[0].(*athena.ExportNotebookOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ExportNotebookRequest mocks base method
func (m *MockAthenaAPI) ExportNotebookRequest(arg0 *athena.ExportNotebookInput) (*request.Request, *athena.ExportNotebookOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExportNotebookRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.ExportNotebookOutput)
	return ret0, ret1
}

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

// ExportNotebookWithContext mocks base method
func (m *MockAthenaAPI) ExportNotebookWithContext(arg0 context.Context, arg1 *athena.ExportNotebookInput, arg2 ...request.Option) (*athena.ExportNotebookOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ExportNotebookWithContext", varargs...)
	ret0, _ := ret[0].(*athena.ExportNotebookOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExportNotebookWithContext indicates an expected call of ExportNotebookWithContext
func (mr *MockAthenaAPIMockRecorder) ExportNotebookWithContext(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, "ExportNotebookWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ExportNotebookWithContext), varargs...)
}

// GetCalculationExecution mocks base method
func (m *MockAthenaAPI) GetCalculationExecution(arg0 *athena.GetCalculationExecutionInput) (*athena.GetCalculationExecutionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCalculationExecution", arg0)
	ret0, _ := ret[0].(*athena.GetCalculationExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCalculationExecutionCode mocks base method
func (m *MockAthenaAPI) GetCalculationExecutionCode(arg0 *athena.GetCalculationExecutionCodeInput) (*athena.GetCalculationExecutionCodeOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCalculationExecutionCode", arg0)
	ret0, _ := ret[0].(*athena.GetCalculationExecutionCodeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCalculationExecutionCodeRequest mocks base method
func (m *MockAthenaAPI) GetCalculationExecutionCodeRequest(arg0 *athena.GetCalculationExecutionCodeInput) (*request.Request, *athena.GetCalculationExecutionCodeOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCalculationExecutionCodeRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.GetCalculationExecutionCodeOutput)
	return ret0, ret1
}

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

// GetCalculationExecutionCodeWithContext mocks base method
func (m *MockAthenaAPI) GetCalculationExecutionCodeWithContext(arg0 context.Context, arg1 *athena.GetCalculationExecutionCodeInput, arg2 ...request.Option) (*athena.GetCalculationExecutionCodeOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCalculationExecutionCodeWithContext", varargs...)
	ret0, _ := ret[0].(*athena.GetCalculationExecutionCodeOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCalculationExecutionCodeWithContext indicates an expected call of GetCalculationExecutionCodeWithContext
func (mr *MockAthenaAPIMockRecorder) GetCalculationExecutionCodeWithContext(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, "GetCalculationExecutionCodeWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetCalculationExecutionCodeWithContext), varargs...)
}

// GetCalculationExecutionRequest mocks base method
func (m *MockAthenaAPI) GetCalculationExecutionRequest(arg0 *athena.GetCalculationExecutionInput) (*request.Request, *athena.GetCalculationExecutionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCalculationExecutionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.GetCalculationExecutionOutput)
	return ret0, ret1
}

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

// GetCalculationExecutionStatus mocks base method
func (m *MockAthenaAPI) GetCalculationExecutionStatus(arg0 *athena.GetCalculationExecutionStatusInput) (*athena.GetCalculationExecutionStatusOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCalculationExecutionStatus", arg0)
	ret0, _ := ret[0].(*athena.GetCalculationExecutionStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCalculationExecutionStatusRequest mocks base method
func (m *MockAthenaAPI) GetCalculationExecutionStatusRequest(arg0 *athena.GetCalculationExecutionStatusInput) (*request.Request, *athena.GetCalculationExecutionStatusOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCalculationExecutionStatusRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.GetCalculationExecutionStatusOutput)
	return ret0, ret1
}

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

// GetCalculationExecutionStatusWithContext mocks base method
func (m *MockAthenaAPI) GetCalculationExecutionStatusWithContext(arg0 context.Context, arg1 *athena.GetCalculationExecutionStatusInput, arg2 ...request.Option) (*athena.GetCalculationExecutionStatusOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCalculationExecutionStatusWithContext", varargs...)
	ret0, _ := ret[0].(*athena.GetCalculationExecutionStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCalculationExecutionStatusWithContext indicates an expected call of GetCalculationExecutionStatusWithContext
func (mr *MockAthenaAPIMockRecorder) GetCalculationExecutionStatusWithContext(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, "GetCalculationExecutionStatusWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetCalculationExecutionStatusWithContext), varargs...)
}

// GetCalculationExecutionWithContext mocks base method
func (m *MockAthenaAPI) GetCalculationExecutionWithContext(arg0 context.Context, arg1 *athena.GetCalculationExecutionInput, arg2 ...request.Option) (*athena.GetCalculationExecutionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCalculationExecutionWithContext", varargs...)
	ret0, _ := ret[0].(*athena.GetCalculationExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCalculationExecutionWithContext indicates an expected call of GetCalculationExecutionWithContext
func (mr *MockAthenaAPIMockRecorder) GetCalculationExecutionWithContext(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, "GetCalculationExecutionWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetCalculationExecutionWithContext), varargs...)
}

// GetCapacityAssignmentConfiguration mocks base method
func (m *MockAthenaAPI) GetCapacityAssignmentConfiguration(arg0 *athena.GetCapacityAssignmentConfigurationInput) (*athena.GetCapacityAssignmentConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCapacityAssignmentConfiguration", arg0)
	ret0, _ := ret[0].(*athena.GetCapacityAssignmentConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCapacityAssignmentConfigurationRequest mocks base method
func (m *MockAthenaAPI) GetCapacityAssignmentConfigurationRequest(arg0 *athena.GetCapacityAssignmentConfigurationInput) (*request.Request, *athena.GetCapacityAssignmentConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCapacityAssignmentConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.GetCapacityAssignmentConfigurationOutput)
	return ret0, ret1
}

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

// GetCapacityAssignmentConfigurationWithContext mocks base method
func (m *MockAthenaAPI) GetCapacityAssignmentConfigurationWithContext(arg0 context.Context, arg1 *athena.GetCapacityAssignmentConfigurationInput, arg2 ...request.Option) (*athena.GetCapacityAssignmentConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCapacityAssignmentConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*athena.GetCapacityAssignmentConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCapacityAssignmentConfigurationWithContext indicates an expected call of GetCapacityAssignmentConfigurationWithContext
func (mr *MockAthenaAPIMockRecorder) GetCapacityAssignmentConfigurationWithContext(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, "GetCapacityAssignmentConfigurationWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetCapacityAssignmentConfigurationWithContext), varargs...)
}

// GetCapacityReservation mocks base method
func (m *MockAthenaAPI) GetCapacityReservation(arg0 *athena.GetCapacityReservationInput) (*athena.GetCapacityReservationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCapacityReservation", arg0)
	ret0, _ := ret[0].(*athena.GetCapacityReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCapacityReservationRequest mocks base method
func (m *MockAthenaAPI) GetCapacityReservationRequest(arg0 *athena.GetCapacityReservationInput) (*request.Request, *athena.GetCapacityReservationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCapacityReservationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.GetCapacityReservationOutput)
	return ret0, ret1
}

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

// GetCapacityReservationWithContext mocks base method
func (m *MockAthenaAPI) GetCapacityReservationWithContext(arg0 context.Context, arg1 *athena.GetCapacityReservationInput, arg2 ...request.Option) (*athena.GetCapacityReservationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCapacityReservationWithContext", varargs...)
	ret0, _ := ret[0].(*athena.GetCapacityReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCapacityReservationWithContext indicates an expected call of GetCapacityReservationWithContext
func (mr *MockAthenaAPIMockRecorder) GetCapacityReservationWithContext(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, "GetCapacityReservationWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetCapacityReservationWithContext), varargs...)
}

// GetDataCatalog mocks base method
func (m *MockAthenaAPI) GetDataCatalog(arg0 *athena.GetDataCatalogInput) (*athena.GetDataCatalogOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDataCatalog", arg0)
	ret0, _ := ret[0].(*athena.GetDataCatalogOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDataCatalogRequest mocks base method
func (m *MockAthenaAPI) GetDataCatalogRequest(arg0 *athena.GetDataCatalogInput) (*request.Request, *athena.GetDataCatalogOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDataCatalogRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.GetDataCatalogOutput)
	return ret0, ret1
}

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

// GetDataCatalogWithContext mocks base method
func (m *MockAthenaAPI) GetDataCatalogWithContext(arg0 context.Context, arg1 *athena.GetDataCatalogInput, arg2 ...request.Option) (*athena.GetDataCatalogOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetDataCatalogWithContext", varargs...)
	ret0, _ := ret[0].(*athena.GetDataCatalogOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDataCatalogWithContext indicates an expected call of GetDataCatalogWithContext
func (mr *MockAthenaAPIMockRecorder) GetDataCatalogWithContext(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, "GetDataCatalogWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetDataCatalogWithContext), varargs...)
}

// GetDatabase mocks base method
func (m *MockAthenaAPI) GetDatabase(arg0 *athena.GetDatabaseInput) (*athena.GetDatabaseOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDatabase", arg0)
	ret0, _ := ret[0].(*athena.GetDatabaseOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDatabaseRequest mocks base method
func (m *MockAthenaAPI) GetDatabaseRequest(arg0 *athena.GetDatabaseInput) (*request.Request, *athena.GetDatabaseOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDatabaseRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.GetDatabaseOutput)
	return ret0, ret1
}

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

// GetDatabaseWithContext mocks base method
func (m *MockAthenaAPI) GetDatabaseWithContext(arg0 context.Context, arg1 *athena.GetDatabaseInput, arg2 ...request.Option) (*athena.GetDatabaseOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetDatabaseWithContext", varargs...)
	ret0, _ := ret[0].(*athena.GetDatabaseOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDatabaseWithContext indicates an expected call of GetDatabaseWithContext
func (mr *MockAthenaAPIMockRecorder) GetDatabaseWithContext(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, "GetDatabaseWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetDatabaseWithContext), varargs...)
}

// GetNamedQuery mocks base method
func (m *MockAthenaAPI) GetNamedQuery(arg0 *athena.GetNamedQueryInput) (*athena.GetNamedQueryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamedQuery", arg0)
	ret0, _ := ret[0].(*athena.GetNamedQueryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNamedQueryRequest mocks base method
func (m *MockAthenaAPI) GetNamedQueryRequest(arg0 *athena.GetNamedQueryInput) (*request.Request, *athena.GetNamedQueryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamedQueryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.GetNamedQueryOutput)
	return ret0, ret1
}

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

// GetNamedQueryWithContext mocks base method
func (m *MockAthenaAPI) GetNamedQueryWithContext(arg0 context.Context, arg1 *athena.GetNamedQueryInput, arg2 ...request.Option) (*athena.GetNamedQueryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNamedQueryWithContext", varargs...)
	ret0, _ := ret[0].(*athena.GetNamedQueryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNamedQueryWithContext indicates an expected call of GetNamedQueryWithContext
func (mr *MockAthenaAPIMockRecorder) GetNamedQueryWithContext(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, "GetNamedQueryWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetNamedQueryWithContext), varargs...)
}

// GetNotebookMetadata mocks base method
func (m *MockAthenaAPI) GetNotebookMetadata(arg0 *athena.GetNotebookMetadataInput) (*athena.GetNotebookMetadataOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNotebookMetadata", arg0)
	ret0, _ := ret[0].(*athena.GetNotebookMetadataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNotebookMetadataRequest mocks base method
func (m *MockAthenaAPI) GetNotebookMetadataRequest(arg0 *athena.GetNotebookMetadataInput) (*request.Request, *athena.GetNotebookMetadataOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNotebookMetadataRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.GetNotebookMetadataOutput)
	return ret0, ret1
}

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

// GetNotebookMetadataWithContext mocks base method
func (m *MockAthenaAPI) GetNotebookMetadataWithContext(arg0 context.Context, arg1 *athena.GetNotebookMetadataInput, arg2 ...request.Option) (*athena.GetNotebookMetadataOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNotebookMetadataWithContext", varargs...)
	ret0, _ := ret[0].(*athena.GetNotebookMetadataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNotebookMetadataWithContext indicates an expected call of GetNotebookMetadataWithContext
func (mr *MockAthenaAPIMockRecorder) GetNotebookMetadataWithContext(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, "GetNotebookMetadataWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetNotebookMetadataWithContext), varargs...)
}

// GetPreparedStatement mocks base method
func (m *MockAthenaAPI) GetPreparedStatement(arg0 *athena.GetPreparedStatementInput) (*athena.GetPreparedStatementOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPreparedStatement", arg0)
	ret0, _ := ret[0].(*athena.GetPreparedStatementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPreparedStatementRequest mocks base method
func (m *MockAthenaAPI) GetPreparedStatementRequest(arg0 *athena.GetPreparedStatementInput) (*request.Request, *athena.GetPreparedStatementOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPreparedStatementRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.GetPreparedStatementOutput)
	return ret0, ret1
}

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

// GetPreparedStatementWithContext mocks base method
func (m *MockAthenaAPI) GetPreparedStatementWithContext(arg0 context.Context, arg1 *athena.GetPreparedStatementInput, arg2 ...request.Option) (*athena.GetPreparedStatementOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPreparedStatementWithContext", varargs...)
	ret0, _ := ret[0].(*athena.GetPreparedStatementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPreparedStatementWithContext indicates an expected call of GetPreparedStatementWithContext
func (mr *MockAthenaAPIMockRecorder) GetPreparedStatementWithContext(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, "GetPreparedStatementWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetPreparedStatementWithContext), varargs...)
}

// GetQueryExecution mocks base method
func (m *MockAthenaAPI) GetQueryExecution(arg0 *athena.GetQueryExecutionInput) (*athena.GetQueryExecutionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueryExecution", arg0)
	ret0, _ := ret[0].(*athena.GetQueryExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetQueryExecutionRequest mocks base method
func (m *MockAthenaAPI) GetQueryExecutionRequest(arg0 *athena.GetQueryExecutionInput) (*request.Request, *athena.GetQueryExecutionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueryExecutionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.GetQueryExecutionOutput)
	return ret0, ret1
}

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

// GetQueryExecutionWithContext mocks base method
func (m *MockAthenaAPI) GetQueryExecutionWithContext(arg0 context.Context, arg1 *athena.GetQueryExecutionInput, arg2 ...request.Option) (*athena.GetQueryExecutionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetQueryExecutionWithContext", varargs...)
	ret0, _ := ret[0].(*athena.GetQueryExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetQueryExecutionWithContext indicates an expected call of GetQueryExecutionWithContext
func (mr *MockAthenaAPIMockRecorder) GetQueryExecutionWithContext(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, "GetQueryExecutionWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetQueryExecutionWithContext), varargs...)
}

// GetQueryResults mocks base method
func (m *MockAthenaAPI) GetQueryResults(arg0 *athena.GetQueryResultsInput) (*athena.GetQueryResultsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueryResults", arg0)
	ret0, _ := ret[0].(*athena.GetQueryResultsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetQueryResultsPages mocks base method
func (m *MockAthenaAPI) GetQueryResultsPages(arg0 *athena.GetQueryResultsInput, arg1 func(*athena.GetQueryResultsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueryResultsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetQueryResultsPagesWithContext mocks base method
func (m *MockAthenaAPI) GetQueryResultsPagesWithContext(arg0 context.Context, arg1 *athena.GetQueryResultsInput, arg2 func(*athena.GetQueryResultsOutput, 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, "GetQueryResultsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetQueryResultsPagesWithContext indicates an expected call of GetQueryResultsPagesWithContext
func (mr *MockAthenaAPIMockRecorder) GetQueryResultsPagesWithContext(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, "GetQueryResultsPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetQueryResultsPagesWithContext), varargs...)
}

// GetQueryResultsRequest mocks base method
func (m *MockAthenaAPI) GetQueryResultsRequest(arg0 *athena.GetQueryResultsInput) (*request.Request, *athena.GetQueryResultsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueryResultsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.GetQueryResultsOutput)
	return ret0, ret1
}

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

// GetQueryResultsWithContext mocks base method
func (m *MockAthenaAPI) GetQueryResultsWithContext(arg0 context.Context, arg1 *athena.GetQueryResultsInput, arg2 ...request.Option) (*athena.GetQueryResultsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetQueryResultsWithContext", varargs...)
	ret0, _ := ret[0].(*athena.GetQueryResultsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetQueryResultsWithContext indicates an expected call of GetQueryResultsWithContext
func (mr *MockAthenaAPIMockRecorder) GetQueryResultsWithContext(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, "GetQueryResultsWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetQueryResultsWithContext), varargs...)
}

// GetQueryRuntimeStatistics mocks base method
func (m *MockAthenaAPI) GetQueryRuntimeStatistics(arg0 *athena.GetQueryRuntimeStatisticsInput) (*athena.GetQueryRuntimeStatisticsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueryRuntimeStatistics", arg0)
	ret0, _ := ret[0].(*athena.GetQueryRuntimeStatisticsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetQueryRuntimeStatisticsRequest mocks base method
func (m *MockAthenaAPI) GetQueryRuntimeStatisticsRequest(arg0 *athena.GetQueryRuntimeStatisticsInput) (*request.Request, *athena.GetQueryRuntimeStatisticsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueryRuntimeStatisticsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.GetQueryRuntimeStatisticsOutput)
	return ret0, ret1
}

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

// GetQueryRuntimeStatisticsWithContext mocks base method
func (m *MockAthenaAPI) GetQueryRuntimeStatisticsWithContext(arg0 context.Context, arg1 *athena.GetQueryRuntimeStatisticsInput, arg2 ...request.Option) (*athena.GetQueryRuntimeStatisticsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetQueryRuntimeStatisticsWithContext", varargs...)
	ret0, _ := ret[0].(*athena.GetQueryRuntimeStatisticsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetQueryRuntimeStatisticsWithContext indicates an expected call of GetQueryRuntimeStatisticsWithContext
func (mr *MockAthenaAPIMockRecorder) GetQueryRuntimeStatisticsWithContext(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, "GetQueryRuntimeStatisticsWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetQueryRuntimeStatisticsWithContext), varargs...)
}

// GetSession mocks base method
func (m *MockAthenaAPI) GetSession(arg0 *athena.GetSessionInput) (*athena.GetSessionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSession", arg0)
	ret0, _ := ret[0].(*athena.GetSessionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSessionRequest mocks base method
func (m *MockAthenaAPI) GetSessionRequest(arg0 *athena.GetSessionInput) (*request.Request, *athena.GetSessionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSessionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.GetSessionOutput)
	return ret0, ret1
}

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

// GetSessionStatus mocks base method
func (m *MockAthenaAPI) GetSessionStatus(arg0 *athena.GetSessionStatusInput) (*athena.GetSessionStatusOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSessionStatus", arg0)
	ret0, _ := ret[0].(*athena.GetSessionStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSessionStatusRequest mocks base method
func (m *MockAthenaAPI) GetSessionStatusRequest(arg0 *athena.GetSessionStatusInput) (*request.Request, *athena.GetSessionStatusOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSessionStatusRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.GetSessionStatusOutput)
	return ret0, ret1
}

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

// GetSessionStatusWithContext mocks base method
func (m *MockAthenaAPI) GetSessionStatusWithContext(arg0 context.Context, arg1 *athena.GetSessionStatusInput, arg2 ...request.Option) (*athena.GetSessionStatusOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSessionStatusWithContext", varargs...)
	ret0, _ := ret[0].(*athena.GetSessionStatusOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSessionStatusWithContext indicates an expected call of GetSessionStatusWithContext
func (mr *MockAthenaAPIMockRecorder) GetSessionStatusWithContext(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, "GetSessionStatusWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetSessionStatusWithContext), varargs...)
}

// GetSessionWithContext mocks base method
func (m *MockAthenaAPI) GetSessionWithContext(arg0 context.Context, arg1 *athena.GetSessionInput, arg2 ...request.Option) (*athena.GetSessionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSessionWithContext", varargs...)
	ret0, _ := ret[0].(*athena.GetSessionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSessionWithContext indicates an expected call of GetSessionWithContext
func (mr *MockAthenaAPIMockRecorder) GetSessionWithContext(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, "GetSessionWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetSessionWithContext), varargs...)
}

// GetTableMetadata mocks base method
func (m *MockAthenaAPI) GetTableMetadata(arg0 *athena.GetTableMetadataInput) (*athena.GetTableMetadataOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTableMetadata", arg0)
	ret0, _ := ret[0].(*athena.GetTableMetadataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTableMetadataRequest mocks base method
func (m *MockAthenaAPI) GetTableMetadataRequest(arg0 *athena.GetTableMetadataInput) (*request.Request, *athena.GetTableMetadataOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTableMetadataRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.GetTableMetadataOutput)
	return ret0, ret1
}

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

// GetTableMetadataWithContext mocks base method
func (m *MockAthenaAPI) GetTableMetadataWithContext(arg0 context.Context, arg1 *athena.GetTableMetadataInput, arg2 ...request.Option) (*athena.GetTableMetadataOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTableMetadataWithContext", varargs...)
	ret0, _ := ret[0].(*athena.GetTableMetadataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTableMetadataWithContext indicates an expected call of GetTableMetadataWithContext
func (mr *MockAthenaAPIMockRecorder) GetTableMetadataWithContext(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, "GetTableMetadataWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetTableMetadataWithContext), varargs...)
}

// GetWorkGroup mocks base method
func (m *MockAthenaAPI) GetWorkGroup(arg0 *athena.GetWorkGroupInput) (*athena.GetWorkGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkGroup", arg0)
	ret0, _ := ret[0].(*athena.GetWorkGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkGroupRequest mocks base method
func (m *MockAthenaAPI) GetWorkGroupRequest(arg0 *athena.GetWorkGroupInput) (*request.Request, *athena.GetWorkGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.GetWorkGroupOutput)
	return ret0, ret1
}

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

// GetWorkGroupWithContext mocks base method
func (m *MockAthenaAPI) GetWorkGroupWithContext(arg0 context.Context, arg1 *athena.GetWorkGroupInput, arg2 ...request.Option) (*athena.GetWorkGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetWorkGroupWithContext", varargs...)
	ret0, _ := ret[0].(*athena.GetWorkGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkGroupWithContext indicates an expected call of GetWorkGroupWithContext
func (mr *MockAthenaAPIMockRecorder) GetWorkGroupWithContext(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, "GetWorkGroupWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).GetWorkGroupWithContext), varargs...)
}

// ImportNotebook mocks base method
func (m *MockAthenaAPI) ImportNotebook(arg0 *athena.ImportNotebookInput) (*athena.ImportNotebookOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportNotebook", arg0)
	ret0, _ := ret[0].(*athena.ImportNotebookOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ImportNotebookRequest mocks base method
func (m *MockAthenaAPI) ImportNotebookRequest(arg0 *athena.ImportNotebookInput) (*request.Request, *athena.ImportNotebookOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportNotebookRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.ImportNotebookOutput)
	return ret0, ret1
}

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

// ImportNotebookWithContext mocks base method
func (m *MockAthenaAPI) ImportNotebookWithContext(arg0 context.Context, arg1 *athena.ImportNotebookInput, arg2 ...request.Option) (*athena.ImportNotebookOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ImportNotebookWithContext", varargs...)
	ret0, _ := ret[0].(*athena.ImportNotebookOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImportNotebookWithContext indicates an expected call of ImportNotebookWithContext
func (mr *MockAthenaAPIMockRecorder) ImportNotebookWithContext(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, "ImportNotebookWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ImportNotebookWithContext), varargs...)
}

// ListApplicationDPUSizes mocks base method
func (m *MockAthenaAPI) ListApplicationDPUSizes(arg0 *athena.ListApplicationDPUSizesInput) (*athena.ListApplicationDPUSizesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListApplicationDPUSizes", arg0)
	ret0, _ := ret[0].(*athena.ListApplicationDPUSizesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListApplicationDPUSizesPages mocks base method
func (m *MockAthenaAPI) ListApplicationDPUSizesPages(arg0 *athena.ListApplicationDPUSizesInput, arg1 func(*athena.ListApplicationDPUSizesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListApplicationDPUSizesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListApplicationDPUSizesPagesWithContext mocks base method
func (m *MockAthenaAPI) ListApplicationDPUSizesPagesWithContext(arg0 context.Context, arg1 *athena.ListApplicationDPUSizesInput, arg2 func(*athena.ListApplicationDPUSizesOutput, 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, "ListApplicationDPUSizesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListApplicationDPUSizesPagesWithContext indicates an expected call of ListApplicationDPUSizesPagesWithContext
func (mr *MockAthenaAPIMockRecorder) ListApplicationDPUSizesPagesWithContext(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, "ListApplicationDPUSizesPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListApplicationDPUSizesPagesWithContext), varargs...)
}

// ListApplicationDPUSizesRequest mocks base method
func (m *MockAthenaAPI) ListApplicationDPUSizesRequest(arg0 *athena.ListApplicationDPUSizesInput) (*request.Request, *athena.ListApplicationDPUSizesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListApplicationDPUSizesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.ListApplicationDPUSizesOutput)
	return ret0, ret1
}

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

// ListApplicationDPUSizesWithContext mocks base method
func (m *MockAthenaAPI) ListApplicationDPUSizesWithContext(arg0 context.Context, arg1 *athena.ListApplicationDPUSizesInput, arg2 ...request.Option) (*athena.ListApplicationDPUSizesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListApplicationDPUSizesWithContext", varargs...)
	ret0, _ := ret[0].(*athena.ListApplicationDPUSizesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListApplicationDPUSizesWithContext indicates an expected call of ListApplicationDPUSizesWithContext
func (mr *MockAthenaAPIMockRecorder) ListApplicationDPUSizesWithContext(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, "ListApplicationDPUSizesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListApplicationDPUSizesWithContext), varargs...)
}

// ListCalculationExecutions mocks base method
func (m *MockAthenaAPI) ListCalculationExecutions(arg0 *athena.ListCalculationExecutionsInput) (*athena.ListCalculationExecutionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCalculationExecutions", arg0)
	ret0, _ := ret[0].(*athena.ListCalculationExecutionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListCalculationExecutionsPages mocks base method
func (m *MockAthenaAPI) ListCalculationExecutionsPages(arg0 *athena.ListCalculationExecutionsInput, arg1 func(*athena.ListCalculationExecutionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCalculationExecutionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListCalculationExecutionsPagesWithContext mocks base method
func (m *MockAthenaAPI) ListCalculationExecutionsPagesWithContext(arg0 context.Context, arg1 *athena.ListCalculationExecutionsInput, arg2 func(*athena.ListCalculationExecutionsOutput, 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, "ListCalculationExecutionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListCalculationExecutionsPagesWithContext indicates an expected call of ListCalculationExecutionsPagesWithContext
func (mr *MockAthenaAPIMockRecorder) ListCalculationExecutionsPagesWithContext(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, "ListCalculationExecutionsPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListCalculationExecutionsPagesWithContext), varargs...)
}

// ListCalculationExecutionsRequest mocks base method
func (m *MockAthenaAPI) ListCalculationExecutionsRequest(arg0 *athena.ListCalculationExecutionsInput) (*request.Request, *athena.ListCalculationExecutionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCalculationExecutionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.ListCalculationExecutionsOutput)
	return ret0, ret1
}

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

// ListCalculationExecutionsWithContext mocks base method
func (m *MockAthenaAPI) ListCalculationExecutionsWithContext(arg0 context.Context, arg1 *athena.ListCalculationExecutionsInput, arg2 ...request.Option) (*athena.ListCalculationExecutionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCalculationExecutionsWithContext", varargs...)
	ret0, _ := ret[0].(*athena.ListCalculationExecutionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCalculationExecutionsWithContext indicates an expected call of ListCalculationExecutionsWithContext
func (mr *MockAthenaAPIMockRecorder) ListCalculationExecutionsWithContext(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, "ListCalculationExecutionsWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListCalculationExecutionsWithContext), varargs...)
}

// ListCapacityReservations mocks base method
func (m *MockAthenaAPI) ListCapacityReservations(arg0 *athena.ListCapacityReservationsInput) (*athena.ListCapacityReservationsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCapacityReservations", arg0)
	ret0, _ := ret[0].(*athena.ListCapacityReservationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListCapacityReservationsPages mocks base method
func (m *MockAthenaAPI) ListCapacityReservationsPages(arg0 *athena.ListCapacityReservationsInput, arg1 func(*athena.ListCapacityReservationsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCapacityReservationsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListCapacityReservationsPagesWithContext mocks base method
func (m *MockAthenaAPI) ListCapacityReservationsPagesWithContext(arg0 context.Context, arg1 *athena.ListCapacityReservationsInput, arg2 func(*athena.ListCapacityReservationsOutput, 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, "ListCapacityReservationsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListCapacityReservationsPagesWithContext indicates an expected call of ListCapacityReservationsPagesWithContext
func (mr *MockAthenaAPIMockRecorder) ListCapacityReservationsPagesWithContext(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, "ListCapacityReservationsPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListCapacityReservationsPagesWithContext), varargs...)
}

// ListCapacityReservationsRequest mocks base method
func (m *MockAthenaAPI) ListCapacityReservationsRequest(arg0 *athena.ListCapacityReservationsInput) (*request.Request, *athena.ListCapacityReservationsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListCapacityReservationsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.ListCapacityReservationsOutput)
	return ret0, ret1
}

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

// ListCapacityReservationsWithContext mocks base method
func (m *MockAthenaAPI) ListCapacityReservationsWithContext(arg0 context.Context, arg1 *athena.ListCapacityReservationsInput, arg2 ...request.Option) (*athena.ListCapacityReservationsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCapacityReservationsWithContext", varargs...)
	ret0, _ := ret[0].(*athena.ListCapacityReservationsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCapacityReservationsWithContext indicates an expected call of ListCapacityReservationsWithContext
func (mr *MockAthenaAPIMockRecorder) ListCapacityReservationsWithContext(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, "ListCapacityReservationsWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListCapacityReservationsWithContext), varargs...)
}

// ListDataCatalogs mocks base method
func (m *MockAthenaAPI) ListDataCatalogs(arg0 *athena.ListDataCatalogsInput) (*athena.ListDataCatalogsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDataCatalogs", arg0)
	ret0, _ := ret[0].(*athena.ListDataCatalogsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListDataCatalogsPages mocks base method
func (m *MockAthenaAPI) ListDataCatalogsPages(arg0 *athena.ListDataCatalogsInput, arg1 func(*athena.ListDataCatalogsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDataCatalogsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListDataCatalogsPagesWithContext mocks base method
func (m *MockAthenaAPI) ListDataCatalogsPagesWithContext(arg0 context.Context, arg1 *athena.ListDataCatalogsInput, arg2 func(*athena.ListDataCatalogsOutput, 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, "ListDataCatalogsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListDataCatalogsPagesWithContext indicates an expected call of ListDataCatalogsPagesWithContext
func (mr *MockAthenaAPIMockRecorder) ListDataCatalogsPagesWithContext(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, "ListDataCatalogsPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListDataCatalogsPagesWithContext), varargs...)
}

// ListDataCatalogsRequest mocks base method
func (m *MockAthenaAPI) ListDataCatalogsRequest(arg0 *athena.ListDataCatalogsInput) (*request.Request, *athena.ListDataCatalogsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDataCatalogsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.ListDataCatalogsOutput)
	return ret0, ret1
}

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

// ListDataCatalogsWithContext mocks base method
func (m *MockAthenaAPI) ListDataCatalogsWithContext(arg0 context.Context, arg1 *athena.ListDataCatalogsInput, arg2 ...request.Option) (*athena.ListDataCatalogsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDataCatalogsWithContext", varargs...)
	ret0, _ := ret[0].(*athena.ListDataCatalogsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDataCatalogsWithContext indicates an expected call of ListDataCatalogsWithContext
func (mr *MockAthenaAPIMockRecorder) ListDataCatalogsWithContext(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, "ListDataCatalogsWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListDataCatalogsWithContext), varargs...)
}

// ListDatabases mocks base method
func (m *MockAthenaAPI) ListDatabases(arg0 *athena.ListDatabasesInput) (*athena.ListDatabasesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDatabases", arg0)
	ret0, _ := ret[0].(*athena.ListDatabasesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListDatabasesPages mocks base method
func (m *MockAthenaAPI) ListDatabasesPages(arg0 *athena.ListDatabasesInput, arg1 func(*athena.ListDatabasesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDatabasesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListDatabasesPagesWithContext mocks base method
func (m *MockAthenaAPI) ListDatabasesPagesWithContext(arg0 context.Context, arg1 *athena.ListDatabasesInput, arg2 func(*athena.ListDatabasesOutput, 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, "ListDatabasesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListDatabasesPagesWithContext indicates an expected call of ListDatabasesPagesWithContext
func (mr *MockAthenaAPIMockRecorder) ListDatabasesPagesWithContext(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, "ListDatabasesPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListDatabasesPagesWithContext), varargs...)
}

// ListDatabasesRequest mocks base method
func (m *MockAthenaAPI) ListDatabasesRequest(arg0 *athena.ListDatabasesInput) (*request.Request, *athena.ListDatabasesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDatabasesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.ListDatabasesOutput)
	return ret0, ret1
}

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

// ListDatabasesWithContext mocks base method
func (m *MockAthenaAPI) ListDatabasesWithContext(arg0 context.Context, arg1 *athena.ListDatabasesInput, arg2 ...request.Option) (*athena.ListDatabasesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDatabasesWithContext", varargs...)
	ret0, _ := ret[0].(*athena.ListDatabasesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDatabasesWithContext indicates an expected call of ListDatabasesWithContext
func (mr *MockAthenaAPIMockRecorder) ListDatabasesWithContext(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, "ListDatabasesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListDatabasesWithContext), varargs...)
}

// ListEngineVersions mocks base method
func (m *MockAthenaAPI) ListEngineVersions(arg0 *athena.ListEngineVersionsInput) (*athena.ListEngineVersionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEngineVersions", arg0)
	ret0, _ := ret[0].(*athena.ListEngineVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListEngineVersionsPages mocks base method
func (m *MockAthenaAPI) ListEngineVersionsPages(arg0 *athena.ListEngineVersionsInput, arg1 func(*athena.ListEngineVersionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEngineVersionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListEngineVersionsPagesWithContext mocks base method
func (m *MockAthenaAPI) ListEngineVersionsPagesWithContext(arg0 context.Context, arg1 *athena.ListEngineVersionsInput, arg2 func(*athena.ListEngineVersionsOutput, 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, "ListEngineVersionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListEngineVersionsPagesWithContext indicates an expected call of ListEngineVersionsPagesWithContext
func (mr *MockAthenaAPIMockRecorder) ListEngineVersionsPagesWithContext(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, "ListEngineVersionsPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListEngineVersionsPagesWithContext), varargs...)
}

// ListEngineVersionsRequest mocks base method
func (m *MockAthenaAPI) ListEngineVersionsRequest(arg0 *athena.ListEngineVersionsInput) (*request.Request, *athena.ListEngineVersionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListEngineVersionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.ListEngineVersionsOutput)
	return ret0, ret1
}

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

// ListEngineVersionsWithContext mocks base method
func (m *MockAthenaAPI) ListEngineVersionsWithContext(arg0 context.Context, arg1 *athena.ListEngineVersionsInput, arg2 ...request.Option) (*athena.ListEngineVersionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListEngineVersionsWithContext", varargs...)
	ret0, _ := ret[0].(*athena.ListEngineVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListEngineVersionsWithContext indicates an expected call of ListEngineVersionsWithContext
func (mr *MockAthenaAPIMockRecorder) ListEngineVersionsWithContext(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, "ListEngineVersionsWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListEngineVersionsWithContext), varargs...)
}

// ListExecutors mocks base method
func (m *MockAthenaAPI) ListExecutors(arg0 *athena.ListExecutorsInput) (*athena.ListExecutorsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListExecutors", arg0)
	ret0, _ := ret[0].(*athena.ListExecutorsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListExecutorsPages mocks base method
func (m *MockAthenaAPI) ListExecutorsPages(arg0 *athena.ListExecutorsInput, arg1 func(*athena.ListExecutorsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListExecutorsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListExecutorsPagesWithContext mocks base method
func (m *MockAthenaAPI) ListExecutorsPagesWithContext(arg0 context.Context, arg1 *athena.ListExecutorsInput, arg2 func(*athena.ListExecutorsOutput, 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, "ListExecutorsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListExecutorsPagesWithContext indicates an expected call of ListExecutorsPagesWithContext
func (mr *MockAthenaAPIMockRecorder) ListExecutorsPagesWithContext(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, "ListExecutorsPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListExecutorsPagesWithContext), varargs...)
}

// ListExecutorsRequest mocks base method
func (m *MockAthenaAPI) ListExecutorsRequest(arg0 *athena.ListExecutorsInput) (*request.Request, *athena.ListExecutorsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListExecutorsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.ListExecutorsOutput)
	return ret0, ret1
}

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

// ListExecutorsWithContext mocks base method
func (m *MockAthenaAPI) ListExecutorsWithContext(arg0 context.Context, arg1 *athena.ListExecutorsInput, arg2 ...request.Option) (*athena.ListExecutorsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListExecutorsWithContext", varargs...)
	ret0, _ := ret[0].(*athena.ListExecutorsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListExecutorsWithContext indicates an expected call of ListExecutorsWithContext
func (mr *MockAthenaAPIMockRecorder) ListExecutorsWithContext(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, "ListExecutorsWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListExecutorsWithContext), varargs...)
}

// ListNamedQueries mocks base method
func (m *MockAthenaAPI) ListNamedQueries(arg0 *athena.ListNamedQueriesInput) (*athena.ListNamedQueriesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNamedQueries", arg0)
	ret0, _ := ret[0].(*athena.ListNamedQueriesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNamedQueriesPages mocks base method
func (m *MockAthenaAPI) ListNamedQueriesPages(arg0 *athena.ListNamedQueriesInput, arg1 func(*athena.ListNamedQueriesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNamedQueriesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListNamedQueriesPagesWithContext mocks base method
func (m *MockAthenaAPI) ListNamedQueriesPagesWithContext(arg0 context.Context, arg1 *athena.ListNamedQueriesInput, arg2 func(*athena.ListNamedQueriesOutput, 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, "ListNamedQueriesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListNamedQueriesPagesWithContext indicates an expected call of ListNamedQueriesPagesWithContext
func (mr *MockAthenaAPIMockRecorder) ListNamedQueriesPagesWithContext(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, "ListNamedQueriesPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListNamedQueriesPagesWithContext), varargs...)
}

// ListNamedQueriesRequest mocks base method
func (m *MockAthenaAPI) ListNamedQueriesRequest(arg0 *athena.ListNamedQueriesInput) (*request.Request, *athena.ListNamedQueriesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNamedQueriesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.ListNamedQueriesOutput)
	return ret0, ret1
}

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

// ListNamedQueriesWithContext mocks base method
func (m *MockAthenaAPI) ListNamedQueriesWithContext(arg0 context.Context, arg1 *athena.ListNamedQueriesInput, arg2 ...request.Option) (*athena.ListNamedQueriesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListNamedQueriesWithContext", varargs...)
	ret0, _ := ret[0].(*athena.ListNamedQueriesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNamedQueriesWithContext indicates an expected call of ListNamedQueriesWithContext
func (mr *MockAthenaAPIMockRecorder) ListNamedQueriesWithContext(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, "ListNamedQueriesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListNamedQueriesWithContext), varargs...)
}

// ListNotebookMetadata mocks base method
func (m *MockAthenaAPI) ListNotebookMetadata(arg0 *athena.ListNotebookMetadataInput) (*athena.ListNotebookMetadataOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNotebookMetadata", arg0)
	ret0, _ := ret[0].(*athena.ListNotebookMetadataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNotebookMetadataRequest mocks base method
func (m *MockAthenaAPI) ListNotebookMetadataRequest(arg0 *athena.ListNotebookMetadataInput) (*request.Request, *athena.ListNotebookMetadataOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNotebookMetadataRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.ListNotebookMetadataOutput)
	return ret0, ret1
}

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

// ListNotebookMetadataWithContext mocks base method
func (m *MockAthenaAPI) ListNotebookMetadataWithContext(arg0 context.Context, arg1 *athena.ListNotebookMetadataInput, arg2 ...request.Option) (*athena.ListNotebookMetadataOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListNotebookMetadataWithContext", varargs...)
	ret0, _ := ret[0].(*athena.ListNotebookMetadataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNotebookMetadataWithContext indicates an expected call of ListNotebookMetadataWithContext
func (mr *MockAthenaAPIMockRecorder) ListNotebookMetadataWithContext(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, "ListNotebookMetadataWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListNotebookMetadataWithContext), varargs...)
}

// ListNotebookSessions mocks base method
func (m *MockAthenaAPI) ListNotebookSessions(arg0 *athena.ListNotebookSessionsInput) (*athena.ListNotebookSessionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNotebookSessions", arg0)
	ret0, _ := ret[0].(*athena.ListNotebookSessionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNotebookSessionsRequest mocks base method
func (m *MockAthenaAPI) ListNotebookSessionsRequest(arg0 *athena.ListNotebookSessionsInput) (*request.Request, *athena.ListNotebookSessionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNotebookSessionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.ListNotebookSessionsOutput)
	return ret0, ret1
}

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

// ListNotebookSessionsWithContext mocks base method
func (m *MockAthenaAPI) ListNotebookSessionsWithContext(arg0 context.Context, arg1 *athena.ListNotebookSessionsInput, arg2 ...request.Option) (*athena.ListNotebookSessionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListNotebookSessionsWithContext", varargs...)
	ret0, _ := ret[0].(*athena.ListNotebookSessionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNotebookSessionsWithContext indicates an expected call of ListNotebookSessionsWithContext
func (mr *MockAthenaAPIMockRecorder) ListNotebookSessionsWithContext(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, "ListNotebookSessionsWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListNotebookSessionsWithContext), varargs...)
}

// ListPreparedStatements mocks base method
func (m *MockAthenaAPI) ListPreparedStatements(arg0 *athena.ListPreparedStatementsInput) (*athena.ListPreparedStatementsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPreparedStatements", arg0)
	ret0, _ := ret[0].(*athena.ListPreparedStatementsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListPreparedStatementsPages mocks base method
func (m *MockAthenaAPI) ListPreparedStatementsPages(arg0 *athena.ListPreparedStatementsInput, arg1 func(*athena.ListPreparedStatementsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPreparedStatementsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListPreparedStatementsPagesWithContext mocks base method
func (m *MockAthenaAPI) ListPreparedStatementsPagesWithContext(arg0 context.Context, arg1 *athena.ListPreparedStatementsInput, arg2 func(*athena.ListPreparedStatementsOutput, 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, "ListPreparedStatementsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListPreparedStatementsPagesWithContext indicates an expected call of ListPreparedStatementsPagesWithContext
func (mr *MockAthenaAPIMockRecorder) ListPreparedStatementsPagesWithContext(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, "ListPreparedStatementsPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListPreparedStatementsPagesWithContext), varargs...)
}

// ListPreparedStatementsRequest mocks base method
func (m *MockAthenaAPI) ListPreparedStatementsRequest(arg0 *athena.ListPreparedStatementsInput) (*request.Request, *athena.ListPreparedStatementsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPreparedStatementsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.ListPreparedStatementsOutput)
	return ret0, ret1
}

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

// ListPreparedStatementsWithContext mocks base method
func (m *MockAthenaAPI) ListPreparedStatementsWithContext(arg0 context.Context, arg1 *athena.ListPreparedStatementsInput, arg2 ...request.Option) (*athena.ListPreparedStatementsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPreparedStatementsWithContext", varargs...)
	ret0, _ := ret[0].(*athena.ListPreparedStatementsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPreparedStatementsWithContext indicates an expected call of ListPreparedStatementsWithContext
func (mr *MockAthenaAPIMockRecorder) ListPreparedStatementsWithContext(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, "ListPreparedStatementsWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListPreparedStatementsWithContext), varargs...)
}

// ListQueryExecutions mocks base method
func (m *MockAthenaAPI) ListQueryExecutions(arg0 *athena.ListQueryExecutionsInput) (*athena.ListQueryExecutionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListQueryExecutions", arg0)
	ret0, _ := ret[0].(*athena.ListQueryExecutionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListQueryExecutionsPages mocks base method
func (m *MockAthenaAPI) ListQueryExecutionsPages(arg0 *athena.ListQueryExecutionsInput, arg1 func(*athena.ListQueryExecutionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListQueryExecutionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListQueryExecutionsPagesWithContext mocks base method
func (m *MockAthenaAPI) ListQueryExecutionsPagesWithContext(arg0 context.Context, arg1 *athena.ListQueryExecutionsInput, arg2 func(*athena.ListQueryExecutionsOutput, 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, "ListQueryExecutionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListQueryExecutionsPagesWithContext indicates an expected call of ListQueryExecutionsPagesWithContext
func (mr *MockAthenaAPIMockRecorder) ListQueryExecutionsPagesWithContext(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, "ListQueryExecutionsPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListQueryExecutionsPagesWithContext), varargs...)
}

// ListQueryExecutionsRequest mocks base method
func (m *MockAthenaAPI) ListQueryExecutionsRequest(arg0 *athena.ListQueryExecutionsInput) (*request.Request, *athena.ListQueryExecutionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListQueryExecutionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.ListQueryExecutionsOutput)
	return ret0, ret1
}

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

// ListQueryExecutionsWithContext mocks base method
func (m *MockAthenaAPI) ListQueryExecutionsWithContext(arg0 context.Context, arg1 *athena.ListQueryExecutionsInput, arg2 ...request.Option) (*athena.ListQueryExecutionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListQueryExecutionsWithContext", varargs...)
	ret0, _ := ret[0].(*athena.ListQueryExecutionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListQueryExecutionsWithContext indicates an expected call of ListQueryExecutionsWithContext
func (mr *MockAthenaAPIMockRecorder) ListQueryExecutionsWithContext(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, "ListQueryExecutionsWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListQueryExecutionsWithContext), varargs...)
}

// ListSessions mocks base method
func (m *MockAthenaAPI) ListSessions(arg0 *athena.ListSessionsInput) (*athena.ListSessionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSessions", arg0)
	ret0, _ := ret[0].(*athena.ListSessionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListSessionsPages mocks base method
func (m *MockAthenaAPI) ListSessionsPages(arg0 *athena.ListSessionsInput, arg1 func(*athena.ListSessionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSessionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListSessionsPagesWithContext mocks base method
func (m *MockAthenaAPI) ListSessionsPagesWithContext(arg0 context.Context, arg1 *athena.ListSessionsInput, arg2 func(*athena.ListSessionsOutput, 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, "ListSessionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListSessionsPagesWithContext indicates an expected call of ListSessionsPagesWithContext
func (mr *MockAthenaAPIMockRecorder) ListSessionsPagesWithContext(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, "ListSessionsPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListSessionsPagesWithContext), varargs...)
}

// ListSessionsRequest mocks base method
func (m *MockAthenaAPI) ListSessionsRequest(arg0 *athena.ListSessionsInput) (*request.Request, *athena.ListSessionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSessionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.ListSessionsOutput)
	return ret0, ret1
}

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

// ListSessionsWithContext mocks base method
func (m *MockAthenaAPI) ListSessionsWithContext(arg0 context.Context, arg1 *athena.ListSessionsInput, arg2 ...request.Option) (*athena.ListSessionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSessionsWithContext", varargs...)
	ret0, _ := ret[0].(*athena.ListSessionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSessionsWithContext indicates an expected call of ListSessionsWithContext
func (mr *MockAthenaAPIMockRecorder) ListSessionsWithContext(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, "ListSessionsWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListSessionsWithContext), varargs...)
}

// ListTableMetadata mocks base method
func (m *MockAthenaAPI) ListTableMetadata(arg0 *athena.ListTableMetadataInput) (*athena.ListTableMetadataOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTableMetadata", arg0)
	ret0, _ := ret[0].(*athena.ListTableMetadataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTableMetadataPages mocks base method
func (m *MockAthenaAPI) ListTableMetadataPages(arg0 *athena.ListTableMetadataInput, arg1 func(*athena.ListTableMetadataOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTableMetadataPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListTableMetadataPagesWithContext mocks base method
func (m *MockAthenaAPI) ListTableMetadataPagesWithContext(arg0 context.Context, arg1 *athena.ListTableMetadataInput, arg2 func(*athena.ListTableMetadataOutput, 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, "ListTableMetadataPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTableMetadataPagesWithContext indicates an expected call of ListTableMetadataPagesWithContext
func (mr *MockAthenaAPIMockRecorder) ListTableMetadataPagesWithContext(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, "ListTableMetadataPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListTableMetadataPagesWithContext), varargs...)
}

// ListTableMetadataRequest mocks base method
func (m *MockAthenaAPI) ListTableMetadataRequest(arg0 *athena.ListTableMetadataInput) (*request.Request, *athena.ListTableMetadataOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTableMetadataRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.ListTableMetadataOutput)
	return ret0, ret1
}

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

// ListTableMetadataWithContext mocks base method
func (m *MockAthenaAPI) ListTableMetadataWithContext(arg0 context.Context, arg1 *athena.ListTableMetadataInput, arg2 ...request.Option) (*athena.ListTableMetadataOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTableMetadataWithContext", varargs...)
	ret0, _ := ret[0].(*athena.ListTableMetadataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTableMetadataWithContext indicates an expected call of ListTableMetadataWithContext
func (mr *MockAthenaAPIMockRecorder) ListTableMetadataWithContext(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, "ListTableMetadataWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListTableMetadataWithContext), varargs...)
}

// ListTagsForResource mocks base method
func (m *MockAthenaAPI) ListTagsForResource(arg0 *athena.ListTagsForResourceInput) (*athena.ListTagsForResourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsForResource", arg0)
	ret0, _ := ret[0].(*athena.ListTagsForResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTagsForResourcePages mocks base method
func (m *MockAthenaAPI) ListTagsForResourcePages(arg0 *athena.ListTagsForResourceInput, arg1 func(*athena.ListTagsForResourceOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsForResourcePages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListTagsForResourcePagesWithContext mocks base method
func (m *MockAthenaAPI) ListTagsForResourcePagesWithContext(arg0 context.Context, arg1 *athena.ListTagsForResourceInput, arg2 func(*athena.ListTagsForResourceOutput, 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, "ListTagsForResourcePagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListTagsForResourcePagesWithContext indicates an expected call of ListTagsForResourcePagesWithContext
func (mr *MockAthenaAPIMockRecorder) ListTagsForResourcePagesWithContext(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, "ListTagsForResourcePagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListTagsForResourcePagesWithContext), varargs...)
}

// ListTagsForResourceRequest mocks base method
func (m *MockAthenaAPI) ListTagsForResourceRequest(arg0 *athena.ListTagsForResourceInput) (*request.Request, *athena.ListTagsForResourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.ListTagsForResourceOutput)
	return ret0, ret1
}

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

// ListTagsForResourceWithContext mocks base method
func (m *MockAthenaAPI) ListTagsForResourceWithContext(arg0 context.Context, arg1 *athena.ListTagsForResourceInput, arg2 ...request.Option) (*athena.ListTagsForResourceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTagsForResourceWithContext", varargs...)
	ret0, _ := ret[0].(*athena.ListTagsForResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext
func (mr *MockAthenaAPIMockRecorder) ListTagsForResourceWithContext(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, "ListTagsForResourceWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListTagsForResourceWithContext), varargs...)
}

// ListWorkGroups mocks base method
func (m *MockAthenaAPI) ListWorkGroups(arg0 *athena.ListWorkGroupsInput) (*athena.ListWorkGroupsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListWorkGroups", arg0)
	ret0, _ := ret[0].(*athena.ListWorkGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListWorkGroupsPages mocks base method
func (m *MockAthenaAPI) ListWorkGroupsPages(arg0 *athena.ListWorkGroupsInput, arg1 func(*athena.ListWorkGroupsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListWorkGroupsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListWorkGroupsPagesWithContext mocks base method
func (m *MockAthenaAPI) ListWorkGroupsPagesWithContext(arg0 context.Context, arg1 *athena.ListWorkGroupsInput, arg2 func(*athena.ListWorkGroupsOutput, 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, "ListWorkGroupsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// ListWorkGroupsPagesWithContext indicates an expected call of ListWorkGroupsPagesWithContext
func (mr *MockAthenaAPIMockRecorder) ListWorkGroupsPagesWithContext(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, "ListWorkGroupsPagesWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListWorkGroupsPagesWithContext), varargs...)
}

// ListWorkGroupsRequest mocks base method
func (m *MockAthenaAPI) ListWorkGroupsRequest(arg0 *athena.ListWorkGroupsInput) (*request.Request, *athena.ListWorkGroupsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListWorkGroupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.ListWorkGroupsOutput)
	return ret0, ret1
}

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

// ListWorkGroupsWithContext mocks base method
func (m *MockAthenaAPI) ListWorkGroupsWithContext(arg0 context.Context, arg1 *athena.ListWorkGroupsInput, arg2 ...request.Option) (*athena.ListWorkGroupsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListWorkGroupsWithContext", varargs...)
	ret0, _ := ret[0].(*athena.ListWorkGroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListWorkGroupsWithContext indicates an expected call of ListWorkGroupsWithContext
func (mr *MockAthenaAPIMockRecorder) ListWorkGroupsWithContext(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, "ListWorkGroupsWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).ListWorkGroupsWithContext), varargs...)
}

// PutCapacityAssignmentConfiguration mocks base method
func (m *MockAthenaAPI) PutCapacityAssignmentConfiguration(arg0 *athena.PutCapacityAssignmentConfigurationInput) (*athena.PutCapacityAssignmentConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutCapacityAssignmentConfiguration", arg0)
	ret0, _ := ret[0].(*athena.PutCapacityAssignmentConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PutCapacityAssignmentConfigurationRequest mocks base method
func (m *MockAthenaAPI) PutCapacityAssignmentConfigurationRequest(arg0 *athena.PutCapacityAssignmentConfigurationInput) (*request.Request, *athena.PutCapacityAssignmentConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutCapacityAssignmentConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.PutCapacityAssignmentConfigurationOutput)
	return ret0, ret1
}

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

// PutCapacityAssignmentConfigurationWithContext mocks base method
func (m *MockAthenaAPI) PutCapacityAssignmentConfigurationWithContext(arg0 context.Context, arg1 *athena.PutCapacityAssignmentConfigurationInput, arg2 ...request.Option) (*athena.PutCapacityAssignmentConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutCapacityAssignmentConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*athena.PutCapacityAssignmentConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutCapacityAssignmentConfigurationWithContext indicates an expected call of PutCapacityAssignmentConfigurationWithContext
func (mr *MockAthenaAPIMockRecorder) PutCapacityAssignmentConfigurationWithContext(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, "PutCapacityAssignmentConfigurationWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).PutCapacityAssignmentConfigurationWithContext), varargs...)
}

// StartCalculationExecution mocks base method
func (m *MockAthenaAPI) StartCalculationExecution(arg0 *athena.StartCalculationExecutionInput) (*athena.StartCalculationExecutionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartCalculationExecution", arg0)
	ret0, _ := ret[0].(*athena.StartCalculationExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartCalculationExecutionRequest mocks base method
func (m *MockAthenaAPI) StartCalculationExecutionRequest(arg0 *athena.StartCalculationExecutionInput) (*request.Request, *athena.StartCalculationExecutionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartCalculationExecutionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.StartCalculationExecutionOutput)
	return ret0, ret1
}

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

// StartCalculationExecutionWithContext mocks base method
func (m *MockAthenaAPI) StartCalculationExecutionWithContext(arg0 context.Context, arg1 *athena.StartCalculationExecutionInput, arg2 ...request.Option) (*athena.StartCalculationExecutionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartCalculationExecutionWithContext", varargs...)
	ret0, _ := ret[0].(*athena.StartCalculationExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartCalculationExecutionWithContext indicates an expected call of StartCalculationExecutionWithContext
func (mr *MockAthenaAPIMockRecorder) StartCalculationExecutionWithContext(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, "StartCalculationExecutionWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).StartCalculationExecutionWithContext), varargs...)
}

// StartQueryExecution mocks base method
func (m *MockAthenaAPI) StartQueryExecution(arg0 *athena.StartQueryExecutionInput) (*athena.StartQueryExecutionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartQueryExecution", arg0)
	ret0, _ := ret[0].(*athena.StartQueryExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartQueryExecutionRequest mocks base method
func (m *MockAthenaAPI) StartQueryExecutionRequest(arg0 *athena.StartQueryExecutionInput) (*request.Request, *athena.StartQueryExecutionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartQueryExecutionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.StartQueryExecutionOutput)
	return ret0, ret1
}

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

// StartQueryExecutionWithContext mocks base method
func (m *MockAthenaAPI) StartQueryExecutionWithContext(arg0 context.Context, arg1 *athena.StartQueryExecutionInput, arg2 ...request.Option) (*athena.StartQueryExecutionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartQueryExecutionWithContext", varargs...)
	ret0, _ := ret[0].(*athena.StartQueryExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartQueryExecutionWithContext indicates an expected call of StartQueryExecutionWithContext
func (mr *MockAthenaAPIMockRecorder) StartQueryExecutionWithContext(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, "StartQueryExecutionWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).StartQueryExecutionWithContext), varargs...)
}

// StartSession mocks base method
func (m *MockAthenaAPI) StartSession(arg0 *athena.StartSessionInput) (*athena.StartSessionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartSession", arg0)
	ret0, _ := ret[0].(*athena.StartSessionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartSessionRequest mocks base method
func (m *MockAthenaAPI) StartSessionRequest(arg0 *athena.StartSessionInput) (*request.Request, *athena.StartSessionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartSessionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.StartSessionOutput)
	return ret0, ret1
}

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

// StartSessionWithContext mocks base method
func (m *MockAthenaAPI) StartSessionWithContext(arg0 context.Context, arg1 *athena.StartSessionInput, arg2 ...request.Option) (*athena.StartSessionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartSessionWithContext", varargs...)
	ret0, _ := ret[0].(*athena.StartSessionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartSessionWithContext indicates an expected call of StartSessionWithContext
func (mr *MockAthenaAPIMockRecorder) StartSessionWithContext(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, "StartSessionWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).StartSessionWithContext), varargs...)
}

// StopCalculationExecution mocks base method
func (m *MockAthenaAPI) StopCalculationExecution(arg0 *athena.StopCalculationExecutionInput) (*athena.StopCalculationExecutionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopCalculationExecution", arg0)
	ret0, _ := ret[0].(*athena.StopCalculationExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StopCalculationExecutionRequest mocks base method
func (m *MockAthenaAPI) StopCalculationExecutionRequest(arg0 *athena.StopCalculationExecutionInput) (*request.Request, *athena.StopCalculationExecutionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopCalculationExecutionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.StopCalculationExecutionOutput)
	return ret0, ret1
}

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

// StopCalculationExecutionWithContext mocks base method
func (m *MockAthenaAPI) StopCalculationExecutionWithContext(arg0 context.Context, arg1 *athena.StopCalculationExecutionInput, arg2 ...request.Option) (*athena.StopCalculationExecutionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopCalculationExecutionWithContext", varargs...)
	ret0, _ := ret[0].(*athena.StopCalculationExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopCalculationExecutionWithContext indicates an expected call of StopCalculationExecutionWithContext
func (mr *MockAthenaAPIMockRecorder) StopCalculationExecutionWithContext(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, "StopCalculationExecutionWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).StopCalculationExecutionWithContext), varargs...)
}

// StopQueryExecution mocks base method
func (m *MockAthenaAPI) StopQueryExecution(arg0 *athena.StopQueryExecutionInput) (*athena.StopQueryExecutionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopQueryExecution", arg0)
	ret0, _ := ret[0].(*athena.StopQueryExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StopQueryExecutionRequest mocks base method
func (m *MockAthenaAPI) StopQueryExecutionRequest(arg0 *athena.StopQueryExecutionInput) (*request.Request, *athena.StopQueryExecutionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopQueryExecutionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.StopQueryExecutionOutput)
	return ret0, ret1
}

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

// StopQueryExecutionWithContext mocks base method
func (m *MockAthenaAPI) StopQueryExecutionWithContext(arg0 context.Context, arg1 *athena.StopQueryExecutionInput, arg2 ...request.Option) (*athena.StopQueryExecutionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StopQueryExecutionWithContext", varargs...)
	ret0, _ := ret[0].(*athena.StopQueryExecutionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StopQueryExecutionWithContext indicates an expected call of StopQueryExecutionWithContext
func (mr *MockAthenaAPIMockRecorder) StopQueryExecutionWithContext(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, "StopQueryExecutionWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).StopQueryExecutionWithContext), varargs...)
}

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

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

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

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

// TagResourceWithContext mocks base method
func (m *MockAthenaAPI) TagResourceWithContext(arg0 context.Context, arg1 *athena.TagResourceInput, arg2 ...request.Option) (*athena.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].(*athena.TagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TagResourceWithContext indicates an expected call of TagResourceWithContext
func (mr *MockAthenaAPIMockRecorder) 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((*MockAthenaAPI)(nil).TagResourceWithContext), varargs...)
}

// TerminateSession mocks base method
func (m *MockAthenaAPI) TerminateSession(arg0 *athena.TerminateSessionInput) (*athena.TerminateSessionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TerminateSession", arg0)
	ret0, _ := ret[0].(*athena.TerminateSessionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// TerminateSessionRequest mocks base method
func (m *MockAthenaAPI) TerminateSessionRequest(arg0 *athena.TerminateSessionInput) (*request.Request, *athena.TerminateSessionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TerminateSessionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.TerminateSessionOutput)
	return ret0, ret1
}

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

// TerminateSessionWithContext mocks base method
func (m *MockAthenaAPI) TerminateSessionWithContext(arg0 context.Context, arg1 *athena.TerminateSessionInput, arg2 ...request.Option) (*athena.TerminateSessionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TerminateSessionWithContext", varargs...)
	ret0, _ := ret[0].(*athena.TerminateSessionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TerminateSessionWithContext indicates an expected call of TerminateSessionWithContext
func (mr *MockAthenaAPIMockRecorder) TerminateSessionWithContext(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, "TerminateSessionWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).TerminateSessionWithContext), varargs...)
}

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

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

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

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

// UntagResourceWithContext mocks base method
func (m *MockAthenaAPI) UntagResourceWithContext(arg0 context.Context, arg1 *athena.UntagResourceInput, arg2 ...request.Option) (*athena.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].(*athena.UntagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UntagResourceWithContext indicates an expected call of UntagResourceWithContext
func (mr *MockAthenaAPIMockRecorder) 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((*MockAthenaAPI)(nil).UntagResourceWithContext), varargs...)
}

// UpdateCapacityReservation mocks base method
func (m *MockAthenaAPI) UpdateCapacityReservation(arg0 *athena.UpdateCapacityReservationInput) (*athena.UpdateCapacityReservationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCapacityReservation", arg0)
	ret0, _ := ret[0].(*athena.UpdateCapacityReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateCapacityReservationRequest mocks base method
func (m *MockAthenaAPI) UpdateCapacityReservationRequest(arg0 *athena.UpdateCapacityReservationInput) (*request.Request, *athena.UpdateCapacityReservationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCapacityReservationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.UpdateCapacityReservationOutput)
	return ret0, ret1
}

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

// UpdateCapacityReservationWithContext mocks base method
func (m *MockAthenaAPI) UpdateCapacityReservationWithContext(arg0 context.Context, arg1 *athena.UpdateCapacityReservationInput, arg2 ...request.Option) (*athena.UpdateCapacityReservationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateCapacityReservationWithContext", varargs...)
	ret0, _ := ret[0].(*athena.UpdateCapacityReservationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateCapacityReservationWithContext indicates an expected call of UpdateCapacityReservationWithContext
func (mr *MockAthenaAPIMockRecorder) UpdateCapacityReservationWithContext(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, "UpdateCapacityReservationWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).UpdateCapacityReservationWithContext), varargs...)
}

// UpdateDataCatalog mocks base method
func (m *MockAthenaAPI) UpdateDataCatalog(arg0 *athena.UpdateDataCatalogInput) (*athena.UpdateDataCatalogOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDataCatalog", arg0)
	ret0, _ := ret[0].(*athena.UpdateDataCatalogOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateDataCatalogRequest mocks base method
func (m *MockAthenaAPI) UpdateDataCatalogRequest(arg0 *athena.UpdateDataCatalogInput) (*request.Request, *athena.UpdateDataCatalogOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDataCatalogRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.UpdateDataCatalogOutput)
	return ret0, ret1
}

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

// UpdateDataCatalogWithContext mocks base method
func (m *MockAthenaAPI) UpdateDataCatalogWithContext(arg0 context.Context, arg1 *athena.UpdateDataCatalogInput, arg2 ...request.Option) (*athena.UpdateDataCatalogOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateDataCatalogWithContext", varargs...)
	ret0, _ := ret[0].(*athena.UpdateDataCatalogOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateDataCatalogWithContext indicates an expected call of UpdateDataCatalogWithContext
func (mr *MockAthenaAPIMockRecorder) UpdateDataCatalogWithContext(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, "UpdateDataCatalogWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).UpdateDataCatalogWithContext), varargs...)
}

// UpdateNamedQuery mocks base method
func (m *MockAthenaAPI) UpdateNamedQuery(arg0 *athena.UpdateNamedQueryInput) (*athena.UpdateNamedQueryOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNamedQuery", arg0)
	ret0, _ := ret[0].(*athena.UpdateNamedQueryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateNamedQueryRequest mocks base method
func (m *MockAthenaAPI) UpdateNamedQueryRequest(arg0 *athena.UpdateNamedQueryInput) (*request.Request, *athena.UpdateNamedQueryOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNamedQueryRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.UpdateNamedQueryOutput)
	return ret0, ret1
}

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

// UpdateNamedQueryWithContext mocks base method
func (m *MockAthenaAPI) UpdateNamedQueryWithContext(arg0 context.Context, arg1 *athena.UpdateNamedQueryInput, arg2 ...request.Option) (*athena.UpdateNamedQueryOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateNamedQueryWithContext", varargs...)
	ret0, _ := ret[0].(*athena.UpdateNamedQueryOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateNamedQueryWithContext indicates an expected call of UpdateNamedQueryWithContext
func (mr *MockAthenaAPIMockRecorder) UpdateNamedQueryWithContext(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, "UpdateNamedQueryWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).UpdateNamedQueryWithContext), varargs...)
}

// UpdateNotebook mocks base method
func (m *MockAthenaAPI) UpdateNotebook(arg0 *athena.UpdateNotebookInput) (*athena.UpdateNotebookOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNotebook", arg0)
	ret0, _ := ret[0].(*athena.UpdateNotebookOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateNotebookMetadata mocks base method
func (m *MockAthenaAPI) UpdateNotebookMetadata(arg0 *athena.UpdateNotebookMetadataInput) (*athena.UpdateNotebookMetadataOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNotebookMetadata", arg0)
	ret0, _ := ret[0].(*athena.UpdateNotebookMetadataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateNotebookMetadataRequest mocks base method
func (m *MockAthenaAPI) UpdateNotebookMetadataRequest(arg0 *athena.UpdateNotebookMetadataInput) (*request.Request, *athena.UpdateNotebookMetadataOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNotebookMetadataRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.UpdateNotebookMetadataOutput)
	return ret0, ret1
}

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

// UpdateNotebookMetadataWithContext mocks base method
func (m *MockAthenaAPI) UpdateNotebookMetadataWithContext(arg0 context.Context, arg1 *athena.UpdateNotebookMetadataInput, arg2 ...request.Option) (*athena.UpdateNotebookMetadataOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateNotebookMetadataWithContext", varargs...)
	ret0, _ := ret[0].(*athena.UpdateNotebookMetadataOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateNotebookMetadataWithContext indicates an expected call of UpdateNotebookMetadataWithContext
func (mr *MockAthenaAPIMockRecorder) UpdateNotebookMetadataWithContext(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, "UpdateNotebookMetadataWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).UpdateNotebookMetadataWithContext), varargs...)
}

// UpdateNotebookRequest mocks base method
func (m *MockAthenaAPI) UpdateNotebookRequest(arg0 *athena.UpdateNotebookInput) (*request.Request, *athena.UpdateNotebookOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNotebookRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.UpdateNotebookOutput)
	return ret0, ret1
}

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

// UpdateNotebookWithContext mocks base method
func (m *MockAthenaAPI) UpdateNotebookWithContext(arg0 context.Context, arg1 *athena.UpdateNotebookInput, arg2 ...request.Option) (*athena.UpdateNotebookOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateNotebookWithContext", varargs...)
	ret0, _ := ret[0].(*athena.UpdateNotebookOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateNotebookWithContext indicates an expected call of UpdateNotebookWithContext
func (mr *MockAthenaAPIMockRecorder) UpdateNotebookWithContext(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, "UpdateNotebookWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).UpdateNotebookWithContext), varargs...)
}

// UpdatePreparedStatement mocks base method
func (m *MockAthenaAPI) UpdatePreparedStatement(arg0 *athena.UpdatePreparedStatementInput) (*athena.UpdatePreparedStatementOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePreparedStatement", arg0)
	ret0, _ := ret[0].(*athena.UpdatePreparedStatementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdatePreparedStatementRequest mocks base method
func (m *MockAthenaAPI) UpdatePreparedStatementRequest(arg0 *athena.UpdatePreparedStatementInput) (*request.Request, *athena.UpdatePreparedStatementOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePreparedStatementRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.UpdatePreparedStatementOutput)
	return ret0, ret1
}

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

// UpdatePreparedStatementWithContext mocks base method
func (m *MockAthenaAPI) UpdatePreparedStatementWithContext(arg0 context.Context, arg1 *athena.UpdatePreparedStatementInput, arg2 ...request.Option) (*athena.UpdatePreparedStatementOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdatePreparedStatementWithContext", varargs...)
	ret0, _ := ret[0].(*athena.UpdatePreparedStatementOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePreparedStatementWithContext indicates an expected call of UpdatePreparedStatementWithContext
func (mr *MockAthenaAPIMockRecorder) UpdatePreparedStatementWithContext(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, "UpdatePreparedStatementWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).UpdatePreparedStatementWithContext), varargs...)
}

// UpdateWorkGroup mocks base method
func (m *MockAthenaAPI) UpdateWorkGroup(arg0 *athena.UpdateWorkGroupInput) (*athena.UpdateWorkGroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkGroup", arg0)
	ret0, _ := ret[0].(*athena.UpdateWorkGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateWorkGroupRequest mocks base method
func (m *MockAthenaAPI) UpdateWorkGroupRequest(arg0 *athena.UpdateWorkGroupInput) (*request.Request, *athena.UpdateWorkGroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkGroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*athena.UpdateWorkGroupOutput)
	return ret0, ret1
}

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

// UpdateWorkGroupWithContext mocks base method
func (m *MockAthenaAPI) UpdateWorkGroupWithContext(arg0 context.Context, arg1 *athena.UpdateWorkGroupInput, arg2 ...request.Option) (*athena.UpdateWorkGroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateWorkGroupWithContext", varargs...)
	ret0, _ := ret[0].(*athena.UpdateWorkGroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateWorkGroupWithContext indicates an expected call of UpdateWorkGroupWithContext
func (mr *MockAthenaAPIMockRecorder) UpdateWorkGroupWithContext(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, "UpdateWorkGroupWithContext", reflect.TypeOf((*MockAthenaAPI)(nil).UpdateWorkGroupWithContext), varargs...)
}