github.com/cs3org/reva/v2@v2.27.7/tests/cs3mocks/mocks/GatewayAPIClient.go

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

package mocks

import (
	appproviderv1beta1 "github.com/cs3org/go-cs3apis/cs3/app/provider/v1beta1"
	applicationsv1beta1 "github.com/cs3org/go-cs3apis/cs3/auth/applications/v1beta1"

	authregistryv1beta1 "github.com/cs3org/go-cs3apis/cs3/auth/registry/v1beta1"

	collaborationv1beta1 "github.com/cs3org/go-cs3apis/cs3/sharing/collaboration/v1beta1"

	context "context"

	corev1beta1 "github.com/cs3org/go-cs3apis/cs3/ocm/core/v1beta1"

	gatewayv1beta1 "github.com/cs3org/go-cs3apis/cs3/gateway/v1beta1"

	groupv1beta1 "github.com/cs3org/go-cs3apis/cs3/identity/group/v1beta1"

	grpc "google.golang.org/grpc"

	invitev1beta1 "github.com/cs3org/go-cs3apis/cs3/ocm/invite/v1beta1"

	linkv1beta1 "github.com/cs3org/go-cs3apis/cs3/sharing/link/v1beta1"

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

	ocmv1beta1 "github.com/cs3org/go-cs3apis/cs3/sharing/ocm/v1beta1"

	permissionsv1beta1 "github.com/cs3org/go-cs3apis/cs3/permissions/v1beta1"

	preferencesv1beta1 "github.com/cs3org/go-cs3apis/cs3/preferences/v1beta1"

	providerv1beta1 "github.com/cs3org/go-cs3apis/cs3/storage/provider/v1beta1"

	registryv1beta1 "github.com/cs3org/go-cs3apis/cs3/app/registry/v1beta1"

	txv1beta1 "github.com/cs3org/go-cs3apis/cs3/tx/v1beta1"

	userv1beta1 "github.com/cs3org/go-cs3apis/cs3/identity/user/v1beta1"

	v1beta1 "github.com/cs3org/go-cs3apis/cs3/ocm/provider/v1beta1"
)

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

type GatewayAPIClient_Expecter struct {
	mock *mock.Mock
}

func (_m *GatewayAPIClient) EXPECT() *GatewayAPIClient_Expecter {
	return &GatewayAPIClient_Expecter{mock: &_m.Mock}
}

// AcceptInvite provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) AcceptInvite(ctx context.Context, in *invitev1beta1.AcceptInviteRequest, opts ...grpc.CallOption) (*invitev1beta1.AcceptInviteResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *invitev1beta1.AcceptInviteResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *invitev1beta1.AcceptInviteRequest, ...grpc.CallOption) (*invitev1beta1.AcceptInviteResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *invitev1beta1.AcceptInviteRequest, ...grpc.CallOption) *invitev1beta1.AcceptInviteResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*invitev1beta1.AcceptInviteResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *invitev1beta1.AcceptInviteRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AcceptInvite is a helper method to define mock.On call
//   - ctx context.Context
//   - in *invitev1beta1.AcceptInviteRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) AcceptInvite(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_AcceptInvite_Call {
	return &GatewayAPIClient_AcceptInvite_Call{Call: _e.mock.On("AcceptInvite",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_AcceptInvite_Call) Run(run func(ctx context.Context, in *invitev1beta1.AcceptInviteRequest, opts ...grpc.CallOption)) *GatewayAPIClient_AcceptInvite_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*invitev1beta1.AcceptInviteRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_AcceptInvite_Call) Return(_a0 *invitev1beta1.AcceptInviteResponse, _a1 error) *GatewayAPIClient_AcceptInvite_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_AcceptInvite_Call) RunAndReturn(run func(context.Context, *invitev1beta1.AcceptInviteRequest, ...grpc.CallOption) (*invitev1beta1.AcceptInviteResponse, error)) *GatewayAPIClient_AcceptInvite_Call {
	_c.Call.Return(run)
	return _c
}

// AddAppProvider provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) AddAppProvider(ctx context.Context, in *registryv1beta1.AddAppProviderRequest, opts ...grpc.CallOption) (*registryv1beta1.AddAppProviderResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *registryv1beta1.AddAppProviderResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *registryv1beta1.AddAppProviderRequest, ...grpc.CallOption) (*registryv1beta1.AddAppProviderResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *registryv1beta1.AddAppProviderRequest, ...grpc.CallOption) *registryv1beta1.AddAppProviderResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*registryv1beta1.AddAppProviderResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *registryv1beta1.AddAppProviderRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AddAppProvider is a helper method to define mock.On call
//   - ctx context.Context
//   - in *registryv1beta1.AddAppProviderRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) AddAppProvider(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_AddAppProvider_Call {
	return &GatewayAPIClient_AddAppProvider_Call{Call: _e.mock.On("AddAppProvider",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_AddAppProvider_Call) Run(run func(ctx context.Context, in *registryv1beta1.AddAppProviderRequest, opts ...grpc.CallOption)) *GatewayAPIClient_AddAppProvider_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*registryv1beta1.AddAppProviderRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_AddAppProvider_Call) Return(_a0 *registryv1beta1.AddAppProviderResponse, _a1 error) *GatewayAPIClient_AddAppProvider_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_AddAppProvider_Call) RunAndReturn(run func(context.Context, *registryv1beta1.AddAppProviderRequest, ...grpc.CallOption) (*registryv1beta1.AddAppProviderResponse, error)) *GatewayAPIClient_AddAppProvider_Call {
	_c.Call.Return(run)
	return _c
}

// Authenticate provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) Authenticate(ctx context.Context, in *gatewayv1beta1.AuthenticateRequest, opts ...grpc.CallOption) (*gatewayv1beta1.AuthenticateResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *gatewayv1beta1.AuthenticateResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *gatewayv1beta1.AuthenticateRequest, ...grpc.CallOption) (*gatewayv1beta1.AuthenticateResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *gatewayv1beta1.AuthenticateRequest, ...grpc.CallOption) *gatewayv1beta1.AuthenticateResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*gatewayv1beta1.AuthenticateResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *gatewayv1beta1.AuthenticateRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Authenticate is a helper method to define mock.On call
//   - ctx context.Context
//   - in *gatewayv1beta1.AuthenticateRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) Authenticate(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_Authenticate_Call {
	return &GatewayAPIClient_Authenticate_Call{Call: _e.mock.On("Authenticate",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_Authenticate_Call) Run(run func(ctx context.Context, in *gatewayv1beta1.AuthenticateRequest, opts ...grpc.CallOption)) *GatewayAPIClient_Authenticate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*gatewayv1beta1.AuthenticateRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_Authenticate_Call) Return(_a0 *gatewayv1beta1.AuthenticateResponse, _a1 error) *GatewayAPIClient_Authenticate_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_Authenticate_Call) RunAndReturn(run func(context.Context, *gatewayv1beta1.AuthenticateRequest, ...grpc.CallOption) (*gatewayv1beta1.AuthenticateResponse, error)) *GatewayAPIClient_Authenticate_Call {
	_c.Call.Return(run)
	return _c
}

// CancelTransfer provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) CancelTransfer(ctx context.Context, in *txv1beta1.CancelTransferRequest, opts ...grpc.CallOption) (*txv1beta1.CancelTransferResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *txv1beta1.CancelTransferResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *txv1beta1.CancelTransferRequest, ...grpc.CallOption) (*txv1beta1.CancelTransferResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *txv1beta1.CancelTransferRequest, ...grpc.CallOption) *txv1beta1.CancelTransferResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*txv1beta1.CancelTransferResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *txv1beta1.CancelTransferRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CancelTransfer is a helper method to define mock.On call
//   - ctx context.Context
//   - in *txv1beta1.CancelTransferRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) CancelTransfer(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_CancelTransfer_Call {
	return &GatewayAPIClient_CancelTransfer_Call{Call: _e.mock.On("CancelTransfer",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_CancelTransfer_Call) Run(run func(ctx context.Context, in *txv1beta1.CancelTransferRequest, opts ...grpc.CallOption)) *GatewayAPIClient_CancelTransfer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*txv1beta1.CancelTransferRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_CancelTransfer_Call) Return(_a0 *txv1beta1.CancelTransferResponse, _a1 error) *GatewayAPIClient_CancelTransfer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_CancelTransfer_Call) RunAndReturn(run func(context.Context, *txv1beta1.CancelTransferRequest, ...grpc.CallOption) (*txv1beta1.CancelTransferResponse, error)) *GatewayAPIClient_CancelTransfer_Call {
	_c.Call.Return(run)
	return _c
}

// CheckPermission provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) CheckPermission(ctx context.Context, in *permissionsv1beta1.CheckPermissionRequest, opts ...grpc.CallOption) (*permissionsv1beta1.CheckPermissionResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *permissionsv1beta1.CheckPermissionResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *permissionsv1beta1.CheckPermissionRequest, ...grpc.CallOption) (*permissionsv1beta1.CheckPermissionResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *permissionsv1beta1.CheckPermissionRequest, ...grpc.CallOption) *permissionsv1beta1.CheckPermissionResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*permissionsv1beta1.CheckPermissionResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *permissionsv1beta1.CheckPermissionRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CheckPermission is a helper method to define mock.On call
//   - ctx context.Context
//   - in *permissionsv1beta1.CheckPermissionRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) CheckPermission(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_CheckPermission_Call {
	return &GatewayAPIClient_CheckPermission_Call{Call: _e.mock.On("CheckPermission",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_CheckPermission_Call) Run(run func(ctx context.Context, in *permissionsv1beta1.CheckPermissionRequest, opts ...grpc.CallOption)) *GatewayAPIClient_CheckPermission_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*permissionsv1beta1.CheckPermissionRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_CheckPermission_Call) Return(_a0 *permissionsv1beta1.CheckPermissionResponse, _a1 error) *GatewayAPIClient_CheckPermission_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_CheckPermission_Call) RunAndReturn(run func(context.Context, *permissionsv1beta1.CheckPermissionRequest, ...grpc.CallOption) (*permissionsv1beta1.CheckPermissionResponse, error)) *GatewayAPIClient_CheckPermission_Call {
	_c.Call.Return(run)
	return _c
}

// CreateContainer provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) CreateContainer(ctx context.Context, in *providerv1beta1.CreateContainerRequest, opts ...grpc.CallOption) (*providerv1beta1.CreateContainerResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.CreateContainerResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.CreateContainerRequest, ...grpc.CallOption) (*providerv1beta1.CreateContainerResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.CreateContainerRequest, ...grpc.CallOption) *providerv1beta1.CreateContainerResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.CreateContainerResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.CreateContainerRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateContainer is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.CreateContainerRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) CreateContainer(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_CreateContainer_Call {
	return &GatewayAPIClient_CreateContainer_Call{Call: _e.mock.On("CreateContainer",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_CreateContainer_Call) Run(run func(ctx context.Context, in *providerv1beta1.CreateContainerRequest, opts ...grpc.CallOption)) *GatewayAPIClient_CreateContainer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.CreateContainerRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_CreateContainer_Call) Return(_a0 *providerv1beta1.CreateContainerResponse, _a1 error) *GatewayAPIClient_CreateContainer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_CreateContainer_Call) RunAndReturn(run func(context.Context, *providerv1beta1.CreateContainerRequest, ...grpc.CallOption) (*providerv1beta1.CreateContainerResponse, error)) *GatewayAPIClient_CreateContainer_Call {
	_c.Call.Return(run)
	return _c
}

// CreateHome provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) CreateHome(ctx context.Context, in *providerv1beta1.CreateHomeRequest, opts ...grpc.CallOption) (*providerv1beta1.CreateHomeResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.CreateHomeResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.CreateHomeRequest, ...grpc.CallOption) (*providerv1beta1.CreateHomeResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.CreateHomeRequest, ...grpc.CallOption) *providerv1beta1.CreateHomeResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.CreateHomeResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.CreateHomeRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateHome is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.CreateHomeRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) CreateHome(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_CreateHome_Call {
	return &GatewayAPIClient_CreateHome_Call{Call: _e.mock.On("CreateHome",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_CreateHome_Call) Run(run func(ctx context.Context, in *providerv1beta1.CreateHomeRequest, opts ...grpc.CallOption)) *GatewayAPIClient_CreateHome_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.CreateHomeRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_CreateHome_Call) Return(_a0 *providerv1beta1.CreateHomeResponse, _a1 error) *GatewayAPIClient_CreateHome_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_CreateHome_Call) RunAndReturn(run func(context.Context, *providerv1beta1.CreateHomeRequest, ...grpc.CallOption) (*providerv1beta1.CreateHomeResponse, error)) *GatewayAPIClient_CreateHome_Call {
	_c.Call.Return(run)
	return _c
}

// CreateOCMCoreShare provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) CreateOCMCoreShare(ctx context.Context, in *corev1beta1.CreateOCMCoreShareRequest, opts ...grpc.CallOption) (*corev1beta1.CreateOCMCoreShareResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *corev1beta1.CreateOCMCoreShareResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *corev1beta1.CreateOCMCoreShareRequest, ...grpc.CallOption) (*corev1beta1.CreateOCMCoreShareResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *corev1beta1.CreateOCMCoreShareRequest, ...grpc.CallOption) *corev1beta1.CreateOCMCoreShareResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*corev1beta1.CreateOCMCoreShareResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *corev1beta1.CreateOCMCoreShareRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateOCMCoreShare is a helper method to define mock.On call
//   - ctx context.Context
//   - in *corev1beta1.CreateOCMCoreShareRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) CreateOCMCoreShare(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_CreateOCMCoreShare_Call {
	return &GatewayAPIClient_CreateOCMCoreShare_Call{Call: _e.mock.On("CreateOCMCoreShare",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_CreateOCMCoreShare_Call) Run(run func(ctx context.Context, in *corev1beta1.CreateOCMCoreShareRequest, opts ...grpc.CallOption)) *GatewayAPIClient_CreateOCMCoreShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*corev1beta1.CreateOCMCoreShareRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_CreateOCMCoreShare_Call) Return(_a0 *corev1beta1.CreateOCMCoreShareResponse, _a1 error) *GatewayAPIClient_CreateOCMCoreShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_CreateOCMCoreShare_Call) RunAndReturn(run func(context.Context, *corev1beta1.CreateOCMCoreShareRequest, ...grpc.CallOption) (*corev1beta1.CreateOCMCoreShareResponse, error)) *GatewayAPIClient_CreateOCMCoreShare_Call {
	_c.Call.Return(run)
	return _c
}

// CreateOCMShare provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) CreateOCMShare(ctx context.Context, in *ocmv1beta1.CreateOCMShareRequest, opts ...grpc.CallOption) (*ocmv1beta1.CreateOCMShareResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *ocmv1beta1.CreateOCMShareResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ocmv1beta1.CreateOCMShareRequest, ...grpc.CallOption) (*ocmv1beta1.CreateOCMShareResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ocmv1beta1.CreateOCMShareRequest, ...grpc.CallOption) *ocmv1beta1.CreateOCMShareResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ocmv1beta1.CreateOCMShareResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ocmv1beta1.CreateOCMShareRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateOCMShare is a helper method to define mock.On call
//   - ctx context.Context
//   - in *ocmv1beta1.CreateOCMShareRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) CreateOCMShare(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_CreateOCMShare_Call {
	return &GatewayAPIClient_CreateOCMShare_Call{Call: _e.mock.On("CreateOCMShare",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_CreateOCMShare_Call) Run(run func(ctx context.Context, in *ocmv1beta1.CreateOCMShareRequest, opts ...grpc.CallOption)) *GatewayAPIClient_CreateOCMShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*ocmv1beta1.CreateOCMShareRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_CreateOCMShare_Call) Return(_a0 *ocmv1beta1.CreateOCMShareResponse, _a1 error) *GatewayAPIClient_CreateOCMShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_CreateOCMShare_Call) RunAndReturn(run func(context.Context, *ocmv1beta1.CreateOCMShareRequest, ...grpc.CallOption) (*ocmv1beta1.CreateOCMShareResponse, error)) *GatewayAPIClient_CreateOCMShare_Call {
	_c.Call.Return(run)
	return _c
}

// CreatePublicShare provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) CreatePublicShare(ctx context.Context, in *linkv1beta1.CreatePublicShareRequest, opts ...grpc.CallOption) (*linkv1beta1.CreatePublicShareResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *linkv1beta1.CreatePublicShareResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *linkv1beta1.CreatePublicShareRequest, ...grpc.CallOption) (*linkv1beta1.CreatePublicShareResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *linkv1beta1.CreatePublicShareRequest, ...grpc.CallOption) *linkv1beta1.CreatePublicShareResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*linkv1beta1.CreatePublicShareResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *linkv1beta1.CreatePublicShareRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreatePublicShare is a helper method to define mock.On call
//   - ctx context.Context
//   - in *linkv1beta1.CreatePublicShareRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) CreatePublicShare(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_CreatePublicShare_Call {
	return &GatewayAPIClient_CreatePublicShare_Call{Call: _e.mock.On("CreatePublicShare",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_CreatePublicShare_Call) Run(run func(ctx context.Context, in *linkv1beta1.CreatePublicShareRequest, opts ...grpc.CallOption)) *GatewayAPIClient_CreatePublicShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*linkv1beta1.CreatePublicShareRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_CreatePublicShare_Call) Return(_a0 *linkv1beta1.CreatePublicShareResponse, _a1 error) *GatewayAPIClient_CreatePublicShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_CreatePublicShare_Call) RunAndReturn(run func(context.Context, *linkv1beta1.CreatePublicShareRequest, ...grpc.CallOption) (*linkv1beta1.CreatePublicShareResponse, error)) *GatewayAPIClient_CreatePublicShare_Call {
	_c.Call.Return(run)
	return _c
}

// CreateShare provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) CreateShare(ctx context.Context, in *collaborationv1beta1.CreateShareRequest, opts ...grpc.CallOption) (*collaborationv1beta1.CreateShareResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *collaborationv1beta1.CreateShareResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.CreateShareRequest, ...grpc.CallOption) (*collaborationv1beta1.CreateShareResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.CreateShareRequest, ...grpc.CallOption) *collaborationv1beta1.CreateShareResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*collaborationv1beta1.CreateShareResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *collaborationv1beta1.CreateShareRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateShare is a helper method to define mock.On call
//   - ctx context.Context
//   - in *collaborationv1beta1.CreateShareRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) CreateShare(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_CreateShare_Call {
	return &GatewayAPIClient_CreateShare_Call{Call: _e.mock.On("CreateShare",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_CreateShare_Call) Run(run func(ctx context.Context, in *collaborationv1beta1.CreateShareRequest, opts ...grpc.CallOption)) *GatewayAPIClient_CreateShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*collaborationv1beta1.CreateShareRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_CreateShare_Call) Return(_a0 *collaborationv1beta1.CreateShareResponse, _a1 error) *GatewayAPIClient_CreateShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_CreateShare_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.CreateShareRequest, ...grpc.CallOption) (*collaborationv1beta1.CreateShareResponse, error)) *GatewayAPIClient_CreateShare_Call {
	_c.Call.Return(run)
	return _c
}

// CreateStorageSpace provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) CreateStorageSpace(ctx context.Context, in *providerv1beta1.CreateStorageSpaceRequest, opts ...grpc.CallOption) (*providerv1beta1.CreateStorageSpaceResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.CreateStorageSpaceResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.CreateStorageSpaceRequest, ...grpc.CallOption) (*providerv1beta1.CreateStorageSpaceResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.CreateStorageSpaceRequest, ...grpc.CallOption) *providerv1beta1.CreateStorageSpaceResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.CreateStorageSpaceResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.CreateStorageSpaceRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateStorageSpace is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.CreateStorageSpaceRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) CreateStorageSpace(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_CreateStorageSpace_Call {
	return &GatewayAPIClient_CreateStorageSpace_Call{Call: _e.mock.On("CreateStorageSpace",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_CreateStorageSpace_Call) Run(run func(ctx context.Context, in *providerv1beta1.CreateStorageSpaceRequest, opts ...grpc.CallOption)) *GatewayAPIClient_CreateStorageSpace_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.CreateStorageSpaceRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_CreateStorageSpace_Call) Return(_a0 *providerv1beta1.CreateStorageSpaceResponse, _a1 error) *GatewayAPIClient_CreateStorageSpace_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_CreateStorageSpace_Call) RunAndReturn(run func(context.Context, *providerv1beta1.CreateStorageSpaceRequest, ...grpc.CallOption) (*providerv1beta1.CreateStorageSpaceResponse, error)) *GatewayAPIClient_CreateStorageSpace_Call {
	_c.Call.Return(run)
	return _c
}

// CreateSymlink provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) CreateSymlink(ctx context.Context, in *providerv1beta1.CreateSymlinkRequest, opts ...grpc.CallOption) (*providerv1beta1.CreateSymlinkResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.CreateSymlinkResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.CreateSymlinkRequest, ...grpc.CallOption) (*providerv1beta1.CreateSymlinkResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.CreateSymlinkRequest, ...grpc.CallOption) *providerv1beta1.CreateSymlinkResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.CreateSymlinkResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.CreateSymlinkRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateSymlink is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.CreateSymlinkRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) CreateSymlink(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_CreateSymlink_Call {
	return &GatewayAPIClient_CreateSymlink_Call{Call: _e.mock.On("CreateSymlink",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_CreateSymlink_Call) Run(run func(ctx context.Context, in *providerv1beta1.CreateSymlinkRequest, opts ...grpc.CallOption)) *GatewayAPIClient_CreateSymlink_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.CreateSymlinkRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_CreateSymlink_Call) Return(_a0 *providerv1beta1.CreateSymlinkResponse, _a1 error) *GatewayAPIClient_CreateSymlink_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_CreateSymlink_Call) RunAndReturn(run func(context.Context, *providerv1beta1.CreateSymlinkRequest, ...grpc.CallOption) (*providerv1beta1.CreateSymlinkResponse, error)) *GatewayAPIClient_CreateSymlink_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTransfer provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) CreateTransfer(ctx context.Context, in *txv1beta1.CreateTransferRequest, opts ...grpc.CallOption) (*txv1beta1.CreateTransferResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *txv1beta1.CreateTransferResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *txv1beta1.CreateTransferRequest, ...grpc.CallOption) (*txv1beta1.CreateTransferResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *txv1beta1.CreateTransferRequest, ...grpc.CallOption) *txv1beta1.CreateTransferResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*txv1beta1.CreateTransferResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *txv1beta1.CreateTransferRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateTransfer is a helper method to define mock.On call
//   - ctx context.Context
//   - in *txv1beta1.CreateTransferRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) CreateTransfer(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_CreateTransfer_Call {
	return &GatewayAPIClient_CreateTransfer_Call{Call: _e.mock.On("CreateTransfer",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_CreateTransfer_Call) Run(run func(ctx context.Context, in *txv1beta1.CreateTransferRequest, opts ...grpc.CallOption)) *GatewayAPIClient_CreateTransfer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*txv1beta1.CreateTransferRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_CreateTransfer_Call) Return(_a0 *txv1beta1.CreateTransferResponse, _a1 error) *GatewayAPIClient_CreateTransfer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_CreateTransfer_Call) RunAndReturn(run func(context.Context, *txv1beta1.CreateTransferRequest, ...grpc.CallOption) (*txv1beta1.CreateTransferResponse, error)) *GatewayAPIClient_CreateTransfer_Call {
	_c.Call.Return(run)
	return _c
}

// Delete provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) Delete(ctx context.Context, in *providerv1beta1.DeleteRequest, opts ...grpc.CallOption) (*providerv1beta1.DeleteResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.DeleteResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.DeleteRequest, ...grpc.CallOption) (*providerv1beta1.DeleteResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.DeleteRequest, ...grpc.CallOption) *providerv1beta1.DeleteResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.DeleteResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.DeleteRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.DeleteRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) Delete(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_Delete_Call {
	return &GatewayAPIClient_Delete_Call{Call: _e.mock.On("Delete",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_Delete_Call) Run(run func(ctx context.Context, in *providerv1beta1.DeleteRequest, opts ...grpc.CallOption)) *GatewayAPIClient_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.DeleteRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_Delete_Call) Return(_a0 *providerv1beta1.DeleteResponse, _a1 error) *GatewayAPIClient_Delete_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_Delete_Call) RunAndReturn(run func(context.Context, *providerv1beta1.DeleteRequest, ...grpc.CallOption) (*providerv1beta1.DeleteResponse, error)) *GatewayAPIClient_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteAcceptedUser provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) DeleteAcceptedUser(ctx context.Context, in *invitev1beta1.DeleteAcceptedUserRequest, opts ...grpc.CallOption) (*invitev1beta1.DeleteAcceptedUserResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *invitev1beta1.DeleteAcceptedUserResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *invitev1beta1.DeleteAcceptedUserRequest, ...grpc.CallOption) (*invitev1beta1.DeleteAcceptedUserResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *invitev1beta1.DeleteAcceptedUserRequest, ...grpc.CallOption) *invitev1beta1.DeleteAcceptedUserResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*invitev1beta1.DeleteAcceptedUserResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *invitev1beta1.DeleteAcceptedUserRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DeleteAcceptedUser is a helper method to define mock.On call
//   - ctx context.Context
//   - in *invitev1beta1.DeleteAcceptedUserRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) DeleteAcceptedUser(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_DeleteAcceptedUser_Call {
	return &GatewayAPIClient_DeleteAcceptedUser_Call{Call: _e.mock.On("DeleteAcceptedUser",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_DeleteAcceptedUser_Call) Run(run func(ctx context.Context, in *invitev1beta1.DeleteAcceptedUserRequest, opts ...grpc.CallOption)) *GatewayAPIClient_DeleteAcceptedUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*invitev1beta1.DeleteAcceptedUserRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_DeleteAcceptedUser_Call) Return(_a0 *invitev1beta1.DeleteAcceptedUserResponse, _a1 error) *GatewayAPIClient_DeleteAcceptedUser_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_DeleteAcceptedUser_Call) RunAndReturn(run func(context.Context, *invitev1beta1.DeleteAcceptedUserRequest, ...grpc.CallOption) (*invitev1beta1.DeleteAcceptedUserResponse, error)) *GatewayAPIClient_DeleteAcceptedUser_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteOCMCoreShare provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) DeleteOCMCoreShare(ctx context.Context, in *corev1beta1.DeleteOCMCoreShareRequest, opts ...grpc.CallOption) (*corev1beta1.DeleteOCMCoreShareResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *corev1beta1.DeleteOCMCoreShareResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *corev1beta1.DeleteOCMCoreShareRequest, ...grpc.CallOption) (*corev1beta1.DeleteOCMCoreShareResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *corev1beta1.DeleteOCMCoreShareRequest, ...grpc.CallOption) *corev1beta1.DeleteOCMCoreShareResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*corev1beta1.DeleteOCMCoreShareResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *corev1beta1.DeleteOCMCoreShareRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DeleteOCMCoreShare is a helper method to define mock.On call
//   - ctx context.Context
//   - in *corev1beta1.DeleteOCMCoreShareRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) DeleteOCMCoreShare(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_DeleteOCMCoreShare_Call {
	return &GatewayAPIClient_DeleteOCMCoreShare_Call{Call: _e.mock.On("DeleteOCMCoreShare",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_DeleteOCMCoreShare_Call) Run(run func(ctx context.Context, in *corev1beta1.DeleteOCMCoreShareRequest, opts ...grpc.CallOption)) *GatewayAPIClient_DeleteOCMCoreShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*corev1beta1.DeleteOCMCoreShareRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_DeleteOCMCoreShare_Call) Return(_a0 *corev1beta1.DeleteOCMCoreShareResponse, _a1 error) *GatewayAPIClient_DeleteOCMCoreShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_DeleteOCMCoreShare_Call) RunAndReturn(run func(context.Context, *corev1beta1.DeleteOCMCoreShareRequest, ...grpc.CallOption) (*corev1beta1.DeleteOCMCoreShareResponse, error)) *GatewayAPIClient_DeleteOCMCoreShare_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteStorageSpace provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) DeleteStorageSpace(ctx context.Context, in *providerv1beta1.DeleteStorageSpaceRequest, opts ...grpc.CallOption) (*providerv1beta1.DeleteStorageSpaceResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.DeleteStorageSpaceResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.DeleteStorageSpaceRequest, ...grpc.CallOption) (*providerv1beta1.DeleteStorageSpaceResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.DeleteStorageSpaceRequest, ...grpc.CallOption) *providerv1beta1.DeleteStorageSpaceResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.DeleteStorageSpaceResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.DeleteStorageSpaceRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DeleteStorageSpace is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.DeleteStorageSpaceRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) DeleteStorageSpace(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_DeleteStorageSpace_Call {
	return &GatewayAPIClient_DeleteStorageSpace_Call{Call: _e.mock.On("DeleteStorageSpace",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_DeleteStorageSpace_Call) Run(run func(ctx context.Context, in *providerv1beta1.DeleteStorageSpaceRequest, opts ...grpc.CallOption)) *GatewayAPIClient_DeleteStorageSpace_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.DeleteStorageSpaceRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_DeleteStorageSpace_Call) Return(_a0 *providerv1beta1.DeleteStorageSpaceResponse, _a1 error) *GatewayAPIClient_DeleteStorageSpace_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_DeleteStorageSpace_Call) RunAndReturn(run func(context.Context, *providerv1beta1.DeleteStorageSpaceRequest, ...grpc.CallOption) (*providerv1beta1.DeleteStorageSpaceResponse, error)) *GatewayAPIClient_DeleteStorageSpace_Call {
	_c.Call.Return(run)
	return _c
}

// FindAcceptedUsers provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) FindAcceptedUsers(ctx context.Context, in *invitev1beta1.FindAcceptedUsersRequest, opts ...grpc.CallOption) (*invitev1beta1.FindAcceptedUsersResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *invitev1beta1.FindAcceptedUsersResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *invitev1beta1.FindAcceptedUsersRequest, ...grpc.CallOption) (*invitev1beta1.FindAcceptedUsersResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *invitev1beta1.FindAcceptedUsersRequest, ...grpc.CallOption) *invitev1beta1.FindAcceptedUsersResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*invitev1beta1.FindAcceptedUsersResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *invitev1beta1.FindAcceptedUsersRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// FindAcceptedUsers is a helper method to define mock.On call
//   - ctx context.Context
//   - in *invitev1beta1.FindAcceptedUsersRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) FindAcceptedUsers(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_FindAcceptedUsers_Call {
	return &GatewayAPIClient_FindAcceptedUsers_Call{Call: _e.mock.On("FindAcceptedUsers",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_FindAcceptedUsers_Call) Run(run func(ctx context.Context, in *invitev1beta1.FindAcceptedUsersRequest, opts ...grpc.CallOption)) *GatewayAPIClient_FindAcceptedUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*invitev1beta1.FindAcceptedUsersRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_FindAcceptedUsers_Call) Return(_a0 *invitev1beta1.FindAcceptedUsersResponse, _a1 error) *GatewayAPIClient_FindAcceptedUsers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_FindAcceptedUsers_Call) RunAndReturn(run func(context.Context, *invitev1beta1.FindAcceptedUsersRequest, ...grpc.CallOption) (*invitev1beta1.FindAcceptedUsersResponse, error)) *GatewayAPIClient_FindAcceptedUsers_Call {
	_c.Call.Return(run)
	return _c
}

// FindGroups provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) FindGroups(ctx context.Context, in *groupv1beta1.FindGroupsRequest, opts ...grpc.CallOption) (*groupv1beta1.FindGroupsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *groupv1beta1.FindGroupsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *groupv1beta1.FindGroupsRequest, ...grpc.CallOption) (*groupv1beta1.FindGroupsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *groupv1beta1.FindGroupsRequest, ...grpc.CallOption) *groupv1beta1.FindGroupsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*groupv1beta1.FindGroupsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *groupv1beta1.FindGroupsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// FindGroups is a helper method to define mock.On call
//   - ctx context.Context
//   - in *groupv1beta1.FindGroupsRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) FindGroups(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_FindGroups_Call {
	return &GatewayAPIClient_FindGroups_Call{Call: _e.mock.On("FindGroups",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_FindGroups_Call) Run(run func(ctx context.Context, in *groupv1beta1.FindGroupsRequest, opts ...grpc.CallOption)) *GatewayAPIClient_FindGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*groupv1beta1.FindGroupsRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_FindGroups_Call) Return(_a0 *groupv1beta1.FindGroupsResponse, _a1 error) *GatewayAPIClient_FindGroups_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_FindGroups_Call) RunAndReturn(run func(context.Context, *groupv1beta1.FindGroupsRequest, ...grpc.CallOption) (*groupv1beta1.FindGroupsResponse, error)) *GatewayAPIClient_FindGroups_Call {
	_c.Call.Return(run)
	return _c
}

// FindUsers provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) FindUsers(ctx context.Context, in *userv1beta1.FindUsersRequest, opts ...grpc.CallOption) (*userv1beta1.FindUsersResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *userv1beta1.FindUsersResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *userv1beta1.FindUsersRequest, ...grpc.CallOption) (*userv1beta1.FindUsersResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *userv1beta1.FindUsersRequest, ...grpc.CallOption) *userv1beta1.FindUsersResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*userv1beta1.FindUsersResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *userv1beta1.FindUsersRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// FindUsers is a helper method to define mock.On call
//   - ctx context.Context
//   - in *userv1beta1.FindUsersRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) FindUsers(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_FindUsers_Call {
	return &GatewayAPIClient_FindUsers_Call{Call: _e.mock.On("FindUsers",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_FindUsers_Call) Run(run func(ctx context.Context, in *userv1beta1.FindUsersRequest, opts ...grpc.CallOption)) *GatewayAPIClient_FindUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*userv1beta1.FindUsersRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_FindUsers_Call) Return(_a0 *userv1beta1.FindUsersResponse, _a1 error) *GatewayAPIClient_FindUsers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_FindUsers_Call) RunAndReturn(run func(context.Context, *userv1beta1.FindUsersRequest, ...grpc.CallOption) (*userv1beta1.FindUsersResponse, error)) *GatewayAPIClient_FindUsers_Call {
	_c.Call.Return(run)
	return _c
}

// ForwardInvite provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ForwardInvite(ctx context.Context, in *invitev1beta1.ForwardInviteRequest, opts ...grpc.CallOption) (*invitev1beta1.ForwardInviteResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *invitev1beta1.ForwardInviteResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *invitev1beta1.ForwardInviteRequest, ...grpc.CallOption) (*invitev1beta1.ForwardInviteResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *invitev1beta1.ForwardInviteRequest, ...grpc.CallOption) *invitev1beta1.ForwardInviteResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*invitev1beta1.ForwardInviteResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *invitev1beta1.ForwardInviteRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ForwardInvite is a helper method to define mock.On call
//   - ctx context.Context
//   - in *invitev1beta1.ForwardInviteRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ForwardInvite(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ForwardInvite_Call {
	return &GatewayAPIClient_ForwardInvite_Call{Call: _e.mock.On("ForwardInvite",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ForwardInvite_Call) Run(run func(ctx context.Context, in *invitev1beta1.ForwardInviteRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ForwardInvite_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*invitev1beta1.ForwardInviteRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ForwardInvite_Call) Return(_a0 *invitev1beta1.ForwardInviteResponse, _a1 error) *GatewayAPIClient_ForwardInvite_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ForwardInvite_Call) RunAndReturn(run func(context.Context, *invitev1beta1.ForwardInviteRequest, ...grpc.CallOption) (*invitev1beta1.ForwardInviteResponse, error)) *GatewayAPIClient_ForwardInvite_Call {
	_c.Call.Return(run)
	return _c
}

// GenerateAppPassword provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GenerateAppPassword(ctx context.Context, in *applicationsv1beta1.GenerateAppPasswordRequest, opts ...grpc.CallOption) (*applicationsv1beta1.GenerateAppPasswordResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *applicationsv1beta1.GenerateAppPasswordResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *applicationsv1beta1.GenerateAppPasswordRequest, ...grpc.CallOption) (*applicationsv1beta1.GenerateAppPasswordResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *applicationsv1beta1.GenerateAppPasswordRequest, ...grpc.CallOption) *applicationsv1beta1.GenerateAppPasswordResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*applicationsv1beta1.GenerateAppPasswordResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *applicationsv1beta1.GenerateAppPasswordRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GenerateAppPassword is a helper method to define mock.On call
//   - ctx context.Context
//   - in *applicationsv1beta1.GenerateAppPasswordRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GenerateAppPassword(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GenerateAppPassword_Call {
	return &GatewayAPIClient_GenerateAppPassword_Call{Call: _e.mock.On("GenerateAppPassword",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GenerateAppPassword_Call) Run(run func(ctx context.Context, in *applicationsv1beta1.GenerateAppPasswordRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GenerateAppPassword_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*applicationsv1beta1.GenerateAppPasswordRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GenerateAppPassword_Call) Return(_a0 *applicationsv1beta1.GenerateAppPasswordResponse, _a1 error) *GatewayAPIClient_GenerateAppPassword_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GenerateAppPassword_Call) RunAndReturn(run func(context.Context, *applicationsv1beta1.GenerateAppPasswordRequest, ...grpc.CallOption) (*applicationsv1beta1.GenerateAppPasswordResponse, error)) *GatewayAPIClient_GenerateAppPassword_Call {
	_c.Call.Return(run)
	return _c
}

// GenerateInviteToken provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GenerateInviteToken(ctx context.Context, in *invitev1beta1.GenerateInviteTokenRequest, opts ...grpc.CallOption) (*invitev1beta1.GenerateInviteTokenResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *invitev1beta1.GenerateInviteTokenResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *invitev1beta1.GenerateInviteTokenRequest, ...grpc.CallOption) (*invitev1beta1.GenerateInviteTokenResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *invitev1beta1.GenerateInviteTokenRequest, ...grpc.CallOption) *invitev1beta1.GenerateInviteTokenResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*invitev1beta1.GenerateInviteTokenResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *invitev1beta1.GenerateInviteTokenRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GenerateInviteToken is a helper method to define mock.On call
//   - ctx context.Context
//   - in *invitev1beta1.GenerateInviteTokenRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GenerateInviteToken(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GenerateInviteToken_Call {
	return &GatewayAPIClient_GenerateInviteToken_Call{Call: _e.mock.On("GenerateInviteToken",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GenerateInviteToken_Call) Run(run func(ctx context.Context, in *invitev1beta1.GenerateInviteTokenRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GenerateInviteToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*invitev1beta1.GenerateInviteTokenRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GenerateInviteToken_Call) Return(_a0 *invitev1beta1.GenerateInviteTokenResponse, _a1 error) *GatewayAPIClient_GenerateInviteToken_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GenerateInviteToken_Call) RunAndReturn(run func(context.Context, *invitev1beta1.GenerateInviteTokenRequest, ...grpc.CallOption) (*invitev1beta1.GenerateInviteTokenResponse, error)) *GatewayAPIClient_GenerateInviteToken_Call {
	_c.Call.Return(run)
	return _c
}

// GetAcceptedUser provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetAcceptedUser(ctx context.Context, in *invitev1beta1.GetAcceptedUserRequest, opts ...grpc.CallOption) (*invitev1beta1.GetAcceptedUserResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *invitev1beta1.GetAcceptedUserResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *invitev1beta1.GetAcceptedUserRequest, ...grpc.CallOption) (*invitev1beta1.GetAcceptedUserResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *invitev1beta1.GetAcceptedUserRequest, ...grpc.CallOption) *invitev1beta1.GetAcceptedUserResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*invitev1beta1.GetAcceptedUserResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *invitev1beta1.GetAcceptedUserRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetAcceptedUser is a helper method to define mock.On call
//   - ctx context.Context
//   - in *invitev1beta1.GetAcceptedUserRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetAcceptedUser(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetAcceptedUser_Call {
	return &GatewayAPIClient_GetAcceptedUser_Call{Call: _e.mock.On("GetAcceptedUser",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetAcceptedUser_Call) Run(run func(ctx context.Context, in *invitev1beta1.GetAcceptedUserRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetAcceptedUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*invitev1beta1.GetAcceptedUserRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetAcceptedUser_Call) Return(_a0 *invitev1beta1.GetAcceptedUserResponse, _a1 error) *GatewayAPIClient_GetAcceptedUser_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetAcceptedUser_Call) RunAndReturn(run func(context.Context, *invitev1beta1.GetAcceptedUserRequest, ...grpc.CallOption) (*invitev1beta1.GetAcceptedUserResponse, error)) *GatewayAPIClient_GetAcceptedUser_Call {
	_c.Call.Return(run)
	return _c
}

// GetAppPassword provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetAppPassword(ctx context.Context, in *applicationsv1beta1.GetAppPasswordRequest, opts ...grpc.CallOption) (*applicationsv1beta1.GetAppPasswordResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *applicationsv1beta1.GetAppPasswordResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *applicationsv1beta1.GetAppPasswordRequest, ...grpc.CallOption) (*applicationsv1beta1.GetAppPasswordResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *applicationsv1beta1.GetAppPasswordRequest, ...grpc.CallOption) *applicationsv1beta1.GetAppPasswordResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*applicationsv1beta1.GetAppPasswordResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *applicationsv1beta1.GetAppPasswordRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetAppPassword is a helper method to define mock.On call
//   - ctx context.Context
//   - in *applicationsv1beta1.GetAppPasswordRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetAppPassword(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetAppPassword_Call {
	return &GatewayAPIClient_GetAppPassword_Call{Call: _e.mock.On("GetAppPassword",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetAppPassword_Call) Run(run func(ctx context.Context, in *applicationsv1beta1.GetAppPasswordRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetAppPassword_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*applicationsv1beta1.GetAppPasswordRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetAppPassword_Call) Return(_a0 *applicationsv1beta1.GetAppPasswordResponse, _a1 error) *GatewayAPIClient_GetAppPassword_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetAppPassword_Call) RunAndReturn(run func(context.Context, *applicationsv1beta1.GetAppPasswordRequest, ...grpc.CallOption) (*applicationsv1beta1.GetAppPasswordResponse, error)) *GatewayAPIClient_GetAppPassword_Call {
	_c.Call.Return(run)
	return _c
}

// GetAppProviders provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetAppProviders(ctx context.Context, in *registryv1beta1.GetAppProvidersRequest, opts ...grpc.CallOption) (*registryv1beta1.GetAppProvidersResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *registryv1beta1.GetAppProvidersResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *registryv1beta1.GetAppProvidersRequest, ...grpc.CallOption) (*registryv1beta1.GetAppProvidersResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *registryv1beta1.GetAppProvidersRequest, ...grpc.CallOption) *registryv1beta1.GetAppProvidersResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*registryv1beta1.GetAppProvidersResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *registryv1beta1.GetAppProvidersRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetAppProviders is a helper method to define mock.On call
//   - ctx context.Context
//   - in *registryv1beta1.GetAppProvidersRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetAppProviders(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetAppProviders_Call {
	return &GatewayAPIClient_GetAppProviders_Call{Call: _e.mock.On("GetAppProviders",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetAppProviders_Call) Run(run func(ctx context.Context, in *registryv1beta1.GetAppProvidersRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetAppProviders_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*registryv1beta1.GetAppProvidersRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetAppProviders_Call) Return(_a0 *registryv1beta1.GetAppProvidersResponse, _a1 error) *GatewayAPIClient_GetAppProviders_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetAppProviders_Call) RunAndReturn(run func(context.Context, *registryv1beta1.GetAppProvidersRequest, ...grpc.CallOption) (*registryv1beta1.GetAppProvidersResponse, error)) *GatewayAPIClient_GetAppProviders_Call {
	_c.Call.Return(run)
	return _c
}

// GetDefaultAppProviderForMimeType provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetDefaultAppProviderForMimeType(ctx context.Context, in *registryv1beta1.GetDefaultAppProviderForMimeTypeRequest, opts ...grpc.CallOption) (*registryv1beta1.GetDefaultAppProviderForMimeTypeResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *registryv1beta1.GetDefaultAppProviderForMimeTypeResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *registryv1beta1.GetDefaultAppProviderForMimeTypeRequest, ...grpc.CallOption) (*registryv1beta1.GetDefaultAppProviderForMimeTypeResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *registryv1beta1.GetDefaultAppProviderForMimeTypeRequest, ...grpc.CallOption) *registryv1beta1.GetDefaultAppProviderForMimeTypeResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*registryv1beta1.GetDefaultAppProviderForMimeTypeResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *registryv1beta1.GetDefaultAppProviderForMimeTypeRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetDefaultAppProviderForMimeType is a helper method to define mock.On call
//   - ctx context.Context
//   - in *registryv1beta1.GetDefaultAppProviderForMimeTypeRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetDefaultAppProviderForMimeType(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetDefaultAppProviderForMimeType_Call {
	return &GatewayAPIClient_GetDefaultAppProviderForMimeType_Call{Call: _e.mock.On("GetDefaultAppProviderForMimeType",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetDefaultAppProviderForMimeType_Call) Run(run func(ctx context.Context, in *registryv1beta1.GetDefaultAppProviderForMimeTypeRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetDefaultAppProviderForMimeType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*registryv1beta1.GetDefaultAppProviderForMimeTypeRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetDefaultAppProviderForMimeType_Call) Return(_a0 *registryv1beta1.GetDefaultAppProviderForMimeTypeResponse, _a1 error) *GatewayAPIClient_GetDefaultAppProviderForMimeType_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetDefaultAppProviderForMimeType_Call) RunAndReturn(run func(context.Context, *registryv1beta1.GetDefaultAppProviderForMimeTypeRequest, ...grpc.CallOption) (*registryv1beta1.GetDefaultAppProviderForMimeTypeResponse, error)) *GatewayAPIClient_GetDefaultAppProviderForMimeType_Call {
	_c.Call.Return(run)
	return _c
}

// GetGroup provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetGroup(ctx context.Context, in *groupv1beta1.GetGroupRequest, opts ...grpc.CallOption) (*groupv1beta1.GetGroupResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *groupv1beta1.GetGroupResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *groupv1beta1.GetGroupRequest, ...grpc.CallOption) (*groupv1beta1.GetGroupResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *groupv1beta1.GetGroupRequest, ...grpc.CallOption) *groupv1beta1.GetGroupResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*groupv1beta1.GetGroupResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *groupv1beta1.GetGroupRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - in *groupv1beta1.GetGroupRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetGroup(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetGroup_Call {
	return &GatewayAPIClient_GetGroup_Call{Call: _e.mock.On("GetGroup",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetGroup_Call) Run(run func(ctx context.Context, in *groupv1beta1.GetGroupRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*groupv1beta1.GetGroupRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetGroup_Call) Return(_a0 *groupv1beta1.GetGroupResponse, _a1 error) *GatewayAPIClient_GetGroup_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetGroup_Call) RunAndReturn(run func(context.Context, *groupv1beta1.GetGroupRequest, ...grpc.CallOption) (*groupv1beta1.GetGroupResponse, error)) *GatewayAPIClient_GetGroup_Call {
	_c.Call.Return(run)
	return _c
}

// GetGroupByClaim provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetGroupByClaim(ctx context.Context, in *groupv1beta1.GetGroupByClaimRequest, opts ...grpc.CallOption) (*groupv1beta1.GetGroupByClaimResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *groupv1beta1.GetGroupByClaimResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *groupv1beta1.GetGroupByClaimRequest, ...grpc.CallOption) (*groupv1beta1.GetGroupByClaimResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *groupv1beta1.GetGroupByClaimRequest, ...grpc.CallOption) *groupv1beta1.GetGroupByClaimResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*groupv1beta1.GetGroupByClaimResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *groupv1beta1.GetGroupByClaimRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetGroupByClaim is a helper method to define mock.On call
//   - ctx context.Context
//   - in *groupv1beta1.GetGroupByClaimRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetGroupByClaim(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetGroupByClaim_Call {
	return &GatewayAPIClient_GetGroupByClaim_Call{Call: _e.mock.On("GetGroupByClaim",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetGroupByClaim_Call) Run(run func(ctx context.Context, in *groupv1beta1.GetGroupByClaimRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetGroupByClaim_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*groupv1beta1.GetGroupByClaimRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetGroupByClaim_Call) Return(_a0 *groupv1beta1.GetGroupByClaimResponse, _a1 error) *GatewayAPIClient_GetGroupByClaim_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetGroupByClaim_Call) RunAndReturn(run func(context.Context, *groupv1beta1.GetGroupByClaimRequest, ...grpc.CallOption) (*groupv1beta1.GetGroupByClaimResponse, error)) *GatewayAPIClient_GetGroupByClaim_Call {
	_c.Call.Return(run)
	return _c
}

// GetHome provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetHome(ctx context.Context, in *providerv1beta1.GetHomeRequest, opts ...grpc.CallOption) (*providerv1beta1.GetHomeResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.GetHomeResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.GetHomeRequest, ...grpc.CallOption) (*providerv1beta1.GetHomeResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.GetHomeRequest, ...grpc.CallOption) *providerv1beta1.GetHomeResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.GetHomeResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.GetHomeRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetHome is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.GetHomeRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetHome(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetHome_Call {
	return &GatewayAPIClient_GetHome_Call{Call: _e.mock.On("GetHome",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetHome_Call) Run(run func(ctx context.Context, in *providerv1beta1.GetHomeRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetHome_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.GetHomeRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetHome_Call) Return(_a0 *providerv1beta1.GetHomeResponse, _a1 error) *GatewayAPIClient_GetHome_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetHome_Call) RunAndReturn(run func(context.Context, *providerv1beta1.GetHomeRequest, ...grpc.CallOption) (*providerv1beta1.GetHomeResponse, error)) *GatewayAPIClient_GetHome_Call {
	_c.Call.Return(run)
	return _c
}

// GetInfoByDomain provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetInfoByDomain(ctx context.Context, in *v1beta1.GetInfoByDomainRequest, opts ...grpc.CallOption) (*v1beta1.GetInfoByDomainResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *v1beta1.GetInfoByDomainResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.GetInfoByDomainRequest, ...grpc.CallOption) (*v1beta1.GetInfoByDomainResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.GetInfoByDomainRequest, ...grpc.CallOption) *v1beta1.GetInfoByDomainResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v1beta1.GetInfoByDomainResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.GetInfoByDomainRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetInfoByDomain is a helper method to define mock.On call
//   - ctx context.Context
//   - in *v1beta1.GetInfoByDomainRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetInfoByDomain(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetInfoByDomain_Call {
	return &GatewayAPIClient_GetInfoByDomain_Call{Call: _e.mock.On("GetInfoByDomain",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetInfoByDomain_Call) Run(run func(ctx context.Context, in *v1beta1.GetInfoByDomainRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetInfoByDomain_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*v1beta1.GetInfoByDomainRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetInfoByDomain_Call) Return(_a0 *v1beta1.GetInfoByDomainResponse, _a1 error) *GatewayAPIClient_GetInfoByDomain_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetInfoByDomain_Call) RunAndReturn(run func(context.Context, *v1beta1.GetInfoByDomainRequest, ...grpc.CallOption) (*v1beta1.GetInfoByDomainResponse, error)) *GatewayAPIClient_GetInfoByDomain_Call {
	_c.Call.Return(run)
	return _c
}

// GetKey provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetKey(ctx context.Context, in *preferencesv1beta1.GetKeyRequest, opts ...grpc.CallOption) (*preferencesv1beta1.GetKeyResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *preferencesv1beta1.GetKeyResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *preferencesv1beta1.GetKeyRequest, ...grpc.CallOption) (*preferencesv1beta1.GetKeyResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *preferencesv1beta1.GetKeyRequest, ...grpc.CallOption) *preferencesv1beta1.GetKeyResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*preferencesv1beta1.GetKeyResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *preferencesv1beta1.GetKeyRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetKey is a helper method to define mock.On call
//   - ctx context.Context
//   - in *preferencesv1beta1.GetKeyRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetKey(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetKey_Call {
	return &GatewayAPIClient_GetKey_Call{Call: _e.mock.On("GetKey",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetKey_Call) Run(run func(ctx context.Context, in *preferencesv1beta1.GetKeyRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetKey_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*preferencesv1beta1.GetKeyRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetKey_Call) Return(_a0 *preferencesv1beta1.GetKeyResponse, _a1 error) *GatewayAPIClient_GetKey_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetKey_Call) RunAndReturn(run func(context.Context, *preferencesv1beta1.GetKeyRequest, ...grpc.CallOption) (*preferencesv1beta1.GetKeyResponse, error)) *GatewayAPIClient_GetKey_Call {
	_c.Call.Return(run)
	return _c
}

// GetLock provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetLock(ctx context.Context, in *providerv1beta1.GetLockRequest, opts ...grpc.CallOption) (*providerv1beta1.GetLockResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.GetLockResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.GetLockRequest, ...grpc.CallOption) (*providerv1beta1.GetLockResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.GetLockRequest, ...grpc.CallOption) *providerv1beta1.GetLockResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.GetLockResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.GetLockRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetLock is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.GetLockRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetLock(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetLock_Call {
	return &GatewayAPIClient_GetLock_Call{Call: _e.mock.On("GetLock",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetLock_Call) Run(run func(ctx context.Context, in *providerv1beta1.GetLockRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetLock_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.GetLockRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetLock_Call) Return(_a0 *providerv1beta1.GetLockResponse, _a1 error) *GatewayAPIClient_GetLock_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetLock_Call) RunAndReturn(run func(context.Context, *providerv1beta1.GetLockRequest, ...grpc.CallOption) (*providerv1beta1.GetLockResponse, error)) *GatewayAPIClient_GetLock_Call {
	_c.Call.Return(run)
	return _c
}

// GetMembers provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetMembers(ctx context.Context, in *groupv1beta1.GetMembersRequest, opts ...grpc.CallOption) (*groupv1beta1.GetMembersResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *groupv1beta1.GetMembersResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *groupv1beta1.GetMembersRequest, ...grpc.CallOption) (*groupv1beta1.GetMembersResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *groupv1beta1.GetMembersRequest, ...grpc.CallOption) *groupv1beta1.GetMembersResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*groupv1beta1.GetMembersResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *groupv1beta1.GetMembersRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - in *groupv1beta1.GetMembersRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetMembers(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetMembers_Call {
	return &GatewayAPIClient_GetMembers_Call{Call: _e.mock.On("GetMembers",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetMembers_Call) Run(run func(ctx context.Context, in *groupv1beta1.GetMembersRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*groupv1beta1.GetMembersRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetMembers_Call) Return(_a0 *groupv1beta1.GetMembersResponse, _a1 error) *GatewayAPIClient_GetMembers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetMembers_Call) RunAndReturn(run func(context.Context, *groupv1beta1.GetMembersRequest, ...grpc.CallOption) (*groupv1beta1.GetMembersResponse, error)) *GatewayAPIClient_GetMembers_Call {
	_c.Call.Return(run)
	return _c
}

// GetOCMShare provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetOCMShare(ctx context.Context, in *ocmv1beta1.GetOCMShareRequest, opts ...grpc.CallOption) (*ocmv1beta1.GetOCMShareResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *ocmv1beta1.GetOCMShareResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ocmv1beta1.GetOCMShareRequest, ...grpc.CallOption) (*ocmv1beta1.GetOCMShareResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ocmv1beta1.GetOCMShareRequest, ...grpc.CallOption) *ocmv1beta1.GetOCMShareResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ocmv1beta1.GetOCMShareResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ocmv1beta1.GetOCMShareRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetOCMShare is a helper method to define mock.On call
//   - ctx context.Context
//   - in *ocmv1beta1.GetOCMShareRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetOCMShare(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetOCMShare_Call {
	return &GatewayAPIClient_GetOCMShare_Call{Call: _e.mock.On("GetOCMShare",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetOCMShare_Call) Run(run func(ctx context.Context, in *ocmv1beta1.GetOCMShareRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetOCMShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*ocmv1beta1.GetOCMShareRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetOCMShare_Call) Return(_a0 *ocmv1beta1.GetOCMShareResponse, _a1 error) *GatewayAPIClient_GetOCMShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetOCMShare_Call) RunAndReturn(run func(context.Context, *ocmv1beta1.GetOCMShareRequest, ...grpc.CallOption) (*ocmv1beta1.GetOCMShareResponse, error)) *GatewayAPIClient_GetOCMShare_Call {
	_c.Call.Return(run)
	return _c
}

// GetOCMShareByToken provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetOCMShareByToken(ctx context.Context, in *ocmv1beta1.GetOCMShareByTokenRequest, opts ...grpc.CallOption) (*ocmv1beta1.GetOCMShareByTokenResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *ocmv1beta1.GetOCMShareByTokenResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ocmv1beta1.GetOCMShareByTokenRequest, ...grpc.CallOption) (*ocmv1beta1.GetOCMShareByTokenResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ocmv1beta1.GetOCMShareByTokenRequest, ...grpc.CallOption) *ocmv1beta1.GetOCMShareByTokenResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ocmv1beta1.GetOCMShareByTokenResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ocmv1beta1.GetOCMShareByTokenRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetOCMShareByToken is a helper method to define mock.On call
//   - ctx context.Context
//   - in *ocmv1beta1.GetOCMShareByTokenRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetOCMShareByToken(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetOCMShareByToken_Call {
	return &GatewayAPIClient_GetOCMShareByToken_Call{Call: _e.mock.On("GetOCMShareByToken",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetOCMShareByToken_Call) Run(run func(ctx context.Context, in *ocmv1beta1.GetOCMShareByTokenRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetOCMShareByToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*ocmv1beta1.GetOCMShareByTokenRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetOCMShareByToken_Call) Return(_a0 *ocmv1beta1.GetOCMShareByTokenResponse, _a1 error) *GatewayAPIClient_GetOCMShareByToken_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetOCMShareByToken_Call) RunAndReturn(run func(context.Context, *ocmv1beta1.GetOCMShareByTokenRequest, ...grpc.CallOption) (*ocmv1beta1.GetOCMShareByTokenResponse, error)) *GatewayAPIClient_GetOCMShareByToken_Call {
	_c.Call.Return(run)
	return _c
}

// GetPath provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetPath(ctx context.Context, in *providerv1beta1.GetPathRequest, opts ...grpc.CallOption) (*providerv1beta1.GetPathResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.GetPathResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.GetPathRequest, ...grpc.CallOption) (*providerv1beta1.GetPathResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.GetPathRequest, ...grpc.CallOption) *providerv1beta1.GetPathResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.GetPathResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.GetPathRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPath is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.GetPathRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetPath(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetPath_Call {
	return &GatewayAPIClient_GetPath_Call{Call: _e.mock.On("GetPath",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetPath_Call) Run(run func(ctx context.Context, in *providerv1beta1.GetPathRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetPath_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.GetPathRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetPath_Call) Return(_a0 *providerv1beta1.GetPathResponse, _a1 error) *GatewayAPIClient_GetPath_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetPath_Call) RunAndReturn(run func(context.Context, *providerv1beta1.GetPathRequest, ...grpc.CallOption) (*providerv1beta1.GetPathResponse, error)) *GatewayAPIClient_GetPath_Call {
	_c.Call.Return(run)
	return _c
}

// GetPublicShare provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetPublicShare(ctx context.Context, in *linkv1beta1.GetPublicShareRequest, opts ...grpc.CallOption) (*linkv1beta1.GetPublicShareResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *linkv1beta1.GetPublicShareResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *linkv1beta1.GetPublicShareRequest, ...grpc.CallOption) (*linkv1beta1.GetPublicShareResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *linkv1beta1.GetPublicShareRequest, ...grpc.CallOption) *linkv1beta1.GetPublicShareResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*linkv1beta1.GetPublicShareResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *linkv1beta1.GetPublicShareRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPublicShare is a helper method to define mock.On call
//   - ctx context.Context
//   - in *linkv1beta1.GetPublicShareRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetPublicShare(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetPublicShare_Call {
	return &GatewayAPIClient_GetPublicShare_Call{Call: _e.mock.On("GetPublicShare",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetPublicShare_Call) Run(run func(ctx context.Context, in *linkv1beta1.GetPublicShareRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetPublicShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*linkv1beta1.GetPublicShareRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetPublicShare_Call) Return(_a0 *linkv1beta1.GetPublicShareResponse, _a1 error) *GatewayAPIClient_GetPublicShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetPublicShare_Call) RunAndReturn(run func(context.Context, *linkv1beta1.GetPublicShareRequest, ...grpc.CallOption) (*linkv1beta1.GetPublicShareResponse, error)) *GatewayAPIClient_GetPublicShare_Call {
	_c.Call.Return(run)
	return _c
}

// GetPublicShareByToken provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetPublicShareByToken(ctx context.Context, in *linkv1beta1.GetPublicShareByTokenRequest, opts ...grpc.CallOption) (*linkv1beta1.GetPublicShareByTokenResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *linkv1beta1.GetPublicShareByTokenResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *linkv1beta1.GetPublicShareByTokenRequest, ...grpc.CallOption) (*linkv1beta1.GetPublicShareByTokenResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *linkv1beta1.GetPublicShareByTokenRequest, ...grpc.CallOption) *linkv1beta1.GetPublicShareByTokenResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*linkv1beta1.GetPublicShareByTokenResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *linkv1beta1.GetPublicShareByTokenRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPublicShareByToken is a helper method to define mock.On call
//   - ctx context.Context
//   - in *linkv1beta1.GetPublicShareByTokenRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetPublicShareByToken(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetPublicShareByToken_Call {
	return &GatewayAPIClient_GetPublicShareByToken_Call{Call: _e.mock.On("GetPublicShareByToken",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetPublicShareByToken_Call) Run(run func(ctx context.Context, in *linkv1beta1.GetPublicShareByTokenRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetPublicShareByToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*linkv1beta1.GetPublicShareByTokenRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetPublicShareByToken_Call) Return(_a0 *linkv1beta1.GetPublicShareByTokenResponse, _a1 error) *GatewayAPIClient_GetPublicShareByToken_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetPublicShareByToken_Call) RunAndReturn(run func(context.Context, *linkv1beta1.GetPublicShareByTokenRequest, ...grpc.CallOption) (*linkv1beta1.GetPublicShareByTokenResponse, error)) *GatewayAPIClient_GetPublicShareByToken_Call {
	_c.Call.Return(run)
	return _c
}

// GetQuota provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetQuota(ctx context.Context, in *gatewayv1beta1.GetQuotaRequest, opts ...grpc.CallOption) (*providerv1beta1.GetQuotaResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.GetQuotaResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *gatewayv1beta1.GetQuotaRequest, ...grpc.CallOption) (*providerv1beta1.GetQuotaResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *gatewayv1beta1.GetQuotaRequest, ...grpc.CallOption) *providerv1beta1.GetQuotaResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.GetQuotaResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *gatewayv1beta1.GetQuotaRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetQuota is a helper method to define mock.On call
//   - ctx context.Context
//   - in *gatewayv1beta1.GetQuotaRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetQuota(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetQuota_Call {
	return &GatewayAPIClient_GetQuota_Call{Call: _e.mock.On("GetQuota",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetQuota_Call) Run(run func(ctx context.Context, in *gatewayv1beta1.GetQuotaRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetQuota_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*gatewayv1beta1.GetQuotaRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetQuota_Call) Return(_a0 *providerv1beta1.GetQuotaResponse, _a1 error) *GatewayAPIClient_GetQuota_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetQuota_Call) RunAndReturn(run func(context.Context, *gatewayv1beta1.GetQuotaRequest, ...grpc.CallOption) (*providerv1beta1.GetQuotaResponse, error)) *GatewayAPIClient_GetQuota_Call {
	_c.Call.Return(run)
	return _c
}

// GetReceivedOCMShare provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetReceivedOCMShare(ctx context.Context, in *ocmv1beta1.GetReceivedOCMShareRequest, opts ...grpc.CallOption) (*ocmv1beta1.GetReceivedOCMShareResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *ocmv1beta1.GetReceivedOCMShareResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ocmv1beta1.GetReceivedOCMShareRequest, ...grpc.CallOption) (*ocmv1beta1.GetReceivedOCMShareResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ocmv1beta1.GetReceivedOCMShareRequest, ...grpc.CallOption) *ocmv1beta1.GetReceivedOCMShareResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ocmv1beta1.GetReceivedOCMShareResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ocmv1beta1.GetReceivedOCMShareRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetReceivedOCMShare is a helper method to define mock.On call
//   - ctx context.Context
//   - in *ocmv1beta1.GetReceivedOCMShareRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetReceivedOCMShare(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetReceivedOCMShare_Call {
	return &GatewayAPIClient_GetReceivedOCMShare_Call{Call: _e.mock.On("GetReceivedOCMShare",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetReceivedOCMShare_Call) Run(run func(ctx context.Context, in *ocmv1beta1.GetReceivedOCMShareRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetReceivedOCMShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*ocmv1beta1.GetReceivedOCMShareRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetReceivedOCMShare_Call) Return(_a0 *ocmv1beta1.GetReceivedOCMShareResponse, _a1 error) *GatewayAPIClient_GetReceivedOCMShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetReceivedOCMShare_Call) RunAndReturn(run func(context.Context, *ocmv1beta1.GetReceivedOCMShareRequest, ...grpc.CallOption) (*ocmv1beta1.GetReceivedOCMShareResponse, error)) *GatewayAPIClient_GetReceivedOCMShare_Call {
	_c.Call.Return(run)
	return _c
}

// GetReceivedShare provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetReceivedShare(ctx context.Context, in *collaborationv1beta1.GetReceivedShareRequest, opts ...grpc.CallOption) (*collaborationv1beta1.GetReceivedShareResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *collaborationv1beta1.GetReceivedShareResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.GetReceivedShareRequest, ...grpc.CallOption) (*collaborationv1beta1.GetReceivedShareResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.GetReceivedShareRequest, ...grpc.CallOption) *collaborationv1beta1.GetReceivedShareResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*collaborationv1beta1.GetReceivedShareResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *collaborationv1beta1.GetReceivedShareRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetReceivedShare is a helper method to define mock.On call
//   - ctx context.Context
//   - in *collaborationv1beta1.GetReceivedShareRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetReceivedShare(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetReceivedShare_Call {
	return &GatewayAPIClient_GetReceivedShare_Call{Call: _e.mock.On("GetReceivedShare",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetReceivedShare_Call) Run(run func(ctx context.Context, in *collaborationv1beta1.GetReceivedShareRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetReceivedShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*collaborationv1beta1.GetReceivedShareRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetReceivedShare_Call) Return(_a0 *collaborationv1beta1.GetReceivedShareResponse, _a1 error) *GatewayAPIClient_GetReceivedShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetReceivedShare_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.GetReceivedShareRequest, ...grpc.CallOption) (*collaborationv1beta1.GetReceivedShareResponse, error)) *GatewayAPIClient_GetReceivedShare_Call {
	_c.Call.Return(run)
	return _c
}

// GetShare provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetShare(ctx context.Context, in *collaborationv1beta1.GetShareRequest, opts ...grpc.CallOption) (*collaborationv1beta1.GetShareResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *collaborationv1beta1.GetShareResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.GetShareRequest, ...grpc.CallOption) (*collaborationv1beta1.GetShareResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.GetShareRequest, ...grpc.CallOption) *collaborationv1beta1.GetShareResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*collaborationv1beta1.GetShareResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *collaborationv1beta1.GetShareRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetShare is a helper method to define mock.On call
//   - ctx context.Context
//   - in *collaborationv1beta1.GetShareRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetShare(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetShare_Call {
	return &GatewayAPIClient_GetShare_Call{Call: _e.mock.On("GetShare",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetShare_Call) Run(run func(ctx context.Context, in *collaborationv1beta1.GetShareRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*collaborationv1beta1.GetShareRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetShare_Call) Return(_a0 *collaborationv1beta1.GetShareResponse, _a1 error) *GatewayAPIClient_GetShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetShare_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.GetShareRequest, ...grpc.CallOption) (*collaborationv1beta1.GetShareResponse, error)) *GatewayAPIClient_GetShare_Call {
	_c.Call.Return(run)
	return _c
}

// GetTransferStatus provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetTransferStatus(ctx context.Context, in *txv1beta1.GetTransferStatusRequest, opts ...grpc.CallOption) (*txv1beta1.GetTransferStatusResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *txv1beta1.GetTransferStatusResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *txv1beta1.GetTransferStatusRequest, ...grpc.CallOption) (*txv1beta1.GetTransferStatusResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *txv1beta1.GetTransferStatusRequest, ...grpc.CallOption) *txv1beta1.GetTransferStatusResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*txv1beta1.GetTransferStatusResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *txv1beta1.GetTransferStatusRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetTransferStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - in *txv1beta1.GetTransferStatusRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetTransferStatus(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetTransferStatus_Call {
	return &GatewayAPIClient_GetTransferStatus_Call{Call: _e.mock.On("GetTransferStatus",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetTransferStatus_Call) Run(run func(ctx context.Context, in *txv1beta1.GetTransferStatusRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetTransferStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*txv1beta1.GetTransferStatusRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetTransferStatus_Call) Return(_a0 *txv1beta1.GetTransferStatusResponse, _a1 error) *GatewayAPIClient_GetTransferStatus_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetTransferStatus_Call) RunAndReturn(run func(context.Context, *txv1beta1.GetTransferStatusRequest, ...grpc.CallOption) (*txv1beta1.GetTransferStatusResponse, error)) *GatewayAPIClient_GetTransferStatus_Call {
	_c.Call.Return(run)
	return _c
}

// GetUser provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetUser(ctx context.Context, in *userv1beta1.GetUserRequest, opts ...grpc.CallOption) (*userv1beta1.GetUserResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *userv1beta1.GetUserResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *userv1beta1.GetUserRequest, ...grpc.CallOption) (*userv1beta1.GetUserResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *userv1beta1.GetUserRequest, ...grpc.CallOption) *userv1beta1.GetUserResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*userv1beta1.GetUserResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *userv1beta1.GetUserRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetUser is a helper method to define mock.On call
//   - ctx context.Context
//   - in *userv1beta1.GetUserRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetUser(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetUser_Call {
	return &GatewayAPIClient_GetUser_Call{Call: _e.mock.On("GetUser",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetUser_Call) Run(run func(ctx context.Context, in *userv1beta1.GetUserRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*userv1beta1.GetUserRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetUser_Call) Return(_a0 *userv1beta1.GetUserResponse, _a1 error) *GatewayAPIClient_GetUser_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetUser_Call) RunAndReturn(run func(context.Context, *userv1beta1.GetUserRequest, ...grpc.CallOption) (*userv1beta1.GetUserResponse, error)) *GatewayAPIClient_GetUser_Call {
	_c.Call.Return(run)
	return _c
}

// GetUserByClaim provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetUserByClaim(ctx context.Context, in *userv1beta1.GetUserByClaimRequest, opts ...grpc.CallOption) (*userv1beta1.GetUserByClaimResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *userv1beta1.GetUserByClaimResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *userv1beta1.GetUserByClaimRequest, ...grpc.CallOption) (*userv1beta1.GetUserByClaimResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *userv1beta1.GetUserByClaimRequest, ...grpc.CallOption) *userv1beta1.GetUserByClaimResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*userv1beta1.GetUserByClaimResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *userv1beta1.GetUserByClaimRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetUserByClaim is a helper method to define mock.On call
//   - ctx context.Context
//   - in *userv1beta1.GetUserByClaimRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetUserByClaim(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetUserByClaim_Call {
	return &GatewayAPIClient_GetUserByClaim_Call{Call: _e.mock.On("GetUserByClaim",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetUserByClaim_Call) Run(run func(ctx context.Context, in *userv1beta1.GetUserByClaimRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetUserByClaim_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*userv1beta1.GetUserByClaimRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetUserByClaim_Call) Return(_a0 *userv1beta1.GetUserByClaimResponse, _a1 error) *GatewayAPIClient_GetUserByClaim_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetUserByClaim_Call) RunAndReturn(run func(context.Context, *userv1beta1.GetUserByClaimRequest, ...grpc.CallOption) (*userv1beta1.GetUserByClaimResponse, error)) *GatewayAPIClient_GetUserByClaim_Call {
	_c.Call.Return(run)
	return _c
}

// GetUserGroups provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) GetUserGroups(ctx context.Context, in *userv1beta1.GetUserGroupsRequest, opts ...grpc.CallOption) (*userv1beta1.GetUserGroupsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *userv1beta1.GetUserGroupsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *userv1beta1.GetUserGroupsRequest, ...grpc.CallOption) (*userv1beta1.GetUserGroupsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *userv1beta1.GetUserGroupsRequest, ...grpc.CallOption) *userv1beta1.GetUserGroupsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*userv1beta1.GetUserGroupsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *userv1beta1.GetUserGroupsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetUserGroups is a helper method to define mock.On call
//   - ctx context.Context
//   - in *userv1beta1.GetUserGroupsRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) GetUserGroups(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_GetUserGroups_Call {
	return &GatewayAPIClient_GetUserGroups_Call{Call: _e.mock.On("GetUserGroups",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_GetUserGroups_Call) Run(run func(ctx context.Context, in *userv1beta1.GetUserGroupsRequest, opts ...grpc.CallOption)) *GatewayAPIClient_GetUserGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*userv1beta1.GetUserGroupsRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_GetUserGroups_Call) Return(_a0 *userv1beta1.GetUserGroupsResponse, _a1 error) *GatewayAPIClient_GetUserGroups_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_GetUserGroups_Call) RunAndReturn(run func(context.Context, *userv1beta1.GetUserGroupsRequest, ...grpc.CallOption) (*userv1beta1.GetUserGroupsResponse, error)) *GatewayAPIClient_GetUserGroups_Call {
	_c.Call.Return(run)
	return _c
}

// HasMember provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) HasMember(ctx context.Context, in *groupv1beta1.HasMemberRequest, opts ...grpc.CallOption) (*groupv1beta1.HasMemberResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *groupv1beta1.HasMemberResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *groupv1beta1.HasMemberRequest, ...grpc.CallOption) (*groupv1beta1.HasMemberResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *groupv1beta1.HasMemberRequest, ...grpc.CallOption) *groupv1beta1.HasMemberResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*groupv1beta1.HasMemberResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *groupv1beta1.HasMemberRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// HasMember is a helper method to define mock.On call
//   - ctx context.Context
//   - in *groupv1beta1.HasMemberRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) HasMember(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_HasMember_Call {
	return &GatewayAPIClient_HasMember_Call{Call: _e.mock.On("HasMember",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_HasMember_Call) Run(run func(ctx context.Context, in *groupv1beta1.HasMemberRequest, opts ...grpc.CallOption)) *GatewayAPIClient_HasMember_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*groupv1beta1.HasMemberRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_HasMember_Call) Return(_a0 *groupv1beta1.HasMemberResponse, _a1 error) *GatewayAPIClient_HasMember_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_HasMember_Call) RunAndReturn(run func(context.Context, *groupv1beta1.HasMemberRequest, ...grpc.CallOption) (*groupv1beta1.HasMemberResponse, error)) *GatewayAPIClient_HasMember_Call {
	_c.Call.Return(run)
	return _c
}

// InitiateFileDownload provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) InitiateFileDownload(ctx context.Context, in *providerv1beta1.InitiateFileDownloadRequest, opts ...grpc.CallOption) (*gatewayv1beta1.InitiateFileDownloadResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *gatewayv1beta1.InitiateFileDownloadResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.InitiateFileDownloadRequest, ...grpc.CallOption) (*gatewayv1beta1.InitiateFileDownloadResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.InitiateFileDownloadRequest, ...grpc.CallOption) *gatewayv1beta1.InitiateFileDownloadResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*gatewayv1beta1.InitiateFileDownloadResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.InitiateFileDownloadRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// InitiateFileDownload is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.InitiateFileDownloadRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) InitiateFileDownload(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_InitiateFileDownload_Call {
	return &GatewayAPIClient_InitiateFileDownload_Call{Call: _e.mock.On("InitiateFileDownload",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_InitiateFileDownload_Call) Run(run func(ctx context.Context, in *providerv1beta1.InitiateFileDownloadRequest, opts ...grpc.CallOption)) *GatewayAPIClient_InitiateFileDownload_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.InitiateFileDownloadRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_InitiateFileDownload_Call) Return(_a0 *gatewayv1beta1.InitiateFileDownloadResponse, _a1 error) *GatewayAPIClient_InitiateFileDownload_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_InitiateFileDownload_Call) RunAndReturn(run func(context.Context, *providerv1beta1.InitiateFileDownloadRequest, ...grpc.CallOption) (*gatewayv1beta1.InitiateFileDownloadResponse, error)) *GatewayAPIClient_InitiateFileDownload_Call {
	_c.Call.Return(run)
	return _c
}

// InitiateFileUpload provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) InitiateFileUpload(ctx context.Context, in *providerv1beta1.InitiateFileUploadRequest, opts ...grpc.CallOption) (*gatewayv1beta1.InitiateFileUploadResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *gatewayv1beta1.InitiateFileUploadResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.InitiateFileUploadRequest, ...grpc.CallOption) (*gatewayv1beta1.InitiateFileUploadResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.InitiateFileUploadRequest, ...grpc.CallOption) *gatewayv1beta1.InitiateFileUploadResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*gatewayv1beta1.InitiateFileUploadResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.InitiateFileUploadRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// InitiateFileUpload is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.InitiateFileUploadRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) InitiateFileUpload(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_InitiateFileUpload_Call {
	return &GatewayAPIClient_InitiateFileUpload_Call{Call: _e.mock.On("InitiateFileUpload",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_InitiateFileUpload_Call) Run(run func(ctx context.Context, in *providerv1beta1.InitiateFileUploadRequest, opts ...grpc.CallOption)) *GatewayAPIClient_InitiateFileUpload_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.InitiateFileUploadRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_InitiateFileUpload_Call) Return(_a0 *gatewayv1beta1.InitiateFileUploadResponse, _a1 error) *GatewayAPIClient_InitiateFileUpload_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_InitiateFileUpload_Call) RunAndReturn(run func(context.Context, *providerv1beta1.InitiateFileUploadRequest, ...grpc.CallOption) (*gatewayv1beta1.InitiateFileUploadResponse, error)) *GatewayAPIClient_InitiateFileUpload_Call {
	_c.Call.Return(run)
	return _c
}

// InvalidateAppPassword provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) InvalidateAppPassword(ctx context.Context, in *applicationsv1beta1.InvalidateAppPasswordRequest, opts ...grpc.CallOption) (*applicationsv1beta1.InvalidateAppPasswordResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *applicationsv1beta1.InvalidateAppPasswordResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *applicationsv1beta1.InvalidateAppPasswordRequest, ...grpc.CallOption) (*applicationsv1beta1.InvalidateAppPasswordResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *applicationsv1beta1.InvalidateAppPasswordRequest, ...grpc.CallOption) *applicationsv1beta1.InvalidateAppPasswordResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*applicationsv1beta1.InvalidateAppPasswordResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *applicationsv1beta1.InvalidateAppPasswordRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// InvalidateAppPassword is a helper method to define mock.On call
//   - ctx context.Context
//   - in *applicationsv1beta1.InvalidateAppPasswordRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) InvalidateAppPassword(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_InvalidateAppPassword_Call {
	return &GatewayAPIClient_InvalidateAppPassword_Call{Call: _e.mock.On("InvalidateAppPassword",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_InvalidateAppPassword_Call) Run(run func(ctx context.Context, in *applicationsv1beta1.InvalidateAppPasswordRequest, opts ...grpc.CallOption)) *GatewayAPIClient_InvalidateAppPassword_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*applicationsv1beta1.InvalidateAppPasswordRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_InvalidateAppPassword_Call) Return(_a0 *applicationsv1beta1.InvalidateAppPasswordResponse, _a1 error) *GatewayAPIClient_InvalidateAppPassword_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_InvalidateAppPassword_Call) RunAndReturn(run func(context.Context, *applicationsv1beta1.InvalidateAppPasswordRequest, ...grpc.CallOption) (*applicationsv1beta1.InvalidateAppPasswordResponse, error)) *GatewayAPIClient_InvalidateAppPassword_Call {
	_c.Call.Return(run)
	return _c
}

// IsProviderAllowed provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) IsProviderAllowed(ctx context.Context, in *v1beta1.IsProviderAllowedRequest, opts ...grpc.CallOption) (*v1beta1.IsProviderAllowedResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *v1beta1.IsProviderAllowedResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.IsProviderAllowedRequest, ...grpc.CallOption) (*v1beta1.IsProviderAllowedResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.IsProviderAllowedRequest, ...grpc.CallOption) *v1beta1.IsProviderAllowedResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v1beta1.IsProviderAllowedResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.IsProviderAllowedRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// IsProviderAllowed is a helper method to define mock.On call
//   - ctx context.Context
//   - in *v1beta1.IsProviderAllowedRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) IsProviderAllowed(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_IsProviderAllowed_Call {
	return &GatewayAPIClient_IsProviderAllowed_Call{Call: _e.mock.On("IsProviderAllowed",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_IsProviderAllowed_Call) Run(run func(ctx context.Context, in *v1beta1.IsProviderAllowedRequest, opts ...grpc.CallOption)) *GatewayAPIClient_IsProviderAllowed_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*v1beta1.IsProviderAllowedRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_IsProviderAllowed_Call) Return(_a0 *v1beta1.IsProviderAllowedResponse, _a1 error) *GatewayAPIClient_IsProviderAllowed_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_IsProviderAllowed_Call) RunAndReturn(run func(context.Context, *v1beta1.IsProviderAllowedRequest, ...grpc.CallOption) (*v1beta1.IsProviderAllowedResponse, error)) *GatewayAPIClient_IsProviderAllowed_Call {
	_c.Call.Return(run)
	return _c
}

// ListAllProviders provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListAllProviders(ctx context.Context, in *v1beta1.ListAllProvidersRequest, opts ...grpc.CallOption) (*v1beta1.ListAllProvidersResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *v1beta1.ListAllProvidersResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.ListAllProvidersRequest, ...grpc.CallOption) (*v1beta1.ListAllProvidersResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.ListAllProvidersRequest, ...grpc.CallOption) *v1beta1.ListAllProvidersResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*v1beta1.ListAllProvidersResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.ListAllProvidersRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListAllProviders is a helper method to define mock.On call
//   - ctx context.Context
//   - in *v1beta1.ListAllProvidersRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListAllProviders(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListAllProviders_Call {
	return &GatewayAPIClient_ListAllProviders_Call{Call: _e.mock.On("ListAllProviders",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListAllProviders_Call) Run(run func(ctx context.Context, in *v1beta1.ListAllProvidersRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListAllProviders_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*v1beta1.ListAllProvidersRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListAllProviders_Call) Return(_a0 *v1beta1.ListAllProvidersResponse, _a1 error) *GatewayAPIClient_ListAllProviders_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListAllProviders_Call) RunAndReturn(run func(context.Context, *v1beta1.ListAllProvidersRequest, ...grpc.CallOption) (*v1beta1.ListAllProvidersResponse, error)) *GatewayAPIClient_ListAllProviders_Call {
	_c.Call.Return(run)
	return _c
}

// ListAppPasswords provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListAppPasswords(ctx context.Context, in *applicationsv1beta1.ListAppPasswordsRequest, opts ...grpc.CallOption) (*applicationsv1beta1.ListAppPasswordsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *applicationsv1beta1.ListAppPasswordsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *applicationsv1beta1.ListAppPasswordsRequest, ...grpc.CallOption) (*applicationsv1beta1.ListAppPasswordsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *applicationsv1beta1.ListAppPasswordsRequest, ...grpc.CallOption) *applicationsv1beta1.ListAppPasswordsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*applicationsv1beta1.ListAppPasswordsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *applicationsv1beta1.ListAppPasswordsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListAppPasswords is a helper method to define mock.On call
//   - ctx context.Context
//   - in *applicationsv1beta1.ListAppPasswordsRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListAppPasswords(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListAppPasswords_Call {
	return &GatewayAPIClient_ListAppPasswords_Call{Call: _e.mock.On("ListAppPasswords",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListAppPasswords_Call) Run(run func(ctx context.Context, in *applicationsv1beta1.ListAppPasswordsRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListAppPasswords_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*applicationsv1beta1.ListAppPasswordsRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListAppPasswords_Call) Return(_a0 *applicationsv1beta1.ListAppPasswordsResponse, _a1 error) *GatewayAPIClient_ListAppPasswords_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListAppPasswords_Call) RunAndReturn(run func(context.Context, *applicationsv1beta1.ListAppPasswordsRequest, ...grpc.CallOption) (*applicationsv1beta1.ListAppPasswordsResponse, error)) *GatewayAPIClient_ListAppPasswords_Call {
	_c.Call.Return(run)
	return _c
}

// ListAppProviders provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListAppProviders(ctx context.Context, in *registryv1beta1.ListAppProvidersRequest, opts ...grpc.CallOption) (*registryv1beta1.ListAppProvidersResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *registryv1beta1.ListAppProvidersResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *registryv1beta1.ListAppProvidersRequest, ...grpc.CallOption) (*registryv1beta1.ListAppProvidersResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *registryv1beta1.ListAppProvidersRequest, ...grpc.CallOption) *registryv1beta1.ListAppProvidersResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*registryv1beta1.ListAppProvidersResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *registryv1beta1.ListAppProvidersRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListAppProviders is a helper method to define mock.On call
//   - ctx context.Context
//   - in *registryv1beta1.ListAppProvidersRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListAppProviders(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListAppProviders_Call {
	return &GatewayAPIClient_ListAppProviders_Call{Call: _e.mock.On("ListAppProviders",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListAppProviders_Call) Run(run func(ctx context.Context, in *registryv1beta1.ListAppProvidersRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListAppProviders_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*registryv1beta1.ListAppProvidersRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListAppProviders_Call) Return(_a0 *registryv1beta1.ListAppProvidersResponse, _a1 error) *GatewayAPIClient_ListAppProviders_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListAppProviders_Call) RunAndReturn(run func(context.Context, *registryv1beta1.ListAppProvidersRequest, ...grpc.CallOption) (*registryv1beta1.ListAppProvidersResponse, error)) *GatewayAPIClient_ListAppProviders_Call {
	_c.Call.Return(run)
	return _c
}

// ListAuthProviders provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListAuthProviders(ctx context.Context, in *authregistryv1beta1.ListAuthProvidersRequest, opts ...grpc.CallOption) (*gatewayv1beta1.ListAuthProvidersResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *gatewayv1beta1.ListAuthProvidersResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *authregistryv1beta1.ListAuthProvidersRequest, ...grpc.CallOption) (*gatewayv1beta1.ListAuthProvidersResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *authregistryv1beta1.ListAuthProvidersRequest, ...grpc.CallOption) *gatewayv1beta1.ListAuthProvidersResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*gatewayv1beta1.ListAuthProvidersResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *authregistryv1beta1.ListAuthProvidersRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListAuthProviders is a helper method to define mock.On call
//   - ctx context.Context
//   - in *authregistryv1beta1.ListAuthProvidersRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListAuthProviders(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListAuthProviders_Call {
	return &GatewayAPIClient_ListAuthProviders_Call{Call: _e.mock.On("ListAuthProviders",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListAuthProviders_Call) Run(run func(ctx context.Context, in *authregistryv1beta1.ListAuthProvidersRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListAuthProviders_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*authregistryv1beta1.ListAuthProvidersRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListAuthProviders_Call) Return(_a0 *gatewayv1beta1.ListAuthProvidersResponse, _a1 error) *GatewayAPIClient_ListAuthProviders_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListAuthProviders_Call) RunAndReturn(run func(context.Context, *authregistryv1beta1.ListAuthProvidersRequest, ...grpc.CallOption) (*gatewayv1beta1.ListAuthProvidersResponse, error)) *GatewayAPIClient_ListAuthProviders_Call {
	_c.Call.Return(run)
	return _c
}

// ListContainer provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListContainer(ctx context.Context, in *providerv1beta1.ListContainerRequest, opts ...grpc.CallOption) (*providerv1beta1.ListContainerResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.ListContainerResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.ListContainerRequest, ...grpc.CallOption) (*providerv1beta1.ListContainerResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.ListContainerRequest, ...grpc.CallOption) *providerv1beta1.ListContainerResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.ListContainerResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.ListContainerRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListContainer is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.ListContainerRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListContainer(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListContainer_Call {
	return &GatewayAPIClient_ListContainer_Call{Call: _e.mock.On("ListContainer",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListContainer_Call) Run(run func(ctx context.Context, in *providerv1beta1.ListContainerRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListContainer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.ListContainerRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListContainer_Call) Return(_a0 *providerv1beta1.ListContainerResponse, _a1 error) *GatewayAPIClient_ListContainer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListContainer_Call) RunAndReturn(run func(context.Context, *providerv1beta1.ListContainerRequest, ...grpc.CallOption) (*providerv1beta1.ListContainerResponse, error)) *GatewayAPIClient_ListContainer_Call {
	_c.Call.Return(run)
	return _c
}

// ListContainerStream provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListContainerStream(ctx context.Context, in *providerv1beta1.ListContainerStreamRequest, opts ...grpc.CallOption) (gatewayv1beta1.GatewayAPI_ListContainerStreamClient, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 gatewayv1beta1.GatewayAPI_ListContainerStreamClient
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.ListContainerStreamRequest, ...grpc.CallOption) (gatewayv1beta1.GatewayAPI_ListContainerStreamClient, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.ListContainerStreamRequest, ...grpc.CallOption) gatewayv1beta1.GatewayAPI_ListContainerStreamClient); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(gatewayv1beta1.GatewayAPI_ListContainerStreamClient)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.ListContainerStreamRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListContainerStream is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.ListContainerStreamRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListContainerStream(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListContainerStream_Call {
	return &GatewayAPIClient_ListContainerStream_Call{Call: _e.mock.On("ListContainerStream",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListContainerStream_Call) Run(run func(ctx context.Context, in *providerv1beta1.ListContainerStreamRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListContainerStream_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.ListContainerStreamRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListContainerStream_Call) Return(_a0 gatewayv1beta1.GatewayAPI_ListContainerStreamClient, _a1 error) *GatewayAPIClient_ListContainerStream_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListContainerStream_Call) RunAndReturn(run func(context.Context, *providerv1beta1.ListContainerStreamRequest, ...grpc.CallOption) (gatewayv1beta1.GatewayAPI_ListContainerStreamClient, error)) *GatewayAPIClient_ListContainerStream_Call {
	_c.Call.Return(run)
	return _c
}

// ListExistingPublicShares provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListExistingPublicShares(ctx context.Context, in *linkv1beta1.ListPublicSharesRequest, opts ...grpc.CallOption) (*gatewayv1beta1.ListExistingPublicSharesResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *gatewayv1beta1.ListExistingPublicSharesResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *linkv1beta1.ListPublicSharesRequest, ...grpc.CallOption) (*gatewayv1beta1.ListExistingPublicSharesResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *linkv1beta1.ListPublicSharesRequest, ...grpc.CallOption) *gatewayv1beta1.ListExistingPublicSharesResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*gatewayv1beta1.ListExistingPublicSharesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *linkv1beta1.ListPublicSharesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListExistingPublicShares is a helper method to define mock.On call
//   - ctx context.Context
//   - in *linkv1beta1.ListPublicSharesRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListExistingPublicShares(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListExistingPublicShares_Call {
	return &GatewayAPIClient_ListExistingPublicShares_Call{Call: _e.mock.On("ListExistingPublicShares",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListExistingPublicShares_Call) Run(run func(ctx context.Context, in *linkv1beta1.ListPublicSharesRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListExistingPublicShares_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*linkv1beta1.ListPublicSharesRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListExistingPublicShares_Call) Return(_a0 *gatewayv1beta1.ListExistingPublicSharesResponse, _a1 error) *GatewayAPIClient_ListExistingPublicShares_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListExistingPublicShares_Call) RunAndReturn(run func(context.Context, *linkv1beta1.ListPublicSharesRequest, ...grpc.CallOption) (*gatewayv1beta1.ListExistingPublicSharesResponse, error)) *GatewayAPIClient_ListExistingPublicShares_Call {
	_c.Call.Return(run)
	return _c
}

// ListExistingReceivedShares provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListExistingReceivedShares(ctx context.Context, in *collaborationv1beta1.ListReceivedSharesRequest, opts ...grpc.CallOption) (*gatewayv1beta1.ListExistingReceivedSharesResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *gatewayv1beta1.ListExistingReceivedSharesResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.ListReceivedSharesRequest, ...grpc.CallOption) (*gatewayv1beta1.ListExistingReceivedSharesResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.ListReceivedSharesRequest, ...grpc.CallOption) *gatewayv1beta1.ListExistingReceivedSharesResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*gatewayv1beta1.ListExistingReceivedSharesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *collaborationv1beta1.ListReceivedSharesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListExistingReceivedShares is a helper method to define mock.On call
//   - ctx context.Context
//   - in *collaborationv1beta1.ListReceivedSharesRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListExistingReceivedShares(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListExistingReceivedShares_Call {
	return &GatewayAPIClient_ListExistingReceivedShares_Call{Call: _e.mock.On("ListExistingReceivedShares",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListExistingReceivedShares_Call) Run(run func(ctx context.Context, in *collaborationv1beta1.ListReceivedSharesRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListExistingReceivedShares_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*collaborationv1beta1.ListReceivedSharesRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListExistingReceivedShares_Call) Return(_a0 *gatewayv1beta1.ListExistingReceivedSharesResponse, _a1 error) *GatewayAPIClient_ListExistingReceivedShares_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListExistingReceivedShares_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.ListReceivedSharesRequest, ...grpc.CallOption) (*gatewayv1beta1.ListExistingReceivedSharesResponse, error)) *GatewayAPIClient_ListExistingReceivedShares_Call {
	_c.Call.Return(run)
	return _c
}

// ListExistingShares provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListExistingShares(ctx context.Context, in *collaborationv1beta1.ListSharesRequest, opts ...grpc.CallOption) (*gatewayv1beta1.ListExistingSharesResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *gatewayv1beta1.ListExistingSharesResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.ListSharesRequest, ...grpc.CallOption) (*gatewayv1beta1.ListExistingSharesResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.ListSharesRequest, ...grpc.CallOption) *gatewayv1beta1.ListExistingSharesResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*gatewayv1beta1.ListExistingSharesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *collaborationv1beta1.ListSharesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListExistingShares is a helper method to define mock.On call
//   - ctx context.Context
//   - in *collaborationv1beta1.ListSharesRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListExistingShares(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListExistingShares_Call {
	return &GatewayAPIClient_ListExistingShares_Call{Call: _e.mock.On("ListExistingShares",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListExistingShares_Call) Run(run func(ctx context.Context, in *collaborationv1beta1.ListSharesRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListExistingShares_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*collaborationv1beta1.ListSharesRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListExistingShares_Call) Return(_a0 *gatewayv1beta1.ListExistingSharesResponse, _a1 error) *GatewayAPIClient_ListExistingShares_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListExistingShares_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.ListSharesRequest, ...grpc.CallOption) (*gatewayv1beta1.ListExistingSharesResponse, error)) *GatewayAPIClient_ListExistingShares_Call {
	_c.Call.Return(run)
	return _c
}

// ListFileVersions provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListFileVersions(ctx context.Context, in *providerv1beta1.ListFileVersionsRequest, opts ...grpc.CallOption) (*providerv1beta1.ListFileVersionsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.ListFileVersionsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.ListFileVersionsRequest, ...grpc.CallOption) (*providerv1beta1.ListFileVersionsResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.ListFileVersionsRequest, ...grpc.CallOption) *providerv1beta1.ListFileVersionsResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.ListFileVersionsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.ListFileVersionsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListFileVersions is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.ListFileVersionsRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListFileVersions(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListFileVersions_Call {
	return &GatewayAPIClient_ListFileVersions_Call{Call: _e.mock.On("ListFileVersions",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListFileVersions_Call) Run(run func(ctx context.Context, in *providerv1beta1.ListFileVersionsRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListFileVersions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.ListFileVersionsRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListFileVersions_Call) Return(_a0 *providerv1beta1.ListFileVersionsResponse, _a1 error) *GatewayAPIClient_ListFileVersions_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListFileVersions_Call) RunAndReturn(run func(context.Context, *providerv1beta1.ListFileVersionsRequest, ...grpc.CallOption) (*providerv1beta1.ListFileVersionsResponse, error)) *GatewayAPIClient_ListFileVersions_Call {
	_c.Call.Return(run)
	return _c
}

// ListInviteTokens provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListInviteTokens(ctx context.Context, in *invitev1beta1.ListInviteTokensRequest, opts ...grpc.CallOption) (*invitev1beta1.ListInviteTokensResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *invitev1beta1.ListInviteTokensResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *invitev1beta1.ListInviteTokensRequest, ...grpc.CallOption) (*invitev1beta1.ListInviteTokensResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *invitev1beta1.ListInviteTokensRequest, ...grpc.CallOption) *invitev1beta1.ListInviteTokensResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*invitev1beta1.ListInviteTokensResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *invitev1beta1.ListInviteTokensRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListInviteTokens is a helper method to define mock.On call
//   - ctx context.Context
//   - in *invitev1beta1.ListInviteTokensRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListInviteTokens(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListInviteTokens_Call {
	return &GatewayAPIClient_ListInviteTokens_Call{Call: _e.mock.On("ListInviteTokens",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListInviteTokens_Call) Run(run func(ctx context.Context, in *invitev1beta1.ListInviteTokensRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListInviteTokens_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*invitev1beta1.ListInviteTokensRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListInviteTokens_Call) Return(_a0 *invitev1beta1.ListInviteTokensResponse, _a1 error) *GatewayAPIClient_ListInviteTokens_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListInviteTokens_Call) RunAndReturn(run func(context.Context, *invitev1beta1.ListInviteTokensRequest, ...grpc.CallOption) (*invitev1beta1.ListInviteTokensResponse, error)) *GatewayAPIClient_ListInviteTokens_Call {
	_c.Call.Return(run)
	return _c
}

// ListOCMShares provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListOCMShares(ctx context.Context, in *ocmv1beta1.ListOCMSharesRequest, opts ...grpc.CallOption) (*ocmv1beta1.ListOCMSharesResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *ocmv1beta1.ListOCMSharesResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ocmv1beta1.ListOCMSharesRequest, ...grpc.CallOption) (*ocmv1beta1.ListOCMSharesResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ocmv1beta1.ListOCMSharesRequest, ...grpc.CallOption) *ocmv1beta1.ListOCMSharesResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ocmv1beta1.ListOCMSharesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ocmv1beta1.ListOCMSharesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListOCMShares is a helper method to define mock.On call
//   - ctx context.Context
//   - in *ocmv1beta1.ListOCMSharesRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListOCMShares(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListOCMShares_Call {
	return &GatewayAPIClient_ListOCMShares_Call{Call: _e.mock.On("ListOCMShares",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListOCMShares_Call) Run(run func(ctx context.Context, in *ocmv1beta1.ListOCMSharesRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListOCMShares_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*ocmv1beta1.ListOCMSharesRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListOCMShares_Call) Return(_a0 *ocmv1beta1.ListOCMSharesResponse, _a1 error) *GatewayAPIClient_ListOCMShares_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListOCMShares_Call) RunAndReturn(run func(context.Context, *ocmv1beta1.ListOCMSharesRequest, ...grpc.CallOption) (*ocmv1beta1.ListOCMSharesResponse, error)) *GatewayAPIClient_ListOCMShares_Call {
	_c.Call.Return(run)
	return _c
}

// ListPublicShares provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListPublicShares(ctx context.Context, in *linkv1beta1.ListPublicSharesRequest, opts ...grpc.CallOption) (*linkv1beta1.ListPublicSharesResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *linkv1beta1.ListPublicSharesResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *linkv1beta1.ListPublicSharesRequest, ...grpc.CallOption) (*linkv1beta1.ListPublicSharesResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *linkv1beta1.ListPublicSharesRequest, ...grpc.CallOption) *linkv1beta1.ListPublicSharesResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*linkv1beta1.ListPublicSharesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *linkv1beta1.ListPublicSharesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListPublicShares is a helper method to define mock.On call
//   - ctx context.Context
//   - in *linkv1beta1.ListPublicSharesRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListPublicShares(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListPublicShares_Call {
	return &GatewayAPIClient_ListPublicShares_Call{Call: _e.mock.On("ListPublicShares",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListPublicShares_Call) Run(run func(ctx context.Context, in *linkv1beta1.ListPublicSharesRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListPublicShares_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*linkv1beta1.ListPublicSharesRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListPublicShares_Call) Return(_a0 *linkv1beta1.ListPublicSharesResponse, _a1 error) *GatewayAPIClient_ListPublicShares_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListPublicShares_Call) RunAndReturn(run func(context.Context, *linkv1beta1.ListPublicSharesRequest, ...grpc.CallOption) (*linkv1beta1.ListPublicSharesResponse, error)) *GatewayAPIClient_ListPublicShares_Call {
	_c.Call.Return(run)
	return _c
}

// ListReceivedOCMShares provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListReceivedOCMShares(ctx context.Context, in *ocmv1beta1.ListReceivedOCMSharesRequest, opts ...grpc.CallOption) (*ocmv1beta1.ListReceivedOCMSharesResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *ocmv1beta1.ListReceivedOCMSharesResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ocmv1beta1.ListReceivedOCMSharesRequest, ...grpc.CallOption) (*ocmv1beta1.ListReceivedOCMSharesResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ocmv1beta1.ListReceivedOCMSharesRequest, ...grpc.CallOption) *ocmv1beta1.ListReceivedOCMSharesResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ocmv1beta1.ListReceivedOCMSharesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ocmv1beta1.ListReceivedOCMSharesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListReceivedOCMShares is a helper method to define mock.On call
//   - ctx context.Context
//   - in *ocmv1beta1.ListReceivedOCMSharesRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListReceivedOCMShares(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListReceivedOCMShares_Call {
	return &GatewayAPIClient_ListReceivedOCMShares_Call{Call: _e.mock.On("ListReceivedOCMShares",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListReceivedOCMShares_Call) Run(run func(ctx context.Context, in *ocmv1beta1.ListReceivedOCMSharesRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListReceivedOCMShares_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*ocmv1beta1.ListReceivedOCMSharesRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListReceivedOCMShares_Call) Return(_a0 *ocmv1beta1.ListReceivedOCMSharesResponse, _a1 error) *GatewayAPIClient_ListReceivedOCMShares_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListReceivedOCMShares_Call) RunAndReturn(run func(context.Context, *ocmv1beta1.ListReceivedOCMSharesRequest, ...grpc.CallOption) (*ocmv1beta1.ListReceivedOCMSharesResponse, error)) *GatewayAPIClient_ListReceivedOCMShares_Call {
	_c.Call.Return(run)
	return _c
}

// ListReceivedShares provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListReceivedShares(ctx context.Context, in *collaborationv1beta1.ListReceivedSharesRequest, opts ...grpc.CallOption) (*collaborationv1beta1.ListReceivedSharesResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *collaborationv1beta1.ListReceivedSharesResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.ListReceivedSharesRequest, ...grpc.CallOption) (*collaborationv1beta1.ListReceivedSharesResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.ListReceivedSharesRequest, ...grpc.CallOption) *collaborationv1beta1.ListReceivedSharesResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*collaborationv1beta1.ListReceivedSharesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *collaborationv1beta1.ListReceivedSharesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListReceivedShares is a helper method to define mock.On call
//   - ctx context.Context
//   - in *collaborationv1beta1.ListReceivedSharesRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListReceivedShares(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListReceivedShares_Call {
	return &GatewayAPIClient_ListReceivedShares_Call{Call: _e.mock.On("ListReceivedShares",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListReceivedShares_Call) Run(run func(ctx context.Context, in *collaborationv1beta1.ListReceivedSharesRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListReceivedShares_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*collaborationv1beta1.ListReceivedSharesRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListReceivedShares_Call) Return(_a0 *collaborationv1beta1.ListReceivedSharesResponse, _a1 error) *GatewayAPIClient_ListReceivedShares_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListReceivedShares_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.ListReceivedSharesRequest, ...grpc.CallOption) (*collaborationv1beta1.ListReceivedSharesResponse, error)) *GatewayAPIClient_ListReceivedShares_Call {
	_c.Call.Return(run)
	return _c
}

// ListRecycle provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListRecycle(ctx context.Context, in *providerv1beta1.ListRecycleRequest, opts ...grpc.CallOption) (*providerv1beta1.ListRecycleResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.ListRecycleResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.ListRecycleRequest, ...grpc.CallOption) (*providerv1beta1.ListRecycleResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.ListRecycleRequest, ...grpc.CallOption) *providerv1beta1.ListRecycleResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.ListRecycleResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.ListRecycleRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListRecycle is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.ListRecycleRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListRecycle(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListRecycle_Call {
	return &GatewayAPIClient_ListRecycle_Call{Call: _e.mock.On("ListRecycle",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListRecycle_Call) Run(run func(ctx context.Context, in *providerv1beta1.ListRecycleRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListRecycle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.ListRecycleRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListRecycle_Call) Return(_a0 *providerv1beta1.ListRecycleResponse, _a1 error) *GatewayAPIClient_ListRecycle_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListRecycle_Call) RunAndReturn(run func(context.Context, *providerv1beta1.ListRecycleRequest, ...grpc.CallOption) (*providerv1beta1.ListRecycleResponse, error)) *GatewayAPIClient_ListRecycle_Call {
	_c.Call.Return(run)
	return _c
}

// ListRecycleStream provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListRecycleStream(ctx context.Context, in *providerv1beta1.ListRecycleStreamRequest, opts ...grpc.CallOption) (gatewayv1beta1.GatewayAPI_ListRecycleStreamClient, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 gatewayv1beta1.GatewayAPI_ListRecycleStreamClient
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.ListRecycleStreamRequest, ...grpc.CallOption) (gatewayv1beta1.GatewayAPI_ListRecycleStreamClient, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.ListRecycleStreamRequest, ...grpc.CallOption) gatewayv1beta1.GatewayAPI_ListRecycleStreamClient); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(gatewayv1beta1.GatewayAPI_ListRecycleStreamClient)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.ListRecycleStreamRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListRecycleStream is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.ListRecycleStreamRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListRecycleStream(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListRecycleStream_Call {
	return &GatewayAPIClient_ListRecycleStream_Call{Call: _e.mock.On("ListRecycleStream",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListRecycleStream_Call) Run(run func(ctx context.Context, in *providerv1beta1.ListRecycleStreamRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListRecycleStream_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.ListRecycleStreamRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListRecycleStream_Call) Return(_a0 gatewayv1beta1.GatewayAPI_ListRecycleStreamClient, _a1 error) *GatewayAPIClient_ListRecycleStream_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListRecycleStream_Call) RunAndReturn(run func(context.Context, *providerv1beta1.ListRecycleStreamRequest, ...grpc.CallOption) (gatewayv1beta1.GatewayAPI_ListRecycleStreamClient, error)) *GatewayAPIClient_ListRecycleStream_Call {
	_c.Call.Return(run)
	return _c
}

// ListShares provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListShares(ctx context.Context, in *collaborationv1beta1.ListSharesRequest, opts ...grpc.CallOption) (*collaborationv1beta1.ListSharesResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *collaborationv1beta1.ListSharesResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.ListSharesRequest, ...grpc.CallOption) (*collaborationv1beta1.ListSharesResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.ListSharesRequest, ...grpc.CallOption) *collaborationv1beta1.ListSharesResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*collaborationv1beta1.ListSharesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *collaborationv1beta1.ListSharesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListShares is a helper method to define mock.On call
//   - ctx context.Context
//   - in *collaborationv1beta1.ListSharesRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListShares(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListShares_Call {
	return &GatewayAPIClient_ListShares_Call{Call: _e.mock.On("ListShares",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListShares_Call) Run(run func(ctx context.Context, in *collaborationv1beta1.ListSharesRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListShares_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*collaborationv1beta1.ListSharesRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListShares_Call) Return(_a0 *collaborationv1beta1.ListSharesResponse, _a1 error) *GatewayAPIClient_ListShares_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListShares_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.ListSharesRequest, ...grpc.CallOption) (*collaborationv1beta1.ListSharesResponse, error)) *GatewayAPIClient_ListShares_Call {
	_c.Call.Return(run)
	return _c
}

// ListStorageSpaces provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListStorageSpaces(ctx context.Context, in *providerv1beta1.ListStorageSpacesRequest, opts ...grpc.CallOption) (*providerv1beta1.ListStorageSpacesResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.ListStorageSpacesResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.ListStorageSpacesRequest, ...grpc.CallOption) (*providerv1beta1.ListStorageSpacesResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.ListStorageSpacesRequest, ...grpc.CallOption) *providerv1beta1.ListStorageSpacesResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.ListStorageSpacesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.ListStorageSpacesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListStorageSpaces is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.ListStorageSpacesRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListStorageSpaces(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListStorageSpaces_Call {
	return &GatewayAPIClient_ListStorageSpaces_Call{Call: _e.mock.On("ListStorageSpaces",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListStorageSpaces_Call) Run(run func(ctx context.Context, in *providerv1beta1.ListStorageSpacesRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListStorageSpaces_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.ListStorageSpacesRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListStorageSpaces_Call) Return(_a0 *providerv1beta1.ListStorageSpacesResponse, _a1 error) *GatewayAPIClient_ListStorageSpaces_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListStorageSpaces_Call) RunAndReturn(run func(context.Context, *providerv1beta1.ListStorageSpacesRequest, ...grpc.CallOption) (*providerv1beta1.ListStorageSpacesResponse, error)) *GatewayAPIClient_ListStorageSpaces_Call {
	_c.Call.Return(run)
	return _c
}

// ListSupportedMimeTypes provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListSupportedMimeTypes(ctx context.Context, in *registryv1beta1.ListSupportedMimeTypesRequest, opts ...grpc.CallOption) (*registryv1beta1.ListSupportedMimeTypesResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *registryv1beta1.ListSupportedMimeTypesResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *registryv1beta1.ListSupportedMimeTypesRequest, ...grpc.CallOption) (*registryv1beta1.ListSupportedMimeTypesResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *registryv1beta1.ListSupportedMimeTypesRequest, ...grpc.CallOption) *registryv1beta1.ListSupportedMimeTypesResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*registryv1beta1.ListSupportedMimeTypesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *registryv1beta1.ListSupportedMimeTypesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListSupportedMimeTypes is a helper method to define mock.On call
//   - ctx context.Context
//   - in *registryv1beta1.ListSupportedMimeTypesRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListSupportedMimeTypes(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListSupportedMimeTypes_Call {
	return &GatewayAPIClient_ListSupportedMimeTypes_Call{Call: _e.mock.On("ListSupportedMimeTypes",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListSupportedMimeTypes_Call) Run(run func(ctx context.Context, in *registryv1beta1.ListSupportedMimeTypesRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListSupportedMimeTypes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*registryv1beta1.ListSupportedMimeTypesRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListSupportedMimeTypes_Call) Return(_a0 *registryv1beta1.ListSupportedMimeTypesResponse, _a1 error) *GatewayAPIClient_ListSupportedMimeTypes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListSupportedMimeTypes_Call) RunAndReturn(run func(context.Context, *registryv1beta1.ListSupportedMimeTypesRequest, ...grpc.CallOption) (*registryv1beta1.ListSupportedMimeTypesResponse, error)) *GatewayAPIClient_ListSupportedMimeTypes_Call {
	_c.Call.Return(run)
	return _c
}

// ListTransfers provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) ListTransfers(ctx context.Context, in *txv1beta1.ListTransfersRequest, opts ...grpc.CallOption) (*txv1beta1.ListTransfersResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *txv1beta1.ListTransfersResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *txv1beta1.ListTransfersRequest, ...grpc.CallOption) (*txv1beta1.ListTransfersResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *txv1beta1.ListTransfersRequest, ...grpc.CallOption) *txv1beta1.ListTransfersResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*txv1beta1.ListTransfersResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *txv1beta1.ListTransfersRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListTransfers is a helper method to define mock.On call
//   - ctx context.Context
//   - in *txv1beta1.ListTransfersRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) ListTransfers(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_ListTransfers_Call {
	return &GatewayAPIClient_ListTransfers_Call{Call: _e.mock.On("ListTransfers",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_ListTransfers_Call) Run(run func(ctx context.Context, in *txv1beta1.ListTransfersRequest, opts ...grpc.CallOption)) *GatewayAPIClient_ListTransfers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*txv1beta1.ListTransfersRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_ListTransfers_Call) Return(_a0 *txv1beta1.ListTransfersResponse, _a1 error) *GatewayAPIClient_ListTransfers_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_ListTransfers_Call) RunAndReturn(run func(context.Context, *txv1beta1.ListTransfersRequest, ...grpc.CallOption) (*txv1beta1.ListTransfersResponse, error)) *GatewayAPIClient_ListTransfers_Call {
	_c.Call.Return(run)
	return _c
}

// Move provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) Move(ctx context.Context, in *providerv1beta1.MoveRequest, opts ...grpc.CallOption) (*providerv1beta1.MoveResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.MoveResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.MoveRequest, ...grpc.CallOption) (*providerv1beta1.MoveResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.MoveRequest, ...grpc.CallOption) *providerv1beta1.MoveResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.MoveResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.MoveRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Move is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.MoveRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) Move(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_Move_Call {
	return &GatewayAPIClient_Move_Call{Call: _e.mock.On("Move",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_Move_Call) Run(run func(ctx context.Context, in *providerv1beta1.MoveRequest, opts ...grpc.CallOption)) *GatewayAPIClient_Move_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.MoveRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_Move_Call) Return(_a0 *providerv1beta1.MoveResponse, _a1 error) *GatewayAPIClient_Move_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_Move_Call) RunAndReturn(run func(context.Context, *providerv1beta1.MoveRequest, ...grpc.CallOption) (*providerv1beta1.MoveResponse, error)) *GatewayAPIClient_Move_Call {
	_c.Call.Return(run)
	return _c
}

// OpenInApp provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) OpenInApp(ctx context.Context, in *gatewayv1beta1.OpenInAppRequest, opts ...grpc.CallOption) (*appproviderv1beta1.OpenInAppResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *appproviderv1beta1.OpenInAppResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *gatewayv1beta1.OpenInAppRequest, ...grpc.CallOption) (*appproviderv1beta1.OpenInAppResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *gatewayv1beta1.OpenInAppRequest, ...grpc.CallOption) *appproviderv1beta1.OpenInAppResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*appproviderv1beta1.OpenInAppResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *gatewayv1beta1.OpenInAppRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// OpenInApp is a helper method to define mock.On call
//   - ctx context.Context
//   - in *gatewayv1beta1.OpenInAppRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) OpenInApp(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_OpenInApp_Call {
	return &GatewayAPIClient_OpenInApp_Call{Call: _e.mock.On("OpenInApp",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_OpenInApp_Call) Run(run func(ctx context.Context, in *gatewayv1beta1.OpenInAppRequest, opts ...grpc.CallOption)) *GatewayAPIClient_OpenInApp_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*gatewayv1beta1.OpenInAppRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_OpenInApp_Call) Return(_a0 *appproviderv1beta1.OpenInAppResponse, _a1 error) *GatewayAPIClient_OpenInApp_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_OpenInApp_Call) RunAndReturn(run func(context.Context, *gatewayv1beta1.OpenInAppRequest, ...grpc.CallOption) (*appproviderv1beta1.OpenInAppResponse, error)) *GatewayAPIClient_OpenInApp_Call {
	_c.Call.Return(run)
	return _c
}

// PurgeRecycle provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) PurgeRecycle(ctx context.Context, in *providerv1beta1.PurgeRecycleRequest, opts ...grpc.CallOption) (*providerv1beta1.PurgeRecycleResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.PurgeRecycleResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.PurgeRecycleRequest, ...grpc.CallOption) (*providerv1beta1.PurgeRecycleResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.PurgeRecycleRequest, ...grpc.CallOption) *providerv1beta1.PurgeRecycleResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.PurgeRecycleResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.PurgeRecycleRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// PurgeRecycle is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.PurgeRecycleRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) PurgeRecycle(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_PurgeRecycle_Call {
	return &GatewayAPIClient_PurgeRecycle_Call{Call: _e.mock.On("PurgeRecycle",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_PurgeRecycle_Call) Run(run func(ctx context.Context, in *providerv1beta1.PurgeRecycleRequest, opts ...grpc.CallOption)) *GatewayAPIClient_PurgeRecycle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.PurgeRecycleRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_PurgeRecycle_Call) Return(_a0 *providerv1beta1.PurgeRecycleResponse, _a1 error) *GatewayAPIClient_PurgeRecycle_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_PurgeRecycle_Call) RunAndReturn(run func(context.Context, *providerv1beta1.PurgeRecycleRequest, ...grpc.CallOption) (*providerv1beta1.PurgeRecycleResponse, error)) *GatewayAPIClient_PurgeRecycle_Call {
	_c.Call.Return(run)
	return _c
}

// RefreshLock provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) RefreshLock(ctx context.Context, in *providerv1beta1.RefreshLockRequest, opts ...grpc.CallOption) (*providerv1beta1.RefreshLockResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.RefreshLockResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.RefreshLockRequest, ...grpc.CallOption) (*providerv1beta1.RefreshLockResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.RefreshLockRequest, ...grpc.CallOption) *providerv1beta1.RefreshLockResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.RefreshLockResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.RefreshLockRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RefreshLock is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.RefreshLockRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) RefreshLock(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_RefreshLock_Call {
	return &GatewayAPIClient_RefreshLock_Call{Call: _e.mock.On("RefreshLock",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_RefreshLock_Call) Run(run func(ctx context.Context, in *providerv1beta1.RefreshLockRequest, opts ...grpc.CallOption)) *GatewayAPIClient_RefreshLock_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.RefreshLockRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_RefreshLock_Call) Return(_a0 *providerv1beta1.RefreshLockResponse, _a1 error) *GatewayAPIClient_RefreshLock_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_RefreshLock_Call) RunAndReturn(run func(context.Context, *providerv1beta1.RefreshLockRequest, ...grpc.CallOption) (*providerv1beta1.RefreshLockResponse, error)) *GatewayAPIClient_RefreshLock_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveOCMShare provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) RemoveOCMShare(ctx context.Context, in *ocmv1beta1.RemoveOCMShareRequest, opts ...grpc.CallOption) (*ocmv1beta1.RemoveOCMShareResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *ocmv1beta1.RemoveOCMShareResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ocmv1beta1.RemoveOCMShareRequest, ...grpc.CallOption) (*ocmv1beta1.RemoveOCMShareResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ocmv1beta1.RemoveOCMShareRequest, ...grpc.CallOption) *ocmv1beta1.RemoveOCMShareResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ocmv1beta1.RemoveOCMShareResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ocmv1beta1.RemoveOCMShareRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RemoveOCMShare is a helper method to define mock.On call
//   - ctx context.Context
//   - in *ocmv1beta1.RemoveOCMShareRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) RemoveOCMShare(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_RemoveOCMShare_Call {
	return &GatewayAPIClient_RemoveOCMShare_Call{Call: _e.mock.On("RemoveOCMShare",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_RemoveOCMShare_Call) Run(run func(ctx context.Context, in *ocmv1beta1.RemoveOCMShareRequest, opts ...grpc.CallOption)) *GatewayAPIClient_RemoveOCMShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*ocmv1beta1.RemoveOCMShareRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_RemoveOCMShare_Call) Return(_a0 *ocmv1beta1.RemoveOCMShareResponse, _a1 error) *GatewayAPIClient_RemoveOCMShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_RemoveOCMShare_Call) RunAndReturn(run func(context.Context, *ocmv1beta1.RemoveOCMShareRequest, ...grpc.CallOption) (*ocmv1beta1.RemoveOCMShareResponse, error)) *GatewayAPIClient_RemoveOCMShare_Call {
	_c.Call.Return(run)
	return _c
}

// RemovePublicShare provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) RemovePublicShare(ctx context.Context, in *linkv1beta1.RemovePublicShareRequest, opts ...grpc.CallOption) (*linkv1beta1.RemovePublicShareResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *linkv1beta1.RemovePublicShareResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *linkv1beta1.RemovePublicShareRequest, ...grpc.CallOption) (*linkv1beta1.RemovePublicShareResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *linkv1beta1.RemovePublicShareRequest, ...grpc.CallOption) *linkv1beta1.RemovePublicShareResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*linkv1beta1.RemovePublicShareResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *linkv1beta1.RemovePublicShareRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RemovePublicShare is a helper method to define mock.On call
//   - ctx context.Context
//   - in *linkv1beta1.RemovePublicShareRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) RemovePublicShare(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_RemovePublicShare_Call {
	return &GatewayAPIClient_RemovePublicShare_Call{Call: _e.mock.On("RemovePublicShare",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_RemovePublicShare_Call) Run(run func(ctx context.Context, in *linkv1beta1.RemovePublicShareRequest, opts ...grpc.CallOption)) *GatewayAPIClient_RemovePublicShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*linkv1beta1.RemovePublicShareRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_RemovePublicShare_Call) Return(_a0 *linkv1beta1.RemovePublicShareResponse, _a1 error) *GatewayAPIClient_RemovePublicShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_RemovePublicShare_Call) RunAndReturn(run func(context.Context, *linkv1beta1.RemovePublicShareRequest, ...grpc.CallOption) (*linkv1beta1.RemovePublicShareResponse, error)) *GatewayAPIClient_RemovePublicShare_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveShare provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) RemoveShare(ctx context.Context, in *collaborationv1beta1.RemoveShareRequest, opts ...grpc.CallOption) (*collaborationv1beta1.RemoveShareResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *collaborationv1beta1.RemoveShareResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.RemoveShareRequest, ...grpc.CallOption) (*collaborationv1beta1.RemoveShareResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.RemoveShareRequest, ...grpc.CallOption) *collaborationv1beta1.RemoveShareResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*collaborationv1beta1.RemoveShareResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *collaborationv1beta1.RemoveShareRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RemoveShare is a helper method to define mock.On call
//   - ctx context.Context
//   - in *collaborationv1beta1.RemoveShareRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) RemoveShare(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_RemoveShare_Call {
	return &GatewayAPIClient_RemoveShare_Call{Call: _e.mock.On("RemoveShare",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_RemoveShare_Call) Run(run func(ctx context.Context, in *collaborationv1beta1.RemoveShareRequest, opts ...grpc.CallOption)) *GatewayAPIClient_RemoveShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*collaborationv1beta1.RemoveShareRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_RemoveShare_Call) Return(_a0 *collaborationv1beta1.RemoveShareResponse, _a1 error) *GatewayAPIClient_RemoveShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_RemoveShare_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.RemoveShareRequest, ...grpc.CallOption) (*collaborationv1beta1.RemoveShareResponse, error)) *GatewayAPIClient_RemoveShare_Call {
	_c.Call.Return(run)
	return _c
}

// RestoreFileVersion provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) RestoreFileVersion(ctx context.Context, in *providerv1beta1.RestoreFileVersionRequest, opts ...grpc.CallOption) (*providerv1beta1.RestoreFileVersionResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.RestoreFileVersionResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.RestoreFileVersionRequest, ...grpc.CallOption) (*providerv1beta1.RestoreFileVersionResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.RestoreFileVersionRequest, ...grpc.CallOption) *providerv1beta1.RestoreFileVersionResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.RestoreFileVersionResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.RestoreFileVersionRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RestoreFileVersion is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.RestoreFileVersionRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) RestoreFileVersion(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_RestoreFileVersion_Call {
	return &GatewayAPIClient_RestoreFileVersion_Call{Call: _e.mock.On("RestoreFileVersion",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_RestoreFileVersion_Call) Run(run func(ctx context.Context, in *providerv1beta1.RestoreFileVersionRequest, opts ...grpc.CallOption)) *GatewayAPIClient_RestoreFileVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.RestoreFileVersionRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_RestoreFileVersion_Call) Return(_a0 *providerv1beta1.RestoreFileVersionResponse, _a1 error) *GatewayAPIClient_RestoreFileVersion_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_RestoreFileVersion_Call) RunAndReturn(run func(context.Context, *providerv1beta1.RestoreFileVersionRequest, ...grpc.CallOption) (*providerv1beta1.RestoreFileVersionResponse, error)) *GatewayAPIClient_RestoreFileVersion_Call {
	_c.Call.Return(run)
	return _c
}

// RestoreRecycleItem provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) RestoreRecycleItem(ctx context.Context, in *providerv1beta1.RestoreRecycleItemRequest, opts ...grpc.CallOption) (*providerv1beta1.RestoreRecycleItemResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.RestoreRecycleItemResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.RestoreRecycleItemRequest, ...grpc.CallOption) (*providerv1beta1.RestoreRecycleItemResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.RestoreRecycleItemRequest, ...grpc.CallOption) *providerv1beta1.RestoreRecycleItemResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.RestoreRecycleItemResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.RestoreRecycleItemRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RestoreRecycleItem is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.RestoreRecycleItemRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) RestoreRecycleItem(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_RestoreRecycleItem_Call {
	return &GatewayAPIClient_RestoreRecycleItem_Call{Call: _e.mock.On("RestoreRecycleItem",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_RestoreRecycleItem_Call) Run(run func(ctx context.Context, in *providerv1beta1.RestoreRecycleItemRequest, opts ...grpc.CallOption)) *GatewayAPIClient_RestoreRecycleItem_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.RestoreRecycleItemRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_RestoreRecycleItem_Call) Return(_a0 *providerv1beta1.RestoreRecycleItemResponse, _a1 error) *GatewayAPIClient_RestoreRecycleItem_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_RestoreRecycleItem_Call) RunAndReturn(run func(context.Context, *providerv1beta1.RestoreRecycleItemRequest, ...grpc.CallOption) (*providerv1beta1.RestoreRecycleItemResponse, error)) *GatewayAPIClient_RestoreRecycleItem_Call {
	_c.Call.Return(run)
	return _c
}

// RetryTransfer provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) RetryTransfer(ctx context.Context, in *txv1beta1.RetryTransferRequest, opts ...grpc.CallOption) (*txv1beta1.RetryTransferResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *txv1beta1.RetryTransferResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *txv1beta1.RetryTransferRequest, ...grpc.CallOption) (*txv1beta1.RetryTransferResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *txv1beta1.RetryTransferRequest, ...grpc.CallOption) *txv1beta1.RetryTransferResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*txv1beta1.RetryTransferResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *txv1beta1.RetryTransferRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RetryTransfer is a helper method to define mock.On call
//   - ctx context.Context
//   - in *txv1beta1.RetryTransferRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) RetryTransfer(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_RetryTransfer_Call {
	return &GatewayAPIClient_RetryTransfer_Call{Call: _e.mock.On("RetryTransfer",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_RetryTransfer_Call) Run(run func(ctx context.Context, in *txv1beta1.RetryTransferRequest, opts ...grpc.CallOption)) *GatewayAPIClient_RetryTransfer_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*txv1beta1.RetryTransferRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_RetryTransfer_Call) Return(_a0 *txv1beta1.RetryTransferResponse, _a1 error) *GatewayAPIClient_RetryTransfer_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_RetryTransfer_Call) RunAndReturn(run func(context.Context, *txv1beta1.RetryTransferRequest, ...grpc.CallOption) (*txv1beta1.RetryTransferResponse, error)) *GatewayAPIClient_RetryTransfer_Call {
	_c.Call.Return(run)
	return _c
}

// SetArbitraryMetadata provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) SetArbitraryMetadata(ctx context.Context, in *providerv1beta1.SetArbitraryMetadataRequest, opts ...grpc.CallOption) (*providerv1beta1.SetArbitraryMetadataResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.SetArbitraryMetadataResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.SetArbitraryMetadataRequest, ...grpc.CallOption) (*providerv1beta1.SetArbitraryMetadataResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.SetArbitraryMetadataRequest, ...grpc.CallOption) *providerv1beta1.SetArbitraryMetadataResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.SetArbitraryMetadataResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.SetArbitraryMetadataRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SetArbitraryMetadata is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.SetArbitraryMetadataRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) SetArbitraryMetadata(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_SetArbitraryMetadata_Call {
	return &GatewayAPIClient_SetArbitraryMetadata_Call{Call: _e.mock.On("SetArbitraryMetadata",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_SetArbitraryMetadata_Call) Run(run func(ctx context.Context, in *providerv1beta1.SetArbitraryMetadataRequest, opts ...grpc.CallOption)) *GatewayAPIClient_SetArbitraryMetadata_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.SetArbitraryMetadataRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_SetArbitraryMetadata_Call) Return(_a0 *providerv1beta1.SetArbitraryMetadataResponse, _a1 error) *GatewayAPIClient_SetArbitraryMetadata_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_SetArbitraryMetadata_Call) RunAndReturn(run func(context.Context, *providerv1beta1.SetArbitraryMetadataRequest, ...grpc.CallOption) (*providerv1beta1.SetArbitraryMetadataResponse, error)) *GatewayAPIClient_SetArbitraryMetadata_Call {
	_c.Call.Return(run)
	return _c
}

// SetDefaultAppProviderForMimeType provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) SetDefaultAppProviderForMimeType(ctx context.Context, in *registryv1beta1.SetDefaultAppProviderForMimeTypeRequest, opts ...grpc.CallOption) (*registryv1beta1.SetDefaultAppProviderForMimeTypeResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *registryv1beta1.SetDefaultAppProviderForMimeTypeResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *registryv1beta1.SetDefaultAppProviderForMimeTypeRequest, ...grpc.CallOption) (*registryv1beta1.SetDefaultAppProviderForMimeTypeResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *registryv1beta1.SetDefaultAppProviderForMimeTypeRequest, ...grpc.CallOption) *registryv1beta1.SetDefaultAppProviderForMimeTypeResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*registryv1beta1.SetDefaultAppProviderForMimeTypeResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *registryv1beta1.SetDefaultAppProviderForMimeTypeRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SetDefaultAppProviderForMimeType is a helper method to define mock.On call
//   - ctx context.Context
//   - in *registryv1beta1.SetDefaultAppProviderForMimeTypeRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) SetDefaultAppProviderForMimeType(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_SetDefaultAppProviderForMimeType_Call {
	return &GatewayAPIClient_SetDefaultAppProviderForMimeType_Call{Call: _e.mock.On("SetDefaultAppProviderForMimeType",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_SetDefaultAppProviderForMimeType_Call) Run(run func(ctx context.Context, in *registryv1beta1.SetDefaultAppProviderForMimeTypeRequest, opts ...grpc.CallOption)) *GatewayAPIClient_SetDefaultAppProviderForMimeType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*registryv1beta1.SetDefaultAppProviderForMimeTypeRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_SetDefaultAppProviderForMimeType_Call) Return(_a0 *registryv1beta1.SetDefaultAppProviderForMimeTypeResponse, _a1 error) *GatewayAPIClient_SetDefaultAppProviderForMimeType_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_SetDefaultAppProviderForMimeType_Call) RunAndReturn(run func(context.Context, *registryv1beta1.SetDefaultAppProviderForMimeTypeRequest, ...grpc.CallOption) (*registryv1beta1.SetDefaultAppProviderForMimeTypeResponse, error)) *GatewayAPIClient_SetDefaultAppProviderForMimeType_Call {
	_c.Call.Return(run)
	return _c
}

// SetKey provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) SetKey(ctx context.Context, in *preferencesv1beta1.SetKeyRequest, opts ...grpc.CallOption) (*preferencesv1beta1.SetKeyResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *preferencesv1beta1.SetKeyResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *preferencesv1beta1.SetKeyRequest, ...grpc.CallOption) (*preferencesv1beta1.SetKeyResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *preferencesv1beta1.SetKeyRequest, ...grpc.CallOption) *preferencesv1beta1.SetKeyResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*preferencesv1beta1.SetKeyResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *preferencesv1beta1.SetKeyRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SetKey is a helper method to define mock.On call
//   - ctx context.Context
//   - in *preferencesv1beta1.SetKeyRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) SetKey(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_SetKey_Call {
	return &GatewayAPIClient_SetKey_Call{Call: _e.mock.On("SetKey",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_SetKey_Call) Run(run func(ctx context.Context, in *preferencesv1beta1.SetKeyRequest, opts ...grpc.CallOption)) *GatewayAPIClient_SetKey_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*preferencesv1beta1.SetKeyRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_SetKey_Call) Return(_a0 *preferencesv1beta1.SetKeyResponse, _a1 error) *GatewayAPIClient_SetKey_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_SetKey_Call) RunAndReturn(run func(context.Context, *preferencesv1beta1.SetKeyRequest, ...grpc.CallOption) (*preferencesv1beta1.SetKeyResponse, error)) *GatewayAPIClient_SetKey_Call {
	_c.Call.Return(run)
	return _c
}

// SetLock provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) SetLock(ctx context.Context, in *providerv1beta1.SetLockRequest, opts ...grpc.CallOption) (*providerv1beta1.SetLockResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.SetLockResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.SetLockRequest, ...grpc.CallOption) (*providerv1beta1.SetLockResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.SetLockRequest, ...grpc.CallOption) *providerv1beta1.SetLockResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.SetLockResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.SetLockRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// SetLock is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.SetLockRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) SetLock(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_SetLock_Call {
	return &GatewayAPIClient_SetLock_Call{Call: _e.mock.On("SetLock",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_SetLock_Call) Run(run func(ctx context.Context, in *providerv1beta1.SetLockRequest, opts ...grpc.CallOption)) *GatewayAPIClient_SetLock_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.SetLockRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_SetLock_Call) Return(_a0 *providerv1beta1.SetLockResponse, _a1 error) *GatewayAPIClient_SetLock_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_SetLock_Call) RunAndReturn(run func(context.Context, *providerv1beta1.SetLockRequest, ...grpc.CallOption) (*providerv1beta1.SetLockResponse, error)) *GatewayAPIClient_SetLock_Call {
	_c.Call.Return(run)
	return _c
}

// Stat provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) Stat(ctx context.Context, in *providerv1beta1.StatRequest, opts ...grpc.CallOption) (*providerv1beta1.StatResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.StatResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.StatRequest, ...grpc.CallOption) (*providerv1beta1.StatResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.StatRequest, ...grpc.CallOption) *providerv1beta1.StatResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.StatResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.StatRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Stat is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.StatRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) Stat(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_Stat_Call {
	return &GatewayAPIClient_Stat_Call{Call: _e.mock.On("Stat",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_Stat_Call) Run(run func(ctx context.Context, in *providerv1beta1.StatRequest, opts ...grpc.CallOption)) *GatewayAPIClient_Stat_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.StatRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_Stat_Call) Return(_a0 *providerv1beta1.StatResponse, _a1 error) *GatewayAPIClient_Stat_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_Stat_Call) RunAndReturn(run func(context.Context, *providerv1beta1.StatRequest, ...grpc.CallOption) (*providerv1beta1.StatResponse, error)) *GatewayAPIClient_Stat_Call {
	_c.Call.Return(run)
	return _c
}

// TouchFile provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) TouchFile(ctx context.Context, in *providerv1beta1.TouchFileRequest, opts ...grpc.CallOption) (*providerv1beta1.TouchFileResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.TouchFileResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.TouchFileRequest, ...grpc.CallOption) (*providerv1beta1.TouchFileResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.TouchFileRequest, ...grpc.CallOption) *providerv1beta1.TouchFileResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.TouchFileResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.TouchFileRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// TouchFile is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.TouchFileRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) TouchFile(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_TouchFile_Call {
	return &GatewayAPIClient_TouchFile_Call{Call: _e.mock.On("TouchFile",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_TouchFile_Call) Run(run func(ctx context.Context, in *providerv1beta1.TouchFileRequest, opts ...grpc.CallOption)) *GatewayAPIClient_TouchFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.TouchFileRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_TouchFile_Call) Return(_a0 *providerv1beta1.TouchFileResponse, _a1 error) *GatewayAPIClient_TouchFile_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_TouchFile_Call) RunAndReturn(run func(context.Context, *providerv1beta1.TouchFileRequest, ...grpc.CallOption) (*providerv1beta1.TouchFileResponse, error)) *GatewayAPIClient_TouchFile_Call {
	_c.Call.Return(run)
	return _c
}

// Unlock provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) Unlock(ctx context.Context, in *providerv1beta1.UnlockRequest, opts ...grpc.CallOption) (*providerv1beta1.UnlockResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.UnlockResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.UnlockRequest, ...grpc.CallOption) (*providerv1beta1.UnlockResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.UnlockRequest, ...grpc.CallOption) *providerv1beta1.UnlockResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.UnlockResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.UnlockRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// Unlock is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.UnlockRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) Unlock(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_Unlock_Call {
	return &GatewayAPIClient_Unlock_Call{Call: _e.mock.On("Unlock",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_Unlock_Call) Run(run func(ctx context.Context, in *providerv1beta1.UnlockRequest, opts ...grpc.CallOption)) *GatewayAPIClient_Unlock_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.UnlockRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_Unlock_Call) Return(_a0 *providerv1beta1.UnlockResponse, _a1 error) *GatewayAPIClient_Unlock_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_Unlock_Call) RunAndReturn(run func(context.Context, *providerv1beta1.UnlockRequest, ...grpc.CallOption) (*providerv1beta1.UnlockResponse, error)) *GatewayAPIClient_Unlock_Call {
	_c.Call.Return(run)
	return _c
}

// UnsetArbitraryMetadata provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) UnsetArbitraryMetadata(ctx context.Context, in *providerv1beta1.UnsetArbitraryMetadataRequest, opts ...grpc.CallOption) (*providerv1beta1.UnsetArbitraryMetadataResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.UnsetArbitraryMetadataResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.UnsetArbitraryMetadataRequest, ...grpc.CallOption) (*providerv1beta1.UnsetArbitraryMetadataResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.UnsetArbitraryMetadataRequest, ...grpc.CallOption) *providerv1beta1.UnsetArbitraryMetadataResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.UnsetArbitraryMetadataResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.UnsetArbitraryMetadataRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UnsetArbitraryMetadata is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.UnsetArbitraryMetadataRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) UnsetArbitraryMetadata(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_UnsetArbitraryMetadata_Call {
	return &GatewayAPIClient_UnsetArbitraryMetadata_Call{Call: _e.mock.On("UnsetArbitraryMetadata",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_UnsetArbitraryMetadata_Call) Run(run func(ctx context.Context, in *providerv1beta1.UnsetArbitraryMetadataRequest, opts ...grpc.CallOption)) *GatewayAPIClient_UnsetArbitraryMetadata_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.UnsetArbitraryMetadataRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_UnsetArbitraryMetadata_Call) Return(_a0 *providerv1beta1.UnsetArbitraryMetadataResponse, _a1 error) *GatewayAPIClient_UnsetArbitraryMetadata_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_UnsetArbitraryMetadata_Call) RunAndReturn(run func(context.Context, *providerv1beta1.UnsetArbitraryMetadataRequest, ...grpc.CallOption) (*providerv1beta1.UnsetArbitraryMetadataResponse, error)) *GatewayAPIClient_UnsetArbitraryMetadata_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateOCMCoreShare provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) UpdateOCMCoreShare(ctx context.Context, in *corev1beta1.UpdateOCMCoreShareRequest, opts ...grpc.CallOption) (*corev1beta1.UpdateOCMCoreShareResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *corev1beta1.UpdateOCMCoreShareResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *corev1beta1.UpdateOCMCoreShareRequest, ...grpc.CallOption) (*corev1beta1.UpdateOCMCoreShareResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *corev1beta1.UpdateOCMCoreShareRequest, ...grpc.CallOption) *corev1beta1.UpdateOCMCoreShareResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*corev1beta1.UpdateOCMCoreShareResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *corev1beta1.UpdateOCMCoreShareRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateOCMCoreShare is a helper method to define mock.On call
//   - ctx context.Context
//   - in *corev1beta1.UpdateOCMCoreShareRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) UpdateOCMCoreShare(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_UpdateOCMCoreShare_Call {
	return &GatewayAPIClient_UpdateOCMCoreShare_Call{Call: _e.mock.On("UpdateOCMCoreShare",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_UpdateOCMCoreShare_Call) Run(run func(ctx context.Context, in *corev1beta1.UpdateOCMCoreShareRequest, opts ...grpc.CallOption)) *GatewayAPIClient_UpdateOCMCoreShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*corev1beta1.UpdateOCMCoreShareRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_UpdateOCMCoreShare_Call) Return(_a0 *corev1beta1.UpdateOCMCoreShareResponse, _a1 error) *GatewayAPIClient_UpdateOCMCoreShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_UpdateOCMCoreShare_Call) RunAndReturn(run func(context.Context, *corev1beta1.UpdateOCMCoreShareRequest, ...grpc.CallOption) (*corev1beta1.UpdateOCMCoreShareResponse, error)) *GatewayAPIClient_UpdateOCMCoreShare_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateOCMShare provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) UpdateOCMShare(ctx context.Context, in *ocmv1beta1.UpdateOCMShareRequest, opts ...grpc.CallOption) (*ocmv1beta1.UpdateOCMShareResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *ocmv1beta1.UpdateOCMShareResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ocmv1beta1.UpdateOCMShareRequest, ...grpc.CallOption) (*ocmv1beta1.UpdateOCMShareResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ocmv1beta1.UpdateOCMShareRequest, ...grpc.CallOption) *ocmv1beta1.UpdateOCMShareResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ocmv1beta1.UpdateOCMShareResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ocmv1beta1.UpdateOCMShareRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateOCMShare is a helper method to define mock.On call
//   - ctx context.Context
//   - in *ocmv1beta1.UpdateOCMShareRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) UpdateOCMShare(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_UpdateOCMShare_Call {
	return &GatewayAPIClient_UpdateOCMShare_Call{Call: _e.mock.On("UpdateOCMShare",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_UpdateOCMShare_Call) Run(run func(ctx context.Context, in *ocmv1beta1.UpdateOCMShareRequest, opts ...grpc.CallOption)) *GatewayAPIClient_UpdateOCMShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*ocmv1beta1.UpdateOCMShareRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_UpdateOCMShare_Call) Return(_a0 *ocmv1beta1.UpdateOCMShareResponse, _a1 error) *GatewayAPIClient_UpdateOCMShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_UpdateOCMShare_Call) RunAndReturn(run func(context.Context, *ocmv1beta1.UpdateOCMShareRequest, ...grpc.CallOption) (*ocmv1beta1.UpdateOCMShareResponse, error)) *GatewayAPIClient_UpdateOCMShare_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePublicShare provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) UpdatePublicShare(ctx context.Context, in *linkv1beta1.UpdatePublicShareRequest, opts ...grpc.CallOption) (*linkv1beta1.UpdatePublicShareResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *linkv1beta1.UpdatePublicShareResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *linkv1beta1.UpdatePublicShareRequest, ...grpc.CallOption) (*linkv1beta1.UpdatePublicShareResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *linkv1beta1.UpdatePublicShareRequest, ...grpc.CallOption) *linkv1beta1.UpdatePublicShareResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*linkv1beta1.UpdatePublicShareResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *linkv1beta1.UpdatePublicShareRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdatePublicShare is a helper method to define mock.On call
//   - ctx context.Context
//   - in *linkv1beta1.UpdatePublicShareRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) UpdatePublicShare(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_UpdatePublicShare_Call {
	return &GatewayAPIClient_UpdatePublicShare_Call{Call: _e.mock.On("UpdatePublicShare",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_UpdatePublicShare_Call) Run(run func(ctx context.Context, in *linkv1beta1.UpdatePublicShareRequest, opts ...grpc.CallOption)) *GatewayAPIClient_UpdatePublicShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*linkv1beta1.UpdatePublicShareRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_UpdatePublicShare_Call) Return(_a0 *linkv1beta1.UpdatePublicShareResponse, _a1 error) *GatewayAPIClient_UpdatePublicShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_UpdatePublicShare_Call) RunAndReturn(run func(context.Context, *linkv1beta1.UpdatePublicShareRequest, ...grpc.CallOption) (*linkv1beta1.UpdatePublicShareResponse, error)) *GatewayAPIClient_UpdatePublicShare_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateReceivedOCMShare provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) UpdateReceivedOCMShare(ctx context.Context, in *ocmv1beta1.UpdateReceivedOCMShareRequest, opts ...grpc.CallOption) (*ocmv1beta1.UpdateReceivedOCMShareResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *ocmv1beta1.UpdateReceivedOCMShareResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *ocmv1beta1.UpdateReceivedOCMShareRequest, ...grpc.CallOption) (*ocmv1beta1.UpdateReceivedOCMShareResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *ocmv1beta1.UpdateReceivedOCMShareRequest, ...grpc.CallOption) *ocmv1beta1.UpdateReceivedOCMShareResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ocmv1beta1.UpdateReceivedOCMShareResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *ocmv1beta1.UpdateReceivedOCMShareRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateReceivedOCMShare is a helper method to define mock.On call
//   - ctx context.Context
//   - in *ocmv1beta1.UpdateReceivedOCMShareRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) UpdateReceivedOCMShare(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_UpdateReceivedOCMShare_Call {
	return &GatewayAPIClient_UpdateReceivedOCMShare_Call{Call: _e.mock.On("UpdateReceivedOCMShare",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_UpdateReceivedOCMShare_Call) Run(run func(ctx context.Context, in *ocmv1beta1.UpdateReceivedOCMShareRequest, opts ...grpc.CallOption)) *GatewayAPIClient_UpdateReceivedOCMShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*ocmv1beta1.UpdateReceivedOCMShareRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_UpdateReceivedOCMShare_Call) Return(_a0 *ocmv1beta1.UpdateReceivedOCMShareResponse, _a1 error) *GatewayAPIClient_UpdateReceivedOCMShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_UpdateReceivedOCMShare_Call) RunAndReturn(run func(context.Context, *ocmv1beta1.UpdateReceivedOCMShareRequest, ...grpc.CallOption) (*ocmv1beta1.UpdateReceivedOCMShareResponse, error)) *GatewayAPIClient_UpdateReceivedOCMShare_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateReceivedShare provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) UpdateReceivedShare(ctx context.Context, in *collaborationv1beta1.UpdateReceivedShareRequest, opts ...grpc.CallOption) (*collaborationv1beta1.UpdateReceivedShareResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *collaborationv1beta1.UpdateReceivedShareResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.UpdateReceivedShareRequest, ...grpc.CallOption) (*collaborationv1beta1.UpdateReceivedShareResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.UpdateReceivedShareRequest, ...grpc.CallOption) *collaborationv1beta1.UpdateReceivedShareResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*collaborationv1beta1.UpdateReceivedShareResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *collaborationv1beta1.UpdateReceivedShareRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateReceivedShare is a helper method to define mock.On call
//   - ctx context.Context
//   - in *collaborationv1beta1.UpdateReceivedShareRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) UpdateReceivedShare(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_UpdateReceivedShare_Call {
	return &GatewayAPIClient_UpdateReceivedShare_Call{Call: _e.mock.On("UpdateReceivedShare",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_UpdateReceivedShare_Call) Run(run func(ctx context.Context, in *collaborationv1beta1.UpdateReceivedShareRequest, opts ...grpc.CallOption)) *GatewayAPIClient_UpdateReceivedShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*collaborationv1beta1.UpdateReceivedShareRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_UpdateReceivedShare_Call) Return(_a0 *collaborationv1beta1.UpdateReceivedShareResponse, _a1 error) *GatewayAPIClient_UpdateReceivedShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_UpdateReceivedShare_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.UpdateReceivedShareRequest, ...grpc.CallOption) (*collaborationv1beta1.UpdateReceivedShareResponse, error)) *GatewayAPIClient_UpdateReceivedShare_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateShare provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) UpdateShare(ctx context.Context, in *collaborationv1beta1.UpdateShareRequest, opts ...grpc.CallOption) (*collaborationv1beta1.UpdateShareResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *collaborationv1beta1.UpdateShareResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.UpdateShareRequest, ...grpc.CallOption) (*collaborationv1beta1.UpdateShareResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.UpdateShareRequest, ...grpc.CallOption) *collaborationv1beta1.UpdateShareResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*collaborationv1beta1.UpdateShareResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *collaborationv1beta1.UpdateShareRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateShare is a helper method to define mock.On call
//   - ctx context.Context
//   - in *collaborationv1beta1.UpdateShareRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) UpdateShare(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_UpdateShare_Call {
	return &GatewayAPIClient_UpdateShare_Call{Call: _e.mock.On("UpdateShare",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_UpdateShare_Call) Run(run func(ctx context.Context, in *collaborationv1beta1.UpdateShareRequest, opts ...grpc.CallOption)) *GatewayAPIClient_UpdateShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*collaborationv1beta1.UpdateShareRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_UpdateShare_Call) Return(_a0 *collaborationv1beta1.UpdateShareResponse, _a1 error) *GatewayAPIClient_UpdateShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_UpdateShare_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.UpdateShareRequest, ...grpc.CallOption) (*collaborationv1beta1.UpdateShareResponse, error)) *GatewayAPIClient_UpdateShare_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateStorageSpace provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) UpdateStorageSpace(ctx context.Context, in *providerv1beta1.UpdateStorageSpaceRequest, opts ...grpc.CallOption) (*providerv1beta1.UpdateStorageSpaceResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *providerv1beta1.UpdateStorageSpaceResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.UpdateStorageSpaceRequest, ...grpc.CallOption) (*providerv1beta1.UpdateStorageSpaceResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.UpdateStorageSpaceRequest, ...grpc.CallOption) *providerv1beta1.UpdateStorageSpaceResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*providerv1beta1.UpdateStorageSpaceResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.UpdateStorageSpaceRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateStorageSpace is a helper method to define mock.On call
//   - ctx context.Context
//   - in *providerv1beta1.UpdateStorageSpaceRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) UpdateStorageSpace(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_UpdateStorageSpace_Call {
	return &GatewayAPIClient_UpdateStorageSpace_Call{Call: _e.mock.On("UpdateStorageSpace",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_UpdateStorageSpace_Call) Run(run func(ctx context.Context, in *providerv1beta1.UpdateStorageSpaceRequest, opts ...grpc.CallOption)) *GatewayAPIClient_UpdateStorageSpace_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*providerv1beta1.UpdateStorageSpaceRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_UpdateStorageSpace_Call) Return(_a0 *providerv1beta1.UpdateStorageSpaceResponse, _a1 error) *GatewayAPIClient_UpdateStorageSpace_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_UpdateStorageSpace_Call) RunAndReturn(run func(context.Context, *providerv1beta1.UpdateStorageSpaceRequest, ...grpc.CallOption) (*providerv1beta1.UpdateStorageSpaceResponse, error)) *GatewayAPIClient_UpdateStorageSpace_Call {
	_c.Call.Return(run)
	return _c
}

// WhoAmI provides a mock function with given fields: ctx, in, opts
func (_m *GatewayAPIClient) WhoAmI(ctx context.Context, in *gatewayv1beta1.WhoAmIRequest, opts ...grpc.CallOption) (*gatewayv1beta1.WhoAmIResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *gatewayv1beta1.WhoAmIResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *gatewayv1beta1.WhoAmIRequest, ...grpc.CallOption) (*gatewayv1beta1.WhoAmIResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *gatewayv1beta1.WhoAmIRequest, ...grpc.CallOption) *gatewayv1beta1.WhoAmIResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*gatewayv1beta1.WhoAmIResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *gatewayv1beta1.WhoAmIRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// WhoAmI is a helper method to define mock.On call
//   - ctx context.Context
//   - in *gatewayv1beta1.WhoAmIRequest
//   - opts ...grpc.CallOption
func (_e *GatewayAPIClient_Expecter) WhoAmI(ctx interface{}, in interface{}, opts ...interface{}) *GatewayAPIClient_WhoAmI_Call {
	return &GatewayAPIClient_WhoAmI_Call{Call: _e.mock.On("WhoAmI",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *GatewayAPIClient_WhoAmI_Call) Run(run func(ctx context.Context, in *gatewayv1beta1.WhoAmIRequest, opts ...grpc.CallOption)) *GatewayAPIClient_WhoAmI_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*gatewayv1beta1.WhoAmIRequest), variadicArgs...)
	})
	return _c
}

func (_c *GatewayAPIClient_WhoAmI_Call) Return(_a0 *gatewayv1beta1.WhoAmIResponse, _a1 error) *GatewayAPIClient_WhoAmI_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *GatewayAPIClient_WhoAmI_Call) RunAndReturn(run func(context.Context, *gatewayv1beta1.WhoAmIRequest, ...grpc.CallOption) (*gatewayv1beta1.WhoAmIResponse, error)) *GatewayAPIClient_WhoAmI_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}