data_federation_api.go

// Code generated by mockery. DO NOT EDIT.

package mockadmin

import (
	context "context"

	admin "go.mongodb.org/atlas-sdk/v20231115008/admin"

	http "net/http"

	io "io"

	mock "github.com/stretchr/testify/mock"
)

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

type DataFederationApi_Expecter struct {
	mock *mock.Mock
}

func (_m *DataFederationApi) EXPECT() *DataFederationApi_Expecter {
	return &DataFederationApi_Expecter{mock: &_m.Mock}
}

// CreateDataFederationPrivateEndpoint provides a mock function with given fields: ctx, groupId, privateNetworkEndpointIdEntry
func (_m *DataFederationApi) CreateDataFederationPrivateEndpoint(ctx context.Context, groupId string, privateNetworkEndpointIdEntry *admin.PrivateNetworkEndpointIdEntry) admin.CreateDataFederationPrivateEndpointApiRequest {
	ret := _m.Called(ctx, groupId, privateNetworkEndpointIdEntry)

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

	var r0 admin.CreateDataFederationPrivateEndpointApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, *admin.PrivateNetworkEndpointIdEntry) admin.CreateDataFederationPrivateEndpointApiRequest); ok {
		r0 = rf(ctx, groupId, privateNetworkEndpointIdEntry)
	} else {
		r0 = ret.Get(0).(admin.CreateDataFederationPrivateEndpointApiRequest)
	}

	return r0
}

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

// CreateDataFederationPrivateEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - privateNetworkEndpointIdEntry *admin.PrivateNetworkEndpointIdEntry
func (_e *DataFederationApi_Expecter) CreateDataFederationPrivateEndpoint(ctx interface{}, groupId interface{}, privateNetworkEndpointIdEntry interface{}) *DataFederationApi_CreateDataFederationPrivateEndpoint_Call {
	return &DataFederationApi_CreateDataFederationPrivateEndpoint_Call{Call: _e.mock.On("CreateDataFederationPrivateEndpoint", ctx, groupId, privateNetworkEndpointIdEntry)}
}

func (_c *DataFederationApi_CreateDataFederationPrivateEndpoint_Call) Run(run func(ctx context.Context, groupId string, privateNetworkEndpointIdEntry *admin.PrivateNetworkEndpointIdEntry)) *DataFederationApi_CreateDataFederationPrivateEndpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*admin.PrivateNetworkEndpointIdEntry))
	})
	return _c
}

func (_c *DataFederationApi_CreateDataFederationPrivateEndpoint_Call) Return(_a0 admin.CreateDataFederationPrivateEndpointApiRequest) *DataFederationApi_CreateDataFederationPrivateEndpoint_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_CreateDataFederationPrivateEndpoint_Call) RunAndReturn(run func(context.Context, string, *admin.PrivateNetworkEndpointIdEntry) admin.CreateDataFederationPrivateEndpointApiRequest) *DataFederationApi_CreateDataFederationPrivateEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// CreateDataFederationPrivateEndpointExecute provides a mock function with given fields: r
func (_m *DataFederationApi) CreateDataFederationPrivateEndpointExecute(r admin.CreateDataFederationPrivateEndpointApiRequest) (*admin.PaginatedPrivateNetworkEndpointIdEntry, *http.Response, error) {
	ret := _m.Called(r)

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

	var r0 *admin.PaginatedPrivateNetworkEndpointIdEntry
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.CreateDataFederationPrivateEndpointApiRequest) (*admin.PaginatedPrivateNetworkEndpointIdEntry, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.CreateDataFederationPrivateEndpointApiRequest) *admin.PaginatedPrivateNetworkEndpointIdEntry); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.PaginatedPrivateNetworkEndpointIdEntry)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.CreateDataFederationPrivateEndpointApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.CreateDataFederationPrivateEndpointApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// CreateDataFederationPrivateEndpointExecute is a helper method to define mock.On call
//   - r admin.CreateDataFederationPrivateEndpointApiRequest
func (_e *DataFederationApi_Expecter) CreateDataFederationPrivateEndpointExecute(r interface{}) *DataFederationApi_CreateDataFederationPrivateEndpointExecute_Call {
	return &DataFederationApi_CreateDataFederationPrivateEndpointExecute_Call{Call: _e.mock.On("CreateDataFederationPrivateEndpointExecute", r)}
}

func (_c *DataFederationApi_CreateDataFederationPrivateEndpointExecute_Call) Run(run func(r admin.CreateDataFederationPrivateEndpointApiRequest)) *DataFederationApi_CreateDataFederationPrivateEndpointExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.CreateDataFederationPrivateEndpointApiRequest))
	})
	return _c
}

func (_c *DataFederationApi_CreateDataFederationPrivateEndpointExecute_Call) Return(_a0 *admin.PaginatedPrivateNetworkEndpointIdEntry, _a1 *http.Response, _a2 error) *DataFederationApi_CreateDataFederationPrivateEndpointExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *DataFederationApi_CreateDataFederationPrivateEndpointExecute_Call) RunAndReturn(run func(admin.CreateDataFederationPrivateEndpointApiRequest) (*admin.PaginatedPrivateNetworkEndpointIdEntry, *http.Response, error)) *DataFederationApi_CreateDataFederationPrivateEndpointExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateDataFederationPrivateEndpointWithParams provides a mock function with given fields: ctx, args
func (_m *DataFederationApi) CreateDataFederationPrivateEndpointWithParams(ctx context.Context, args *admin.CreateDataFederationPrivateEndpointApiParams) admin.CreateDataFederationPrivateEndpointApiRequest {
	ret := _m.Called(ctx, args)

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

	var r0 admin.CreateDataFederationPrivateEndpointApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateDataFederationPrivateEndpointApiParams) admin.CreateDataFederationPrivateEndpointApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.CreateDataFederationPrivateEndpointApiRequest)
	}

	return r0
}

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

// CreateDataFederationPrivateEndpointWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreateDataFederationPrivateEndpointApiParams
func (_e *DataFederationApi_Expecter) CreateDataFederationPrivateEndpointWithParams(ctx interface{}, args interface{}) *DataFederationApi_CreateDataFederationPrivateEndpointWithParams_Call {
	return &DataFederationApi_CreateDataFederationPrivateEndpointWithParams_Call{Call: _e.mock.On("CreateDataFederationPrivateEndpointWithParams", ctx, args)}
}

func (_c *DataFederationApi_CreateDataFederationPrivateEndpointWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateDataFederationPrivateEndpointApiParams)) *DataFederationApi_CreateDataFederationPrivateEndpointWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.CreateDataFederationPrivateEndpointApiParams))
	})
	return _c
}

func (_c *DataFederationApi_CreateDataFederationPrivateEndpointWithParams_Call) Return(_a0 admin.CreateDataFederationPrivateEndpointApiRequest) *DataFederationApi_CreateDataFederationPrivateEndpointWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_CreateDataFederationPrivateEndpointWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateDataFederationPrivateEndpointApiParams) admin.CreateDataFederationPrivateEndpointApiRequest) *DataFederationApi_CreateDataFederationPrivateEndpointWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// CreateFederatedDatabase provides a mock function with given fields: ctx, groupId, dataLakeTenant
func (_m *DataFederationApi) CreateFederatedDatabase(ctx context.Context, groupId string, dataLakeTenant *admin.DataLakeTenant) admin.CreateFederatedDatabaseApiRequest {
	ret := _m.Called(ctx, groupId, dataLakeTenant)

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

	var r0 admin.CreateFederatedDatabaseApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, *admin.DataLakeTenant) admin.CreateFederatedDatabaseApiRequest); ok {
		r0 = rf(ctx, groupId, dataLakeTenant)
	} else {
		r0 = ret.Get(0).(admin.CreateFederatedDatabaseApiRequest)
	}

	return r0
}

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

// CreateFederatedDatabase is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - dataLakeTenant *admin.DataLakeTenant
func (_e *DataFederationApi_Expecter) CreateFederatedDatabase(ctx interface{}, groupId interface{}, dataLakeTenant interface{}) *DataFederationApi_CreateFederatedDatabase_Call {
	return &DataFederationApi_CreateFederatedDatabase_Call{Call: _e.mock.On("CreateFederatedDatabase", ctx, groupId, dataLakeTenant)}
}

func (_c *DataFederationApi_CreateFederatedDatabase_Call) Run(run func(ctx context.Context, groupId string, dataLakeTenant *admin.DataLakeTenant)) *DataFederationApi_CreateFederatedDatabase_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*admin.DataLakeTenant))
	})
	return _c
}

func (_c *DataFederationApi_CreateFederatedDatabase_Call) Return(_a0 admin.CreateFederatedDatabaseApiRequest) *DataFederationApi_CreateFederatedDatabase_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_CreateFederatedDatabase_Call) RunAndReturn(run func(context.Context, string, *admin.DataLakeTenant) admin.CreateFederatedDatabaseApiRequest) *DataFederationApi_CreateFederatedDatabase_Call {
	_c.Call.Return(run)
	return _c
}

// CreateFederatedDatabaseExecute provides a mock function with given fields: r
func (_m *DataFederationApi) CreateFederatedDatabaseExecute(r admin.CreateFederatedDatabaseApiRequest) (*admin.DataLakeTenant, *http.Response, error) {
	ret := _m.Called(r)

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

	var r0 *admin.DataLakeTenant
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.CreateFederatedDatabaseApiRequest) (*admin.DataLakeTenant, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.CreateFederatedDatabaseApiRequest) *admin.DataLakeTenant); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.DataLakeTenant)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.CreateFederatedDatabaseApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.CreateFederatedDatabaseApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// CreateFederatedDatabaseExecute is a helper method to define mock.On call
//   - r admin.CreateFederatedDatabaseApiRequest
func (_e *DataFederationApi_Expecter) CreateFederatedDatabaseExecute(r interface{}) *DataFederationApi_CreateFederatedDatabaseExecute_Call {
	return &DataFederationApi_CreateFederatedDatabaseExecute_Call{Call: _e.mock.On("CreateFederatedDatabaseExecute", r)}
}

func (_c *DataFederationApi_CreateFederatedDatabaseExecute_Call) Run(run func(r admin.CreateFederatedDatabaseApiRequest)) *DataFederationApi_CreateFederatedDatabaseExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.CreateFederatedDatabaseApiRequest))
	})
	return _c
}

func (_c *DataFederationApi_CreateFederatedDatabaseExecute_Call) Return(_a0 *admin.DataLakeTenant, _a1 *http.Response, _a2 error) *DataFederationApi_CreateFederatedDatabaseExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *DataFederationApi_CreateFederatedDatabaseExecute_Call) RunAndReturn(run func(admin.CreateFederatedDatabaseApiRequest) (*admin.DataLakeTenant, *http.Response, error)) *DataFederationApi_CreateFederatedDatabaseExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateFederatedDatabaseWithParams provides a mock function with given fields: ctx, args
func (_m *DataFederationApi) CreateFederatedDatabaseWithParams(ctx context.Context, args *admin.CreateFederatedDatabaseApiParams) admin.CreateFederatedDatabaseApiRequest {
	ret := _m.Called(ctx, args)

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

	var r0 admin.CreateFederatedDatabaseApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateFederatedDatabaseApiParams) admin.CreateFederatedDatabaseApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.CreateFederatedDatabaseApiRequest)
	}

	return r0
}

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

// CreateFederatedDatabaseWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreateFederatedDatabaseApiParams
func (_e *DataFederationApi_Expecter) CreateFederatedDatabaseWithParams(ctx interface{}, args interface{}) *DataFederationApi_CreateFederatedDatabaseWithParams_Call {
	return &DataFederationApi_CreateFederatedDatabaseWithParams_Call{Call: _e.mock.On("CreateFederatedDatabaseWithParams", ctx, args)}
}

func (_c *DataFederationApi_CreateFederatedDatabaseWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateFederatedDatabaseApiParams)) *DataFederationApi_CreateFederatedDatabaseWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.CreateFederatedDatabaseApiParams))
	})
	return _c
}

func (_c *DataFederationApi_CreateFederatedDatabaseWithParams_Call) Return(_a0 admin.CreateFederatedDatabaseApiRequest) *DataFederationApi_CreateFederatedDatabaseWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_CreateFederatedDatabaseWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateFederatedDatabaseApiParams) admin.CreateFederatedDatabaseApiRequest) *DataFederationApi_CreateFederatedDatabaseWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// CreateOneDataFederationQueryLimit provides a mock function with given fields: ctx, groupId, tenantName, limitName, dataFederationTenantQueryLimit
func (_m *DataFederationApi) CreateOneDataFederationQueryLimit(ctx context.Context, groupId string, tenantName string, limitName string, dataFederationTenantQueryLimit *admin.DataFederationTenantQueryLimit) admin.CreateOneDataFederationQueryLimitApiRequest {
	ret := _m.Called(ctx, groupId, tenantName, limitName, dataFederationTenantQueryLimit)

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

	var r0 admin.CreateOneDataFederationQueryLimitApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *admin.DataFederationTenantQueryLimit) admin.CreateOneDataFederationQueryLimitApiRequest); ok {
		r0 = rf(ctx, groupId, tenantName, limitName, dataFederationTenantQueryLimit)
	} else {
		r0 = ret.Get(0).(admin.CreateOneDataFederationQueryLimitApiRequest)
	}

	return r0
}

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

// CreateOneDataFederationQueryLimit is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - tenantName string
//   - limitName string
//   - dataFederationTenantQueryLimit *admin.DataFederationTenantQueryLimit
func (_e *DataFederationApi_Expecter) CreateOneDataFederationQueryLimit(ctx interface{}, groupId interface{}, tenantName interface{}, limitName interface{}, dataFederationTenantQueryLimit interface{}) *DataFederationApi_CreateOneDataFederationQueryLimit_Call {
	return &DataFederationApi_CreateOneDataFederationQueryLimit_Call{Call: _e.mock.On("CreateOneDataFederationQueryLimit", ctx, groupId, tenantName, limitName, dataFederationTenantQueryLimit)}
}

func (_c *DataFederationApi_CreateOneDataFederationQueryLimit_Call) Run(run func(ctx context.Context, groupId string, tenantName string, limitName string, dataFederationTenantQueryLimit *admin.DataFederationTenantQueryLimit)) *DataFederationApi_CreateOneDataFederationQueryLimit_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*admin.DataFederationTenantQueryLimit))
	})
	return _c
}

func (_c *DataFederationApi_CreateOneDataFederationQueryLimit_Call) Return(_a0 admin.CreateOneDataFederationQueryLimitApiRequest) *DataFederationApi_CreateOneDataFederationQueryLimit_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_CreateOneDataFederationQueryLimit_Call) RunAndReturn(run func(context.Context, string, string, string, *admin.DataFederationTenantQueryLimit) admin.CreateOneDataFederationQueryLimitApiRequest) *DataFederationApi_CreateOneDataFederationQueryLimit_Call {
	_c.Call.Return(run)
	return _c
}

// CreateOneDataFederationQueryLimitExecute provides a mock function with given fields: r
func (_m *DataFederationApi) CreateOneDataFederationQueryLimitExecute(r admin.CreateOneDataFederationQueryLimitApiRequest) (*admin.DataFederationTenantQueryLimit, *http.Response, error) {
	ret := _m.Called(r)

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

	var r0 *admin.DataFederationTenantQueryLimit
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.CreateOneDataFederationQueryLimitApiRequest) (*admin.DataFederationTenantQueryLimit, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.CreateOneDataFederationQueryLimitApiRequest) *admin.DataFederationTenantQueryLimit); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.DataFederationTenantQueryLimit)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.CreateOneDataFederationQueryLimitApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.CreateOneDataFederationQueryLimitApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// CreateOneDataFederationQueryLimitExecute is a helper method to define mock.On call
//   - r admin.CreateOneDataFederationQueryLimitApiRequest
func (_e *DataFederationApi_Expecter) CreateOneDataFederationQueryLimitExecute(r interface{}) *DataFederationApi_CreateOneDataFederationQueryLimitExecute_Call {
	return &DataFederationApi_CreateOneDataFederationQueryLimitExecute_Call{Call: _e.mock.On("CreateOneDataFederationQueryLimitExecute", r)}
}

func (_c *DataFederationApi_CreateOneDataFederationQueryLimitExecute_Call) Run(run func(r admin.CreateOneDataFederationQueryLimitApiRequest)) *DataFederationApi_CreateOneDataFederationQueryLimitExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.CreateOneDataFederationQueryLimitApiRequest))
	})
	return _c
}

func (_c *DataFederationApi_CreateOneDataFederationQueryLimitExecute_Call) Return(_a0 *admin.DataFederationTenantQueryLimit, _a1 *http.Response, _a2 error) *DataFederationApi_CreateOneDataFederationQueryLimitExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *DataFederationApi_CreateOneDataFederationQueryLimitExecute_Call) RunAndReturn(run func(admin.CreateOneDataFederationQueryLimitApiRequest) (*admin.DataFederationTenantQueryLimit, *http.Response, error)) *DataFederationApi_CreateOneDataFederationQueryLimitExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreateOneDataFederationQueryLimitWithParams provides a mock function with given fields: ctx, args
func (_m *DataFederationApi) CreateOneDataFederationQueryLimitWithParams(ctx context.Context, args *admin.CreateOneDataFederationQueryLimitApiParams) admin.CreateOneDataFederationQueryLimitApiRequest {
	ret := _m.Called(ctx, args)

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

	var r0 admin.CreateOneDataFederationQueryLimitApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.CreateOneDataFederationQueryLimitApiParams) admin.CreateOneDataFederationQueryLimitApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.CreateOneDataFederationQueryLimitApiRequest)
	}

	return r0
}

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

// CreateOneDataFederationQueryLimitWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreateOneDataFederationQueryLimitApiParams
func (_e *DataFederationApi_Expecter) CreateOneDataFederationQueryLimitWithParams(ctx interface{}, args interface{}) *DataFederationApi_CreateOneDataFederationQueryLimitWithParams_Call {
	return &DataFederationApi_CreateOneDataFederationQueryLimitWithParams_Call{Call: _e.mock.On("CreateOneDataFederationQueryLimitWithParams", ctx, args)}
}

func (_c *DataFederationApi_CreateOneDataFederationQueryLimitWithParams_Call) Run(run func(ctx context.Context, args *admin.CreateOneDataFederationQueryLimitApiParams)) *DataFederationApi_CreateOneDataFederationQueryLimitWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.CreateOneDataFederationQueryLimitApiParams))
	})
	return _c
}

func (_c *DataFederationApi_CreateOneDataFederationQueryLimitWithParams_Call) Return(_a0 admin.CreateOneDataFederationQueryLimitApiRequest) *DataFederationApi_CreateOneDataFederationQueryLimitWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_CreateOneDataFederationQueryLimitWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreateOneDataFederationQueryLimitApiParams) admin.CreateOneDataFederationQueryLimitApiRequest) *DataFederationApi_CreateOneDataFederationQueryLimitWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDataFederationPrivateEndpoint provides a mock function with given fields: ctx, groupId, endpointId
func (_m *DataFederationApi) DeleteDataFederationPrivateEndpoint(ctx context.Context, groupId string, endpointId string) admin.DeleteDataFederationPrivateEndpointApiRequest {
	ret := _m.Called(ctx, groupId, endpointId)

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

	var r0 admin.DeleteDataFederationPrivateEndpointApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteDataFederationPrivateEndpointApiRequest); ok {
		r0 = rf(ctx, groupId, endpointId)
	} else {
		r0 = ret.Get(0).(admin.DeleteDataFederationPrivateEndpointApiRequest)
	}

	return r0
}

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

// DeleteDataFederationPrivateEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - endpointId string
func (_e *DataFederationApi_Expecter) DeleteDataFederationPrivateEndpoint(ctx interface{}, groupId interface{}, endpointId interface{}) *DataFederationApi_DeleteDataFederationPrivateEndpoint_Call {
	return &DataFederationApi_DeleteDataFederationPrivateEndpoint_Call{Call: _e.mock.On("DeleteDataFederationPrivateEndpoint", ctx, groupId, endpointId)}
}

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

func (_c *DataFederationApi_DeleteDataFederationPrivateEndpoint_Call) Return(_a0 admin.DeleteDataFederationPrivateEndpointApiRequest) *DataFederationApi_DeleteDataFederationPrivateEndpoint_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_DeleteDataFederationPrivateEndpoint_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteDataFederationPrivateEndpointApiRequest) *DataFederationApi_DeleteDataFederationPrivateEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDataFederationPrivateEndpointExecute provides a mock function with given fields: r
func (_m *DataFederationApi) DeleteDataFederationPrivateEndpointExecute(r admin.DeleteDataFederationPrivateEndpointApiRequest) (map[string]interface{}, *http.Response, error) {
	ret := _m.Called(r)

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

	var r0 map[string]interface{}
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.DeleteDataFederationPrivateEndpointApiRequest) (map[string]interface{}, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.DeleteDataFederationPrivateEndpointApiRequest) map[string]interface{}); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]interface{})
		}
	}

	if rf, ok := ret.Get(1).(func(admin.DeleteDataFederationPrivateEndpointApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.DeleteDataFederationPrivateEndpointApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// DeleteDataFederationPrivateEndpointExecute is a helper method to define mock.On call
//   - r admin.DeleteDataFederationPrivateEndpointApiRequest
func (_e *DataFederationApi_Expecter) DeleteDataFederationPrivateEndpointExecute(r interface{}) *DataFederationApi_DeleteDataFederationPrivateEndpointExecute_Call {
	return &DataFederationApi_DeleteDataFederationPrivateEndpointExecute_Call{Call: _e.mock.On("DeleteDataFederationPrivateEndpointExecute", r)}
}

func (_c *DataFederationApi_DeleteDataFederationPrivateEndpointExecute_Call) Run(run func(r admin.DeleteDataFederationPrivateEndpointApiRequest)) *DataFederationApi_DeleteDataFederationPrivateEndpointExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.DeleteDataFederationPrivateEndpointApiRequest))
	})
	return _c
}

func (_c *DataFederationApi_DeleteDataFederationPrivateEndpointExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *DataFederationApi_DeleteDataFederationPrivateEndpointExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *DataFederationApi_DeleteDataFederationPrivateEndpointExecute_Call) RunAndReturn(run func(admin.DeleteDataFederationPrivateEndpointApiRequest) (map[string]interface{}, *http.Response, error)) *DataFederationApi_DeleteDataFederationPrivateEndpointExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDataFederationPrivateEndpointWithParams provides a mock function with given fields: ctx, args
func (_m *DataFederationApi) DeleteDataFederationPrivateEndpointWithParams(ctx context.Context, args *admin.DeleteDataFederationPrivateEndpointApiParams) admin.DeleteDataFederationPrivateEndpointApiRequest {
	ret := _m.Called(ctx, args)

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

	var r0 admin.DeleteDataFederationPrivateEndpointApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteDataFederationPrivateEndpointApiParams) admin.DeleteDataFederationPrivateEndpointApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.DeleteDataFederationPrivateEndpointApiRequest)
	}

	return r0
}

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

// DeleteDataFederationPrivateEndpointWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeleteDataFederationPrivateEndpointApiParams
func (_e *DataFederationApi_Expecter) DeleteDataFederationPrivateEndpointWithParams(ctx interface{}, args interface{}) *DataFederationApi_DeleteDataFederationPrivateEndpointWithParams_Call {
	return &DataFederationApi_DeleteDataFederationPrivateEndpointWithParams_Call{Call: _e.mock.On("DeleteDataFederationPrivateEndpointWithParams", ctx, args)}
}

func (_c *DataFederationApi_DeleteDataFederationPrivateEndpointWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteDataFederationPrivateEndpointApiParams)) *DataFederationApi_DeleteDataFederationPrivateEndpointWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.DeleteDataFederationPrivateEndpointApiParams))
	})
	return _c
}

func (_c *DataFederationApi_DeleteDataFederationPrivateEndpointWithParams_Call) Return(_a0 admin.DeleteDataFederationPrivateEndpointApiRequest) *DataFederationApi_DeleteDataFederationPrivateEndpointWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_DeleteDataFederationPrivateEndpointWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteDataFederationPrivateEndpointApiParams) admin.DeleteDataFederationPrivateEndpointApiRequest) *DataFederationApi_DeleteDataFederationPrivateEndpointWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteFederatedDatabase provides a mock function with given fields: ctx, groupId, tenantName
func (_m *DataFederationApi) DeleteFederatedDatabase(ctx context.Context, groupId string, tenantName string) admin.DeleteFederatedDatabaseApiRequest {
	ret := _m.Called(ctx, groupId, tenantName)

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

	var r0 admin.DeleteFederatedDatabaseApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DeleteFederatedDatabaseApiRequest); ok {
		r0 = rf(ctx, groupId, tenantName)
	} else {
		r0 = ret.Get(0).(admin.DeleteFederatedDatabaseApiRequest)
	}

	return r0
}

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

// DeleteFederatedDatabase is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - tenantName string
func (_e *DataFederationApi_Expecter) DeleteFederatedDatabase(ctx interface{}, groupId interface{}, tenantName interface{}) *DataFederationApi_DeleteFederatedDatabase_Call {
	return &DataFederationApi_DeleteFederatedDatabase_Call{Call: _e.mock.On("DeleteFederatedDatabase", ctx, groupId, tenantName)}
}

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

func (_c *DataFederationApi_DeleteFederatedDatabase_Call) Return(_a0 admin.DeleteFederatedDatabaseApiRequest) *DataFederationApi_DeleteFederatedDatabase_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_DeleteFederatedDatabase_Call) RunAndReturn(run func(context.Context, string, string) admin.DeleteFederatedDatabaseApiRequest) *DataFederationApi_DeleteFederatedDatabase_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteFederatedDatabaseExecute provides a mock function with given fields: r
func (_m *DataFederationApi) DeleteFederatedDatabaseExecute(r admin.DeleteFederatedDatabaseApiRequest) (map[string]interface{}, *http.Response, error) {
	ret := _m.Called(r)

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

	var r0 map[string]interface{}
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.DeleteFederatedDatabaseApiRequest) (map[string]interface{}, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.DeleteFederatedDatabaseApiRequest) map[string]interface{}); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]interface{})
		}
	}

	if rf, ok := ret.Get(1).(func(admin.DeleteFederatedDatabaseApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.DeleteFederatedDatabaseApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// DeleteFederatedDatabaseExecute is a helper method to define mock.On call
//   - r admin.DeleteFederatedDatabaseApiRequest
func (_e *DataFederationApi_Expecter) DeleteFederatedDatabaseExecute(r interface{}) *DataFederationApi_DeleteFederatedDatabaseExecute_Call {
	return &DataFederationApi_DeleteFederatedDatabaseExecute_Call{Call: _e.mock.On("DeleteFederatedDatabaseExecute", r)}
}

func (_c *DataFederationApi_DeleteFederatedDatabaseExecute_Call) Run(run func(r admin.DeleteFederatedDatabaseApiRequest)) *DataFederationApi_DeleteFederatedDatabaseExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.DeleteFederatedDatabaseApiRequest))
	})
	return _c
}

func (_c *DataFederationApi_DeleteFederatedDatabaseExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *DataFederationApi_DeleteFederatedDatabaseExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *DataFederationApi_DeleteFederatedDatabaseExecute_Call) RunAndReturn(run func(admin.DeleteFederatedDatabaseApiRequest) (map[string]interface{}, *http.Response, error)) *DataFederationApi_DeleteFederatedDatabaseExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteFederatedDatabaseWithParams provides a mock function with given fields: ctx, args
func (_m *DataFederationApi) DeleteFederatedDatabaseWithParams(ctx context.Context, args *admin.DeleteFederatedDatabaseApiParams) admin.DeleteFederatedDatabaseApiRequest {
	ret := _m.Called(ctx, args)

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

	var r0 admin.DeleteFederatedDatabaseApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteFederatedDatabaseApiParams) admin.DeleteFederatedDatabaseApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.DeleteFederatedDatabaseApiRequest)
	}

	return r0
}

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

// DeleteFederatedDatabaseWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeleteFederatedDatabaseApiParams
func (_e *DataFederationApi_Expecter) DeleteFederatedDatabaseWithParams(ctx interface{}, args interface{}) *DataFederationApi_DeleteFederatedDatabaseWithParams_Call {
	return &DataFederationApi_DeleteFederatedDatabaseWithParams_Call{Call: _e.mock.On("DeleteFederatedDatabaseWithParams", ctx, args)}
}

func (_c *DataFederationApi_DeleteFederatedDatabaseWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteFederatedDatabaseApiParams)) *DataFederationApi_DeleteFederatedDatabaseWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.DeleteFederatedDatabaseApiParams))
	})
	return _c
}

func (_c *DataFederationApi_DeleteFederatedDatabaseWithParams_Call) Return(_a0 admin.DeleteFederatedDatabaseApiRequest) *DataFederationApi_DeleteFederatedDatabaseWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_DeleteFederatedDatabaseWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteFederatedDatabaseApiParams) admin.DeleteFederatedDatabaseApiRequest) *DataFederationApi_DeleteFederatedDatabaseWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteOneDataFederationInstanceQueryLimit provides a mock function with given fields: ctx, groupId, tenantName, limitName
func (_m *DataFederationApi) DeleteOneDataFederationInstanceQueryLimit(ctx context.Context, groupId string, tenantName string, limitName string) admin.DeleteOneDataFederationInstanceQueryLimitApiRequest {
	ret := _m.Called(ctx, groupId, tenantName, limitName)

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

	var r0 admin.DeleteOneDataFederationInstanceQueryLimitApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.DeleteOneDataFederationInstanceQueryLimitApiRequest); ok {
		r0 = rf(ctx, groupId, tenantName, limitName)
	} else {
		r0 = ret.Get(0).(admin.DeleteOneDataFederationInstanceQueryLimitApiRequest)
	}

	return r0
}

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

// DeleteOneDataFederationInstanceQueryLimit is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - tenantName string
//   - limitName string
func (_e *DataFederationApi_Expecter) DeleteOneDataFederationInstanceQueryLimit(ctx interface{}, groupId interface{}, tenantName interface{}, limitName interface{}) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimit_Call {
	return &DataFederationApi_DeleteOneDataFederationInstanceQueryLimit_Call{Call: _e.mock.On("DeleteOneDataFederationInstanceQueryLimit", ctx, groupId, tenantName, limitName)}
}

func (_c *DataFederationApi_DeleteOneDataFederationInstanceQueryLimit_Call) Run(run func(ctx context.Context, groupId string, tenantName string, limitName string)) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimit_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *DataFederationApi_DeleteOneDataFederationInstanceQueryLimit_Call) Return(_a0 admin.DeleteOneDataFederationInstanceQueryLimitApiRequest) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimit_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_DeleteOneDataFederationInstanceQueryLimit_Call) RunAndReturn(run func(context.Context, string, string, string) admin.DeleteOneDataFederationInstanceQueryLimitApiRequest) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimit_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteOneDataFederationInstanceQueryLimitExecute provides a mock function with given fields: r
func (_m *DataFederationApi) DeleteOneDataFederationInstanceQueryLimitExecute(r admin.DeleteOneDataFederationInstanceQueryLimitApiRequest) (map[string]interface{}, *http.Response, error) {
	ret := _m.Called(r)

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

	var r0 map[string]interface{}
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.DeleteOneDataFederationInstanceQueryLimitApiRequest) (map[string]interface{}, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.DeleteOneDataFederationInstanceQueryLimitApiRequest) map[string]interface{}); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]interface{})
		}
	}

	if rf, ok := ret.Get(1).(func(admin.DeleteOneDataFederationInstanceQueryLimitApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.DeleteOneDataFederationInstanceQueryLimitApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// DeleteOneDataFederationInstanceQueryLimitExecute is a helper method to define mock.On call
//   - r admin.DeleteOneDataFederationInstanceQueryLimitApiRequest
func (_e *DataFederationApi_Expecter) DeleteOneDataFederationInstanceQueryLimitExecute(r interface{}) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitExecute_Call {
	return &DataFederationApi_DeleteOneDataFederationInstanceQueryLimitExecute_Call{Call: _e.mock.On("DeleteOneDataFederationInstanceQueryLimitExecute", r)}
}

func (_c *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitExecute_Call) Run(run func(r admin.DeleteOneDataFederationInstanceQueryLimitApiRequest)) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.DeleteOneDataFederationInstanceQueryLimitApiRequest))
	})
	return _c
}

func (_c *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitExecute_Call) Return(_a0 map[string]interface{}, _a1 *http.Response, _a2 error) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitExecute_Call) RunAndReturn(run func(admin.DeleteOneDataFederationInstanceQueryLimitApiRequest) (map[string]interface{}, *http.Response, error)) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteOneDataFederationInstanceQueryLimitWithParams provides a mock function with given fields: ctx, args
func (_m *DataFederationApi) DeleteOneDataFederationInstanceQueryLimitWithParams(ctx context.Context, args *admin.DeleteOneDataFederationInstanceQueryLimitApiParams) admin.DeleteOneDataFederationInstanceQueryLimitApiRequest {
	ret := _m.Called(ctx, args)

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

	var r0 admin.DeleteOneDataFederationInstanceQueryLimitApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.DeleteOneDataFederationInstanceQueryLimitApiParams) admin.DeleteOneDataFederationInstanceQueryLimitApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.DeleteOneDataFederationInstanceQueryLimitApiRequest)
	}

	return r0
}

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

// DeleteOneDataFederationInstanceQueryLimitWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeleteOneDataFederationInstanceQueryLimitApiParams
func (_e *DataFederationApi_Expecter) DeleteOneDataFederationInstanceQueryLimitWithParams(ctx interface{}, args interface{}) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitWithParams_Call {
	return &DataFederationApi_DeleteOneDataFederationInstanceQueryLimitWithParams_Call{Call: _e.mock.On("DeleteOneDataFederationInstanceQueryLimitWithParams", ctx, args)}
}

func (_c *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitWithParams_Call) Run(run func(ctx context.Context, args *admin.DeleteOneDataFederationInstanceQueryLimitApiParams)) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.DeleteOneDataFederationInstanceQueryLimitApiParams))
	})
	return _c
}

func (_c *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitWithParams_Call) Return(_a0 admin.DeleteOneDataFederationInstanceQueryLimitApiRequest) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeleteOneDataFederationInstanceQueryLimitApiParams) admin.DeleteOneDataFederationInstanceQueryLimitApiRequest) *DataFederationApi_DeleteOneDataFederationInstanceQueryLimitWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// DownloadFederatedDatabaseQueryLogs provides a mock function with given fields: ctx, groupId, tenantName
func (_m *DataFederationApi) DownloadFederatedDatabaseQueryLogs(ctx context.Context, groupId string, tenantName string) admin.DownloadFederatedDatabaseQueryLogsApiRequest {
	ret := _m.Called(ctx, groupId, tenantName)

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

	var r0 admin.DownloadFederatedDatabaseQueryLogsApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.DownloadFederatedDatabaseQueryLogsApiRequest); ok {
		r0 = rf(ctx, groupId, tenantName)
	} else {
		r0 = ret.Get(0).(admin.DownloadFederatedDatabaseQueryLogsApiRequest)
	}

	return r0
}

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

// DownloadFederatedDatabaseQueryLogs is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - tenantName string
func (_e *DataFederationApi_Expecter) DownloadFederatedDatabaseQueryLogs(ctx interface{}, groupId interface{}, tenantName interface{}) *DataFederationApi_DownloadFederatedDatabaseQueryLogs_Call {
	return &DataFederationApi_DownloadFederatedDatabaseQueryLogs_Call{Call: _e.mock.On("DownloadFederatedDatabaseQueryLogs", ctx, groupId, tenantName)}
}

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

func (_c *DataFederationApi_DownloadFederatedDatabaseQueryLogs_Call) Return(_a0 admin.DownloadFederatedDatabaseQueryLogsApiRequest) *DataFederationApi_DownloadFederatedDatabaseQueryLogs_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_DownloadFederatedDatabaseQueryLogs_Call) RunAndReturn(run func(context.Context, string, string) admin.DownloadFederatedDatabaseQueryLogsApiRequest) *DataFederationApi_DownloadFederatedDatabaseQueryLogs_Call {
	_c.Call.Return(run)
	return _c
}

// DownloadFederatedDatabaseQueryLogsExecute provides a mock function with given fields: r
func (_m *DataFederationApi) DownloadFederatedDatabaseQueryLogsExecute(r admin.DownloadFederatedDatabaseQueryLogsApiRequest) (io.ReadCloser, *http.Response, error) {
	ret := _m.Called(r)

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

	var r0 io.ReadCloser
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.DownloadFederatedDatabaseQueryLogsApiRequest) (io.ReadCloser, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.DownloadFederatedDatabaseQueryLogsApiRequest) io.ReadCloser); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(io.ReadCloser)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.DownloadFederatedDatabaseQueryLogsApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.DownloadFederatedDatabaseQueryLogsApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// DownloadFederatedDatabaseQueryLogsExecute is a helper method to define mock.On call
//   - r admin.DownloadFederatedDatabaseQueryLogsApiRequest
func (_e *DataFederationApi_Expecter) DownloadFederatedDatabaseQueryLogsExecute(r interface{}) *DataFederationApi_DownloadFederatedDatabaseQueryLogsExecute_Call {
	return &DataFederationApi_DownloadFederatedDatabaseQueryLogsExecute_Call{Call: _e.mock.On("DownloadFederatedDatabaseQueryLogsExecute", r)}
}

func (_c *DataFederationApi_DownloadFederatedDatabaseQueryLogsExecute_Call) Run(run func(r admin.DownloadFederatedDatabaseQueryLogsApiRequest)) *DataFederationApi_DownloadFederatedDatabaseQueryLogsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.DownloadFederatedDatabaseQueryLogsApiRequest))
	})
	return _c
}

func (_c *DataFederationApi_DownloadFederatedDatabaseQueryLogsExecute_Call) Return(_a0 io.ReadCloser, _a1 *http.Response, _a2 error) *DataFederationApi_DownloadFederatedDatabaseQueryLogsExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *DataFederationApi_DownloadFederatedDatabaseQueryLogsExecute_Call) RunAndReturn(run func(admin.DownloadFederatedDatabaseQueryLogsApiRequest) (io.ReadCloser, *http.Response, error)) *DataFederationApi_DownloadFederatedDatabaseQueryLogsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// DownloadFederatedDatabaseQueryLogsWithParams provides a mock function with given fields: ctx, args
func (_m *DataFederationApi) DownloadFederatedDatabaseQueryLogsWithParams(ctx context.Context, args *admin.DownloadFederatedDatabaseQueryLogsApiParams) admin.DownloadFederatedDatabaseQueryLogsApiRequest {
	ret := _m.Called(ctx, args)

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

	var r0 admin.DownloadFederatedDatabaseQueryLogsApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.DownloadFederatedDatabaseQueryLogsApiParams) admin.DownloadFederatedDatabaseQueryLogsApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.DownloadFederatedDatabaseQueryLogsApiRequest)
	}

	return r0
}

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

// DownloadFederatedDatabaseQueryLogsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DownloadFederatedDatabaseQueryLogsApiParams
func (_e *DataFederationApi_Expecter) DownloadFederatedDatabaseQueryLogsWithParams(ctx interface{}, args interface{}) *DataFederationApi_DownloadFederatedDatabaseQueryLogsWithParams_Call {
	return &DataFederationApi_DownloadFederatedDatabaseQueryLogsWithParams_Call{Call: _e.mock.On("DownloadFederatedDatabaseQueryLogsWithParams", ctx, args)}
}

func (_c *DataFederationApi_DownloadFederatedDatabaseQueryLogsWithParams_Call) Run(run func(ctx context.Context, args *admin.DownloadFederatedDatabaseQueryLogsApiParams)) *DataFederationApi_DownloadFederatedDatabaseQueryLogsWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.DownloadFederatedDatabaseQueryLogsApiParams))
	})
	return _c
}

func (_c *DataFederationApi_DownloadFederatedDatabaseQueryLogsWithParams_Call) Return(_a0 admin.DownloadFederatedDatabaseQueryLogsApiRequest) *DataFederationApi_DownloadFederatedDatabaseQueryLogsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_DownloadFederatedDatabaseQueryLogsWithParams_Call) RunAndReturn(run func(context.Context, *admin.DownloadFederatedDatabaseQueryLogsApiParams) admin.DownloadFederatedDatabaseQueryLogsApiRequest) *DataFederationApi_DownloadFederatedDatabaseQueryLogsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetDataFederationPrivateEndpoint provides a mock function with given fields: ctx, groupId, endpointId
func (_m *DataFederationApi) GetDataFederationPrivateEndpoint(ctx context.Context, groupId string, endpointId string) admin.GetDataFederationPrivateEndpointApiRequest {
	ret := _m.Called(ctx, groupId, endpointId)

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

	var r0 admin.GetDataFederationPrivateEndpointApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetDataFederationPrivateEndpointApiRequest); ok {
		r0 = rf(ctx, groupId, endpointId)
	} else {
		r0 = ret.Get(0).(admin.GetDataFederationPrivateEndpointApiRequest)
	}

	return r0
}

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

// GetDataFederationPrivateEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - endpointId string
func (_e *DataFederationApi_Expecter) GetDataFederationPrivateEndpoint(ctx interface{}, groupId interface{}, endpointId interface{}) *DataFederationApi_GetDataFederationPrivateEndpoint_Call {
	return &DataFederationApi_GetDataFederationPrivateEndpoint_Call{Call: _e.mock.On("GetDataFederationPrivateEndpoint", ctx, groupId, endpointId)}
}

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

func (_c *DataFederationApi_GetDataFederationPrivateEndpoint_Call) Return(_a0 admin.GetDataFederationPrivateEndpointApiRequest) *DataFederationApi_GetDataFederationPrivateEndpoint_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_GetDataFederationPrivateEndpoint_Call) RunAndReturn(run func(context.Context, string, string) admin.GetDataFederationPrivateEndpointApiRequest) *DataFederationApi_GetDataFederationPrivateEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// GetDataFederationPrivateEndpointExecute provides a mock function with given fields: r
func (_m *DataFederationApi) GetDataFederationPrivateEndpointExecute(r admin.GetDataFederationPrivateEndpointApiRequest) (*admin.PrivateNetworkEndpointIdEntry, *http.Response, error) {
	ret := _m.Called(r)

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

	var r0 *admin.PrivateNetworkEndpointIdEntry
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.GetDataFederationPrivateEndpointApiRequest) (*admin.PrivateNetworkEndpointIdEntry, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.GetDataFederationPrivateEndpointApiRequest) *admin.PrivateNetworkEndpointIdEntry); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.PrivateNetworkEndpointIdEntry)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.GetDataFederationPrivateEndpointApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.GetDataFederationPrivateEndpointApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// GetDataFederationPrivateEndpointExecute is a helper method to define mock.On call
//   - r admin.GetDataFederationPrivateEndpointApiRequest
func (_e *DataFederationApi_Expecter) GetDataFederationPrivateEndpointExecute(r interface{}) *DataFederationApi_GetDataFederationPrivateEndpointExecute_Call {
	return &DataFederationApi_GetDataFederationPrivateEndpointExecute_Call{Call: _e.mock.On("GetDataFederationPrivateEndpointExecute", r)}
}

func (_c *DataFederationApi_GetDataFederationPrivateEndpointExecute_Call) Run(run func(r admin.GetDataFederationPrivateEndpointApiRequest)) *DataFederationApi_GetDataFederationPrivateEndpointExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.GetDataFederationPrivateEndpointApiRequest))
	})
	return _c
}

func (_c *DataFederationApi_GetDataFederationPrivateEndpointExecute_Call) Return(_a0 *admin.PrivateNetworkEndpointIdEntry, _a1 *http.Response, _a2 error) *DataFederationApi_GetDataFederationPrivateEndpointExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *DataFederationApi_GetDataFederationPrivateEndpointExecute_Call) RunAndReturn(run func(admin.GetDataFederationPrivateEndpointApiRequest) (*admin.PrivateNetworkEndpointIdEntry, *http.Response, error)) *DataFederationApi_GetDataFederationPrivateEndpointExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetDataFederationPrivateEndpointWithParams provides a mock function with given fields: ctx, args
func (_m *DataFederationApi) GetDataFederationPrivateEndpointWithParams(ctx context.Context, args *admin.GetDataFederationPrivateEndpointApiParams) admin.GetDataFederationPrivateEndpointApiRequest {
	ret := _m.Called(ctx, args)

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

	var r0 admin.GetDataFederationPrivateEndpointApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.GetDataFederationPrivateEndpointApiParams) admin.GetDataFederationPrivateEndpointApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.GetDataFederationPrivateEndpointApiRequest)
	}

	return r0
}

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

// GetDataFederationPrivateEndpointWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetDataFederationPrivateEndpointApiParams
func (_e *DataFederationApi_Expecter) GetDataFederationPrivateEndpointWithParams(ctx interface{}, args interface{}) *DataFederationApi_GetDataFederationPrivateEndpointWithParams_Call {
	return &DataFederationApi_GetDataFederationPrivateEndpointWithParams_Call{Call: _e.mock.On("GetDataFederationPrivateEndpointWithParams", ctx, args)}
}

func (_c *DataFederationApi_GetDataFederationPrivateEndpointWithParams_Call) Run(run func(ctx context.Context, args *admin.GetDataFederationPrivateEndpointApiParams)) *DataFederationApi_GetDataFederationPrivateEndpointWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.GetDataFederationPrivateEndpointApiParams))
	})
	return _c
}

func (_c *DataFederationApi_GetDataFederationPrivateEndpointWithParams_Call) Return(_a0 admin.GetDataFederationPrivateEndpointApiRequest) *DataFederationApi_GetDataFederationPrivateEndpointWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_GetDataFederationPrivateEndpointWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetDataFederationPrivateEndpointApiParams) admin.GetDataFederationPrivateEndpointApiRequest) *DataFederationApi_GetDataFederationPrivateEndpointWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetFederatedDatabase provides a mock function with given fields: ctx, groupId, tenantName
func (_m *DataFederationApi) GetFederatedDatabase(ctx context.Context, groupId string, tenantName string) admin.GetFederatedDatabaseApiRequest {
	ret := _m.Called(ctx, groupId, tenantName)

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

	var r0 admin.GetFederatedDatabaseApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.GetFederatedDatabaseApiRequest); ok {
		r0 = rf(ctx, groupId, tenantName)
	} else {
		r0 = ret.Get(0).(admin.GetFederatedDatabaseApiRequest)
	}

	return r0
}

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

// GetFederatedDatabase is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - tenantName string
func (_e *DataFederationApi_Expecter) GetFederatedDatabase(ctx interface{}, groupId interface{}, tenantName interface{}) *DataFederationApi_GetFederatedDatabase_Call {
	return &DataFederationApi_GetFederatedDatabase_Call{Call: _e.mock.On("GetFederatedDatabase", ctx, groupId, tenantName)}
}

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

func (_c *DataFederationApi_GetFederatedDatabase_Call) Return(_a0 admin.GetFederatedDatabaseApiRequest) *DataFederationApi_GetFederatedDatabase_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_GetFederatedDatabase_Call) RunAndReturn(run func(context.Context, string, string) admin.GetFederatedDatabaseApiRequest) *DataFederationApi_GetFederatedDatabase_Call {
	_c.Call.Return(run)
	return _c
}

// GetFederatedDatabaseExecute provides a mock function with given fields: r
func (_m *DataFederationApi) GetFederatedDatabaseExecute(r admin.GetFederatedDatabaseApiRequest) (*admin.DataLakeTenant, *http.Response, error) {
	ret := _m.Called(r)

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

	var r0 *admin.DataLakeTenant
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.GetFederatedDatabaseApiRequest) (*admin.DataLakeTenant, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.GetFederatedDatabaseApiRequest) *admin.DataLakeTenant); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.DataLakeTenant)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.GetFederatedDatabaseApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.GetFederatedDatabaseApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// GetFederatedDatabaseExecute is a helper method to define mock.On call
//   - r admin.GetFederatedDatabaseApiRequest
func (_e *DataFederationApi_Expecter) GetFederatedDatabaseExecute(r interface{}) *DataFederationApi_GetFederatedDatabaseExecute_Call {
	return &DataFederationApi_GetFederatedDatabaseExecute_Call{Call: _e.mock.On("GetFederatedDatabaseExecute", r)}
}

func (_c *DataFederationApi_GetFederatedDatabaseExecute_Call) Run(run func(r admin.GetFederatedDatabaseApiRequest)) *DataFederationApi_GetFederatedDatabaseExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.GetFederatedDatabaseApiRequest))
	})
	return _c
}

func (_c *DataFederationApi_GetFederatedDatabaseExecute_Call) Return(_a0 *admin.DataLakeTenant, _a1 *http.Response, _a2 error) *DataFederationApi_GetFederatedDatabaseExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *DataFederationApi_GetFederatedDatabaseExecute_Call) RunAndReturn(run func(admin.GetFederatedDatabaseApiRequest) (*admin.DataLakeTenant, *http.Response, error)) *DataFederationApi_GetFederatedDatabaseExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetFederatedDatabaseWithParams provides a mock function with given fields: ctx, args
func (_m *DataFederationApi) GetFederatedDatabaseWithParams(ctx context.Context, args *admin.GetFederatedDatabaseApiParams) admin.GetFederatedDatabaseApiRequest {
	ret := _m.Called(ctx, args)

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

	var r0 admin.GetFederatedDatabaseApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.GetFederatedDatabaseApiParams) admin.GetFederatedDatabaseApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.GetFederatedDatabaseApiRequest)
	}

	return r0
}

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

// GetFederatedDatabaseWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetFederatedDatabaseApiParams
func (_e *DataFederationApi_Expecter) GetFederatedDatabaseWithParams(ctx interface{}, args interface{}) *DataFederationApi_GetFederatedDatabaseWithParams_Call {
	return &DataFederationApi_GetFederatedDatabaseWithParams_Call{Call: _e.mock.On("GetFederatedDatabaseWithParams", ctx, args)}
}

func (_c *DataFederationApi_GetFederatedDatabaseWithParams_Call) Run(run func(ctx context.Context, args *admin.GetFederatedDatabaseApiParams)) *DataFederationApi_GetFederatedDatabaseWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.GetFederatedDatabaseApiParams))
	})
	return _c
}

func (_c *DataFederationApi_GetFederatedDatabaseWithParams_Call) Return(_a0 admin.GetFederatedDatabaseApiRequest) *DataFederationApi_GetFederatedDatabaseWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_GetFederatedDatabaseWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetFederatedDatabaseApiParams) admin.GetFederatedDatabaseApiRequest) *DataFederationApi_GetFederatedDatabaseWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ListDataFederationPrivateEndpoints provides a mock function with given fields: ctx, groupId
func (_m *DataFederationApi) ListDataFederationPrivateEndpoints(ctx context.Context, groupId string) admin.ListDataFederationPrivateEndpointsApiRequest {
	ret := _m.Called(ctx, groupId)

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

	var r0 admin.ListDataFederationPrivateEndpointsApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListDataFederationPrivateEndpointsApiRequest); ok {
		r0 = rf(ctx, groupId)
	} else {
		r0 = ret.Get(0).(admin.ListDataFederationPrivateEndpointsApiRequest)
	}

	return r0
}

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

// ListDataFederationPrivateEndpoints is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
func (_e *DataFederationApi_Expecter) ListDataFederationPrivateEndpoints(ctx interface{}, groupId interface{}) *DataFederationApi_ListDataFederationPrivateEndpoints_Call {
	return &DataFederationApi_ListDataFederationPrivateEndpoints_Call{Call: _e.mock.On("ListDataFederationPrivateEndpoints", ctx, groupId)}
}

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

func (_c *DataFederationApi_ListDataFederationPrivateEndpoints_Call) Return(_a0 admin.ListDataFederationPrivateEndpointsApiRequest) *DataFederationApi_ListDataFederationPrivateEndpoints_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_ListDataFederationPrivateEndpoints_Call) RunAndReturn(run func(context.Context, string) admin.ListDataFederationPrivateEndpointsApiRequest) *DataFederationApi_ListDataFederationPrivateEndpoints_Call {
	_c.Call.Return(run)
	return _c
}

// ListDataFederationPrivateEndpointsExecute provides a mock function with given fields: r
func (_m *DataFederationApi) ListDataFederationPrivateEndpointsExecute(r admin.ListDataFederationPrivateEndpointsApiRequest) (*admin.PaginatedPrivateNetworkEndpointIdEntry, *http.Response, error) {
	ret := _m.Called(r)

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

	var r0 *admin.PaginatedPrivateNetworkEndpointIdEntry
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.ListDataFederationPrivateEndpointsApiRequest) (*admin.PaginatedPrivateNetworkEndpointIdEntry, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.ListDataFederationPrivateEndpointsApiRequest) *admin.PaginatedPrivateNetworkEndpointIdEntry); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.PaginatedPrivateNetworkEndpointIdEntry)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.ListDataFederationPrivateEndpointsApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.ListDataFederationPrivateEndpointsApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// ListDataFederationPrivateEndpointsExecute is a helper method to define mock.On call
//   - r admin.ListDataFederationPrivateEndpointsApiRequest
func (_e *DataFederationApi_Expecter) ListDataFederationPrivateEndpointsExecute(r interface{}) *DataFederationApi_ListDataFederationPrivateEndpointsExecute_Call {
	return &DataFederationApi_ListDataFederationPrivateEndpointsExecute_Call{Call: _e.mock.On("ListDataFederationPrivateEndpointsExecute", r)}
}

func (_c *DataFederationApi_ListDataFederationPrivateEndpointsExecute_Call) Run(run func(r admin.ListDataFederationPrivateEndpointsApiRequest)) *DataFederationApi_ListDataFederationPrivateEndpointsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.ListDataFederationPrivateEndpointsApiRequest))
	})
	return _c
}

func (_c *DataFederationApi_ListDataFederationPrivateEndpointsExecute_Call) Return(_a0 *admin.PaginatedPrivateNetworkEndpointIdEntry, _a1 *http.Response, _a2 error) *DataFederationApi_ListDataFederationPrivateEndpointsExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *DataFederationApi_ListDataFederationPrivateEndpointsExecute_Call) RunAndReturn(run func(admin.ListDataFederationPrivateEndpointsApiRequest) (*admin.PaginatedPrivateNetworkEndpointIdEntry, *http.Response, error)) *DataFederationApi_ListDataFederationPrivateEndpointsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListDataFederationPrivateEndpointsWithParams provides a mock function with given fields: ctx, args
func (_m *DataFederationApi) ListDataFederationPrivateEndpointsWithParams(ctx context.Context, args *admin.ListDataFederationPrivateEndpointsApiParams) admin.ListDataFederationPrivateEndpointsApiRequest {
	ret := _m.Called(ctx, args)

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

	var r0 admin.ListDataFederationPrivateEndpointsApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ListDataFederationPrivateEndpointsApiParams) admin.ListDataFederationPrivateEndpointsApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.ListDataFederationPrivateEndpointsApiRequest)
	}

	return r0
}

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

// ListDataFederationPrivateEndpointsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListDataFederationPrivateEndpointsApiParams
func (_e *DataFederationApi_Expecter) ListDataFederationPrivateEndpointsWithParams(ctx interface{}, args interface{}) *DataFederationApi_ListDataFederationPrivateEndpointsWithParams_Call {
	return &DataFederationApi_ListDataFederationPrivateEndpointsWithParams_Call{Call: _e.mock.On("ListDataFederationPrivateEndpointsWithParams", ctx, args)}
}

func (_c *DataFederationApi_ListDataFederationPrivateEndpointsWithParams_Call) Run(run func(ctx context.Context, args *admin.ListDataFederationPrivateEndpointsApiParams)) *DataFederationApi_ListDataFederationPrivateEndpointsWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.ListDataFederationPrivateEndpointsApiParams))
	})
	return _c
}

func (_c *DataFederationApi_ListDataFederationPrivateEndpointsWithParams_Call) Return(_a0 admin.ListDataFederationPrivateEndpointsApiRequest) *DataFederationApi_ListDataFederationPrivateEndpointsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_ListDataFederationPrivateEndpointsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListDataFederationPrivateEndpointsApiParams) admin.ListDataFederationPrivateEndpointsApiRequest) *DataFederationApi_ListDataFederationPrivateEndpointsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ListFederatedDatabases provides a mock function with given fields: ctx, groupId
func (_m *DataFederationApi) ListFederatedDatabases(ctx context.Context, groupId string) admin.ListFederatedDatabasesApiRequest {
	ret := _m.Called(ctx, groupId)

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

	var r0 admin.ListFederatedDatabasesApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string) admin.ListFederatedDatabasesApiRequest); ok {
		r0 = rf(ctx, groupId)
	} else {
		r0 = ret.Get(0).(admin.ListFederatedDatabasesApiRequest)
	}

	return r0
}

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

// ListFederatedDatabases is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
func (_e *DataFederationApi_Expecter) ListFederatedDatabases(ctx interface{}, groupId interface{}) *DataFederationApi_ListFederatedDatabases_Call {
	return &DataFederationApi_ListFederatedDatabases_Call{Call: _e.mock.On("ListFederatedDatabases", ctx, groupId)}
}

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

func (_c *DataFederationApi_ListFederatedDatabases_Call) Return(_a0 admin.ListFederatedDatabasesApiRequest) *DataFederationApi_ListFederatedDatabases_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_ListFederatedDatabases_Call) RunAndReturn(run func(context.Context, string) admin.ListFederatedDatabasesApiRequest) *DataFederationApi_ListFederatedDatabases_Call {
	_c.Call.Return(run)
	return _c
}

// ListFederatedDatabasesExecute provides a mock function with given fields: r
func (_m *DataFederationApi) ListFederatedDatabasesExecute(r admin.ListFederatedDatabasesApiRequest) ([]admin.DataLakeTenant, *http.Response, error) {
	ret := _m.Called(r)

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

	var r0 []admin.DataLakeTenant
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.ListFederatedDatabasesApiRequest) ([]admin.DataLakeTenant, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.ListFederatedDatabasesApiRequest) []admin.DataLakeTenant); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]admin.DataLakeTenant)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.ListFederatedDatabasesApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.ListFederatedDatabasesApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// ListFederatedDatabasesExecute is a helper method to define mock.On call
//   - r admin.ListFederatedDatabasesApiRequest
func (_e *DataFederationApi_Expecter) ListFederatedDatabasesExecute(r interface{}) *DataFederationApi_ListFederatedDatabasesExecute_Call {
	return &DataFederationApi_ListFederatedDatabasesExecute_Call{Call: _e.mock.On("ListFederatedDatabasesExecute", r)}
}

func (_c *DataFederationApi_ListFederatedDatabasesExecute_Call) Run(run func(r admin.ListFederatedDatabasesApiRequest)) *DataFederationApi_ListFederatedDatabasesExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.ListFederatedDatabasesApiRequest))
	})
	return _c
}

func (_c *DataFederationApi_ListFederatedDatabasesExecute_Call) Return(_a0 []admin.DataLakeTenant, _a1 *http.Response, _a2 error) *DataFederationApi_ListFederatedDatabasesExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *DataFederationApi_ListFederatedDatabasesExecute_Call) RunAndReturn(run func(admin.ListFederatedDatabasesApiRequest) ([]admin.DataLakeTenant, *http.Response, error)) *DataFederationApi_ListFederatedDatabasesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListFederatedDatabasesWithParams provides a mock function with given fields: ctx, args
func (_m *DataFederationApi) ListFederatedDatabasesWithParams(ctx context.Context, args *admin.ListFederatedDatabasesApiParams) admin.ListFederatedDatabasesApiRequest {
	ret := _m.Called(ctx, args)

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

	var r0 admin.ListFederatedDatabasesApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ListFederatedDatabasesApiParams) admin.ListFederatedDatabasesApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.ListFederatedDatabasesApiRequest)
	}

	return r0
}

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

// ListFederatedDatabasesWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListFederatedDatabasesApiParams
func (_e *DataFederationApi_Expecter) ListFederatedDatabasesWithParams(ctx interface{}, args interface{}) *DataFederationApi_ListFederatedDatabasesWithParams_Call {
	return &DataFederationApi_ListFederatedDatabasesWithParams_Call{Call: _e.mock.On("ListFederatedDatabasesWithParams", ctx, args)}
}

func (_c *DataFederationApi_ListFederatedDatabasesWithParams_Call) Run(run func(ctx context.Context, args *admin.ListFederatedDatabasesApiParams)) *DataFederationApi_ListFederatedDatabasesWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.ListFederatedDatabasesApiParams))
	})
	return _c
}

func (_c *DataFederationApi_ListFederatedDatabasesWithParams_Call) Return(_a0 admin.ListFederatedDatabasesApiRequest) *DataFederationApi_ListFederatedDatabasesWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_ListFederatedDatabasesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListFederatedDatabasesApiParams) admin.ListFederatedDatabasesApiRequest) *DataFederationApi_ListFederatedDatabasesWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ReturnFederatedDatabaseQueryLimit provides a mock function with given fields: ctx, groupId, tenantName, limitName
func (_m *DataFederationApi) ReturnFederatedDatabaseQueryLimit(ctx context.Context, groupId string, tenantName string, limitName string) admin.ReturnFederatedDatabaseQueryLimitApiRequest {
	ret := _m.Called(ctx, groupId, tenantName, limitName)

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

	var r0 admin.ReturnFederatedDatabaseQueryLimitApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) admin.ReturnFederatedDatabaseQueryLimitApiRequest); ok {
		r0 = rf(ctx, groupId, tenantName, limitName)
	} else {
		r0 = ret.Get(0).(admin.ReturnFederatedDatabaseQueryLimitApiRequest)
	}

	return r0
}

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

// ReturnFederatedDatabaseQueryLimit is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - tenantName string
//   - limitName string
func (_e *DataFederationApi_Expecter) ReturnFederatedDatabaseQueryLimit(ctx interface{}, groupId interface{}, tenantName interface{}, limitName interface{}) *DataFederationApi_ReturnFederatedDatabaseQueryLimit_Call {
	return &DataFederationApi_ReturnFederatedDatabaseQueryLimit_Call{Call: _e.mock.On("ReturnFederatedDatabaseQueryLimit", ctx, groupId, tenantName, limitName)}
}

func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimit_Call) Run(run func(ctx context.Context, groupId string, tenantName string, limitName string)) *DataFederationApi_ReturnFederatedDatabaseQueryLimit_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimit_Call) Return(_a0 admin.ReturnFederatedDatabaseQueryLimitApiRequest) *DataFederationApi_ReturnFederatedDatabaseQueryLimit_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimit_Call) RunAndReturn(run func(context.Context, string, string, string) admin.ReturnFederatedDatabaseQueryLimitApiRequest) *DataFederationApi_ReturnFederatedDatabaseQueryLimit_Call {
	_c.Call.Return(run)
	return _c
}

// ReturnFederatedDatabaseQueryLimitExecute provides a mock function with given fields: r
func (_m *DataFederationApi) ReturnFederatedDatabaseQueryLimitExecute(r admin.ReturnFederatedDatabaseQueryLimitApiRequest) (*admin.DataFederationTenantQueryLimit, *http.Response, error) {
	ret := _m.Called(r)

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

	var r0 *admin.DataFederationTenantQueryLimit
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.ReturnFederatedDatabaseQueryLimitApiRequest) (*admin.DataFederationTenantQueryLimit, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.ReturnFederatedDatabaseQueryLimitApiRequest) *admin.DataFederationTenantQueryLimit); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.DataFederationTenantQueryLimit)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.ReturnFederatedDatabaseQueryLimitApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.ReturnFederatedDatabaseQueryLimitApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// ReturnFederatedDatabaseQueryLimitExecute is a helper method to define mock.On call
//   - r admin.ReturnFederatedDatabaseQueryLimitApiRequest
func (_e *DataFederationApi_Expecter) ReturnFederatedDatabaseQueryLimitExecute(r interface{}) *DataFederationApi_ReturnFederatedDatabaseQueryLimitExecute_Call {
	return &DataFederationApi_ReturnFederatedDatabaseQueryLimitExecute_Call{Call: _e.mock.On("ReturnFederatedDatabaseQueryLimitExecute", r)}
}

func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitExecute_Call) Run(run func(r admin.ReturnFederatedDatabaseQueryLimitApiRequest)) *DataFederationApi_ReturnFederatedDatabaseQueryLimitExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.ReturnFederatedDatabaseQueryLimitApiRequest))
	})
	return _c
}

func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitExecute_Call) Return(_a0 *admin.DataFederationTenantQueryLimit, _a1 *http.Response, _a2 error) *DataFederationApi_ReturnFederatedDatabaseQueryLimitExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitExecute_Call) RunAndReturn(run func(admin.ReturnFederatedDatabaseQueryLimitApiRequest) (*admin.DataFederationTenantQueryLimit, *http.Response, error)) *DataFederationApi_ReturnFederatedDatabaseQueryLimitExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ReturnFederatedDatabaseQueryLimitWithParams provides a mock function with given fields: ctx, args
func (_m *DataFederationApi) ReturnFederatedDatabaseQueryLimitWithParams(ctx context.Context, args *admin.ReturnFederatedDatabaseQueryLimitApiParams) admin.ReturnFederatedDatabaseQueryLimitApiRequest {
	ret := _m.Called(ctx, args)

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

	var r0 admin.ReturnFederatedDatabaseQueryLimitApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ReturnFederatedDatabaseQueryLimitApiParams) admin.ReturnFederatedDatabaseQueryLimitApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.ReturnFederatedDatabaseQueryLimitApiRequest)
	}

	return r0
}

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

// ReturnFederatedDatabaseQueryLimitWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ReturnFederatedDatabaseQueryLimitApiParams
func (_e *DataFederationApi_Expecter) ReturnFederatedDatabaseQueryLimitWithParams(ctx interface{}, args interface{}) *DataFederationApi_ReturnFederatedDatabaseQueryLimitWithParams_Call {
	return &DataFederationApi_ReturnFederatedDatabaseQueryLimitWithParams_Call{Call: _e.mock.On("ReturnFederatedDatabaseQueryLimitWithParams", ctx, args)}
}

func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitWithParams_Call) Run(run func(ctx context.Context, args *admin.ReturnFederatedDatabaseQueryLimitApiParams)) *DataFederationApi_ReturnFederatedDatabaseQueryLimitWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.ReturnFederatedDatabaseQueryLimitApiParams))
	})
	return _c
}

func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitWithParams_Call) Return(_a0 admin.ReturnFederatedDatabaseQueryLimitApiRequest) *DataFederationApi_ReturnFederatedDatabaseQueryLimitWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitWithParams_Call) RunAndReturn(run func(context.Context, *admin.ReturnFederatedDatabaseQueryLimitApiParams) admin.ReturnFederatedDatabaseQueryLimitApiRequest) *DataFederationApi_ReturnFederatedDatabaseQueryLimitWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ReturnFederatedDatabaseQueryLimits provides a mock function with given fields: ctx, groupId, tenantName
func (_m *DataFederationApi) ReturnFederatedDatabaseQueryLimits(ctx context.Context, groupId string, tenantName string) admin.ReturnFederatedDatabaseQueryLimitsApiRequest {
	ret := _m.Called(ctx, groupId, tenantName)

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

	var r0 admin.ReturnFederatedDatabaseQueryLimitsApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string) admin.ReturnFederatedDatabaseQueryLimitsApiRequest); ok {
		r0 = rf(ctx, groupId, tenantName)
	} else {
		r0 = ret.Get(0).(admin.ReturnFederatedDatabaseQueryLimitsApiRequest)
	}

	return r0
}

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

// ReturnFederatedDatabaseQueryLimits is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - tenantName string
func (_e *DataFederationApi_Expecter) ReturnFederatedDatabaseQueryLimits(ctx interface{}, groupId interface{}, tenantName interface{}) *DataFederationApi_ReturnFederatedDatabaseQueryLimits_Call {
	return &DataFederationApi_ReturnFederatedDatabaseQueryLimits_Call{Call: _e.mock.On("ReturnFederatedDatabaseQueryLimits", ctx, groupId, tenantName)}
}

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

func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimits_Call) Return(_a0 admin.ReturnFederatedDatabaseQueryLimitsApiRequest) *DataFederationApi_ReturnFederatedDatabaseQueryLimits_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimits_Call) RunAndReturn(run func(context.Context, string, string) admin.ReturnFederatedDatabaseQueryLimitsApiRequest) *DataFederationApi_ReturnFederatedDatabaseQueryLimits_Call {
	_c.Call.Return(run)
	return _c
}

// ReturnFederatedDatabaseQueryLimitsExecute provides a mock function with given fields: r
func (_m *DataFederationApi) ReturnFederatedDatabaseQueryLimitsExecute(r admin.ReturnFederatedDatabaseQueryLimitsApiRequest) ([]admin.DataFederationTenantQueryLimit, *http.Response, error) {
	ret := _m.Called(r)

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

	var r0 []admin.DataFederationTenantQueryLimit
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.ReturnFederatedDatabaseQueryLimitsApiRequest) ([]admin.DataFederationTenantQueryLimit, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.ReturnFederatedDatabaseQueryLimitsApiRequest) []admin.DataFederationTenantQueryLimit); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]admin.DataFederationTenantQueryLimit)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.ReturnFederatedDatabaseQueryLimitsApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.ReturnFederatedDatabaseQueryLimitsApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// ReturnFederatedDatabaseQueryLimitsExecute is a helper method to define mock.On call
//   - r admin.ReturnFederatedDatabaseQueryLimitsApiRequest
func (_e *DataFederationApi_Expecter) ReturnFederatedDatabaseQueryLimitsExecute(r interface{}) *DataFederationApi_ReturnFederatedDatabaseQueryLimitsExecute_Call {
	return &DataFederationApi_ReturnFederatedDatabaseQueryLimitsExecute_Call{Call: _e.mock.On("ReturnFederatedDatabaseQueryLimitsExecute", r)}
}

func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitsExecute_Call) Run(run func(r admin.ReturnFederatedDatabaseQueryLimitsApiRequest)) *DataFederationApi_ReturnFederatedDatabaseQueryLimitsExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.ReturnFederatedDatabaseQueryLimitsApiRequest))
	})
	return _c
}

func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitsExecute_Call) Return(_a0 []admin.DataFederationTenantQueryLimit, _a1 *http.Response, _a2 error) *DataFederationApi_ReturnFederatedDatabaseQueryLimitsExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitsExecute_Call) RunAndReturn(run func(admin.ReturnFederatedDatabaseQueryLimitsApiRequest) ([]admin.DataFederationTenantQueryLimit, *http.Response, error)) *DataFederationApi_ReturnFederatedDatabaseQueryLimitsExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ReturnFederatedDatabaseQueryLimitsWithParams provides a mock function with given fields: ctx, args
func (_m *DataFederationApi) ReturnFederatedDatabaseQueryLimitsWithParams(ctx context.Context, args *admin.ReturnFederatedDatabaseQueryLimitsApiParams) admin.ReturnFederatedDatabaseQueryLimitsApiRequest {
	ret := _m.Called(ctx, args)

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

	var r0 admin.ReturnFederatedDatabaseQueryLimitsApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ReturnFederatedDatabaseQueryLimitsApiParams) admin.ReturnFederatedDatabaseQueryLimitsApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.ReturnFederatedDatabaseQueryLimitsApiRequest)
	}

	return r0
}

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

// ReturnFederatedDatabaseQueryLimitsWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ReturnFederatedDatabaseQueryLimitsApiParams
func (_e *DataFederationApi_Expecter) ReturnFederatedDatabaseQueryLimitsWithParams(ctx interface{}, args interface{}) *DataFederationApi_ReturnFederatedDatabaseQueryLimitsWithParams_Call {
	return &DataFederationApi_ReturnFederatedDatabaseQueryLimitsWithParams_Call{Call: _e.mock.On("ReturnFederatedDatabaseQueryLimitsWithParams", ctx, args)}
}

func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitsWithParams_Call) Run(run func(ctx context.Context, args *admin.ReturnFederatedDatabaseQueryLimitsApiParams)) *DataFederationApi_ReturnFederatedDatabaseQueryLimitsWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.ReturnFederatedDatabaseQueryLimitsApiParams))
	})
	return _c
}

func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitsWithParams_Call) Return(_a0 admin.ReturnFederatedDatabaseQueryLimitsApiRequest) *DataFederationApi_ReturnFederatedDatabaseQueryLimitsWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_ReturnFederatedDatabaseQueryLimitsWithParams_Call) RunAndReturn(run func(context.Context, *admin.ReturnFederatedDatabaseQueryLimitsApiParams) admin.ReturnFederatedDatabaseQueryLimitsApiRequest) *DataFederationApi_ReturnFederatedDatabaseQueryLimitsWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateFederatedDatabase provides a mock function with given fields: ctx, groupId, tenantName, dataLakeTenant
func (_m *DataFederationApi) UpdateFederatedDatabase(ctx context.Context, groupId string, tenantName string, dataLakeTenant *admin.DataLakeTenant) admin.UpdateFederatedDatabaseApiRequest {
	ret := _m.Called(ctx, groupId, tenantName, dataLakeTenant)

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

	var r0 admin.UpdateFederatedDatabaseApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string, *admin.DataLakeTenant) admin.UpdateFederatedDatabaseApiRequest); ok {
		r0 = rf(ctx, groupId, tenantName, dataLakeTenant)
	} else {
		r0 = ret.Get(0).(admin.UpdateFederatedDatabaseApiRequest)
	}

	return r0
}

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

// UpdateFederatedDatabase is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - tenantName string
//   - dataLakeTenant *admin.DataLakeTenant
func (_e *DataFederationApi_Expecter) UpdateFederatedDatabase(ctx interface{}, groupId interface{}, tenantName interface{}, dataLakeTenant interface{}) *DataFederationApi_UpdateFederatedDatabase_Call {
	return &DataFederationApi_UpdateFederatedDatabase_Call{Call: _e.mock.On("UpdateFederatedDatabase", ctx, groupId, tenantName, dataLakeTenant)}
}

func (_c *DataFederationApi_UpdateFederatedDatabase_Call) Run(run func(ctx context.Context, groupId string, tenantName string, dataLakeTenant *admin.DataLakeTenant)) *DataFederationApi_UpdateFederatedDatabase_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*admin.DataLakeTenant))
	})
	return _c
}

func (_c *DataFederationApi_UpdateFederatedDatabase_Call) Return(_a0 admin.UpdateFederatedDatabaseApiRequest) *DataFederationApi_UpdateFederatedDatabase_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_UpdateFederatedDatabase_Call) RunAndReturn(run func(context.Context, string, string, *admin.DataLakeTenant) admin.UpdateFederatedDatabaseApiRequest) *DataFederationApi_UpdateFederatedDatabase_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateFederatedDatabaseExecute provides a mock function with given fields: r
func (_m *DataFederationApi) UpdateFederatedDatabaseExecute(r admin.UpdateFederatedDatabaseApiRequest) (*admin.DataLakeTenant, *http.Response, error) {
	ret := _m.Called(r)

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

	var r0 *admin.DataLakeTenant
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.UpdateFederatedDatabaseApiRequest) (*admin.DataLakeTenant, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.UpdateFederatedDatabaseApiRequest) *admin.DataLakeTenant); ok {
		r0 = rf(r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.DataLakeTenant)
		}
	}

	if rf, ok := ret.Get(1).(func(admin.UpdateFederatedDatabaseApiRequest) *http.Response); ok {
		r1 = rf(r)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*http.Response)
		}
	}

	if rf, ok := ret.Get(2).(func(admin.UpdateFederatedDatabaseApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// UpdateFederatedDatabaseExecute is a helper method to define mock.On call
//   - r admin.UpdateFederatedDatabaseApiRequest
func (_e *DataFederationApi_Expecter) UpdateFederatedDatabaseExecute(r interface{}) *DataFederationApi_UpdateFederatedDatabaseExecute_Call {
	return &DataFederationApi_UpdateFederatedDatabaseExecute_Call{Call: _e.mock.On("UpdateFederatedDatabaseExecute", r)}
}

func (_c *DataFederationApi_UpdateFederatedDatabaseExecute_Call) Run(run func(r admin.UpdateFederatedDatabaseApiRequest)) *DataFederationApi_UpdateFederatedDatabaseExecute_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(admin.UpdateFederatedDatabaseApiRequest))
	})
	return _c
}

func (_c *DataFederationApi_UpdateFederatedDatabaseExecute_Call) Return(_a0 *admin.DataLakeTenant, _a1 *http.Response, _a2 error) *DataFederationApi_UpdateFederatedDatabaseExecute_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *DataFederationApi_UpdateFederatedDatabaseExecute_Call) RunAndReturn(run func(admin.UpdateFederatedDatabaseApiRequest) (*admin.DataLakeTenant, *http.Response, error)) *DataFederationApi_UpdateFederatedDatabaseExecute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateFederatedDatabaseWithParams provides a mock function with given fields: ctx, args
func (_m *DataFederationApi) UpdateFederatedDatabaseWithParams(ctx context.Context, args *admin.UpdateFederatedDatabaseApiParams) admin.UpdateFederatedDatabaseApiRequest {
	ret := _m.Called(ctx, args)

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

	var r0 admin.UpdateFederatedDatabaseApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, *admin.UpdateFederatedDatabaseApiParams) admin.UpdateFederatedDatabaseApiRequest); ok {
		r0 = rf(ctx, args)
	} else {
		r0 = ret.Get(0).(admin.UpdateFederatedDatabaseApiRequest)
	}

	return r0
}

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

// UpdateFederatedDatabaseWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.UpdateFederatedDatabaseApiParams
func (_e *DataFederationApi_Expecter) UpdateFederatedDatabaseWithParams(ctx interface{}, args interface{}) *DataFederationApi_UpdateFederatedDatabaseWithParams_Call {
	return &DataFederationApi_UpdateFederatedDatabaseWithParams_Call{Call: _e.mock.On("UpdateFederatedDatabaseWithParams", ctx, args)}
}

func (_c *DataFederationApi_UpdateFederatedDatabaseWithParams_Call) Run(run func(ctx context.Context, args *admin.UpdateFederatedDatabaseApiParams)) *DataFederationApi_UpdateFederatedDatabaseWithParams_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*admin.UpdateFederatedDatabaseApiParams))
	})
	return _c
}

func (_c *DataFederationApi_UpdateFederatedDatabaseWithParams_Call) Return(_a0 admin.UpdateFederatedDatabaseApiRequest) *DataFederationApi_UpdateFederatedDatabaseWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DataFederationApi_UpdateFederatedDatabaseWithParams_Call) RunAndReturn(run func(context.Context, *admin.UpdateFederatedDatabaseApiParams) admin.UpdateFederatedDatabaseApiRequest) *DataFederationApi_UpdateFederatedDatabaseWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// NewDataFederationApi creates a new instance of DataFederationApi. 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 NewDataFederationApi(t interface {
	mock.TestingT
	Cleanup(func())
}) *DataFederationApi {
	mock := &DataFederationApi{}
	mock.Mock.Test(t)

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

	return mock
}