mock_warehouses_interface.go

// Code generated by mockery v2.39.1. DO NOT EDIT.

package sql

import (
	context "context"

	listing "github.com/databricks/databricks-sdk-go/listing"
	mock "github.com/stretchr/testify/mock"

	retries "github.com/databricks/databricks-sdk-go/retries"

	sql "github.com/databricks/databricks-sdk-go/service/sql"

	time "time"
)

// MockWarehousesInterface is an autogenerated mock type for the WarehousesInterface type
type MockWarehousesInterface struct {
	mock.Mock
}

type MockWarehousesInterface_Expecter struct {
	mock *mock.Mock
}

func (_m *MockWarehousesInterface) EXPECT() *MockWarehousesInterface_Expecter {
	return &MockWarehousesInterface_Expecter{mock: &_m.Mock}
}

// Create provides a mock function with given fields: ctx, createWarehouseRequest
func (_m *MockWarehousesInterface) Create(ctx context.Context, createWarehouseRequest sql.CreateWarehouseRequest) (*sql.WaitGetWarehouseRunning[sql.CreateWarehouseResponse], error) {
	ret := _m.Called(ctx, createWarehouseRequest)

	if len(ret) == 0 {
		panic("no return value specified for Create")
	}

	var r0 *sql.WaitGetWarehouseRunning[sql.CreateWarehouseResponse]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, sql.CreateWarehouseRequest) (*sql.WaitGetWarehouseRunning[sql.CreateWarehouseResponse], error)); ok {
		return rf(ctx, createWarehouseRequest)
	}
	if rf, ok := ret.Get(0).(func(context.Context, sql.CreateWarehouseRequest) *sql.WaitGetWarehouseRunning[sql.CreateWarehouseResponse]); ok {
		r0 = rf(ctx, createWarehouseRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sql.WaitGetWarehouseRunning[sql.CreateWarehouseResponse])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, sql.CreateWarehouseRequest) error); ok {
		r1 = rf(ctx, createWarehouseRequest)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
type MockWarehousesInterface_Create_Call struct {
	*mock.Call
}

// Create is a helper method to define mock.On call
//   - ctx context.Context
//   - createWarehouseRequest sql.CreateWarehouseRequest
func (_e *MockWarehousesInterface_Expecter) Create(ctx interface{}, createWarehouseRequest interface{}) *MockWarehousesInterface_Create_Call {
	return &MockWarehousesInterface_Create_Call{Call: _e.mock.On("Create", ctx, createWarehouseRequest)}
}

func (_c *MockWarehousesInterface_Create_Call) Run(run func(ctx context.Context, createWarehouseRequest sql.CreateWarehouseRequest)) *MockWarehousesInterface_Create_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(sql.CreateWarehouseRequest))
	})
	return _c
}

func (_c *MockWarehousesInterface_Create_Call) Return(_a0 *sql.WaitGetWarehouseRunning[sql.CreateWarehouseResponse], _a1 error) *MockWarehousesInterface_Create_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_Create_Call) RunAndReturn(run func(context.Context, sql.CreateWarehouseRequest) (*sql.WaitGetWarehouseRunning[sql.CreateWarehouseResponse], error)) *MockWarehousesInterface_Create_Call {
	_c.Call.Return(run)
	return _c
}

// CreateAndWait provides a mock function with given fields: ctx, createWarehouseRequest, options
func (_m *MockWarehousesInterface) CreateAndWait(ctx context.Context, createWarehouseRequest sql.CreateWarehouseRequest, options ...retries.Option[sql.GetWarehouseResponse]) (*sql.GetWarehouseResponse, error) {
	_va := make([]interface{}, len(options))
	for _i := range options {
		_va[_i] = options[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, createWarehouseRequest)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for CreateAndWait")
	}

	var r0 *sql.GetWarehouseResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, sql.CreateWarehouseRequest, ...retries.Option[sql.GetWarehouseResponse]) (*sql.GetWarehouseResponse, error)); ok {
		return rf(ctx, createWarehouseRequest, options...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, sql.CreateWarehouseRequest, ...retries.Option[sql.GetWarehouseResponse]) *sql.GetWarehouseResponse); ok {
		r0 = rf(ctx, createWarehouseRequest, options...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sql.GetWarehouseResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, sql.CreateWarehouseRequest, ...retries.Option[sql.GetWarehouseResponse]) error); ok {
		r1 = rf(ctx, createWarehouseRequest, options...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_CreateAndWait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAndWait'
type MockWarehousesInterface_CreateAndWait_Call struct {
	*mock.Call
}

// CreateAndWait is a helper method to define mock.On call
//   - ctx context.Context
//   - createWarehouseRequest sql.CreateWarehouseRequest
//   - options ...retries.Option[sql.GetWarehouseResponse]
func (_e *MockWarehousesInterface_Expecter) CreateAndWait(ctx interface{}, createWarehouseRequest interface{}, options ...interface{}) *MockWarehousesInterface_CreateAndWait_Call {
	return &MockWarehousesInterface_CreateAndWait_Call{Call: _e.mock.On("CreateAndWait",
		append([]interface{}{ctx, createWarehouseRequest}, options...)...)}
}

func (_c *MockWarehousesInterface_CreateAndWait_Call) Run(run func(ctx context.Context, createWarehouseRequest sql.CreateWarehouseRequest, options ...retries.Option[sql.GetWarehouseResponse])) *MockWarehousesInterface_CreateAndWait_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]retries.Option[sql.GetWarehouseResponse], len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(retries.Option[sql.GetWarehouseResponse])
			}
		}
		run(args[0].(context.Context), args[1].(sql.CreateWarehouseRequest), variadicArgs...)
	})
	return _c
}

func (_c *MockWarehousesInterface_CreateAndWait_Call) Return(_a0 *sql.GetWarehouseResponse, _a1 error) *MockWarehousesInterface_CreateAndWait_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_CreateAndWait_Call) RunAndReturn(run func(context.Context, sql.CreateWarehouseRequest, ...retries.Option[sql.GetWarehouseResponse]) (*sql.GetWarehouseResponse, error)) *MockWarehousesInterface_CreateAndWait_Call {
	_c.Call.Return(run)
	return _c
}

// Delete provides a mock function with given fields: ctx, request
func (_m *MockWarehousesInterface) Delete(ctx context.Context, request sql.DeleteWarehouseRequest) error {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for Delete")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, sql.DeleteWarehouseRequest) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockWarehousesInterface_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
type MockWarehousesInterface_Delete_Call struct {
	*mock.Call
}

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - request sql.DeleteWarehouseRequest
func (_e *MockWarehousesInterface_Expecter) Delete(ctx interface{}, request interface{}) *MockWarehousesInterface_Delete_Call {
	return &MockWarehousesInterface_Delete_Call{Call: _e.mock.On("Delete", ctx, request)}
}

func (_c *MockWarehousesInterface_Delete_Call) Run(run func(ctx context.Context, request sql.DeleteWarehouseRequest)) *MockWarehousesInterface_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(sql.DeleteWarehouseRequest))
	})
	return _c
}

func (_c *MockWarehousesInterface_Delete_Call) Return(_a0 error) *MockWarehousesInterface_Delete_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockWarehousesInterface_Delete_Call) RunAndReturn(run func(context.Context, sql.DeleteWarehouseRequest) error) *MockWarehousesInterface_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteById provides a mock function with given fields: ctx, id
func (_m *MockWarehousesInterface) DeleteById(ctx context.Context, id string) error {
	ret := _m.Called(ctx, id)

	if len(ret) == 0 {
		panic("no return value specified for DeleteById")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = rf(ctx, id)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockWarehousesInterface_DeleteById_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteById'
type MockWarehousesInterface_DeleteById_Call struct {
	*mock.Call
}

// DeleteById is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockWarehousesInterface_Expecter) DeleteById(ctx interface{}, id interface{}) *MockWarehousesInterface_DeleteById_Call {
	return &MockWarehousesInterface_DeleteById_Call{Call: _e.mock.On("DeleteById", ctx, id)}
}

func (_c *MockWarehousesInterface_DeleteById_Call) Run(run func(ctx context.Context, id string)) *MockWarehousesInterface_DeleteById_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockWarehousesInterface_DeleteById_Call) Return(_a0 error) *MockWarehousesInterface_DeleteById_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockWarehousesInterface_DeleteById_Call) RunAndReturn(run func(context.Context, string) error) *MockWarehousesInterface_DeleteById_Call {
	_c.Call.Return(run)
	return _c
}

// Edit provides a mock function with given fields: ctx, editWarehouseRequest
func (_m *MockWarehousesInterface) Edit(ctx context.Context, editWarehouseRequest sql.EditWarehouseRequest) (*sql.WaitGetWarehouseRunning[struct{}], error) {
	ret := _m.Called(ctx, editWarehouseRequest)

	if len(ret) == 0 {
		panic("no return value specified for Edit")
	}

	var r0 *sql.WaitGetWarehouseRunning[struct{}]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, sql.EditWarehouseRequest) (*sql.WaitGetWarehouseRunning[struct{}], error)); ok {
		return rf(ctx, editWarehouseRequest)
	}
	if rf, ok := ret.Get(0).(func(context.Context, sql.EditWarehouseRequest) *sql.WaitGetWarehouseRunning[struct{}]); ok {
		r0 = rf(ctx, editWarehouseRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sql.WaitGetWarehouseRunning[struct{}])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, sql.EditWarehouseRequest) error); ok {
		r1 = rf(ctx, editWarehouseRequest)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_Edit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Edit'
type MockWarehousesInterface_Edit_Call struct {
	*mock.Call
}

// Edit is a helper method to define mock.On call
//   - ctx context.Context
//   - editWarehouseRequest sql.EditWarehouseRequest
func (_e *MockWarehousesInterface_Expecter) Edit(ctx interface{}, editWarehouseRequest interface{}) *MockWarehousesInterface_Edit_Call {
	return &MockWarehousesInterface_Edit_Call{Call: _e.mock.On("Edit", ctx, editWarehouseRequest)}
}

func (_c *MockWarehousesInterface_Edit_Call) Run(run func(ctx context.Context, editWarehouseRequest sql.EditWarehouseRequest)) *MockWarehousesInterface_Edit_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(sql.EditWarehouseRequest))
	})
	return _c
}

func (_c *MockWarehousesInterface_Edit_Call) Return(_a0 *sql.WaitGetWarehouseRunning[struct{}], _a1 error) *MockWarehousesInterface_Edit_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_Edit_Call) RunAndReturn(run func(context.Context, sql.EditWarehouseRequest) (*sql.WaitGetWarehouseRunning[struct{}], error)) *MockWarehousesInterface_Edit_Call {
	_c.Call.Return(run)
	return _c
}

// EditAndWait provides a mock function with given fields: ctx, editWarehouseRequest, options
func (_m *MockWarehousesInterface) EditAndWait(ctx context.Context, editWarehouseRequest sql.EditWarehouseRequest, options ...retries.Option[sql.GetWarehouseResponse]) (*sql.GetWarehouseResponse, error) {
	_va := make([]interface{}, len(options))
	for _i := range options {
		_va[_i] = options[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, editWarehouseRequest)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for EditAndWait")
	}

	var r0 *sql.GetWarehouseResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, sql.EditWarehouseRequest, ...retries.Option[sql.GetWarehouseResponse]) (*sql.GetWarehouseResponse, error)); ok {
		return rf(ctx, editWarehouseRequest, options...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, sql.EditWarehouseRequest, ...retries.Option[sql.GetWarehouseResponse]) *sql.GetWarehouseResponse); ok {
		r0 = rf(ctx, editWarehouseRequest, options...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sql.GetWarehouseResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, sql.EditWarehouseRequest, ...retries.Option[sql.GetWarehouseResponse]) error); ok {
		r1 = rf(ctx, editWarehouseRequest, options...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_EditAndWait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EditAndWait'
type MockWarehousesInterface_EditAndWait_Call struct {
	*mock.Call
}

// EditAndWait is a helper method to define mock.On call
//   - ctx context.Context
//   - editWarehouseRequest sql.EditWarehouseRequest
//   - options ...retries.Option[sql.GetWarehouseResponse]
func (_e *MockWarehousesInterface_Expecter) EditAndWait(ctx interface{}, editWarehouseRequest interface{}, options ...interface{}) *MockWarehousesInterface_EditAndWait_Call {
	return &MockWarehousesInterface_EditAndWait_Call{Call: _e.mock.On("EditAndWait",
		append([]interface{}{ctx, editWarehouseRequest}, options...)...)}
}

func (_c *MockWarehousesInterface_EditAndWait_Call) Run(run func(ctx context.Context, editWarehouseRequest sql.EditWarehouseRequest, options ...retries.Option[sql.GetWarehouseResponse])) *MockWarehousesInterface_EditAndWait_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]retries.Option[sql.GetWarehouseResponse], len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(retries.Option[sql.GetWarehouseResponse])
			}
		}
		run(args[0].(context.Context), args[1].(sql.EditWarehouseRequest), variadicArgs...)
	})
	return _c
}

func (_c *MockWarehousesInterface_EditAndWait_Call) Return(_a0 *sql.GetWarehouseResponse, _a1 error) *MockWarehousesInterface_EditAndWait_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_EditAndWait_Call) RunAndReturn(run func(context.Context, sql.EditWarehouseRequest, ...retries.Option[sql.GetWarehouseResponse]) (*sql.GetWarehouseResponse, error)) *MockWarehousesInterface_EditAndWait_Call {
	_c.Call.Return(run)
	return _c
}

// EndpointInfoNameToIdMap provides a mock function with given fields: ctx, request
func (_m *MockWarehousesInterface) EndpointInfoNameToIdMap(ctx context.Context, request sql.ListWarehousesRequest) (map[string]string, error) {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for EndpointInfoNameToIdMap")
	}

	var r0 map[string]string
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, sql.ListWarehousesRequest) (map[string]string, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, sql.ListWarehousesRequest) map[string]string); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]string)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, sql.ListWarehousesRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_EndpointInfoNameToIdMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EndpointInfoNameToIdMap'
type MockWarehousesInterface_EndpointInfoNameToIdMap_Call struct {
	*mock.Call
}

// EndpointInfoNameToIdMap is a helper method to define mock.On call
//   - ctx context.Context
//   - request sql.ListWarehousesRequest
func (_e *MockWarehousesInterface_Expecter) EndpointInfoNameToIdMap(ctx interface{}, request interface{}) *MockWarehousesInterface_EndpointInfoNameToIdMap_Call {
	return &MockWarehousesInterface_EndpointInfoNameToIdMap_Call{Call: _e.mock.On("EndpointInfoNameToIdMap", ctx, request)}
}

func (_c *MockWarehousesInterface_EndpointInfoNameToIdMap_Call) Run(run func(ctx context.Context, request sql.ListWarehousesRequest)) *MockWarehousesInterface_EndpointInfoNameToIdMap_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(sql.ListWarehousesRequest))
	})
	return _c
}

func (_c *MockWarehousesInterface_EndpointInfoNameToIdMap_Call) Return(_a0 map[string]string, _a1 error) *MockWarehousesInterface_EndpointInfoNameToIdMap_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_EndpointInfoNameToIdMap_Call) RunAndReturn(run func(context.Context, sql.ListWarehousesRequest) (map[string]string, error)) *MockWarehousesInterface_EndpointInfoNameToIdMap_Call {
	_c.Call.Return(run)
	return _c
}

// Get provides a mock function with given fields: ctx, request
func (_m *MockWarehousesInterface) Get(ctx context.Context, request sql.GetWarehouseRequest) (*sql.GetWarehouseResponse, error) {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for Get")
	}

	var r0 *sql.GetWarehouseResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, sql.GetWarehouseRequest) (*sql.GetWarehouseResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, sql.GetWarehouseRequest) *sql.GetWarehouseResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sql.GetWarehouseResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, sql.GetWarehouseRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
type MockWarehousesInterface_Get_Call struct {
	*mock.Call
}

// Get is a helper method to define mock.On call
//   - ctx context.Context
//   - request sql.GetWarehouseRequest
func (_e *MockWarehousesInterface_Expecter) Get(ctx interface{}, request interface{}) *MockWarehousesInterface_Get_Call {
	return &MockWarehousesInterface_Get_Call{Call: _e.mock.On("Get", ctx, request)}
}

func (_c *MockWarehousesInterface_Get_Call) Run(run func(ctx context.Context, request sql.GetWarehouseRequest)) *MockWarehousesInterface_Get_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(sql.GetWarehouseRequest))
	})
	return _c
}

func (_c *MockWarehousesInterface_Get_Call) Return(_a0 *sql.GetWarehouseResponse, _a1 error) *MockWarehousesInterface_Get_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_Get_Call) RunAndReturn(run func(context.Context, sql.GetWarehouseRequest) (*sql.GetWarehouseResponse, error)) *MockWarehousesInterface_Get_Call {
	_c.Call.Return(run)
	return _c
}

// GetById provides a mock function with given fields: ctx, id
func (_m *MockWarehousesInterface) GetById(ctx context.Context, id string) (*sql.GetWarehouseResponse, error) {
	ret := _m.Called(ctx, id)

	if len(ret) == 0 {
		panic("no return value specified for GetById")
	}

	var r0 *sql.GetWarehouseResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*sql.GetWarehouseResponse, error)); ok {
		return rf(ctx, id)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *sql.GetWarehouseResponse); ok {
		r0 = rf(ctx, id)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sql.GetWarehouseResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, id)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_GetById_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetById'
type MockWarehousesInterface_GetById_Call struct {
	*mock.Call
}

// GetById is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockWarehousesInterface_Expecter) GetById(ctx interface{}, id interface{}) *MockWarehousesInterface_GetById_Call {
	return &MockWarehousesInterface_GetById_Call{Call: _e.mock.On("GetById", ctx, id)}
}

func (_c *MockWarehousesInterface_GetById_Call) Run(run func(ctx context.Context, id string)) *MockWarehousesInterface_GetById_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockWarehousesInterface_GetById_Call) Return(_a0 *sql.GetWarehouseResponse, _a1 error) *MockWarehousesInterface_GetById_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_GetById_Call) RunAndReturn(run func(context.Context, string) (*sql.GetWarehouseResponse, error)) *MockWarehousesInterface_GetById_Call {
	_c.Call.Return(run)
	return _c
}

// GetByName provides a mock function with given fields: ctx, name
func (_m *MockWarehousesInterface) GetByName(ctx context.Context, name string) (*sql.EndpointInfo, error) {
	ret := _m.Called(ctx, name)

	if len(ret) == 0 {
		panic("no return value specified for GetByName")
	}

	var r0 *sql.EndpointInfo
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*sql.EndpointInfo, error)); ok {
		return rf(ctx, name)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *sql.EndpointInfo); ok {
		r0 = rf(ctx, name)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sql.EndpointInfo)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, name)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_GetByName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetByName'
type MockWarehousesInterface_GetByName_Call struct {
	*mock.Call
}

// GetByName is a helper method to define mock.On call
//   - ctx context.Context
//   - name string
func (_e *MockWarehousesInterface_Expecter) GetByName(ctx interface{}, name interface{}) *MockWarehousesInterface_GetByName_Call {
	return &MockWarehousesInterface_GetByName_Call{Call: _e.mock.On("GetByName", ctx, name)}
}

func (_c *MockWarehousesInterface_GetByName_Call) Run(run func(ctx context.Context, name string)) *MockWarehousesInterface_GetByName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockWarehousesInterface_GetByName_Call) Return(_a0 *sql.EndpointInfo, _a1 error) *MockWarehousesInterface_GetByName_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_GetByName_Call) RunAndReturn(run func(context.Context, string) (*sql.EndpointInfo, error)) *MockWarehousesInterface_GetByName_Call {
	_c.Call.Return(run)
	return _c
}

// GetPermissionLevels provides a mock function with given fields: ctx, request
func (_m *MockWarehousesInterface) GetPermissionLevels(ctx context.Context, request sql.GetWarehousePermissionLevelsRequest) (*sql.GetWarehousePermissionLevelsResponse, error) {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for GetPermissionLevels")
	}

	var r0 *sql.GetWarehousePermissionLevelsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, sql.GetWarehousePermissionLevelsRequest) (*sql.GetWarehousePermissionLevelsResponse, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, sql.GetWarehousePermissionLevelsRequest) *sql.GetWarehousePermissionLevelsResponse); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sql.GetWarehousePermissionLevelsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, sql.GetWarehousePermissionLevelsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_GetPermissionLevels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPermissionLevels'
type MockWarehousesInterface_GetPermissionLevels_Call struct {
	*mock.Call
}

// GetPermissionLevels is a helper method to define mock.On call
//   - ctx context.Context
//   - request sql.GetWarehousePermissionLevelsRequest
func (_e *MockWarehousesInterface_Expecter) GetPermissionLevels(ctx interface{}, request interface{}) *MockWarehousesInterface_GetPermissionLevels_Call {
	return &MockWarehousesInterface_GetPermissionLevels_Call{Call: _e.mock.On("GetPermissionLevels", ctx, request)}
}

func (_c *MockWarehousesInterface_GetPermissionLevels_Call) Run(run func(ctx context.Context, request sql.GetWarehousePermissionLevelsRequest)) *MockWarehousesInterface_GetPermissionLevels_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(sql.GetWarehousePermissionLevelsRequest))
	})
	return _c
}

func (_c *MockWarehousesInterface_GetPermissionLevels_Call) Return(_a0 *sql.GetWarehousePermissionLevelsResponse, _a1 error) *MockWarehousesInterface_GetPermissionLevels_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_GetPermissionLevels_Call) RunAndReturn(run func(context.Context, sql.GetWarehousePermissionLevelsRequest) (*sql.GetWarehousePermissionLevelsResponse, error)) *MockWarehousesInterface_GetPermissionLevels_Call {
	_c.Call.Return(run)
	return _c
}

// GetPermissionLevelsByWarehouseId provides a mock function with given fields: ctx, warehouseId
func (_m *MockWarehousesInterface) GetPermissionLevelsByWarehouseId(ctx context.Context, warehouseId string) (*sql.GetWarehousePermissionLevelsResponse, error) {
	ret := _m.Called(ctx, warehouseId)

	if len(ret) == 0 {
		panic("no return value specified for GetPermissionLevelsByWarehouseId")
	}

	var r0 *sql.GetWarehousePermissionLevelsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*sql.GetWarehousePermissionLevelsResponse, error)); ok {
		return rf(ctx, warehouseId)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *sql.GetWarehousePermissionLevelsResponse); ok {
		r0 = rf(ctx, warehouseId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sql.GetWarehousePermissionLevelsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, warehouseId)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_GetPermissionLevelsByWarehouseId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPermissionLevelsByWarehouseId'
type MockWarehousesInterface_GetPermissionLevelsByWarehouseId_Call struct {
	*mock.Call
}

// GetPermissionLevelsByWarehouseId is a helper method to define mock.On call
//   - ctx context.Context
//   - warehouseId string
func (_e *MockWarehousesInterface_Expecter) GetPermissionLevelsByWarehouseId(ctx interface{}, warehouseId interface{}) *MockWarehousesInterface_GetPermissionLevelsByWarehouseId_Call {
	return &MockWarehousesInterface_GetPermissionLevelsByWarehouseId_Call{Call: _e.mock.On("GetPermissionLevelsByWarehouseId", ctx, warehouseId)}
}

func (_c *MockWarehousesInterface_GetPermissionLevelsByWarehouseId_Call) Run(run func(ctx context.Context, warehouseId string)) *MockWarehousesInterface_GetPermissionLevelsByWarehouseId_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockWarehousesInterface_GetPermissionLevelsByWarehouseId_Call) Return(_a0 *sql.GetWarehousePermissionLevelsResponse, _a1 error) *MockWarehousesInterface_GetPermissionLevelsByWarehouseId_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_GetPermissionLevelsByWarehouseId_Call) RunAndReturn(run func(context.Context, string) (*sql.GetWarehousePermissionLevelsResponse, error)) *MockWarehousesInterface_GetPermissionLevelsByWarehouseId_Call {
	_c.Call.Return(run)
	return _c
}

// GetPermissions provides a mock function with given fields: ctx, request
func (_m *MockWarehousesInterface) GetPermissions(ctx context.Context, request sql.GetWarehousePermissionsRequest) (*sql.WarehousePermissions, error) {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for GetPermissions")
	}

	var r0 *sql.WarehousePermissions
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, sql.GetWarehousePermissionsRequest) (*sql.WarehousePermissions, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, sql.GetWarehousePermissionsRequest) *sql.WarehousePermissions); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sql.WarehousePermissions)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, sql.GetWarehousePermissionsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_GetPermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPermissions'
type MockWarehousesInterface_GetPermissions_Call struct {
	*mock.Call
}

// GetPermissions is a helper method to define mock.On call
//   - ctx context.Context
//   - request sql.GetWarehousePermissionsRequest
func (_e *MockWarehousesInterface_Expecter) GetPermissions(ctx interface{}, request interface{}) *MockWarehousesInterface_GetPermissions_Call {
	return &MockWarehousesInterface_GetPermissions_Call{Call: _e.mock.On("GetPermissions", ctx, request)}
}

func (_c *MockWarehousesInterface_GetPermissions_Call) Run(run func(ctx context.Context, request sql.GetWarehousePermissionsRequest)) *MockWarehousesInterface_GetPermissions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(sql.GetWarehousePermissionsRequest))
	})
	return _c
}

func (_c *MockWarehousesInterface_GetPermissions_Call) Return(_a0 *sql.WarehousePermissions, _a1 error) *MockWarehousesInterface_GetPermissions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_GetPermissions_Call) RunAndReturn(run func(context.Context, sql.GetWarehousePermissionsRequest) (*sql.WarehousePermissions, error)) *MockWarehousesInterface_GetPermissions_Call {
	_c.Call.Return(run)
	return _c
}

// GetPermissionsByWarehouseId provides a mock function with given fields: ctx, warehouseId
func (_m *MockWarehousesInterface) GetPermissionsByWarehouseId(ctx context.Context, warehouseId string) (*sql.WarehousePermissions, error) {
	ret := _m.Called(ctx, warehouseId)

	if len(ret) == 0 {
		panic("no return value specified for GetPermissionsByWarehouseId")
	}

	var r0 *sql.WarehousePermissions
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (*sql.WarehousePermissions, error)); ok {
		return rf(ctx, warehouseId)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) *sql.WarehousePermissions); ok {
		r0 = rf(ctx, warehouseId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sql.WarehousePermissions)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, warehouseId)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_GetPermissionsByWarehouseId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPermissionsByWarehouseId'
type MockWarehousesInterface_GetPermissionsByWarehouseId_Call struct {
	*mock.Call
}

// GetPermissionsByWarehouseId is a helper method to define mock.On call
//   - ctx context.Context
//   - warehouseId string
func (_e *MockWarehousesInterface_Expecter) GetPermissionsByWarehouseId(ctx interface{}, warehouseId interface{}) *MockWarehousesInterface_GetPermissionsByWarehouseId_Call {
	return &MockWarehousesInterface_GetPermissionsByWarehouseId_Call{Call: _e.mock.On("GetPermissionsByWarehouseId", ctx, warehouseId)}
}

func (_c *MockWarehousesInterface_GetPermissionsByWarehouseId_Call) Run(run func(ctx context.Context, warehouseId string)) *MockWarehousesInterface_GetPermissionsByWarehouseId_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockWarehousesInterface_GetPermissionsByWarehouseId_Call) Return(_a0 *sql.WarehousePermissions, _a1 error) *MockWarehousesInterface_GetPermissionsByWarehouseId_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_GetPermissionsByWarehouseId_Call) RunAndReturn(run func(context.Context, string) (*sql.WarehousePermissions, error)) *MockWarehousesInterface_GetPermissionsByWarehouseId_Call {
	_c.Call.Return(run)
	return _c
}

// GetWorkspaceWarehouseConfig provides a mock function with given fields: ctx
func (_m *MockWarehousesInterface) GetWorkspaceWarehouseConfig(ctx context.Context) (*sql.GetWorkspaceWarehouseConfigResponse, error) {
	ret := _m.Called(ctx)

	if len(ret) == 0 {
		panic("no return value specified for GetWorkspaceWarehouseConfig")
	}

	var r0 *sql.GetWorkspaceWarehouseConfigResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (*sql.GetWorkspaceWarehouseConfigResponse, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) *sql.GetWorkspaceWarehouseConfigResponse); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sql.GetWorkspaceWarehouseConfigResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_GetWorkspaceWarehouseConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWorkspaceWarehouseConfig'
type MockWarehousesInterface_GetWorkspaceWarehouseConfig_Call struct {
	*mock.Call
}

// GetWorkspaceWarehouseConfig is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockWarehousesInterface_Expecter) GetWorkspaceWarehouseConfig(ctx interface{}) *MockWarehousesInterface_GetWorkspaceWarehouseConfig_Call {
	return &MockWarehousesInterface_GetWorkspaceWarehouseConfig_Call{Call: _e.mock.On("GetWorkspaceWarehouseConfig", ctx)}
}

func (_c *MockWarehousesInterface_GetWorkspaceWarehouseConfig_Call) Run(run func(ctx context.Context)) *MockWarehousesInterface_GetWorkspaceWarehouseConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockWarehousesInterface_GetWorkspaceWarehouseConfig_Call) Return(_a0 *sql.GetWorkspaceWarehouseConfigResponse, _a1 error) *MockWarehousesInterface_GetWorkspaceWarehouseConfig_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_GetWorkspaceWarehouseConfig_Call) RunAndReturn(run func(context.Context) (*sql.GetWorkspaceWarehouseConfigResponse, error)) *MockWarehousesInterface_GetWorkspaceWarehouseConfig_Call {
	_c.Call.Return(run)
	return _c
}

// Impl provides a mock function with given fields:
func (_m *MockWarehousesInterface) Impl() sql.WarehousesService {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Impl")
	}

	var r0 sql.WarehousesService
	if rf, ok := ret.Get(0).(func() sql.WarehousesService); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(sql.WarehousesService)
		}
	}

	return r0
}

// MockWarehousesInterface_Impl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Impl'
type MockWarehousesInterface_Impl_Call struct {
	*mock.Call
}

// Impl is a helper method to define mock.On call
func (_e *MockWarehousesInterface_Expecter) Impl() *MockWarehousesInterface_Impl_Call {
	return &MockWarehousesInterface_Impl_Call{Call: _e.mock.On("Impl")}
}

func (_c *MockWarehousesInterface_Impl_Call) Run(run func()) *MockWarehousesInterface_Impl_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockWarehousesInterface_Impl_Call) Return(_a0 sql.WarehousesService) *MockWarehousesInterface_Impl_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockWarehousesInterface_Impl_Call) RunAndReturn(run func() sql.WarehousesService) *MockWarehousesInterface_Impl_Call {
	_c.Call.Return(run)
	return _c
}

// List provides a mock function with given fields: ctx, request
func (_m *MockWarehousesInterface) List(ctx context.Context, request sql.ListWarehousesRequest) listing.Iterator[sql.EndpointInfo] {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for List")
	}

	var r0 listing.Iterator[sql.EndpointInfo]
	if rf, ok := ret.Get(0).(func(context.Context, sql.ListWarehousesRequest) listing.Iterator[sql.EndpointInfo]); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(listing.Iterator[sql.EndpointInfo])
		}
	}

	return r0
}

// MockWarehousesInterface_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'
type MockWarehousesInterface_List_Call struct {
	*mock.Call
}

// List is a helper method to define mock.On call
//   - ctx context.Context
//   - request sql.ListWarehousesRequest
func (_e *MockWarehousesInterface_Expecter) List(ctx interface{}, request interface{}) *MockWarehousesInterface_List_Call {
	return &MockWarehousesInterface_List_Call{Call: _e.mock.On("List", ctx, request)}
}

func (_c *MockWarehousesInterface_List_Call) Run(run func(ctx context.Context, request sql.ListWarehousesRequest)) *MockWarehousesInterface_List_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(sql.ListWarehousesRequest))
	})
	return _c
}

func (_c *MockWarehousesInterface_List_Call) Return(_a0 listing.Iterator[sql.EndpointInfo]) *MockWarehousesInterface_List_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockWarehousesInterface_List_Call) RunAndReturn(run func(context.Context, sql.ListWarehousesRequest) listing.Iterator[sql.EndpointInfo]) *MockWarehousesInterface_List_Call {
	_c.Call.Return(run)
	return _c
}

// ListAll provides a mock function with given fields: ctx, request
func (_m *MockWarehousesInterface) ListAll(ctx context.Context, request sql.ListWarehousesRequest) ([]sql.EndpointInfo, error) {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for ListAll")
	}

	var r0 []sql.EndpointInfo
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, sql.ListWarehousesRequest) ([]sql.EndpointInfo, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, sql.ListWarehousesRequest) []sql.EndpointInfo); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]sql.EndpointInfo)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, sql.ListWarehousesRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_ListAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAll'
type MockWarehousesInterface_ListAll_Call struct {
	*mock.Call
}

// ListAll is a helper method to define mock.On call
//   - ctx context.Context
//   - request sql.ListWarehousesRequest
func (_e *MockWarehousesInterface_Expecter) ListAll(ctx interface{}, request interface{}) *MockWarehousesInterface_ListAll_Call {
	return &MockWarehousesInterface_ListAll_Call{Call: _e.mock.On("ListAll", ctx, request)}
}

func (_c *MockWarehousesInterface_ListAll_Call) Run(run func(ctx context.Context, request sql.ListWarehousesRequest)) *MockWarehousesInterface_ListAll_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(sql.ListWarehousesRequest))
	})
	return _c
}

func (_c *MockWarehousesInterface_ListAll_Call) Return(_a0 []sql.EndpointInfo, _a1 error) *MockWarehousesInterface_ListAll_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_ListAll_Call) RunAndReturn(run func(context.Context, sql.ListWarehousesRequest) ([]sql.EndpointInfo, error)) *MockWarehousesInterface_ListAll_Call {
	_c.Call.Return(run)
	return _c
}

// SetPermissions provides a mock function with given fields: ctx, request
func (_m *MockWarehousesInterface) SetPermissions(ctx context.Context, request sql.WarehousePermissionsRequest) (*sql.WarehousePermissions, error) {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for SetPermissions")
	}

	var r0 *sql.WarehousePermissions
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, sql.WarehousePermissionsRequest) (*sql.WarehousePermissions, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, sql.WarehousePermissionsRequest) *sql.WarehousePermissions); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sql.WarehousePermissions)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, sql.WarehousePermissionsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_SetPermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPermissions'
type MockWarehousesInterface_SetPermissions_Call struct {
	*mock.Call
}

// SetPermissions is a helper method to define mock.On call
//   - ctx context.Context
//   - request sql.WarehousePermissionsRequest
func (_e *MockWarehousesInterface_Expecter) SetPermissions(ctx interface{}, request interface{}) *MockWarehousesInterface_SetPermissions_Call {
	return &MockWarehousesInterface_SetPermissions_Call{Call: _e.mock.On("SetPermissions", ctx, request)}
}

func (_c *MockWarehousesInterface_SetPermissions_Call) Run(run func(ctx context.Context, request sql.WarehousePermissionsRequest)) *MockWarehousesInterface_SetPermissions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(sql.WarehousePermissionsRequest))
	})
	return _c
}

func (_c *MockWarehousesInterface_SetPermissions_Call) Return(_a0 *sql.WarehousePermissions, _a1 error) *MockWarehousesInterface_SetPermissions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_SetPermissions_Call) RunAndReturn(run func(context.Context, sql.WarehousePermissionsRequest) (*sql.WarehousePermissions, error)) *MockWarehousesInterface_SetPermissions_Call {
	_c.Call.Return(run)
	return _c
}

// SetWorkspaceWarehouseConfig provides a mock function with given fields: ctx, request
func (_m *MockWarehousesInterface) SetWorkspaceWarehouseConfig(ctx context.Context, request sql.SetWorkspaceWarehouseConfigRequest) error {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for SetWorkspaceWarehouseConfig")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, sql.SetWorkspaceWarehouseConfigRequest) error); ok {
		r0 = rf(ctx, request)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockWarehousesInterface_SetWorkspaceWarehouseConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetWorkspaceWarehouseConfig'
type MockWarehousesInterface_SetWorkspaceWarehouseConfig_Call struct {
	*mock.Call
}

// SetWorkspaceWarehouseConfig is a helper method to define mock.On call
//   - ctx context.Context
//   - request sql.SetWorkspaceWarehouseConfigRequest
func (_e *MockWarehousesInterface_Expecter) SetWorkspaceWarehouseConfig(ctx interface{}, request interface{}) *MockWarehousesInterface_SetWorkspaceWarehouseConfig_Call {
	return &MockWarehousesInterface_SetWorkspaceWarehouseConfig_Call{Call: _e.mock.On("SetWorkspaceWarehouseConfig", ctx, request)}
}

func (_c *MockWarehousesInterface_SetWorkspaceWarehouseConfig_Call) Run(run func(ctx context.Context, request sql.SetWorkspaceWarehouseConfigRequest)) *MockWarehousesInterface_SetWorkspaceWarehouseConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(sql.SetWorkspaceWarehouseConfigRequest))
	})
	return _c
}

func (_c *MockWarehousesInterface_SetWorkspaceWarehouseConfig_Call) Return(_a0 error) *MockWarehousesInterface_SetWorkspaceWarehouseConfig_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockWarehousesInterface_SetWorkspaceWarehouseConfig_Call) RunAndReturn(run func(context.Context, sql.SetWorkspaceWarehouseConfigRequest) error) *MockWarehousesInterface_SetWorkspaceWarehouseConfig_Call {
	_c.Call.Return(run)
	return _c
}

// Start provides a mock function with given fields: ctx, startRequest
func (_m *MockWarehousesInterface) Start(ctx context.Context, startRequest sql.StartRequest) (*sql.WaitGetWarehouseRunning[struct{}], error) {
	ret := _m.Called(ctx, startRequest)

	if len(ret) == 0 {
		panic("no return value specified for Start")
	}

	var r0 *sql.WaitGetWarehouseRunning[struct{}]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, sql.StartRequest) (*sql.WaitGetWarehouseRunning[struct{}], error)); ok {
		return rf(ctx, startRequest)
	}
	if rf, ok := ret.Get(0).(func(context.Context, sql.StartRequest) *sql.WaitGetWarehouseRunning[struct{}]); ok {
		r0 = rf(ctx, startRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sql.WaitGetWarehouseRunning[struct{}])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, sql.StartRequest) error); ok {
		r1 = rf(ctx, startRequest)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
type MockWarehousesInterface_Start_Call struct {
	*mock.Call
}

// Start is a helper method to define mock.On call
//   - ctx context.Context
//   - startRequest sql.StartRequest
func (_e *MockWarehousesInterface_Expecter) Start(ctx interface{}, startRequest interface{}) *MockWarehousesInterface_Start_Call {
	return &MockWarehousesInterface_Start_Call{Call: _e.mock.On("Start", ctx, startRequest)}
}

func (_c *MockWarehousesInterface_Start_Call) Run(run func(ctx context.Context, startRequest sql.StartRequest)) *MockWarehousesInterface_Start_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(sql.StartRequest))
	})
	return _c
}

func (_c *MockWarehousesInterface_Start_Call) Return(_a0 *sql.WaitGetWarehouseRunning[struct{}], _a1 error) *MockWarehousesInterface_Start_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_Start_Call) RunAndReturn(run func(context.Context, sql.StartRequest) (*sql.WaitGetWarehouseRunning[struct{}], error)) *MockWarehousesInterface_Start_Call {
	_c.Call.Return(run)
	return _c
}

// StartAndWait provides a mock function with given fields: ctx, startRequest, options
func (_m *MockWarehousesInterface) StartAndWait(ctx context.Context, startRequest sql.StartRequest, options ...retries.Option[sql.GetWarehouseResponse]) (*sql.GetWarehouseResponse, error) {
	_va := make([]interface{}, len(options))
	for _i := range options {
		_va[_i] = options[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, startRequest)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for StartAndWait")
	}

	var r0 *sql.GetWarehouseResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, sql.StartRequest, ...retries.Option[sql.GetWarehouseResponse]) (*sql.GetWarehouseResponse, error)); ok {
		return rf(ctx, startRequest, options...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, sql.StartRequest, ...retries.Option[sql.GetWarehouseResponse]) *sql.GetWarehouseResponse); ok {
		r0 = rf(ctx, startRequest, options...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sql.GetWarehouseResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, sql.StartRequest, ...retries.Option[sql.GetWarehouseResponse]) error); ok {
		r1 = rf(ctx, startRequest, options...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_StartAndWait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartAndWait'
type MockWarehousesInterface_StartAndWait_Call struct {
	*mock.Call
}

// StartAndWait is a helper method to define mock.On call
//   - ctx context.Context
//   - startRequest sql.StartRequest
//   - options ...retries.Option[sql.GetWarehouseResponse]
func (_e *MockWarehousesInterface_Expecter) StartAndWait(ctx interface{}, startRequest interface{}, options ...interface{}) *MockWarehousesInterface_StartAndWait_Call {
	return &MockWarehousesInterface_StartAndWait_Call{Call: _e.mock.On("StartAndWait",
		append([]interface{}{ctx, startRequest}, options...)...)}
}

func (_c *MockWarehousesInterface_StartAndWait_Call) Run(run func(ctx context.Context, startRequest sql.StartRequest, options ...retries.Option[sql.GetWarehouseResponse])) *MockWarehousesInterface_StartAndWait_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]retries.Option[sql.GetWarehouseResponse], len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(retries.Option[sql.GetWarehouseResponse])
			}
		}
		run(args[0].(context.Context), args[1].(sql.StartRequest), variadicArgs...)
	})
	return _c
}

func (_c *MockWarehousesInterface_StartAndWait_Call) Return(_a0 *sql.GetWarehouseResponse, _a1 error) *MockWarehousesInterface_StartAndWait_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_StartAndWait_Call) RunAndReturn(run func(context.Context, sql.StartRequest, ...retries.Option[sql.GetWarehouseResponse]) (*sql.GetWarehouseResponse, error)) *MockWarehousesInterface_StartAndWait_Call {
	_c.Call.Return(run)
	return _c
}

// Stop provides a mock function with given fields: ctx, stopRequest
func (_m *MockWarehousesInterface) Stop(ctx context.Context, stopRequest sql.StopRequest) (*sql.WaitGetWarehouseStopped[struct{}], error) {
	ret := _m.Called(ctx, stopRequest)

	if len(ret) == 0 {
		panic("no return value specified for Stop")
	}

	var r0 *sql.WaitGetWarehouseStopped[struct{}]
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, sql.StopRequest) (*sql.WaitGetWarehouseStopped[struct{}], error)); ok {
		return rf(ctx, stopRequest)
	}
	if rf, ok := ret.Get(0).(func(context.Context, sql.StopRequest) *sql.WaitGetWarehouseStopped[struct{}]); ok {
		r0 = rf(ctx, stopRequest)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sql.WaitGetWarehouseStopped[struct{}])
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, sql.StopRequest) error); ok {
		r1 = rf(ctx, stopRequest)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
type MockWarehousesInterface_Stop_Call struct {
	*mock.Call
}

// Stop is a helper method to define mock.On call
//   - ctx context.Context
//   - stopRequest sql.StopRequest
func (_e *MockWarehousesInterface_Expecter) Stop(ctx interface{}, stopRequest interface{}) *MockWarehousesInterface_Stop_Call {
	return &MockWarehousesInterface_Stop_Call{Call: _e.mock.On("Stop", ctx, stopRequest)}
}

func (_c *MockWarehousesInterface_Stop_Call) Run(run func(ctx context.Context, stopRequest sql.StopRequest)) *MockWarehousesInterface_Stop_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(sql.StopRequest))
	})
	return _c
}

func (_c *MockWarehousesInterface_Stop_Call) Return(_a0 *sql.WaitGetWarehouseStopped[struct{}], _a1 error) *MockWarehousesInterface_Stop_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_Stop_Call) RunAndReturn(run func(context.Context, sql.StopRequest) (*sql.WaitGetWarehouseStopped[struct{}], error)) *MockWarehousesInterface_Stop_Call {
	_c.Call.Return(run)
	return _c
}

// StopAndWait provides a mock function with given fields: ctx, stopRequest, options
func (_m *MockWarehousesInterface) StopAndWait(ctx context.Context, stopRequest sql.StopRequest, options ...retries.Option[sql.GetWarehouseResponse]) (*sql.GetWarehouseResponse, error) {
	_va := make([]interface{}, len(options))
	for _i := range options {
		_va[_i] = options[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, stopRequest)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for StopAndWait")
	}

	var r0 *sql.GetWarehouseResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, sql.StopRequest, ...retries.Option[sql.GetWarehouseResponse]) (*sql.GetWarehouseResponse, error)); ok {
		return rf(ctx, stopRequest, options...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, sql.StopRequest, ...retries.Option[sql.GetWarehouseResponse]) *sql.GetWarehouseResponse); ok {
		r0 = rf(ctx, stopRequest, options...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sql.GetWarehouseResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, sql.StopRequest, ...retries.Option[sql.GetWarehouseResponse]) error); ok {
		r1 = rf(ctx, stopRequest, options...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_StopAndWait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StopAndWait'
type MockWarehousesInterface_StopAndWait_Call struct {
	*mock.Call
}

// StopAndWait is a helper method to define mock.On call
//   - ctx context.Context
//   - stopRequest sql.StopRequest
//   - options ...retries.Option[sql.GetWarehouseResponse]
func (_e *MockWarehousesInterface_Expecter) StopAndWait(ctx interface{}, stopRequest interface{}, options ...interface{}) *MockWarehousesInterface_StopAndWait_Call {
	return &MockWarehousesInterface_StopAndWait_Call{Call: _e.mock.On("StopAndWait",
		append([]interface{}{ctx, stopRequest}, options...)...)}
}

func (_c *MockWarehousesInterface_StopAndWait_Call) Run(run func(ctx context.Context, stopRequest sql.StopRequest, options ...retries.Option[sql.GetWarehouseResponse])) *MockWarehousesInterface_StopAndWait_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]retries.Option[sql.GetWarehouseResponse], len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(retries.Option[sql.GetWarehouseResponse])
			}
		}
		run(args[0].(context.Context), args[1].(sql.StopRequest), variadicArgs...)
	})
	return _c
}

func (_c *MockWarehousesInterface_StopAndWait_Call) Return(_a0 *sql.GetWarehouseResponse, _a1 error) *MockWarehousesInterface_StopAndWait_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_StopAndWait_Call) RunAndReturn(run func(context.Context, sql.StopRequest, ...retries.Option[sql.GetWarehouseResponse]) (*sql.GetWarehouseResponse, error)) *MockWarehousesInterface_StopAndWait_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePermissions provides a mock function with given fields: ctx, request
func (_m *MockWarehousesInterface) UpdatePermissions(ctx context.Context, request sql.WarehousePermissionsRequest) (*sql.WarehousePermissions, error) {
	ret := _m.Called(ctx, request)

	if len(ret) == 0 {
		panic("no return value specified for UpdatePermissions")
	}

	var r0 *sql.WarehousePermissions
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, sql.WarehousePermissionsRequest) (*sql.WarehousePermissions, error)); ok {
		return rf(ctx, request)
	}
	if rf, ok := ret.Get(0).(func(context.Context, sql.WarehousePermissionsRequest) *sql.WarehousePermissions); ok {
		r0 = rf(ctx, request)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sql.WarehousePermissions)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, sql.WarehousePermissionsRequest) error); ok {
		r1 = rf(ctx, request)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_UpdatePermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePermissions'
type MockWarehousesInterface_UpdatePermissions_Call struct {
	*mock.Call
}

// UpdatePermissions is a helper method to define mock.On call
//   - ctx context.Context
//   - request sql.WarehousePermissionsRequest
func (_e *MockWarehousesInterface_Expecter) UpdatePermissions(ctx interface{}, request interface{}) *MockWarehousesInterface_UpdatePermissions_Call {
	return &MockWarehousesInterface_UpdatePermissions_Call{Call: _e.mock.On("UpdatePermissions", ctx, request)}
}

func (_c *MockWarehousesInterface_UpdatePermissions_Call) Run(run func(ctx context.Context, request sql.WarehousePermissionsRequest)) *MockWarehousesInterface_UpdatePermissions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(sql.WarehousePermissionsRequest))
	})
	return _c
}

func (_c *MockWarehousesInterface_UpdatePermissions_Call) Return(_a0 *sql.WarehousePermissions, _a1 error) *MockWarehousesInterface_UpdatePermissions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_UpdatePermissions_Call) RunAndReturn(run func(context.Context, sql.WarehousePermissionsRequest) (*sql.WarehousePermissions, error)) *MockWarehousesInterface_UpdatePermissions_Call {
	_c.Call.Return(run)
	return _c
}

// WaitGetWarehouseRunning provides a mock function with given fields: ctx, id, timeout, callback
func (_m *MockWarehousesInterface) WaitGetWarehouseRunning(ctx context.Context, id string, timeout time.Duration, callback func(*sql.GetWarehouseResponse)) (*sql.GetWarehouseResponse, error) {
	ret := _m.Called(ctx, id, timeout, callback)

	if len(ret) == 0 {
		panic("no return value specified for WaitGetWarehouseRunning")
	}

	var r0 *sql.GetWarehouseResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration, func(*sql.GetWarehouseResponse)) (*sql.GetWarehouseResponse, error)); ok {
		return rf(ctx, id, timeout, callback)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration, func(*sql.GetWarehouseResponse)) *sql.GetWarehouseResponse); ok {
		r0 = rf(ctx, id, timeout, callback)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sql.GetWarehouseResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, time.Duration, func(*sql.GetWarehouseResponse)) error); ok {
		r1 = rf(ctx, id, timeout, callback)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_WaitGetWarehouseRunning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitGetWarehouseRunning'
type MockWarehousesInterface_WaitGetWarehouseRunning_Call struct {
	*mock.Call
}

// WaitGetWarehouseRunning is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - timeout time.Duration
//   - callback func(*sql.GetWarehouseResponse)
func (_e *MockWarehousesInterface_Expecter) WaitGetWarehouseRunning(ctx interface{}, id interface{}, timeout interface{}, callback interface{}) *MockWarehousesInterface_WaitGetWarehouseRunning_Call {
	return &MockWarehousesInterface_WaitGetWarehouseRunning_Call{Call: _e.mock.On("WaitGetWarehouseRunning", ctx, id, timeout, callback)}
}

func (_c *MockWarehousesInterface_WaitGetWarehouseRunning_Call) Run(run func(ctx context.Context, id string, timeout time.Duration, callback func(*sql.GetWarehouseResponse))) *MockWarehousesInterface_WaitGetWarehouseRunning_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(time.Duration), args[3].(func(*sql.GetWarehouseResponse)))
	})
	return _c
}

func (_c *MockWarehousesInterface_WaitGetWarehouseRunning_Call) Return(_a0 *sql.GetWarehouseResponse, _a1 error) *MockWarehousesInterface_WaitGetWarehouseRunning_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_WaitGetWarehouseRunning_Call) RunAndReturn(run func(context.Context, string, time.Duration, func(*sql.GetWarehouseResponse)) (*sql.GetWarehouseResponse, error)) *MockWarehousesInterface_WaitGetWarehouseRunning_Call {
	_c.Call.Return(run)
	return _c
}

// WaitGetWarehouseStopped provides a mock function with given fields: ctx, id, timeout, callback
func (_m *MockWarehousesInterface) WaitGetWarehouseStopped(ctx context.Context, id string, timeout time.Duration, callback func(*sql.GetWarehouseResponse)) (*sql.GetWarehouseResponse, error) {
	ret := _m.Called(ctx, id, timeout, callback)

	if len(ret) == 0 {
		panic("no return value specified for WaitGetWarehouseStopped")
	}

	var r0 *sql.GetWarehouseResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration, func(*sql.GetWarehouseResponse)) (*sql.GetWarehouseResponse, error)); ok {
		return rf(ctx, id, timeout, callback)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, time.Duration, func(*sql.GetWarehouseResponse)) *sql.GetWarehouseResponse); ok {
		r0 = rf(ctx, id, timeout, callback)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sql.GetWarehouseResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, time.Duration, func(*sql.GetWarehouseResponse)) error); ok {
		r1 = rf(ctx, id, timeout, callback)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockWarehousesInterface_WaitGetWarehouseStopped_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitGetWarehouseStopped'
type MockWarehousesInterface_WaitGetWarehouseStopped_Call struct {
	*mock.Call
}

// WaitGetWarehouseStopped is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - timeout time.Duration
//   - callback func(*sql.GetWarehouseResponse)
func (_e *MockWarehousesInterface_Expecter) WaitGetWarehouseStopped(ctx interface{}, id interface{}, timeout interface{}, callback interface{}) *MockWarehousesInterface_WaitGetWarehouseStopped_Call {
	return &MockWarehousesInterface_WaitGetWarehouseStopped_Call{Call: _e.mock.On("WaitGetWarehouseStopped", ctx, id, timeout, callback)}
}

func (_c *MockWarehousesInterface_WaitGetWarehouseStopped_Call) Run(run func(ctx context.Context, id string, timeout time.Duration, callback func(*sql.GetWarehouseResponse))) *MockWarehousesInterface_WaitGetWarehouseStopped_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(time.Duration), args[3].(func(*sql.GetWarehouseResponse)))
	})
	return _c
}

func (_c *MockWarehousesInterface_WaitGetWarehouseStopped_Call) Return(_a0 *sql.GetWarehouseResponse, _a1 error) *MockWarehousesInterface_WaitGetWarehouseStopped_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockWarehousesInterface_WaitGetWarehouseStopped_Call) RunAndReturn(run func(context.Context, string, time.Duration, func(*sql.GetWarehouseResponse)) (*sql.GetWarehouseResponse, error)) *MockWarehousesInterface_WaitGetWarehouseStopped_Call {
	_c.Call.Return(run)
	return _c
}

// WithImpl provides a mock function with given fields: impl
func (_m *MockWarehousesInterface) WithImpl(impl sql.WarehousesService) sql.WarehousesInterface {
	ret := _m.Called(impl)

	if len(ret) == 0 {
		panic("no return value specified for WithImpl")
	}

	var r0 sql.WarehousesInterface
	if rf, ok := ret.Get(0).(func(sql.WarehousesService) sql.WarehousesInterface); ok {
		r0 = rf(impl)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(sql.WarehousesInterface)
		}
	}

	return r0
}

// MockWarehousesInterface_WithImpl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WithImpl'
type MockWarehousesInterface_WithImpl_Call struct {
	*mock.Call
}

// WithImpl is a helper method to define mock.On call
//   - impl sql.WarehousesService
func (_e *MockWarehousesInterface_Expecter) WithImpl(impl interface{}) *MockWarehousesInterface_WithImpl_Call {
	return &MockWarehousesInterface_WithImpl_Call{Call: _e.mock.On("WithImpl", impl)}
}

func (_c *MockWarehousesInterface_WithImpl_Call) Run(run func(impl sql.WarehousesService)) *MockWarehousesInterface_WithImpl_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(sql.WarehousesService))
	})
	return _c
}

func (_c *MockWarehousesInterface_WithImpl_Call) Return(_a0 sql.WarehousesInterface) *MockWarehousesInterface_WithImpl_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockWarehousesInterface_WithImpl_Call) RunAndReturn(run func(sql.WarehousesService) sql.WarehousesInterface) *MockWarehousesInterface_WithImpl_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockWarehousesInterface creates a new instance of MockWarehousesInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockWarehousesInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockWarehousesInterface {
	mock := &MockWarehousesInterface{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}