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

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

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

type PrivateEndpointServicesApi_Expecter struct {
	mock *mock.Mock
}

func (_m *PrivateEndpointServicesApi) EXPECT() *PrivateEndpointServicesApi_Expecter {
	return &PrivateEndpointServicesApi_Expecter{mock: &_m.Mock}
}

// CreatePrivateEndpoint provides a mock function with given fields: ctx, groupId, cloudProvider, endpointServiceId, createEndpointRequest
func (_m *PrivateEndpointServicesApi) CreatePrivateEndpoint(ctx context.Context, groupId string, cloudProvider string, endpointServiceId string, createEndpointRequest *admin.CreateEndpointRequest) admin.CreatePrivateEndpointApiRequest {
	ret := _m.Called(ctx, groupId, cloudProvider, endpointServiceId, createEndpointRequest)

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

	var r0 admin.CreatePrivateEndpointApiRequest
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *admin.CreateEndpointRequest) admin.CreatePrivateEndpointApiRequest); ok {
		r0 = rf(ctx, groupId, cloudProvider, endpointServiceId, createEndpointRequest)
	} else {
		r0 = ret.Get(0).(admin.CreatePrivateEndpointApiRequest)
	}

	return r0
}

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

// CreatePrivateEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - cloudProvider string
//   - endpointServiceId string
//   - createEndpointRequest *admin.CreateEndpointRequest
func (_e *PrivateEndpointServicesApi_Expecter) CreatePrivateEndpoint(ctx interface{}, groupId interface{}, cloudProvider interface{}, endpointServiceId interface{}, createEndpointRequest interface{}) *PrivateEndpointServicesApi_CreatePrivateEndpoint_Call {
	return &PrivateEndpointServicesApi_CreatePrivateEndpoint_Call{Call: _e.mock.On("CreatePrivateEndpoint", ctx, groupId, cloudProvider, endpointServiceId, createEndpointRequest)}
}

func (_c *PrivateEndpointServicesApi_CreatePrivateEndpoint_Call) Run(run func(ctx context.Context, groupId string, cloudProvider string, endpointServiceId string, createEndpointRequest *admin.CreateEndpointRequest)) *PrivateEndpointServicesApi_CreatePrivateEndpoint_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.CreateEndpointRequest))
	})
	return _c
}

func (_c *PrivateEndpointServicesApi_CreatePrivateEndpoint_Call) Return(_a0 admin.CreatePrivateEndpointApiRequest) *PrivateEndpointServicesApi_CreatePrivateEndpoint_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PrivateEndpointServicesApi_CreatePrivateEndpoint_Call) RunAndReturn(run func(context.Context, string, string, string, *admin.CreateEndpointRequest) admin.CreatePrivateEndpointApiRequest) *PrivateEndpointServicesApi_CreatePrivateEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePrivateEndpointExecute provides a mock function with given fields: r
func (_m *PrivateEndpointServicesApi) CreatePrivateEndpointExecute(r admin.CreatePrivateEndpointApiRequest) (*admin.PrivateLinkEndpoint, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.CreatePrivateEndpointApiRequest) *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.CreatePrivateEndpointApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// CreatePrivateEndpointExecute is a helper method to define mock.On call
//   - r admin.CreatePrivateEndpointApiRequest
func (_e *PrivateEndpointServicesApi_Expecter) CreatePrivateEndpointExecute(r interface{}) *PrivateEndpointServicesApi_CreatePrivateEndpointExecute_Call {
	return &PrivateEndpointServicesApi_CreatePrivateEndpointExecute_Call{Call: _e.mock.On("CreatePrivateEndpointExecute", r)}
}

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

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

func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointExecute_Call) RunAndReturn(run func(admin.CreatePrivateEndpointApiRequest) (*admin.PrivateLinkEndpoint, *http.Response, error)) *PrivateEndpointServicesApi_CreatePrivateEndpointExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePrivateEndpointService provides a mock function with given fields: ctx, groupId, cloudProviderEndpointServiceRequest
func (_m *PrivateEndpointServicesApi) CreatePrivateEndpointService(ctx context.Context, groupId string, cloudProviderEndpointServiceRequest *admin.CloudProviderEndpointServiceRequest) admin.CreatePrivateEndpointServiceApiRequest {
	ret := _m.Called(ctx, groupId, cloudProviderEndpointServiceRequest)

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

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

	return r0
}

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

// CreatePrivateEndpointService is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - cloudProviderEndpointServiceRequest *admin.CloudProviderEndpointServiceRequest
func (_e *PrivateEndpointServicesApi_Expecter) CreatePrivateEndpointService(ctx interface{}, groupId interface{}, cloudProviderEndpointServiceRequest interface{}) *PrivateEndpointServicesApi_CreatePrivateEndpointService_Call {
	return &PrivateEndpointServicesApi_CreatePrivateEndpointService_Call{Call: _e.mock.On("CreatePrivateEndpointService", ctx, groupId, cloudProviderEndpointServiceRequest)}
}

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

func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointService_Call) Return(_a0 admin.CreatePrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_CreatePrivateEndpointService_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointService_Call) RunAndReturn(run func(context.Context, string, *admin.CloudProviderEndpointServiceRequest) admin.CreatePrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_CreatePrivateEndpointService_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePrivateEndpointServiceExecute provides a mock function with given fields: r
func (_m *PrivateEndpointServicesApi) CreatePrivateEndpointServiceExecute(r admin.CreatePrivateEndpointServiceApiRequest) (*admin.EndpointService, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.CreatePrivateEndpointServiceApiRequest) *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.CreatePrivateEndpointServiceApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// CreatePrivateEndpointServiceExecute is a helper method to define mock.On call
//   - r admin.CreatePrivateEndpointServiceApiRequest
func (_e *PrivateEndpointServicesApi_Expecter) CreatePrivateEndpointServiceExecute(r interface{}) *PrivateEndpointServicesApi_CreatePrivateEndpointServiceExecute_Call {
	return &PrivateEndpointServicesApi_CreatePrivateEndpointServiceExecute_Call{Call: _e.mock.On("CreatePrivateEndpointServiceExecute", r)}
}

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

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

func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointServiceExecute_Call) RunAndReturn(run func(admin.CreatePrivateEndpointServiceApiRequest) (*admin.EndpointService, *http.Response, error)) *PrivateEndpointServicesApi_CreatePrivateEndpointServiceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePrivateEndpointServiceWithParams provides a mock function with given fields: ctx, args
func (_m *PrivateEndpointServicesApi) CreatePrivateEndpointServiceWithParams(ctx context.Context, args *admin.CreatePrivateEndpointServiceApiParams) admin.CreatePrivateEndpointServiceApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// CreatePrivateEndpointServiceWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreatePrivateEndpointServiceApiParams
func (_e *PrivateEndpointServicesApi_Expecter) CreatePrivateEndpointServiceWithParams(ctx interface{}, args interface{}) *PrivateEndpointServicesApi_CreatePrivateEndpointServiceWithParams_Call {
	return &PrivateEndpointServicesApi_CreatePrivateEndpointServiceWithParams_Call{Call: _e.mock.On("CreatePrivateEndpointServiceWithParams", ctx, args)}
}

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

func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointServiceWithParams_Call) Return(_a0 admin.CreatePrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_CreatePrivateEndpointServiceWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointServiceWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreatePrivateEndpointServiceApiParams) admin.CreatePrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_CreatePrivateEndpointServiceWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePrivateEndpointWithParams provides a mock function with given fields: ctx, args
func (_m *PrivateEndpointServicesApi) CreatePrivateEndpointWithParams(ctx context.Context, args *admin.CreatePrivateEndpointApiParams) admin.CreatePrivateEndpointApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// CreatePrivateEndpointWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.CreatePrivateEndpointApiParams
func (_e *PrivateEndpointServicesApi_Expecter) CreatePrivateEndpointWithParams(ctx interface{}, args interface{}) *PrivateEndpointServicesApi_CreatePrivateEndpointWithParams_Call {
	return &PrivateEndpointServicesApi_CreatePrivateEndpointWithParams_Call{Call: _e.mock.On("CreatePrivateEndpointWithParams", ctx, args)}
}

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

func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointWithParams_Call) Return(_a0 admin.CreatePrivateEndpointApiRequest) *PrivateEndpointServicesApi_CreatePrivateEndpointWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PrivateEndpointServicesApi_CreatePrivateEndpointWithParams_Call) RunAndReturn(run func(context.Context, *admin.CreatePrivateEndpointApiParams) admin.CreatePrivateEndpointApiRequest) *PrivateEndpointServicesApi_CreatePrivateEndpointWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// DeletePrivateEndpoint provides a mock function with given fields: ctx, groupId, cloudProvider, endpointId, endpointServiceId
func (_m *PrivateEndpointServicesApi) DeletePrivateEndpoint(ctx context.Context, groupId string, cloudProvider string, endpointId string, endpointServiceId string) admin.DeletePrivateEndpointApiRequest {
	ret := _m.Called(ctx, groupId, cloudProvider, endpointId, endpointServiceId)

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

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

	return r0
}

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

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

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

func (_c *PrivateEndpointServicesApi_DeletePrivateEndpoint_Call) Return(_a0 admin.DeletePrivateEndpointApiRequest) *PrivateEndpointServicesApi_DeletePrivateEndpoint_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

	var r0 map[string]interface{}
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.DeletePrivateEndpointApiRequest) (map[string]interface{}, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.DeletePrivateEndpointApiRequest) 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.DeletePrivateEndpointApiRequest) *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.DeletePrivateEndpointApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// DeletePrivateEndpointExecute is a helper method to define mock.On call
//   - r admin.DeletePrivateEndpointApiRequest
func (_e *PrivateEndpointServicesApi_Expecter) DeletePrivateEndpointExecute(r interface{}) *PrivateEndpointServicesApi_DeletePrivateEndpointExecute_Call {
	return &PrivateEndpointServicesApi_DeletePrivateEndpointExecute_Call{Call: _e.mock.On("DeletePrivateEndpointExecute", r)}
}

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

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

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

// DeletePrivateEndpointService provides a mock function with given fields: ctx, groupId, cloudProvider, endpointServiceId
func (_m *PrivateEndpointServicesApi) DeletePrivateEndpointService(ctx context.Context, groupId string, cloudProvider string, endpointServiceId string) admin.DeletePrivateEndpointServiceApiRequest {
	ret := _m.Called(ctx, groupId, cloudProvider, endpointServiceId)

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

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

	return r0
}

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

// DeletePrivateEndpointService is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - cloudProvider string
//   - endpointServiceId string
func (_e *PrivateEndpointServicesApi_Expecter) DeletePrivateEndpointService(ctx interface{}, groupId interface{}, cloudProvider interface{}, endpointServiceId interface{}) *PrivateEndpointServicesApi_DeletePrivateEndpointService_Call {
	return &PrivateEndpointServicesApi_DeletePrivateEndpointService_Call{Call: _e.mock.On("DeletePrivateEndpointService", ctx, groupId, cloudProvider, endpointServiceId)}
}

func (_c *PrivateEndpointServicesApi_DeletePrivateEndpointService_Call) Run(run func(ctx context.Context, groupId string, cloudProvider string, endpointServiceId string)) *PrivateEndpointServicesApi_DeletePrivateEndpointService_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 *PrivateEndpointServicesApi_DeletePrivateEndpointService_Call) Return(_a0 admin.DeletePrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_DeletePrivateEndpointService_Call {
	_c.Call.Return(_a0)
	return _c
}

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

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

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

	var r0 map[string]interface{}
	var r1 *http.Response
	var r2 error
	if rf, ok := ret.Get(0).(func(admin.DeletePrivateEndpointServiceApiRequest) (map[string]interface{}, *http.Response, error)); ok {
		return rf(r)
	}
	if rf, ok := ret.Get(0).(func(admin.DeletePrivateEndpointServiceApiRequest) 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.DeletePrivateEndpointServiceApiRequest) *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.DeletePrivateEndpointServiceApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// DeletePrivateEndpointServiceExecute is a helper method to define mock.On call
//   - r admin.DeletePrivateEndpointServiceApiRequest
func (_e *PrivateEndpointServicesApi_Expecter) DeletePrivateEndpointServiceExecute(r interface{}) *PrivateEndpointServicesApi_DeletePrivateEndpointServiceExecute_Call {
	return &PrivateEndpointServicesApi_DeletePrivateEndpointServiceExecute_Call{Call: _e.mock.On("DeletePrivateEndpointServiceExecute", r)}
}

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

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

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

// DeletePrivateEndpointServiceWithParams provides a mock function with given fields: ctx, args
func (_m *PrivateEndpointServicesApi) DeletePrivateEndpointServiceWithParams(ctx context.Context, args *admin.DeletePrivateEndpointServiceApiParams) admin.DeletePrivateEndpointServiceApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// DeletePrivateEndpointServiceWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeletePrivateEndpointServiceApiParams
func (_e *PrivateEndpointServicesApi_Expecter) DeletePrivateEndpointServiceWithParams(ctx interface{}, args interface{}) *PrivateEndpointServicesApi_DeletePrivateEndpointServiceWithParams_Call {
	return &PrivateEndpointServicesApi_DeletePrivateEndpointServiceWithParams_Call{Call: _e.mock.On("DeletePrivateEndpointServiceWithParams", ctx, args)}
}

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

func (_c *PrivateEndpointServicesApi_DeletePrivateEndpointServiceWithParams_Call) Return(_a0 admin.DeletePrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_DeletePrivateEndpointServiceWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PrivateEndpointServicesApi_DeletePrivateEndpointServiceWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeletePrivateEndpointServiceApiParams) admin.DeletePrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_DeletePrivateEndpointServiceWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// DeletePrivateEndpointWithParams provides a mock function with given fields: ctx, args
func (_m *PrivateEndpointServicesApi) DeletePrivateEndpointWithParams(ctx context.Context, args *admin.DeletePrivateEndpointApiParams) admin.DeletePrivateEndpointApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// DeletePrivateEndpointWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.DeletePrivateEndpointApiParams
func (_e *PrivateEndpointServicesApi_Expecter) DeletePrivateEndpointWithParams(ctx interface{}, args interface{}) *PrivateEndpointServicesApi_DeletePrivateEndpointWithParams_Call {
	return &PrivateEndpointServicesApi_DeletePrivateEndpointWithParams_Call{Call: _e.mock.On("DeletePrivateEndpointWithParams", ctx, args)}
}

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

func (_c *PrivateEndpointServicesApi_DeletePrivateEndpointWithParams_Call) Return(_a0 admin.DeletePrivateEndpointApiRequest) *PrivateEndpointServicesApi_DeletePrivateEndpointWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PrivateEndpointServicesApi_DeletePrivateEndpointWithParams_Call) RunAndReturn(run func(context.Context, *admin.DeletePrivateEndpointApiParams) admin.DeletePrivateEndpointApiRequest) *PrivateEndpointServicesApi_DeletePrivateEndpointWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetPrivateEndpoint provides a mock function with given fields: ctx, groupId, cloudProvider, endpointId, endpointServiceId
func (_m *PrivateEndpointServicesApi) GetPrivateEndpoint(ctx context.Context, groupId string, cloudProvider string, endpointId string, endpointServiceId string) admin.GetPrivateEndpointApiRequest {
	ret := _m.Called(ctx, groupId, cloudProvider, endpointId, endpointServiceId)

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

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

	return r0
}

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

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

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

func (_c *PrivateEndpointServicesApi_GetPrivateEndpoint_Call) Return(_a0 admin.GetPrivateEndpointApiRequest) *PrivateEndpointServicesApi_GetPrivateEndpoint_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetPrivateEndpointExecute provides a mock function with given fields: r
func (_m *PrivateEndpointServicesApi) GetPrivateEndpointExecute(r admin.GetPrivateEndpointApiRequest) (*admin.PrivateLinkEndpoint, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.GetPrivateEndpointApiRequest) *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.GetPrivateEndpointApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// GetPrivateEndpointExecute is a helper method to define mock.On call
//   - r admin.GetPrivateEndpointApiRequest
func (_e *PrivateEndpointServicesApi_Expecter) GetPrivateEndpointExecute(r interface{}) *PrivateEndpointServicesApi_GetPrivateEndpointExecute_Call {
	return &PrivateEndpointServicesApi_GetPrivateEndpointExecute_Call{Call: _e.mock.On("GetPrivateEndpointExecute", r)}
}

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

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

func (_c *PrivateEndpointServicesApi_GetPrivateEndpointExecute_Call) RunAndReturn(run func(admin.GetPrivateEndpointApiRequest) (*admin.PrivateLinkEndpoint, *http.Response, error)) *PrivateEndpointServicesApi_GetPrivateEndpointExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetPrivateEndpointService provides a mock function with given fields: ctx, groupId, cloudProvider, endpointServiceId
func (_m *PrivateEndpointServicesApi) GetPrivateEndpointService(ctx context.Context, groupId string, cloudProvider string, endpointServiceId string) admin.GetPrivateEndpointServiceApiRequest {
	ret := _m.Called(ctx, groupId, cloudProvider, endpointServiceId)

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

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

	return r0
}

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

// GetPrivateEndpointService is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - cloudProvider string
//   - endpointServiceId string
func (_e *PrivateEndpointServicesApi_Expecter) GetPrivateEndpointService(ctx interface{}, groupId interface{}, cloudProvider interface{}, endpointServiceId interface{}) *PrivateEndpointServicesApi_GetPrivateEndpointService_Call {
	return &PrivateEndpointServicesApi_GetPrivateEndpointService_Call{Call: _e.mock.On("GetPrivateEndpointService", ctx, groupId, cloudProvider, endpointServiceId)}
}

func (_c *PrivateEndpointServicesApi_GetPrivateEndpointService_Call) Run(run func(ctx context.Context, groupId string, cloudProvider string, endpointServiceId string)) *PrivateEndpointServicesApi_GetPrivateEndpointService_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 *PrivateEndpointServicesApi_GetPrivateEndpointService_Call) Return(_a0 admin.GetPrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_GetPrivateEndpointService_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetPrivateEndpointServiceExecute provides a mock function with given fields: r
func (_m *PrivateEndpointServicesApi) GetPrivateEndpointServiceExecute(r admin.GetPrivateEndpointServiceApiRequest) (*admin.EndpointService, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.GetPrivateEndpointServiceApiRequest) *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.GetPrivateEndpointServiceApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// GetPrivateEndpointServiceExecute is a helper method to define mock.On call
//   - r admin.GetPrivateEndpointServiceApiRequest
func (_e *PrivateEndpointServicesApi_Expecter) GetPrivateEndpointServiceExecute(r interface{}) *PrivateEndpointServicesApi_GetPrivateEndpointServiceExecute_Call {
	return &PrivateEndpointServicesApi_GetPrivateEndpointServiceExecute_Call{Call: _e.mock.On("GetPrivateEndpointServiceExecute", r)}
}

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

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

func (_c *PrivateEndpointServicesApi_GetPrivateEndpointServiceExecute_Call) RunAndReturn(run func(admin.GetPrivateEndpointServiceApiRequest) (*admin.EndpointService, *http.Response, error)) *PrivateEndpointServicesApi_GetPrivateEndpointServiceExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetPrivateEndpointServiceWithParams provides a mock function with given fields: ctx, args
func (_m *PrivateEndpointServicesApi) GetPrivateEndpointServiceWithParams(ctx context.Context, args *admin.GetPrivateEndpointServiceApiParams) admin.GetPrivateEndpointServiceApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetPrivateEndpointServiceWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetPrivateEndpointServiceApiParams
func (_e *PrivateEndpointServicesApi_Expecter) GetPrivateEndpointServiceWithParams(ctx interface{}, args interface{}) *PrivateEndpointServicesApi_GetPrivateEndpointServiceWithParams_Call {
	return &PrivateEndpointServicesApi_GetPrivateEndpointServiceWithParams_Call{Call: _e.mock.On("GetPrivateEndpointServiceWithParams", ctx, args)}
}

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

func (_c *PrivateEndpointServicesApi_GetPrivateEndpointServiceWithParams_Call) Return(_a0 admin.GetPrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_GetPrivateEndpointServiceWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PrivateEndpointServicesApi_GetPrivateEndpointServiceWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetPrivateEndpointServiceApiParams) admin.GetPrivateEndpointServiceApiRequest) *PrivateEndpointServicesApi_GetPrivateEndpointServiceWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// GetPrivateEndpointWithParams provides a mock function with given fields: ctx, args
func (_m *PrivateEndpointServicesApi) GetPrivateEndpointWithParams(ctx context.Context, args *admin.GetPrivateEndpointApiParams) admin.GetPrivateEndpointApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetPrivateEndpointWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetPrivateEndpointApiParams
func (_e *PrivateEndpointServicesApi_Expecter) GetPrivateEndpointWithParams(ctx interface{}, args interface{}) *PrivateEndpointServicesApi_GetPrivateEndpointWithParams_Call {
	return &PrivateEndpointServicesApi_GetPrivateEndpointWithParams_Call{Call: _e.mock.On("GetPrivateEndpointWithParams", ctx, args)}
}

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

func (_c *PrivateEndpointServicesApi_GetPrivateEndpointWithParams_Call) Return(_a0 admin.GetPrivateEndpointApiRequest) *PrivateEndpointServicesApi_GetPrivateEndpointWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PrivateEndpointServicesApi_GetPrivateEndpointWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetPrivateEndpointApiParams) admin.GetPrivateEndpointApiRequest) *PrivateEndpointServicesApi_GetPrivateEndpointWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0
}

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

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

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

func (_c *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSetting_Call) Return(_a0 admin.GetRegionalizedPrivateEndpointSettingApiRequest) *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSetting_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// GetRegionalizedPrivateEndpointSettingExecute provides a mock function with given fields: r
func (_m *PrivateEndpointServicesApi) GetRegionalizedPrivateEndpointSettingExecute(r admin.GetRegionalizedPrivateEndpointSettingApiRequest) (*admin.ProjectSettingItem, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.GetRegionalizedPrivateEndpointSettingApiRequest) *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.GetRegionalizedPrivateEndpointSettingApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// GetRegionalizedPrivateEndpointSettingExecute is a helper method to define mock.On call
//   - r admin.GetRegionalizedPrivateEndpointSettingApiRequest
func (_e *PrivateEndpointServicesApi_Expecter) GetRegionalizedPrivateEndpointSettingExecute(r interface{}) *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingExecute_Call {
	return &PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingExecute_Call{Call: _e.mock.On("GetRegionalizedPrivateEndpointSettingExecute", r)}
}

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

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

func (_c *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingExecute_Call) RunAndReturn(run func(admin.GetRegionalizedPrivateEndpointSettingApiRequest) (*admin.ProjectSettingItem, *http.Response, error)) *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingExecute_Call {
	_c.Call.Return(run)
	return _c
}

// GetRegionalizedPrivateEndpointSettingWithParams provides a mock function with given fields: ctx, args
func (_m *PrivateEndpointServicesApi) GetRegionalizedPrivateEndpointSettingWithParams(ctx context.Context, args *admin.GetRegionalizedPrivateEndpointSettingApiParams) admin.GetRegionalizedPrivateEndpointSettingApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// GetRegionalizedPrivateEndpointSettingWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.GetRegionalizedPrivateEndpointSettingApiParams
func (_e *PrivateEndpointServicesApi_Expecter) GetRegionalizedPrivateEndpointSettingWithParams(ctx interface{}, args interface{}) *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingWithParams_Call {
	return &PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingWithParams_Call{Call: _e.mock.On("GetRegionalizedPrivateEndpointSettingWithParams", ctx, args)}
}

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

func (_c *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingWithParams_Call) Return(_a0 admin.GetRegionalizedPrivateEndpointSettingApiRequest) *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingWithParams_Call) RunAndReturn(run func(context.Context, *admin.GetRegionalizedPrivateEndpointSettingApiParams) admin.GetRegionalizedPrivateEndpointSettingApiRequest) *PrivateEndpointServicesApi_GetRegionalizedPrivateEndpointSettingWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ListPrivateEndpointServices provides a mock function with given fields: ctx, groupId, cloudProvider
func (_m *PrivateEndpointServicesApi) ListPrivateEndpointServices(ctx context.Context, groupId string, cloudProvider string) admin.ListPrivateEndpointServicesApiRequest {
	ret := _m.Called(ctx, groupId, cloudProvider)

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

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

	return r0
}

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

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

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

func (_c *PrivateEndpointServicesApi_ListPrivateEndpointServices_Call) Return(_a0 admin.ListPrivateEndpointServicesApiRequest) *PrivateEndpointServicesApi_ListPrivateEndpointServices_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ListPrivateEndpointServicesExecute provides a mock function with given fields: r
func (_m *PrivateEndpointServicesApi) ListPrivateEndpointServicesExecute(r admin.ListPrivateEndpointServicesApiRequest) ([]admin.EndpointService, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.ListPrivateEndpointServicesApiRequest) *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.ListPrivateEndpointServicesApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// ListPrivateEndpointServicesExecute is a helper method to define mock.On call
//   - r admin.ListPrivateEndpointServicesApiRequest
func (_e *PrivateEndpointServicesApi_Expecter) ListPrivateEndpointServicesExecute(r interface{}) *PrivateEndpointServicesApi_ListPrivateEndpointServicesExecute_Call {
	return &PrivateEndpointServicesApi_ListPrivateEndpointServicesExecute_Call{Call: _e.mock.On("ListPrivateEndpointServicesExecute", r)}
}

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

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

func (_c *PrivateEndpointServicesApi_ListPrivateEndpointServicesExecute_Call) RunAndReturn(run func(admin.ListPrivateEndpointServicesApiRequest) ([]admin.EndpointService, *http.Response, error)) *PrivateEndpointServicesApi_ListPrivateEndpointServicesExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ListPrivateEndpointServicesWithParams provides a mock function with given fields: ctx, args
func (_m *PrivateEndpointServicesApi) ListPrivateEndpointServicesWithParams(ctx context.Context, args *admin.ListPrivateEndpointServicesApiParams) admin.ListPrivateEndpointServicesApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ListPrivateEndpointServicesWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ListPrivateEndpointServicesApiParams
func (_e *PrivateEndpointServicesApi_Expecter) ListPrivateEndpointServicesWithParams(ctx interface{}, args interface{}) *PrivateEndpointServicesApi_ListPrivateEndpointServicesWithParams_Call {
	return &PrivateEndpointServicesApi_ListPrivateEndpointServicesWithParams_Call{Call: _e.mock.On("ListPrivateEndpointServicesWithParams", ctx, args)}
}

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

func (_c *PrivateEndpointServicesApi_ListPrivateEndpointServicesWithParams_Call) Return(_a0 admin.ListPrivateEndpointServicesApiRequest) *PrivateEndpointServicesApi_ListPrivateEndpointServicesWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PrivateEndpointServicesApi_ListPrivateEndpointServicesWithParams_Call) RunAndReturn(run func(context.Context, *admin.ListPrivateEndpointServicesApiParams) admin.ListPrivateEndpointServicesApiRequest) *PrivateEndpointServicesApi_ListPrivateEndpointServicesWithParams_Call {
	_c.Call.Return(run)
	return _c
}

// ToggleRegionalizedPrivateEndpointSetting provides a mock function with given fields: ctx, groupId, projectSettingItem
func (_m *PrivateEndpointServicesApi) ToggleRegionalizedPrivateEndpointSetting(ctx context.Context, groupId string, projectSettingItem *admin.ProjectSettingItem) admin.ToggleRegionalizedPrivateEndpointSettingApiRequest {
	ret := _m.Called(ctx, groupId, projectSettingItem)

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

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

	return r0
}

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

// ToggleRegionalizedPrivateEndpointSetting is a helper method to define mock.On call
//   - ctx context.Context
//   - groupId string
//   - projectSettingItem *admin.ProjectSettingItem
func (_e *PrivateEndpointServicesApi_Expecter) ToggleRegionalizedPrivateEndpointSetting(ctx interface{}, groupId interface{}, projectSettingItem interface{}) *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSetting_Call {
	return &PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSetting_Call{Call: _e.mock.On("ToggleRegionalizedPrivateEndpointSetting", ctx, groupId, projectSettingItem)}
}

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

func (_c *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSetting_Call) Return(_a0 admin.ToggleRegionalizedPrivateEndpointSettingApiRequest) *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSetting_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSetting_Call) RunAndReturn(run func(context.Context, string, *admin.ProjectSettingItem) admin.ToggleRegionalizedPrivateEndpointSettingApiRequest) *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSetting_Call {
	_c.Call.Return(run)
	return _c
}

// ToggleRegionalizedPrivateEndpointSettingExecute provides a mock function with given fields: r
func (_m *PrivateEndpointServicesApi) ToggleRegionalizedPrivateEndpointSettingExecute(r admin.ToggleRegionalizedPrivateEndpointSettingApiRequest) (*admin.ProjectSettingItem, *http.Response, error) {
	ret := _m.Called(r)

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

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

	if rf, ok := ret.Get(1).(func(admin.ToggleRegionalizedPrivateEndpointSettingApiRequest) *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.ToggleRegionalizedPrivateEndpointSettingApiRequest) error); ok {
		r2 = rf(r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// ToggleRegionalizedPrivateEndpointSettingExecute is a helper method to define mock.On call
//   - r admin.ToggleRegionalizedPrivateEndpointSettingApiRequest
func (_e *PrivateEndpointServicesApi_Expecter) ToggleRegionalizedPrivateEndpointSettingExecute(r interface{}) *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingExecute_Call {
	return &PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingExecute_Call{Call: _e.mock.On("ToggleRegionalizedPrivateEndpointSettingExecute", r)}
}

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

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

func (_c *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingExecute_Call) RunAndReturn(run func(admin.ToggleRegionalizedPrivateEndpointSettingApiRequest) (*admin.ProjectSettingItem, *http.Response, error)) *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingExecute_Call {
	_c.Call.Return(run)
	return _c
}

// ToggleRegionalizedPrivateEndpointSettingWithParams provides a mock function with given fields: ctx, args
func (_m *PrivateEndpointServicesApi) ToggleRegionalizedPrivateEndpointSettingWithParams(ctx context.Context, args *admin.ToggleRegionalizedPrivateEndpointSettingApiParams) admin.ToggleRegionalizedPrivateEndpointSettingApiRequest {
	ret := _m.Called(ctx, args)

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

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

	return r0
}

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

// ToggleRegionalizedPrivateEndpointSettingWithParams is a helper method to define mock.On call
//   - ctx context.Context
//   - args *admin.ToggleRegionalizedPrivateEndpointSettingApiParams
func (_e *PrivateEndpointServicesApi_Expecter) ToggleRegionalizedPrivateEndpointSettingWithParams(ctx interface{}, args interface{}) *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingWithParams_Call {
	return &PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingWithParams_Call{Call: _e.mock.On("ToggleRegionalizedPrivateEndpointSettingWithParams", ctx, args)}
}

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

func (_c *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingWithParams_Call) Return(_a0 admin.ToggleRegionalizedPrivateEndpointSettingApiRequest) *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingWithParams_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingWithParams_Call) RunAndReturn(run func(context.Context, *admin.ToggleRegionalizedPrivateEndpointSettingApiParams) admin.ToggleRegionalizedPrivateEndpointSettingApiRequest) *PrivateEndpointServicesApi_ToggleRegionalizedPrivateEndpointSettingWithParams_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}