// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"context"

	mock "github.com/stretchr/testify/mock"
	"github.com/tidbcloud/cluster-service-ng/api/dataplane-manager/v1"
	"google.golang.org/grpc"
	"google.golang.org/protobuf/types/known/emptypb"
)

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

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

	return mock
}

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

type Client_Expecter struct {
	mock *mock.Mock
}

func (_m *Client) EXPECT() *Client_Expecter {
	return &Client_Expecter{mock: &_m.Mock}
}

// AddManualBackupLifecycleRules provides a mock function for the type Client
func (_mock *Client) AddManualBackupLifecycleRules(ctx context.Context, in *dedicatedv1.AddManualBackupLifecycleRulesRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.AddManualBackupLifecycleRulesRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.AddManualBackupLifecycleRulesRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.AddManualBackupLifecycleRulesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddManualBackupLifecycleRules is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.AddManualBackupLifecycleRulesRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) AddManualBackupLifecycleRules(ctx interface{}, in interface{}, opts ...interface{}) *Client_AddManualBackupLifecycleRules_Call {
	return &Client_AddManualBackupLifecycleRules_Call{Call: _e.mock.On("AddManualBackupLifecycleRules",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_AddManualBackupLifecycleRules_Call) Run(run func(ctx context.Context, in *dedicatedv1.AddManualBackupLifecycleRulesRequest, opts ...grpc.CallOption)) *Client_AddManualBackupLifecycleRules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.AddManualBackupLifecycleRulesRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.AddManualBackupLifecycleRulesRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_AddManualBackupLifecycleRules_Call) Return(empty *emptypb.Empty, err error) *Client_AddManualBackupLifecycleRules_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *Client_AddManualBackupLifecycleRules_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.AddManualBackupLifecycleRulesRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *Client_AddManualBackupLifecycleRules_Call {
	_c.Call.Return(run)
	return _c
}

// ApplyLifecycleRules provides a mock function for the type Client
func (_mock *Client) ApplyLifecycleRules(ctx context.Context, in *dedicatedv1.ApplyLifecycleRulesRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.ApplyLifecycleRulesRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.ApplyLifecycleRulesRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.ApplyLifecycleRulesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ApplyLifecycleRules is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.ApplyLifecycleRulesRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) ApplyLifecycleRules(ctx interface{}, in interface{}, opts ...interface{}) *Client_ApplyLifecycleRules_Call {
	return &Client_ApplyLifecycleRules_Call{Call: _e.mock.On("ApplyLifecycleRules",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_ApplyLifecycleRules_Call) Run(run func(ctx context.Context, in *dedicatedv1.ApplyLifecycleRulesRequest, opts ...grpc.CallOption)) *Client_ApplyLifecycleRules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.ApplyLifecycleRulesRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.ApplyLifecycleRulesRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_ApplyLifecycleRules_Call) Return(empty *emptypb.Empty, err error) *Client_ApplyLifecycleRules_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *Client_ApplyLifecycleRules_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.ApplyLifecycleRulesRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *Client_ApplyLifecycleRules_Call {
	_c.Call.Return(run)
	return _c
}

// CheckNodePoolScaleActivities provides a mock function for the type Client
func (_mock *Client) CheckNodePoolScaleActivities(ctx context.Context, in *dedicatedv1.CheckNodePoolScaleActivitiesRequest, opts ...grpc.CallOption) (*dedicatedv1.CheckNodePoolScaleActivitiesResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.CheckNodePoolScaleActivitiesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.CheckNodePoolScaleActivitiesRequest, ...grpc.CallOption) (*dedicatedv1.CheckNodePoolScaleActivitiesResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.CheckNodePoolScaleActivitiesRequest, ...grpc.CallOption) *dedicatedv1.CheckNodePoolScaleActivitiesResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.CheckNodePoolScaleActivitiesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.CheckNodePoolScaleActivitiesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CheckNodePoolScaleActivities is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.CheckNodePoolScaleActivitiesRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) CheckNodePoolScaleActivities(ctx interface{}, in interface{}, opts ...interface{}) *Client_CheckNodePoolScaleActivities_Call {
	return &Client_CheckNodePoolScaleActivities_Call{Call: _e.mock.On("CheckNodePoolScaleActivities",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_CheckNodePoolScaleActivities_Call) Run(run func(ctx context.Context, in *dedicatedv1.CheckNodePoolScaleActivitiesRequest, opts ...grpc.CallOption)) *Client_CheckNodePoolScaleActivities_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.CheckNodePoolScaleActivitiesRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.CheckNodePoolScaleActivitiesRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_CheckNodePoolScaleActivities_Call) Return(checkNodePoolScaleActivitiesResponse *dedicatedv1.CheckNodePoolScaleActivitiesResponse, err error) *Client_CheckNodePoolScaleActivities_Call {
	_c.Call.Return(checkNodePoolScaleActivitiesResponse, err)
	return _c
}

func (_c *Client_CheckNodePoolScaleActivities_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.CheckNodePoolScaleActivitiesRequest, opts ...grpc.CallOption) (*dedicatedv1.CheckNodePoolScaleActivitiesResponse, error)) *Client_CheckNodePoolScaleActivities_Call {
	_c.Call.Return(run)
	return _c
}

// CreateBucket provides a mock function for the type Client
func (_mock *Client) CreateBucket(ctx context.Context, in *dedicatedv1.CreateBucketRequest, opts ...grpc.CallOption) (*dedicatedv1.Bucket, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.Bucket
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.CreateBucketRequest, ...grpc.CallOption) (*dedicatedv1.Bucket, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.CreateBucketRequest, ...grpc.CallOption) *dedicatedv1.Bucket); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.Bucket)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.CreateBucketRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreateBucket is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.CreateBucketRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) CreateBucket(ctx interface{}, in interface{}, opts ...interface{}) *Client_CreateBucket_Call {
	return &Client_CreateBucket_Call{Call: _e.mock.On("CreateBucket",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_CreateBucket_Call) Run(run func(ctx context.Context, in *dedicatedv1.CreateBucketRequest, opts ...grpc.CallOption)) *Client_CreateBucket_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.CreateBucketRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.CreateBucketRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_CreateBucket_Call) Return(bucket *dedicatedv1.Bucket, err error) *Client_CreateBucket_Call {
	_c.Call.Return(bucket, err)
	return _c
}

func (_c *Client_CreateBucket_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.CreateBucketRequest, opts ...grpc.CallOption) (*dedicatedv1.Bucket, error)) *Client_CreateBucket_Call {
	_c.Call.Return(run)
	return _c
}

// CreateDataPlane provides a mock function for the type Client
func (_mock *Client) CreateDataPlane(ctx context.Context, in *dedicatedv1.CreateDataPlaneRequest, opts ...grpc.CallOption) (*dedicatedv1.DataPlane, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.DataPlane
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.CreateDataPlaneRequest, ...grpc.CallOption) (*dedicatedv1.DataPlane, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.CreateDataPlaneRequest, ...grpc.CallOption) *dedicatedv1.DataPlane); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.DataPlane)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.CreateDataPlaneRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreateDataPlane is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.CreateDataPlaneRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) CreateDataPlane(ctx interface{}, in interface{}, opts ...interface{}) *Client_CreateDataPlane_Call {
	return &Client_CreateDataPlane_Call{Call: _e.mock.On("CreateDataPlane",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_CreateDataPlane_Call) Run(run func(ctx context.Context, in *dedicatedv1.CreateDataPlaneRequest, opts ...grpc.CallOption)) *Client_CreateDataPlane_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.CreateDataPlaneRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.CreateDataPlaneRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_CreateDataPlane_Call) Return(dataPlane *dedicatedv1.DataPlane, err error) *Client_CreateDataPlane_Call {
	_c.Call.Return(dataPlane, err)
	return _c
}

func (_c *Client_CreateDataPlane_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.CreateDataPlaneRequest, opts ...grpc.CallOption) (*dedicatedv1.DataPlane, error)) *Client_CreateDataPlane_Call {
	_c.Call.Return(run)
	return _c
}

// CreateKeyspaceRole provides a mock function for the type Client
func (_mock *Client) CreateKeyspaceRole(ctx context.Context, in *dedicatedv1.CreateKeyspaceRoleRequest, opts ...grpc.CallOption) (*dedicatedv1.KeyspaceRole, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.KeyspaceRole
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.CreateKeyspaceRoleRequest, ...grpc.CallOption) (*dedicatedv1.KeyspaceRole, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.CreateKeyspaceRoleRequest, ...grpc.CallOption) *dedicatedv1.KeyspaceRole); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.KeyspaceRole)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.CreateKeyspaceRoleRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreateKeyspaceRole is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.CreateKeyspaceRoleRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) CreateKeyspaceRole(ctx interface{}, in interface{}, opts ...interface{}) *Client_CreateKeyspaceRole_Call {
	return &Client_CreateKeyspaceRole_Call{Call: _e.mock.On("CreateKeyspaceRole",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_CreateKeyspaceRole_Call) Run(run func(ctx context.Context, in *dedicatedv1.CreateKeyspaceRoleRequest, opts ...grpc.CallOption)) *Client_CreateKeyspaceRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.CreateKeyspaceRoleRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.CreateKeyspaceRoleRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_CreateKeyspaceRole_Call) Return(keyspaceRole *dedicatedv1.KeyspaceRole, err error) *Client_CreateKeyspaceRole_Call {
	_c.Call.Return(keyspaceRole, err)
	return _c
}

func (_c *Client_CreateKeyspaceRole_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.CreateKeyspaceRoleRequest, opts ...grpc.CallOption) (*dedicatedv1.KeyspaceRole, error)) *Client_CreateKeyspaceRole_Call {
	_c.Call.Return(run)
	return _c
}

// CreateLoadBalancer provides a mock function for the type Client
func (_mock *Client) CreateLoadBalancer(ctx context.Context, in *dedicatedv1.CreateLoadBalancerRequest, opts ...grpc.CallOption) (*dedicatedv1.LoadBalancer, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.LoadBalancer
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.CreateLoadBalancerRequest, ...grpc.CallOption) (*dedicatedv1.LoadBalancer, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.CreateLoadBalancerRequest, ...grpc.CallOption) *dedicatedv1.LoadBalancer); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.LoadBalancer)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.CreateLoadBalancerRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreateLoadBalancer is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.CreateLoadBalancerRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) CreateLoadBalancer(ctx interface{}, in interface{}, opts ...interface{}) *Client_CreateLoadBalancer_Call {
	return &Client_CreateLoadBalancer_Call{Call: _e.mock.On("CreateLoadBalancer",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_CreateLoadBalancer_Call) Run(run func(ctx context.Context, in *dedicatedv1.CreateLoadBalancerRequest, opts ...grpc.CallOption)) *Client_CreateLoadBalancer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.CreateLoadBalancerRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.CreateLoadBalancerRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_CreateLoadBalancer_Call) Return(loadBalancer *dedicatedv1.LoadBalancer, err error) *Client_CreateLoadBalancer_Call {
	_c.Call.Return(loadBalancer, err)
	return _c
}

func (_c *Client_CreateLoadBalancer_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.CreateLoadBalancerRequest, opts ...grpc.CallOption) (*dedicatedv1.LoadBalancer, error)) *Client_CreateLoadBalancer_Call {
	_c.Call.Return(run)
	return _c
}

// CreateNodePool provides a mock function for the type Client
func (_mock *Client) CreateNodePool(ctx context.Context, in *dedicatedv1.CreateNodePoolRequest, opts ...grpc.CallOption) (*dedicatedv1.NodePool, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.NodePool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.CreateNodePoolRequest, ...grpc.CallOption) (*dedicatedv1.NodePool, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.CreateNodePoolRequest, ...grpc.CallOption) *dedicatedv1.NodePool); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.NodePool)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.CreateNodePoolRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreateNodePool is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.CreateNodePoolRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) CreateNodePool(ctx interface{}, in interface{}, opts ...interface{}) *Client_CreateNodePool_Call {
	return &Client_CreateNodePool_Call{Call: _e.mock.On("CreateNodePool",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_CreateNodePool_Call) Run(run func(ctx context.Context, in *dedicatedv1.CreateNodePoolRequest, opts ...grpc.CallOption)) *Client_CreateNodePool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.CreateNodePoolRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.CreateNodePoolRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_CreateNodePool_Call) Return(nodePool *dedicatedv1.NodePool, err error) *Client_CreateNodePool_Call {
	_c.Call.Return(nodePool, err)
	return _c
}

func (_c *Client_CreateNodePool_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.CreateNodePoolRequest, opts ...grpc.CallOption) (*dedicatedv1.NodePool, error)) *Client_CreateNodePool_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePrivateLinkEndpoint provides a mock function for the type Client
func (_mock *Client) CreatePrivateLinkEndpoint(ctx context.Context, in *dedicatedv1.CreatePrivateLinkEndpointRequest, opts ...grpc.CallOption) (*dedicatedv1.PrivateLinkEndpoint, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.PrivateLinkEndpoint
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.CreatePrivateLinkEndpointRequest, ...grpc.CallOption) (*dedicatedv1.PrivateLinkEndpoint, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.CreatePrivateLinkEndpointRequest, ...grpc.CallOption) *dedicatedv1.PrivateLinkEndpoint); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.PrivateLinkEndpoint)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.CreatePrivateLinkEndpointRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreatePrivateLinkEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.CreatePrivateLinkEndpointRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) CreatePrivateLinkEndpoint(ctx interface{}, in interface{}, opts ...interface{}) *Client_CreatePrivateLinkEndpoint_Call {
	return &Client_CreatePrivateLinkEndpoint_Call{Call: _e.mock.On("CreatePrivateLinkEndpoint",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_CreatePrivateLinkEndpoint_Call) Run(run func(ctx context.Context, in *dedicatedv1.CreatePrivateLinkEndpointRequest, opts ...grpc.CallOption)) *Client_CreatePrivateLinkEndpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.CreatePrivateLinkEndpointRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.CreatePrivateLinkEndpointRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_CreatePrivateLinkEndpoint_Call) Return(privateLinkEndpoint *dedicatedv1.PrivateLinkEndpoint, err error) *Client_CreatePrivateLinkEndpoint_Call {
	_c.Call.Return(privateLinkEndpoint, err)
	return _c
}

func (_c *Client_CreatePrivateLinkEndpoint_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.CreatePrivateLinkEndpointRequest, opts ...grpc.CallOption) (*dedicatedv1.PrivateLinkEndpoint, error)) *Client_CreatePrivateLinkEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePrivateLinkService provides a mock function for the type Client
func (_mock *Client) CreatePrivateLinkService(ctx context.Context, in *dedicatedv1.CreatePrivateLinkServiceRequest, opts ...grpc.CallOption) (*dedicatedv1.PrivateLinkService, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.PrivateLinkService
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.CreatePrivateLinkServiceRequest, ...grpc.CallOption) (*dedicatedv1.PrivateLinkService, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.CreatePrivateLinkServiceRequest, ...grpc.CallOption) *dedicatedv1.PrivateLinkService); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.PrivateLinkService)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.CreatePrivateLinkServiceRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CreatePrivateLinkService is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.CreatePrivateLinkServiceRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) CreatePrivateLinkService(ctx interface{}, in interface{}, opts ...interface{}) *Client_CreatePrivateLinkService_Call {
	return &Client_CreatePrivateLinkService_Call{Call: _e.mock.On("CreatePrivateLinkService",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_CreatePrivateLinkService_Call) Run(run func(ctx context.Context, in *dedicatedv1.CreatePrivateLinkServiceRequest, opts ...grpc.CallOption)) *Client_CreatePrivateLinkService_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.CreatePrivateLinkServiceRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.CreatePrivateLinkServiceRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_CreatePrivateLinkService_Call) Return(privateLinkService *dedicatedv1.PrivateLinkService, err error) *Client_CreatePrivateLinkService_Call {
	_c.Call.Return(privateLinkService, err)
	return _c
}

func (_c *Client_CreatePrivateLinkService_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.CreatePrivateLinkServiceRequest, opts ...grpc.CallOption) (*dedicatedv1.PrivateLinkService, error)) *Client_CreatePrivateLinkService_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteBucket provides a mock function for the type Client
func (_mock *Client) DeleteBucket(ctx context.Context, in *dedicatedv1.DeleteBucketRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.DeleteBucketRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.DeleteBucketRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.DeleteBucketRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteBucket is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.DeleteBucketRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) DeleteBucket(ctx interface{}, in interface{}, opts ...interface{}) *Client_DeleteBucket_Call {
	return &Client_DeleteBucket_Call{Call: _e.mock.On("DeleteBucket",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_DeleteBucket_Call) Run(run func(ctx context.Context, in *dedicatedv1.DeleteBucketRequest, opts ...grpc.CallOption)) *Client_DeleteBucket_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.DeleteBucketRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.DeleteBucketRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_DeleteBucket_Call) Return(empty *emptypb.Empty, err error) *Client_DeleteBucket_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *Client_DeleteBucket_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.DeleteBucketRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *Client_DeleteBucket_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDataPlane provides a mock function for the type Client
func (_mock *Client) DeleteDataPlane(ctx context.Context, in *dedicatedv1.DeleteDataPlaneRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.DeleteDataPlaneRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.DeleteDataPlaneRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.DeleteDataPlaneRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteDataPlane is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.DeleteDataPlaneRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) DeleteDataPlane(ctx interface{}, in interface{}, opts ...interface{}) *Client_DeleteDataPlane_Call {
	return &Client_DeleteDataPlane_Call{Call: _e.mock.On("DeleteDataPlane",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_DeleteDataPlane_Call) Run(run func(ctx context.Context, in *dedicatedv1.DeleteDataPlaneRequest, opts ...grpc.CallOption)) *Client_DeleteDataPlane_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.DeleteDataPlaneRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.DeleteDataPlaneRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_DeleteDataPlane_Call) Return(empty *emptypb.Empty, err error) *Client_DeleteDataPlane_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *Client_DeleteDataPlane_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.DeleteDataPlaneRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *Client_DeleteDataPlane_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteKeyspaceRole provides a mock function for the type Client
func (_mock *Client) DeleteKeyspaceRole(ctx context.Context, in *dedicatedv1.DeleteKeyspaceRoleRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.DeleteKeyspaceRoleRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.DeleteKeyspaceRoleRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.DeleteKeyspaceRoleRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteKeyspaceRole is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.DeleteKeyspaceRoleRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) DeleteKeyspaceRole(ctx interface{}, in interface{}, opts ...interface{}) *Client_DeleteKeyspaceRole_Call {
	return &Client_DeleteKeyspaceRole_Call{Call: _e.mock.On("DeleteKeyspaceRole",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_DeleteKeyspaceRole_Call) Run(run func(ctx context.Context, in *dedicatedv1.DeleteKeyspaceRoleRequest, opts ...grpc.CallOption)) *Client_DeleteKeyspaceRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.DeleteKeyspaceRoleRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.DeleteKeyspaceRoleRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_DeleteKeyspaceRole_Call) Return(empty *emptypb.Empty, err error) *Client_DeleteKeyspaceRole_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *Client_DeleteKeyspaceRole_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.DeleteKeyspaceRoleRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *Client_DeleteKeyspaceRole_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteLoadBalancer provides a mock function for the type Client
func (_mock *Client) DeleteLoadBalancer(ctx context.Context, in *dedicatedv1.DeleteLoadBalancerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.DeleteLoadBalancerRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.DeleteLoadBalancerRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.DeleteLoadBalancerRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteLoadBalancer is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.DeleteLoadBalancerRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) DeleteLoadBalancer(ctx interface{}, in interface{}, opts ...interface{}) *Client_DeleteLoadBalancer_Call {
	return &Client_DeleteLoadBalancer_Call{Call: _e.mock.On("DeleteLoadBalancer",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_DeleteLoadBalancer_Call) Run(run func(ctx context.Context, in *dedicatedv1.DeleteLoadBalancerRequest, opts ...grpc.CallOption)) *Client_DeleteLoadBalancer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.DeleteLoadBalancerRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.DeleteLoadBalancerRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_DeleteLoadBalancer_Call) Return(empty *emptypb.Empty, err error) *Client_DeleteLoadBalancer_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *Client_DeleteLoadBalancer_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.DeleteLoadBalancerRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *Client_DeleteLoadBalancer_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteManualBackupLifecycleRules provides a mock function for the type Client
func (_mock *Client) DeleteManualBackupLifecycleRules(ctx context.Context, in *dedicatedv1.DeleteManualBackupLifecycleRulesRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.DeleteManualBackupLifecycleRulesRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.DeleteManualBackupLifecycleRulesRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.DeleteManualBackupLifecycleRulesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteManualBackupLifecycleRules is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.DeleteManualBackupLifecycleRulesRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) DeleteManualBackupLifecycleRules(ctx interface{}, in interface{}, opts ...interface{}) *Client_DeleteManualBackupLifecycleRules_Call {
	return &Client_DeleteManualBackupLifecycleRules_Call{Call: _e.mock.On("DeleteManualBackupLifecycleRules",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_DeleteManualBackupLifecycleRules_Call) Run(run func(ctx context.Context, in *dedicatedv1.DeleteManualBackupLifecycleRulesRequest, opts ...grpc.CallOption)) *Client_DeleteManualBackupLifecycleRules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.DeleteManualBackupLifecycleRulesRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.DeleteManualBackupLifecycleRulesRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_DeleteManualBackupLifecycleRules_Call) Return(empty *emptypb.Empty, err error) *Client_DeleteManualBackupLifecycleRules_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *Client_DeleteManualBackupLifecycleRules_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.DeleteManualBackupLifecycleRulesRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *Client_DeleteManualBackupLifecycleRules_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteNodePool provides a mock function for the type Client
func (_mock *Client) DeleteNodePool(ctx context.Context, in *dedicatedv1.DeleteNodePoolRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.DeleteNodePoolRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.DeleteNodePoolRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.DeleteNodePoolRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteNodePool is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.DeleteNodePoolRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) DeleteNodePool(ctx interface{}, in interface{}, opts ...interface{}) *Client_DeleteNodePool_Call {
	return &Client_DeleteNodePool_Call{Call: _e.mock.On("DeleteNodePool",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_DeleteNodePool_Call) Run(run func(ctx context.Context, in *dedicatedv1.DeleteNodePoolRequest, opts ...grpc.CallOption)) *Client_DeleteNodePool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.DeleteNodePoolRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.DeleteNodePoolRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_DeleteNodePool_Call) Return(empty *emptypb.Empty, err error) *Client_DeleteNodePool_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *Client_DeleteNodePool_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.DeleteNodePoolRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *Client_DeleteNodePool_Call {
	_c.Call.Return(run)
	return _c
}

// DeletePrivateLinkEndpoint provides a mock function for the type Client
func (_mock *Client) DeletePrivateLinkEndpoint(ctx context.Context, in *dedicatedv1.DeletePrivateLinkEndpointRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.DeletePrivateLinkEndpointRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.DeletePrivateLinkEndpointRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.DeletePrivateLinkEndpointRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeletePrivateLinkEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.DeletePrivateLinkEndpointRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) DeletePrivateLinkEndpoint(ctx interface{}, in interface{}, opts ...interface{}) *Client_DeletePrivateLinkEndpoint_Call {
	return &Client_DeletePrivateLinkEndpoint_Call{Call: _e.mock.On("DeletePrivateLinkEndpoint",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_DeletePrivateLinkEndpoint_Call) Run(run func(ctx context.Context, in *dedicatedv1.DeletePrivateLinkEndpointRequest, opts ...grpc.CallOption)) *Client_DeletePrivateLinkEndpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.DeletePrivateLinkEndpointRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.DeletePrivateLinkEndpointRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_DeletePrivateLinkEndpoint_Call) Return(empty *emptypb.Empty, err error) *Client_DeletePrivateLinkEndpoint_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *Client_DeletePrivateLinkEndpoint_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.DeletePrivateLinkEndpointRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *Client_DeletePrivateLinkEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// DeletePrivateLinkService provides a mock function for the type Client
func (_mock *Client) DeletePrivateLinkService(ctx context.Context, in *dedicatedv1.DeletePrivateLinkServiceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.DeletePrivateLinkServiceRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.DeletePrivateLinkServiceRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.DeletePrivateLinkServiceRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeletePrivateLinkService is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.DeletePrivateLinkServiceRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) DeletePrivateLinkService(ctx interface{}, in interface{}, opts ...interface{}) *Client_DeletePrivateLinkService_Call {
	return &Client_DeletePrivateLinkService_Call{Call: _e.mock.On("DeletePrivateLinkService",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_DeletePrivateLinkService_Call) Run(run func(ctx context.Context, in *dedicatedv1.DeletePrivateLinkServiceRequest, opts ...grpc.CallOption)) *Client_DeletePrivateLinkService_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.DeletePrivateLinkServiceRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.DeletePrivateLinkServiceRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_DeletePrivateLinkService_Call) Return(empty *emptypb.Empty, err error) *Client_DeletePrivateLinkService_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *Client_DeletePrivateLinkService_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.DeletePrivateLinkServiceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *Client_DeletePrivateLinkService_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteSharedPoolCloudTags provides a mock function for the type Client
func (_mock *Client) DeleteSharedPoolCloudTags(ctx context.Context, in *dedicatedv1.DeleteSharedPoolCloudTagsRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.DeleteSharedPoolCloudTagsRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.DeleteSharedPoolCloudTagsRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.DeleteSharedPoolCloudTagsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteSharedPoolCloudTags is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.DeleteSharedPoolCloudTagsRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) DeleteSharedPoolCloudTags(ctx interface{}, in interface{}, opts ...interface{}) *Client_DeleteSharedPoolCloudTags_Call {
	return &Client_DeleteSharedPoolCloudTags_Call{Call: _e.mock.On("DeleteSharedPoolCloudTags",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_DeleteSharedPoolCloudTags_Call) Run(run func(ctx context.Context, in *dedicatedv1.DeleteSharedPoolCloudTagsRequest, opts ...grpc.CallOption)) *Client_DeleteSharedPoolCloudTags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.DeleteSharedPoolCloudTagsRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.DeleteSharedPoolCloudTagsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_DeleteSharedPoolCloudTags_Call) Return(empty *emptypb.Empty, err error) *Client_DeleteSharedPoolCloudTags_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *Client_DeleteSharedPoolCloudTags_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.DeleteSharedPoolCloudTagsRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *Client_DeleteSharedPoolCloudTags_Call {
	_c.Call.Return(run)
	return _c
}

// DescribePrivateLinkEndpointServiceZones provides a mock function for the type Client
func (_mock *Client) DescribePrivateLinkEndpointServiceZones(ctx context.Context, in *dedicatedv1.DescribePrivateLinkEndpointServiceZonesRequest, opts ...grpc.CallOption) (*dedicatedv1.DescribePrivateLinkEndpointServiceZonesResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.DescribePrivateLinkEndpointServiceZonesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.DescribePrivateLinkEndpointServiceZonesRequest, ...grpc.CallOption) (*dedicatedv1.DescribePrivateLinkEndpointServiceZonesResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.DescribePrivateLinkEndpointServiceZonesRequest, ...grpc.CallOption) *dedicatedv1.DescribePrivateLinkEndpointServiceZonesResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.DescribePrivateLinkEndpointServiceZonesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.DescribePrivateLinkEndpointServiceZonesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DescribePrivateLinkEndpointServiceZones is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.DescribePrivateLinkEndpointServiceZonesRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) DescribePrivateLinkEndpointServiceZones(ctx interface{}, in interface{}, opts ...interface{}) *Client_DescribePrivateLinkEndpointServiceZones_Call {
	return &Client_DescribePrivateLinkEndpointServiceZones_Call{Call: _e.mock.On("DescribePrivateLinkEndpointServiceZones",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_DescribePrivateLinkEndpointServiceZones_Call) Run(run func(ctx context.Context, in *dedicatedv1.DescribePrivateLinkEndpointServiceZonesRequest, opts ...grpc.CallOption)) *Client_DescribePrivateLinkEndpointServiceZones_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.DescribePrivateLinkEndpointServiceZonesRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.DescribePrivateLinkEndpointServiceZonesRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_DescribePrivateLinkEndpointServiceZones_Call) Return(describePrivateLinkEndpointServiceZonesResponse *dedicatedv1.DescribePrivateLinkEndpointServiceZonesResponse, err error) *Client_DescribePrivateLinkEndpointServiceZones_Call {
	_c.Call.Return(describePrivateLinkEndpointServiceZonesResponse, err)
	return _c
}

func (_c *Client_DescribePrivateLinkEndpointServiceZones_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.DescribePrivateLinkEndpointServiceZonesRequest, opts ...grpc.CallOption) (*dedicatedv1.DescribePrivateLinkEndpointServiceZonesResponse, error)) *Client_DescribePrivateLinkEndpointServiceZones_Call {
	_c.Call.Return(run)
	return _c
}

// EvaluateDataPlaneNetworkCapacity provides a mock function for the type Client
func (_mock *Client) EvaluateDataPlaneNetworkCapacity(ctx context.Context, in *dedicatedv1.EvaluateDataPlaneNetworkCapacityRequest, opts ...grpc.CallOption) (*dedicatedv1.EvaluateDataPlaneNetworkCapacityResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.EvaluateDataPlaneNetworkCapacityResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.EvaluateDataPlaneNetworkCapacityRequest, ...grpc.CallOption) (*dedicatedv1.EvaluateDataPlaneNetworkCapacityResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.EvaluateDataPlaneNetworkCapacityRequest, ...grpc.CallOption) *dedicatedv1.EvaluateDataPlaneNetworkCapacityResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.EvaluateDataPlaneNetworkCapacityResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.EvaluateDataPlaneNetworkCapacityRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// EvaluateDataPlaneNetworkCapacity is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.EvaluateDataPlaneNetworkCapacityRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) EvaluateDataPlaneNetworkCapacity(ctx interface{}, in interface{}, opts ...interface{}) *Client_EvaluateDataPlaneNetworkCapacity_Call {
	return &Client_EvaluateDataPlaneNetworkCapacity_Call{Call: _e.mock.On("EvaluateDataPlaneNetworkCapacity",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_EvaluateDataPlaneNetworkCapacity_Call) Run(run func(ctx context.Context, in *dedicatedv1.EvaluateDataPlaneNetworkCapacityRequest, opts ...grpc.CallOption)) *Client_EvaluateDataPlaneNetworkCapacity_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.EvaluateDataPlaneNetworkCapacityRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.EvaluateDataPlaneNetworkCapacityRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_EvaluateDataPlaneNetworkCapacity_Call) Return(evaluateDataPlaneNetworkCapacityResponse *dedicatedv1.EvaluateDataPlaneNetworkCapacityResponse, err error) *Client_EvaluateDataPlaneNetworkCapacity_Call {
	_c.Call.Return(evaluateDataPlaneNetworkCapacityResponse, err)
	return _c
}

func (_c *Client_EvaluateDataPlaneNetworkCapacity_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.EvaluateDataPlaneNetworkCapacityRequest, opts ...grpc.CallOption) (*dedicatedv1.EvaluateDataPlaneNetworkCapacityResponse, error)) *Client_EvaluateDataPlaneNetworkCapacity_Call {
	_c.Call.Return(run)
	return _c
}

// GetBucket provides a mock function for the type Client
func (_mock *Client) GetBucket(ctx context.Context, in *dedicatedv1.GetBucketRequest, opts ...grpc.CallOption) (*dedicatedv1.Bucket, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.Bucket
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.GetBucketRequest, ...grpc.CallOption) (*dedicatedv1.Bucket, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.GetBucketRequest, ...grpc.CallOption) *dedicatedv1.Bucket); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.Bucket)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.GetBucketRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetBucket is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.GetBucketRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) GetBucket(ctx interface{}, in interface{}, opts ...interface{}) *Client_GetBucket_Call {
	return &Client_GetBucket_Call{Call: _e.mock.On("GetBucket",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_GetBucket_Call) Run(run func(ctx context.Context, in *dedicatedv1.GetBucketRequest, opts ...grpc.CallOption)) *Client_GetBucket_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.GetBucketRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.GetBucketRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_GetBucket_Call) Return(bucket *dedicatedv1.Bucket, err error) *Client_GetBucket_Call {
	_c.Call.Return(bucket, err)
	return _c
}

func (_c *Client_GetBucket_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.GetBucketRequest, opts ...grpc.CallOption) (*dedicatedv1.Bucket, error)) *Client_GetBucket_Call {
	_c.Call.Return(run)
	return _c
}

// GetBucketServiceClient provides a mock function for the type Client
func (_mock *Client) GetBucketServiceClient() dedicatedv1.BucketServiceClient {
	ret := _mock.Called()

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

	var r0 dedicatedv1.BucketServiceClient
	if returnFunc, ok := ret.Get(0).(func() dedicatedv1.BucketServiceClient); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(dedicatedv1.BucketServiceClient)
		}
	}
	return r0
}

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

// GetBucketServiceClient is a helper method to define mock.On call
func (_e *Client_Expecter) GetBucketServiceClient() *Client_GetBucketServiceClient_Call {
	return &Client_GetBucketServiceClient_Call{Call: _e.mock.On("GetBucketServiceClient")}
}

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

func (_c *Client_GetBucketServiceClient_Call) Return(bucketServiceClient dedicatedv1.BucketServiceClient) *Client_GetBucketServiceClient_Call {
	_c.Call.Return(bucketServiceClient)
	return _c
}

func (_c *Client_GetBucketServiceClient_Call) RunAndReturn(run func() dedicatedv1.BucketServiceClient) *Client_GetBucketServiceClient_Call {
	_c.Call.Return(run)
	return _c
}

// GetDataPlane provides a mock function for the type Client
func (_mock *Client) GetDataPlane(ctx context.Context, in *dedicatedv1.GetDataPlaneRequest, opts ...grpc.CallOption) (*dedicatedv1.DataPlane, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.DataPlane
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.GetDataPlaneRequest, ...grpc.CallOption) (*dedicatedv1.DataPlane, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.GetDataPlaneRequest, ...grpc.CallOption) *dedicatedv1.DataPlane); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.DataPlane)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.GetDataPlaneRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetDataPlane is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.GetDataPlaneRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) GetDataPlane(ctx interface{}, in interface{}, opts ...interface{}) *Client_GetDataPlane_Call {
	return &Client_GetDataPlane_Call{Call: _e.mock.On("GetDataPlane",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_GetDataPlane_Call) Run(run func(ctx context.Context, in *dedicatedv1.GetDataPlaneRequest, opts ...grpc.CallOption)) *Client_GetDataPlane_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.GetDataPlaneRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.GetDataPlaneRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_GetDataPlane_Call) Return(dataPlane *dedicatedv1.DataPlane, err error) *Client_GetDataPlane_Call {
	_c.Call.Return(dataPlane, err)
	return _c
}

func (_c *Client_GetDataPlane_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.GetDataPlaneRequest, opts ...grpc.CallOption) (*dedicatedv1.DataPlane, error)) *Client_GetDataPlane_Call {
	_c.Call.Return(run)
	return _c
}

// GetDataPlaneServiceClient provides a mock function for the type Client
func (_mock *Client) GetDataPlaneServiceClient() dedicatedv1.DataPlaneServiceClient {
	ret := _mock.Called()

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

	var r0 dedicatedv1.DataPlaneServiceClient
	if returnFunc, ok := ret.Get(0).(func() dedicatedv1.DataPlaneServiceClient); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(dedicatedv1.DataPlaneServiceClient)
		}
	}
	return r0
}

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

// GetDataPlaneServiceClient is a helper method to define mock.On call
func (_e *Client_Expecter) GetDataPlaneServiceClient() *Client_GetDataPlaneServiceClient_Call {
	return &Client_GetDataPlaneServiceClient_Call{Call: _e.mock.On("GetDataPlaneServiceClient")}
}

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

func (_c *Client_GetDataPlaneServiceClient_Call) Return(dataPlaneServiceClient dedicatedv1.DataPlaneServiceClient) *Client_GetDataPlaneServiceClient_Call {
	_c.Call.Return(dataPlaneServiceClient)
	return _c
}

func (_c *Client_GetDataPlaneServiceClient_Call) RunAndReturn(run func() dedicatedv1.DataPlaneServiceClient) *Client_GetDataPlaneServiceClient_Call {
	_c.Call.Return(run)
	return _c
}

// GetDataplanePermission provides a mock function for the type Client
func (_mock *Client) GetDataplanePermission(ctx context.Context, in *dedicatedv1.GetDataplanePermissionRequest, opts ...grpc.CallOption) (*dedicatedv1.GetDataplanePermissionResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.GetDataplanePermissionResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.GetDataplanePermissionRequest, ...grpc.CallOption) (*dedicatedv1.GetDataplanePermissionResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.GetDataplanePermissionRequest, ...grpc.CallOption) *dedicatedv1.GetDataplanePermissionResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.GetDataplanePermissionResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.GetDataplanePermissionRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetDataplanePermission is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.GetDataplanePermissionRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) GetDataplanePermission(ctx interface{}, in interface{}, opts ...interface{}) *Client_GetDataplanePermission_Call {
	return &Client_GetDataplanePermission_Call{Call: _e.mock.On("GetDataplanePermission",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_GetDataplanePermission_Call) Run(run func(ctx context.Context, in *dedicatedv1.GetDataplanePermissionRequest, opts ...grpc.CallOption)) *Client_GetDataplanePermission_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.GetDataplanePermissionRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.GetDataplanePermissionRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_GetDataplanePermission_Call) Return(getDataplanePermissionResponse *dedicatedv1.GetDataplanePermissionResponse, err error) *Client_GetDataplanePermission_Call {
	_c.Call.Return(getDataplanePermissionResponse, err)
	return _c
}

func (_c *Client_GetDataplanePermission_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.GetDataplanePermissionRequest, opts ...grpc.CallOption) (*dedicatedv1.GetDataplanePermissionResponse, error)) *Client_GetDataplanePermission_Call {
	_c.Call.Return(run)
	return _c
}

// GetK8SInformation provides a mock function for the type Client
func (_mock *Client) GetK8SInformation(ctx context.Context, in *dedicatedv1.GetK8SInformationRequest, opts ...grpc.CallOption) (*dedicatedv1.K8SInformation, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.K8SInformation
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.GetK8SInformationRequest, ...grpc.CallOption) (*dedicatedv1.K8SInformation, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.GetK8SInformationRequest, ...grpc.CallOption) *dedicatedv1.K8SInformation); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.K8SInformation)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.GetK8SInformationRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetK8SInformation is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.GetK8SInformationRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) GetK8SInformation(ctx interface{}, in interface{}, opts ...interface{}) *Client_GetK8SInformation_Call {
	return &Client_GetK8SInformation_Call{Call: _e.mock.On("GetK8SInformation",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_GetK8SInformation_Call) Run(run func(ctx context.Context, in *dedicatedv1.GetK8SInformationRequest, opts ...grpc.CallOption)) *Client_GetK8SInformation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.GetK8SInformationRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.GetK8SInformationRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_GetK8SInformation_Call) Return(k8SInformation *dedicatedv1.K8SInformation, err error) *Client_GetK8SInformation_Call {
	_c.Call.Return(k8SInformation, err)
	return _c
}

func (_c *Client_GetK8SInformation_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.GetK8SInformationRequest, opts ...grpc.CallOption) (*dedicatedv1.K8SInformation, error)) *Client_GetK8SInformation_Call {
	_c.Call.Return(run)
	return _c
}

// GetKeyspaceRole provides a mock function for the type Client
func (_mock *Client) GetKeyspaceRole(ctx context.Context, in *dedicatedv1.GetKeyspaceRoleRequest, opts ...grpc.CallOption) (*dedicatedv1.KeyspaceRole, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.KeyspaceRole
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.GetKeyspaceRoleRequest, ...grpc.CallOption) (*dedicatedv1.KeyspaceRole, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.GetKeyspaceRoleRequest, ...grpc.CallOption) *dedicatedv1.KeyspaceRole); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.KeyspaceRole)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.GetKeyspaceRoleRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetKeyspaceRole is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.GetKeyspaceRoleRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) GetKeyspaceRole(ctx interface{}, in interface{}, opts ...interface{}) *Client_GetKeyspaceRole_Call {
	return &Client_GetKeyspaceRole_Call{Call: _e.mock.On("GetKeyspaceRole",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_GetKeyspaceRole_Call) Run(run func(ctx context.Context, in *dedicatedv1.GetKeyspaceRoleRequest, opts ...grpc.CallOption)) *Client_GetKeyspaceRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.GetKeyspaceRoleRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.GetKeyspaceRoleRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_GetKeyspaceRole_Call) Return(keyspaceRole *dedicatedv1.KeyspaceRole, err error) *Client_GetKeyspaceRole_Call {
	_c.Call.Return(keyspaceRole, err)
	return _c
}

func (_c *Client_GetKeyspaceRole_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.GetKeyspaceRoleRequest, opts ...grpc.CallOption) (*dedicatedv1.KeyspaceRole, error)) *Client_GetKeyspaceRole_Call {
	_c.Call.Return(run)
	return _c
}

// GetKeyspaceRoleServiceClient provides a mock function for the type Client
func (_mock *Client) GetKeyspaceRoleServiceClient() dedicatedv1.KeyspaceRoleServiceClient {
	ret := _mock.Called()

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

	var r0 dedicatedv1.KeyspaceRoleServiceClient
	if returnFunc, ok := ret.Get(0).(func() dedicatedv1.KeyspaceRoleServiceClient); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(dedicatedv1.KeyspaceRoleServiceClient)
		}
	}
	return r0
}

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

// GetKeyspaceRoleServiceClient is a helper method to define mock.On call
func (_e *Client_Expecter) GetKeyspaceRoleServiceClient() *Client_GetKeyspaceRoleServiceClient_Call {
	return &Client_GetKeyspaceRoleServiceClient_Call{Call: _e.mock.On("GetKeyspaceRoleServiceClient")}
}

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

func (_c *Client_GetKeyspaceRoleServiceClient_Call) Return(keyspaceRoleServiceClient dedicatedv1.KeyspaceRoleServiceClient) *Client_GetKeyspaceRoleServiceClient_Call {
	_c.Call.Return(keyspaceRoleServiceClient)
	return _c
}

func (_c *Client_GetKeyspaceRoleServiceClient_Call) RunAndReturn(run func() dedicatedv1.KeyspaceRoleServiceClient) *Client_GetKeyspaceRoleServiceClient_Call {
	_c.Call.Return(run)
	return _c
}

// GetLifecycleRules provides a mock function for the type Client
func (_mock *Client) GetLifecycleRules(ctx context.Context, in *dedicatedv1.GetLifecycleRulesRequest, opts ...grpc.CallOption) (*dedicatedv1.GetLifecycleRulesResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.GetLifecycleRulesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.GetLifecycleRulesRequest, ...grpc.CallOption) (*dedicatedv1.GetLifecycleRulesResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.GetLifecycleRulesRequest, ...grpc.CallOption) *dedicatedv1.GetLifecycleRulesResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.GetLifecycleRulesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.GetLifecycleRulesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetLifecycleRules is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.GetLifecycleRulesRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) GetLifecycleRules(ctx interface{}, in interface{}, opts ...interface{}) *Client_GetLifecycleRules_Call {
	return &Client_GetLifecycleRules_Call{Call: _e.mock.On("GetLifecycleRules",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_GetLifecycleRules_Call) Run(run func(ctx context.Context, in *dedicatedv1.GetLifecycleRulesRequest, opts ...grpc.CallOption)) *Client_GetLifecycleRules_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.GetLifecycleRulesRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.GetLifecycleRulesRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_GetLifecycleRules_Call) Return(getLifecycleRulesResponse *dedicatedv1.GetLifecycleRulesResponse, err error) *Client_GetLifecycleRules_Call {
	_c.Call.Return(getLifecycleRulesResponse, err)
	return _c
}

func (_c *Client_GetLifecycleRules_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.GetLifecycleRulesRequest, opts ...grpc.CallOption) (*dedicatedv1.GetLifecycleRulesResponse, error)) *Client_GetLifecycleRules_Call {
	_c.Call.Return(run)
	return _c
}

// GetLoadBalancer provides a mock function for the type Client
func (_mock *Client) GetLoadBalancer(ctx context.Context, in *dedicatedv1.GetLoadBalancerRequest, opts ...grpc.CallOption) (*dedicatedv1.LoadBalancer, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.LoadBalancer
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.GetLoadBalancerRequest, ...grpc.CallOption) (*dedicatedv1.LoadBalancer, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.GetLoadBalancerRequest, ...grpc.CallOption) *dedicatedv1.LoadBalancer); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.LoadBalancer)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.GetLoadBalancerRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetLoadBalancer is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.GetLoadBalancerRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) GetLoadBalancer(ctx interface{}, in interface{}, opts ...interface{}) *Client_GetLoadBalancer_Call {
	return &Client_GetLoadBalancer_Call{Call: _e.mock.On("GetLoadBalancer",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_GetLoadBalancer_Call) Run(run func(ctx context.Context, in *dedicatedv1.GetLoadBalancerRequest, opts ...grpc.CallOption)) *Client_GetLoadBalancer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.GetLoadBalancerRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.GetLoadBalancerRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_GetLoadBalancer_Call) Return(loadBalancer *dedicatedv1.LoadBalancer, err error) *Client_GetLoadBalancer_Call {
	_c.Call.Return(loadBalancer, err)
	return _c
}

func (_c *Client_GetLoadBalancer_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.GetLoadBalancerRequest, opts ...grpc.CallOption) (*dedicatedv1.LoadBalancer, error)) *Client_GetLoadBalancer_Call {
	_c.Call.Return(run)
	return _c
}

// GetLoadBalancerServiceClient provides a mock function for the type Client
func (_mock *Client) GetLoadBalancerServiceClient() dedicatedv1.LoadBalancerServiceClient {
	ret := _mock.Called()

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

	var r0 dedicatedv1.LoadBalancerServiceClient
	if returnFunc, ok := ret.Get(0).(func() dedicatedv1.LoadBalancerServiceClient); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(dedicatedv1.LoadBalancerServiceClient)
		}
	}
	return r0
}

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

// GetLoadBalancerServiceClient is a helper method to define mock.On call
func (_e *Client_Expecter) GetLoadBalancerServiceClient() *Client_GetLoadBalancerServiceClient_Call {
	return &Client_GetLoadBalancerServiceClient_Call{Call: _e.mock.On("GetLoadBalancerServiceClient")}
}

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

func (_c *Client_GetLoadBalancerServiceClient_Call) Return(loadBalancerServiceClient dedicatedv1.LoadBalancerServiceClient) *Client_GetLoadBalancerServiceClient_Call {
	_c.Call.Return(loadBalancerServiceClient)
	return _c
}

func (_c *Client_GetLoadBalancerServiceClient_Call) RunAndReturn(run func() dedicatedv1.LoadBalancerServiceClient) *Client_GetLoadBalancerServiceClient_Call {
	_c.Call.Return(run)
	return _c
}

// GetPrivateLinkConnectionServiceClient provides a mock function for the type Client
func (_mock *Client) GetPrivateLinkConnectionServiceClient() dedicatedv1.PrivateLinkConnectionServiceClient {
	ret := _mock.Called()

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

	var r0 dedicatedv1.PrivateLinkConnectionServiceClient
	if returnFunc, ok := ret.Get(0).(func() dedicatedv1.PrivateLinkConnectionServiceClient); ok {
		r0 = returnFunc()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(dedicatedv1.PrivateLinkConnectionServiceClient)
		}
	}
	return r0
}

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

// GetPrivateLinkConnectionServiceClient is a helper method to define mock.On call
func (_e *Client_Expecter) GetPrivateLinkConnectionServiceClient() *Client_GetPrivateLinkConnectionServiceClient_Call {
	return &Client_GetPrivateLinkConnectionServiceClient_Call{Call: _e.mock.On("GetPrivateLinkConnectionServiceClient")}
}

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

func (_c *Client_GetPrivateLinkConnectionServiceClient_Call) Return(privateLinkConnectionServiceClient dedicatedv1.PrivateLinkConnectionServiceClient) *Client_GetPrivateLinkConnectionServiceClient_Call {
	_c.Call.Return(privateLinkConnectionServiceClient)
	return _c
}

func (_c *Client_GetPrivateLinkConnectionServiceClient_Call) RunAndReturn(run func() dedicatedv1.PrivateLinkConnectionServiceClient) *Client_GetPrivateLinkConnectionServiceClient_Call {
	_c.Call.Return(run)
	return _c
}

// GetPrivateLinkEndpoint provides a mock function for the type Client
func (_mock *Client) GetPrivateLinkEndpoint(ctx context.Context, in *dedicatedv1.GetPrivateLinkEndpointRequest, opts ...grpc.CallOption) (*dedicatedv1.PrivateLinkEndpoint, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.PrivateLinkEndpoint
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.GetPrivateLinkEndpointRequest, ...grpc.CallOption) (*dedicatedv1.PrivateLinkEndpoint, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.GetPrivateLinkEndpointRequest, ...grpc.CallOption) *dedicatedv1.PrivateLinkEndpoint); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.PrivateLinkEndpoint)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.GetPrivateLinkEndpointRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetPrivateLinkEndpoint is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.GetPrivateLinkEndpointRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) GetPrivateLinkEndpoint(ctx interface{}, in interface{}, opts ...interface{}) *Client_GetPrivateLinkEndpoint_Call {
	return &Client_GetPrivateLinkEndpoint_Call{Call: _e.mock.On("GetPrivateLinkEndpoint",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_GetPrivateLinkEndpoint_Call) Run(run func(ctx context.Context, in *dedicatedv1.GetPrivateLinkEndpointRequest, opts ...grpc.CallOption)) *Client_GetPrivateLinkEndpoint_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.GetPrivateLinkEndpointRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.GetPrivateLinkEndpointRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_GetPrivateLinkEndpoint_Call) Return(privateLinkEndpoint *dedicatedv1.PrivateLinkEndpoint, err error) *Client_GetPrivateLinkEndpoint_Call {
	_c.Call.Return(privateLinkEndpoint, err)
	return _c
}

func (_c *Client_GetPrivateLinkEndpoint_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.GetPrivateLinkEndpointRequest, opts ...grpc.CallOption) (*dedicatedv1.PrivateLinkEndpoint, error)) *Client_GetPrivateLinkEndpoint_Call {
	_c.Call.Return(run)
	return _c
}

// GetPrivateLinkService provides a mock function for the type Client
func (_mock *Client) GetPrivateLinkService(ctx context.Context, in *dedicatedv1.GetPrivateLinkServiceRequest, opts ...grpc.CallOption) (*dedicatedv1.PrivateLinkService, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.PrivateLinkService
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.GetPrivateLinkServiceRequest, ...grpc.CallOption) (*dedicatedv1.PrivateLinkService, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.GetPrivateLinkServiceRequest, ...grpc.CallOption) *dedicatedv1.PrivateLinkService); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.PrivateLinkService)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.GetPrivateLinkServiceRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetPrivateLinkService is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.GetPrivateLinkServiceRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) GetPrivateLinkService(ctx interface{}, in interface{}, opts ...interface{}) *Client_GetPrivateLinkService_Call {
	return &Client_GetPrivateLinkService_Call{Call: _e.mock.On("GetPrivateLinkService",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_GetPrivateLinkService_Call) Run(run func(ctx context.Context, in *dedicatedv1.GetPrivateLinkServiceRequest, opts ...grpc.CallOption)) *Client_GetPrivateLinkService_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.GetPrivateLinkServiceRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.GetPrivateLinkServiceRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_GetPrivateLinkService_Call) Return(privateLinkService *dedicatedv1.PrivateLinkService, err error) *Client_GetPrivateLinkService_Call {
	_c.Call.Return(privateLinkService, err)
	return _c
}

func (_c *Client_GetPrivateLinkService_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.GetPrivateLinkServiceRequest, opts ...grpc.CallOption) (*dedicatedv1.PrivateLinkService, error)) *Client_GetPrivateLinkService_Call {
	_c.Call.Return(run)
	return _c
}

// GrantDataplanePermission provides a mock function for the type Client
func (_mock *Client) GrantDataplanePermission(ctx context.Context, in *dedicatedv1.GrantDataplanePermissionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.GrantDataplanePermissionRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.GrantDataplanePermissionRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.GrantDataplanePermissionRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GrantDataplanePermission is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.GrantDataplanePermissionRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) GrantDataplanePermission(ctx interface{}, in interface{}, opts ...interface{}) *Client_GrantDataplanePermission_Call {
	return &Client_GrantDataplanePermission_Call{Call: _e.mock.On("GrantDataplanePermission",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_GrantDataplanePermission_Call) Run(run func(ctx context.Context, in *dedicatedv1.GrantDataplanePermissionRequest, opts ...grpc.CallOption)) *Client_GrantDataplanePermission_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.GrantDataplanePermissionRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.GrantDataplanePermissionRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_GrantDataplanePermission_Call) Return(empty *emptypb.Empty, err error) *Client_GrantDataplanePermission_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *Client_GrantDataplanePermission_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.GrantDataplanePermissionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *Client_GrantDataplanePermission_Call {
	_c.Call.Return(run)
	return _c
}

// LegacyDeleteNodePool provides a mock function for the type Client
func (_mock *Client) LegacyDeleteNodePool(ctx context.Context, in *dedicatedv1.LegacyDeleteNodePoolRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.LegacyDeleteNodePoolRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.LegacyDeleteNodePoolRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.LegacyDeleteNodePoolRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// LegacyDeleteNodePool is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.LegacyDeleteNodePoolRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) LegacyDeleteNodePool(ctx interface{}, in interface{}, opts ...interface{}) *Client_LegacyDeleteNodePool_Call {
	return &Client_LegacyDeleteNodePool_Call{Call: _e.mock.On("LegacyDeleteNodePool",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_LegacyDeleteNodePool_Call) Run(run func(ctx context.Context, in *dedicatedv1.LegacyDeleteNodePoolRequest, opts ...grpc.CallOption)) *Client_LegacyDeleteNodePool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.LegacyDeleteNodePoolRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.LegacyDeleteNodePoolRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_LegacyDeleteNodePool_Call) Return(empty *emptypb.Empty, err error) *Client_LegacyDeleteNodePool_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *Client_LegacyDeleteNodePool_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.LegacyDeleteNodePoolRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *Client_LegacyDeleteNodePool_Call {
	_c.Call.Return(run)
	return _c
}

// ListBuckets provides a mock function for the type Client
func (_mock *Client) ListBuckets(ctx context.Context, in *dedicatedv1.ListBucketsRequest, opts ...grpc.CallOption) (*dedicatedv1.ListBucketsResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.ListBucketsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.ListBucketsRequest, ...grpc.CallOption) (*dedicatedv1.ListBucketsResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.ListBucketsRequest, ...grpc.CallOption) *dedicatedv1.ListBucketsResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.ListBucketsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.ListBucketsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListBuckets is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.ListBucketsRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) ListBuckets(ctx interface{}, in interface{}, opts ...interface{}) *Client_ListBuckets_Call {
	return &Client_ListBuckets_Call{Call: _e.mock.On("ListBuckets",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_ListBuckets_Call) Run(run func(ctx context.Context, in *dedicatedv1.ListBucketsRequest, opts ...grpc.CallOption)) *Client_ListBuckets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.ListBucketsRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.ListBucketsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_ListBuckets_Call) Return(listBucketsResponse *dedicatedv1.ListBucketsResponse, err error) *Client_ListBuckets_Call {
	_c.Call.Return(listBucketsResponse, err)
	return _c
}

func (_c *Client_ListBuckets_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.ListBucketsRequest, opts ...grpc.CallOption) (*dedicatedv1.ListBucketsResponse, error)) *Client_ListBuckets_Call {
	_c.Call.Return(run)
	return _c
}

// ListDataPlanes provides a mock function for the type Client
func (_mock *Client) ListDataPlanes(ctx context.Context, in *dedicatedv1.ListDataPlanesRequest, opts ...grpc.CallOption) (*dedicatedv1.ListDataPlanesResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.ListDataPlanesResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.ListDataPlanesRequest, ...grpc.CallOption) (*dedicatedv1.ListDataPlanesResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.ListDataPlanesRequest, ...grpc.CallOption) *dedicatedv1.ListDataPlanesResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.ListDataPlanesResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.ListDataPlanesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListDataPlanes is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.ListDataPlanesRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) ListDataPlanes(ctx interface{}, in interface{}, opts ...interface{}) *Client_ListDataPlanes_Call {
	return &Client_ListDataPlanes_Call{Call: _e.mock.On("ListDataPlanes",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_ListDataPlanes_Call) Run(run func(ctx context.Context, in *dedicatedv1.ListDataPlanesRequest, opts ...grpc.CallOption)) *Client_ListDataPlanes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.ListDataPlanesRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.ListDataPlanesRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_ListDataPlanes_Call) Return(listDataPlanesResponse *dedicatedv1.ListDataPlanesResponse, err error) *Client_ListDataPlanes_Call {
	_c.Call.Return(listDataPlanesResponse, err)
	return _c
}

func (_c *Client_ListDataPlanes_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.ListDataPlanesRequest, opts ...grpc.CallOption) (*dedicatedv1.ListDataPlanesResponse, error)) *Client_ListDataPlanes_Call {
	_c.Call.Return(run)
	return _c
}

// ListK8SInformation provides a mock function for the type Client
func (_mock *Client) ListK8SInformation(ctx context.Context, in *dedicatedv1.ListK8SInformationRequest, opts ...grpc.CallOption) (*dedicatedv1.K8SInformationList, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.K8SInformationList
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.ListK8SInformationRequest, ...grpc.CallOption) (*dedicatedv1.K8SInformationList, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.ListK8SInformationRequest, ...grpc.CallOption) *dedicatedv1.K8SInformationList); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.K8SInformationList)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.ListK8SInformationRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListK8SInformation is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.ListK8SInformationRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) ListK8SInformation(ctx interface{}, in interface{}, opts ...interface{}) *Client_ListK8SInformation_Call {
	return &Client_ListK8SInformation_Call{Call: _e.mock.On("ListK8SInformation",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_ListK8SInformation_Call) Run(run func(ctx context.Context, in *dedicatedv1.ListK8SInformationRequest, opts ...grpc.CallOption)) *Client_ListK8SInformation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.ListK8SInformationRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.ListK8SInformationRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_ListK8SInformation_Call) Return(k8SInformationList *dedicatedv1.K8SInformationList, err error) *Client_ListK8SInformation_Call {
	_c.Call.Return(k8SInformationList, err)
	return _c
}

func (_c *Client_ListK8SInformation_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.ListK8SInformationRequest, opts ...grpc.CallOption) (*dedicatedv1.K8SInformationList, error)) *Client_ListK8SInformation_Call {
	_c.Call.Return(run)
	return _c
}

// ListNodePoolConfigs provides a mock function for the type Client
func (_mock *Client) ListNodePoolConfigs(ctx context.Context, in *dedicatedv1.ListNodePoolConfigsRequest, opts ...grpc.CallOption) (*dedicatedv1.ListNodePoolConfigsResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.ListNodePoolConfigsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.ListNodePoolConfigsRequest, ...grpc.CallOption) (*dedicatedv1.ListNodePoolConfigsResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.ListNodePoolConfigsRequest, ...grpc.CallOption) *dedicatedv1.ListNodePoolConfigsResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.ListNodePoolConfigsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.ListNodePoolConfigsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListNodePoolConfigs is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.ListNodePoolConfigsRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) ListNodePoolConfigs(ctx interface{}, in interface{}, opts ...interface{}) *Client_ListNodePoolConfigs_Call {
	return &Client_ListNodePoolConfigs_Call{Call: _e.mock.On("ListNodePoolConfigs",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_ListNodePoolConfigs_Call) Run(run func(ctx context.Context, in *dedicatedv1.ListNodePoolConfigsRequest, opts ...grpc.CallOption)) *Client_ListNodePoolConfigs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.ListNodePoolConfigsRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.ListNodePoolConfigsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_ListNodePoolConfigs_Call) Return(listNodePoolConfigsResponse *dedicatedv1.ListNodePoolConfigsResponse, err error) *Client_ListNodePoolConfigs_Call {
	_c.Call.Return(listNodePoolConfigsResponse, err)
	return _c
}

func (_c *Client_ListNodePoolConfigs_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.ListNodePoolConfigsRequest, opts ...grpc.CallOption) (*dedicatedv1.ListNodePoolConfigsResponse, error)) *Client_ListNodePoolConfigs_Call {
	_c.Call.Return(run)
	return _c
}

// ListNodePools provides a mock function for the type Client
func (_mock *Client) ListNodePools(ctx context.Context, in *dedicatedv1.ListNodePoolsRequest, opts ...grpc.CallOption) (*dedicatedv1.ListNodePoolsResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.ListNodePoolsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.ListNodePoolsRequest, ...grpc.CallOption) (*dedicatedv1.ListNodePoolsResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.ListNodePoolsRequest, ...grpc.CallOption) *dedicatedv1.ListNodePoolsResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.ListNodePoolsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.ListNodePoolsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListNodePools is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.ListNodePoolsRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) ListNodePools(ctx interface{}, in interface{}, opts ...interface{}) *Client_ListNodePools_Call {
	return &Client_ListNodePools_Call{Call: _e.mock.On("ListNodePools",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_ListNodePools_Call) Run(run func(ctx context.Context, in *dedicatedv1.ListNodePoolsRequest, opts ...grpc.CallOption)) *Client_ListNodePools_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.ListNodePoolsRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.ListNodePoolsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_ListNodePools_Call) Return(listNodePoolsResponse *dedicatedv1.ListNodePoolsResponse, err error) *Client_ListNodePools_Call {
	_c.Call.Return(listNodePoolsResponse, err)
	return _c
}

func (_c *Client_ListNodePools_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.ListNodePoolsRequest, opts ...grpc.CallOption) (*dedicatedv1.ListNodePoolsResponse, error)) *Client_ListNodePools_Call {
	_c.Call.Return(run)
	return _c
}

// ListPrivateLinkEndpoints provides a mock function for the type Client
func (_mock *Client) ListPrivateLinkEndpoints(ctx context.Context, in *dedicatedv1.ListPrivateLinkEndpointsRequest, opts ...grpc.CallOption) (*dedicatedv1.ListPrivateLinkEndpointsResponse, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.ListPrivateLinkEndpointsResponse
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.ListPrivateLinkEndpointsRequest, ...grpc.CallOption) (*dedicatedv1.ListPrivateLinkEndpointsResponse, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.ListPrivateLinkEndpointsRequest, ...grpc.CallOption) *dedicatedv1.ListPrivateLinkEndpointsResponse); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.ListPrivateLinkEndpointsResponse)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.ListPrivateLinkEndpointsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListPrivateLinkEndpoints is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.ListPrivateLinkEndpointsRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) ListPrivateLinkEndpoints(ctx interface{}, in interface{}, opts ...interface{}) *Client_ListPrivateLinkEndpoints_Call {
	return &Client_ListPrivateLinkEndpoints_Call{Call: _e.mock.On("ListPrivateLinkEndpoints",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_ListPrivateLinkEndpoints_Call) Run(run func(ctx context.Context, in *dedicatedv1.ListPrivateLinkEndpointsRequest, opts ...grpc.CallOption)) *Client_ListPrivateLinkEndpoints_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.ListPrivateLinkEndpointsRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.ListPrivateLinkEndpointsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_ListPrivateLinkEndpoints_Call) Return(listPrivateLinkEndpointsResponse *dedicatedv1.ListPrivateLinkEndpointsResponse, err error) *Client_ListPrivateLinkEndpoints_Call {
	_c.Call.Return(listPrivateLinkEndpointsResponse, err)
	return _c
}

func (_c *Client_ListPrivateLinkEndpoints_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.ListPrivateLinkEndpointsRequest, opts ...grpc.CallOption) (*dedicatedv1.ListPrivateLinkEndpointsResponse, error)) *Client_ListPrivateLinkEndpoints_Call {
	_c.Call.Return(run)
	return _c
}

// RevokeDataplanePermission provides a mock function for the type Client
func (_mock *Client) RevokeDataplanePermission(ctx context.Context, in *dedicatedv1.RevokeDataplanePermissionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.RevokeDataplanePermissionRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.RevokeDataplanePermissionRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.RevokeDataplanePermissionRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// RevokeDataplanePermission is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.RevokeDataplanePermissionRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) RevokeDataplanePermission(ctx interface{}, in interface{}, opts ...interface{}) *Client_RevokeDataplanePermission_Call {
	return &Client_RevokeDataplanePermission_Call{Call: _e.mock.On("RevokeDataplanePermission",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_RevokeDataplanePermission_Call) Run(run func(ctx context.Context, in *dedicatedv1.RevokeDataplanePermissionRequest, opts ...grpc.CallOption)) *Client_RevokeDataplanePermission_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.RevokeDataplanePermissionRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.RevokeDataplanePermissionRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_RevokeDataplanePermission_Call) Return(empty *emptypb.Empty, err error) *Client_RevokeDataplanePermission_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *Client_RevokeDataplanePermission_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.RevokeDataplanePermissionRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *Client_RevokeDataplanePermission_Call {
	_c.Call.Return(run)
	return _c
}

// SetKongAuditLogSetting provides a mock function for the type Client
func (_mock *Client) SetKongAuditLogSetting(ctx context.Context, in *dedicatedv1.SetKongAuditLogSettingRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.SetKongAuditLogSettingRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.SetKongAuditLogSettingRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.SetKongAuditLogSettingRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// SetKongAuditLogSetting is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.SetKongAuditLogSettingRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) SetKongAuditLogSetting(ctx interface{}, in interface{}, opts ...interface{}) *Client_SetKongAuditLogSetting_Call {
	return &Client_SetKongAuditLogSetting_Call{Call: _e.mock.On("SetKongAuditLogSetting",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_SetKongAuditLogSetting_Call) Run(run func(ctx context.Context, in *dedicatedv1.SetKongAuditLogSettingRequest, opts ...grpc.CallOption)) *Client_SetKongAuditLogSetting_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.SetKongAuditLogSettingRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.SetKongAuditLogSettingRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_SetKongAuditLogSetting_Call) Return(empty *emptypb.Empty, err error) *Client_SetKongAuditLogSetting_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *Client_SetKongAuditLogSetting_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.SetKongAuditLogSettingRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *Client_SetKongAuditLogSetting_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDataPlaneCloudTags provides a mock function for the type Client
func (_mock *Client) UpdateDataPlaneCloudTags(ctx context.Context, in *dedicatedv1.UpdateDataPlaneCloudTagsRequest, opts ...grpc.CallOption) (*dedicatedv1.DataPlane, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.DataPlane
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.UpdateDataPlaneCloudTagsRequest, ...grpc.CallOption) (*dedicatedv1.DataPlane, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.UpdateDataPlaneCloudTagsRequest, ...grpc.CallOption) *dedicatedv1.DataPlane); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.DataPlane)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.UpdateDataPlaneCloudTagsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateDataPlaneCloudTags is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.UpdateDataPlaneCloudTagsRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) UpdateDataPlaneCloudTags(ctx interface{}, in interface{}, opts ...interface{}) *Client_UpdateDataPlaneCloudTags_Call {
	return &Client_UpdateDataPlaneCloudTags_Call{Call: _e.mock.On("UpdateDataPlaneCloudTags",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_UpdateDataPlaneCloudTags_Call) Run(run func(ctx context.Context, in *dedicatedv1.UpdateDataPlaneCloudTagsRequest, opts ...grpc.CallOption)) *Client_UpdateDataPlaneCloudTags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.UpdateDataPlaneCloudTagsRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.UpdateDataPlaneCloudTagsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_UpdateDataPlaneCloudTags_Call) Return(dataPlane *dedicatedv1.DataPlane, err error) *Client_UpdateDataPlaneCloudTags_Call {
	_c.Call.Return(dataPlane, err)
	return _c
}

func (_c *Client_UpdateDataPlaneCloudTags_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.UpdateDataPlaneCloudTagsRequest, opts ...grpc.CallOption) (*dedicatedv1.DataPlane, error)) *Client_UpdateDataPlaneCloudTags_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateLoadBalancer provides a mock function for the type Client
func (_mock *Client) UpdateLoadBalancer(ctx context.Context, in *dedicatedv1.UpdateLoadBalancerRequest, opts ...grpc.CallOption) (*dedicatedv1.LoadBalancer, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.LoadBalancer
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.UpdateLoadBalancerRequest, ...grpc.CallOption) (*dedicatedv1.LoadBalancer, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.UpdateLoadBalancerRequest, ...grpc.CallOption) *dedicatedv1.LoadBalancer); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.LoadBalancer)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.UpdateLoadBalancerRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateLoadBalancer is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.UpdateLoadBalancerRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) UpdateLoadBalancer(ctx interface{}, in interface{}, opts ...interface{}) *Client_UpdateLoadBalancer_Call {
	return &Client_UpdateLoadBalancer_Call{Call: _e.mock.On("UpdateLoadBalancer",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_UpdateLoadBalancer_Call) Run(run func(ctx context.Context, in *dedicatedv1.UpdateLoadBalancerRequest, opts ...grpc.CallOption)) *Client_UpdateLoadBalancer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.UpdateLoadBalancerRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.UpdateLoadBalancerRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_UpdateLoadBalancer_Call) Return(loadBalancer *dedicatedv1.LoadBalancer, err error) *Client_UpdateLoadBalancer_Call {
	_c.Call.Return(loadBalancer, err)
	return _c
}

func (_c *Client_UpdateLoadBalancer_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.UpdateLoadBalancerRequest, opts ...grpc.CallOption) (*dedicatedv1.LoadBalancer, error)) *Client_UpdateLoadBalancer_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateNodePool provides a mock function for the type Client
func (_mock *Client) UpdateNodePool(ctx context.Context, in *dedicatedv1.UpdateNodePoolRequest, opts ...grpc.CallOption) (*dedicatedv1.NodePool, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.NodePool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.UpdateNodePoolRequest, ...grpc.CallOption) (*dedicatedv1.NodePool, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.UpdateNodePoolRequest, ...grpc.CallOption) *dedicatedv1.NodePool); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.NodePool)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.UpdateNodePoolRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateNodePool is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.UpdateNodePoolRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) UpdateNodePool(ctx interface{}, in interface{}, opts ...interface{}) *Client_UpdateNodePool_Call {
	return &Client_UpdateNodePool_Call{Call: _e.mock.On("UpdateNodePool",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_UpdateNodePool_Call) Run(run func(ctx context.Context, in *dedicatedv1.UpdateNodePoolRequest, opts ...grpc.CallOption)) *Client_UpdateNodePool_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.UpdateNodePoolRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.UpdateNodePoolRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_UpdateNodePool_Call) Return(nodePool *dedicatedv1.NodePool, err error) *Client_UpdateNodePool_Call {
	_c.Call.Return(nodePool, err)
	return _c
}

func (_c *Client_UpdateNodePool_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.UpdateNodePoolRequest, opts ...grpc.CallOption) (*dedicatedv1.NodePool, error)) *Client_UpdateNodePool_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePrivateLinkService provides a mock function for the type Client
func (_mock *Client) UpdatePrivateLinkService(ctx context.Context, in *dedicatedv1.UpdatePrivateLinkServiceRequest, opts ...grpc.CallOption) (*dedicatedv1.PrivateLinkService, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *dedicatedv1.PrivateLinkService
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.UpdatePrivateLinkServiceRequest, ...grpc.CallOption) (*dedicatedv1.PrivateLinkService, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.UpdatePrivateLinkServiceRequest, ...grpc.CallOption) *dedicatedv1.PrivateLinkService); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dedicatedv1.PrivateLinkService)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.UpdatePrivateLinkServiceRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdatePrivateLinkService is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.UpdatePrivateLinkServiceRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) UpdatePrivateLinkService(ctx interface{}, in interface{}, opts ...interface{}) *Client_UpdatePrivateLinkService_Call {
	return &Client_UpdatePrivateLinkService_Call{Call: _e.mock.On("UpdatePrivateLinkService",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_UpdatePrivateLinkService_Call) Run(run func(ctx context.Context, in *dedicatedv1.UpdatePrivateLinkServiceRequest, opts ...grpc.CallOption)) *Client_UpdatePrivateLinkService_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.UpdatePrivateLinkServiceRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.UpdatePrivateLinkServiceRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_UpdatePrivateLinkService_Call) Return(privateLinkService *dedicatedv1.PrivateLinkService, err error) *Client_UpdatePrivateLinkService_Call {
	_c.Call.Return(privateLinkService, err)
	return _c
}

func (_c *Client_UpdatePrivateLinkService_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.UpdatePrivateLinkServiceRequest, opts ...grpc.CallOption) (*dedicatedv1.PrivateLinkService, error)) *Client_UpdatePrivateLinkService_Call {
	_c.Call.Return(run)
	return _c
}

// UpgradeDataPlane provides a mock function for the type Client
func (_mock *Client) UpgradeDataPlane(ctx context.Context, in *dedicatedv1.UpgradeDataPlaneRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.UpgradeDataPlaneRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.UpgradeDataPlaneRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.UpgradeDataPlaneRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpgradeDataPlane is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.UpgradeDataPlaneRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) UpgradeDataPlane(ctx interface{}, in interface{}, opts ...interface{}) *Client_UpgradeDataPlane_Call {
	return &Client_UpgradeDataPlane_Call{Call: _e.mock.On("UpgradeDataPlane",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_UpgradeDataPlane_Call) Run(run func(ctx context.Context, in *dedicatedv1.UpgradeDataPlaneRequest, opts ...grpc.CallOption)) *Client_UpgradeDataPlane_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.UpgradeDataPlaneRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.UpgradeDataPlaneRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_UpgradeDataPlane_Call) Return(empty *emptypb.Empty, err error) *Client_UpgradeDataPlane_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *Client_UpgradeDataPlane_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.UpgradeDataPlaneRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *Client_UpgradeDataPlane_Call {
	_c.Call.Return(run)
	return _c
}

// UpsertSharedPoolCloudTags provides a mock function for the type Client
func (_mock *Client) UpsertSharedPoolCloudTags(ctx context.Context, in *dedicatedv1.UpsertSharedPoolCloudTagsRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.UpsertSharedPoolCloudTagsRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.UpsertSharedPoolCloudTagsRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.UpsertSharedPoolCloudTagsRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpsertSharedPoolCloudTags is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.UpsertSharedPoolCloudTagsRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) UpsertSharedPoolCloudTags(ctx interface{}, in interface{}, opts ...interface{}) *Client_UpsertSharedPoolCloudTags_Call {
	return &Client_UpsertSharedPoolCloudTags_Call{Call: _e.mock.On("UpsertSharedPoolCloudTags",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_UpsertSharedPoolCloudTags_Call) Run(run func(ctx context.Context, in *dedicatedv1.UpsertSharedPoolCloudTagsRequest, opts ...grpc.CallOption)) *Client_UpsertSharedPoolCloudTags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.UpsertSharedPoolCloudTagsRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.UpsertSharedPoolCloudTagsRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_UpsertSharedPoolCloudTags_Call) Return(empty *emptypb.Empty, err error) *Client_UpsertSharedPoolCloudTags_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *Client_UpsertSharedPoolCloudTags_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.UpsertSharedPoolCloudTagsRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *Client_UpsertSharedPoolCloudTags_Call {
	_c.Call.Return(run)
	return _c
}

// ValidatePrivateLinkEndpointZones provides a mock function for the type Client
func (_mock *Client) ValidatePrivateLinkEndpointZones(ctx context.Context, in *dedicatedv1.ValidatePrivateLinkEndpointZonesRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	var tmpRet mock.Arguments
	if len(opts) > 0 {
		tmpRet = _mock.Called(ctx, in, opts)
	} else {
		tmpRet = _mock.Called(ctx, in)
	}
	ret := tmpRet

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

	var r0 *emptypb.Empty
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.ValidatePrivateLinkEndpointZonesRequest, ...grpc.CallOption) (*emptypb.Empty, error)); ok {
		return returnFunc(ctx, in, opts...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *dedicatedv1.ValidatePrivateLinkEndpointZonesRequest, ...grpc.CallOption) *emptypb.Empty); ok {
		r0 = returnFunc(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*emptypb.Empty)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *dedicatedv1.ValidatePrivateLinkEndpointZonesRequest, ...grpc.CallOption) error); ok {
		r1 = returnFunc(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ValidatePrivateLinkEndpointZones is a helper method to define mock.On call
//   - ctx context.Context
//   - in *dedicatedv1.ValidatePrivateLinkEndpointZonesRequest
//   - opts ...grpc.CallOption
func (_e *Client_Expecter) ValidatePrivateLinkEndpointZones(ctx interface{}, in interface{}, opts ...interface{}) *Client_ValidatePrivateLinkEndpointZones_Call {
	return &Client_ValidatePrivateLinkEndpointZones_Call{Call: _e.mock.On("ValidatePrivateLinkEndpointZones",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *Client_ValidatePrivateLinkEndpointZones_Call) Run(run func(ctx context.Context, in *dedicatedv1.ValidatePrivateLinkEndpointZonesRequest, opts ...grpc.CallOption)) *Client_ValidatePrivateLinkEndpointZones_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *dedicatedv1.ValidatePrivateLinkEndpointZonesRequest
		if args[1] != nil {
			arg1 = args[1].(*dedicatedv1.ValidatePrivateLinkEndpointZonesRequest)
		}
		var arg2 []grpc.CallOption
		var variadicArgs []grpc.CallOption
		if len(args) > 2 {
			variadicArgs = args[2].([]grpc.CallOption)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *Client_ValidatePrivateLinkEndpointZones_Call) Return(empty *emptypb.Empty, err error) *Client_ValidatePrivateLinkEndpointZones_Call {
	_c.Call.Return(empty, err)
	return _c
}

func (_c *Client_ValidatePrivateLinkEndpointZones_Call) RunAndReturn(run func(ctx context.Context, in *dedicatedv1.ValidatePrivateLinkEndpointZonesRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)) *Client_ValidatePrivateLinkEndpointZones_Call {
	_c.Call.Return(run)
	return _c
}