diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml index 4927f09..30977b6 100644 --- a/.github/workflows/go.yml +++ b/.github/workflows/go.yml @@ -20,7 +20,7 @@ jobs: uses: actions/setup-go@v4 with: go-version: '1.21' - + - name: Build run: go build -v ./... diff --git a/.mockery.yaml b/.mockery.yaml new file mode 100644 index 0000000..d1eb56f --- /dev/null +++ b/.mockery.yaml @@ -0,0 +1,7 @@ +# See https://vektra.github.io/mockery/latest/configuration/ for more info +with-expecter: true +packages: + github.com/cs3org/go-cs3apis/cs3/gateway/v1beta1: + config: + interfaces: + GatewayAPIClient: \ No newline at end of file diff --git a/go.mod b/go.mod index 2eb6d2e..76daa69 100644 --- a/go.mod +++ b/go.mod @@ -9,8 +9,13 @@ require ( ) require ( + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/stretchr/objx v0.5.2 // indirect + github.com/stretchr/testify v1.9.0 // indirect golang.org/x/net v0.17.0 // indirect golang.org/x/sys v0.13.0 // indirect golang.org/x/text v0.13.0 // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index a0db5e6..9ad369d 100644 --- a/go.sum +++ b/go.sum @@ -1,9 +1,17 @@ +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM= golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE= golang.org/x/sys v0.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE= @@ -19,3 +27,6 @@ google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp0 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8= google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/mocks/github.com/cs3org/go-cs3apis/cs3/gateway/v1beta1/mock_GatewayAPIClient.go b/mocks/github.com/cs3org/go-cs3apis/cs3/gateway/v1beta1/mock_GatewayAPIClient.go new file mode 100644 index 0000000..ed1b08b --- /dev/null +++ b/mocks/github.com/cs3org/go-cs3apis/cs3/gateway/v1beta1/mock_GatewayAPIClient.go @@ -0,0 +1,7471 @@ +// Code generated by mockery v2.40.0. DO NOT EDIT. + +package gatewayv1beta1 + +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" +) + +// MockGatewayAPIClient is an autogenerated mock type for the GatewayAPIClient type +type MockGatewayAPIClient struct { + mock.Mock +} + +type MockGatewayAPIClient_Expecter struct { + mock *mock.Mock +} + +func (_m *MockGatewayAPIClient) EXPECT() *MockGatewayAPIClient_Expecter { + return &MockGatewayAPIClient_Expecter{mock: &_m.Mock} +} + +// AcceptInvite provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_AcceptInvite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcceptInvite' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) AcceptInvite(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_AcceptInvite_Call { + return &MockGatewayAPIClient_AcceptInvite_Call{Call: _e.mock.On("AcceptInvite", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_AcceptInvite_Call) Run(run func(ctx context.Context, in *invitev1beta1.AcceptInviteRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_AcceptInvite_Call) Return(_a0 *invitev1beta1.AcceptInviteResponse, _a1 error) *MockGatewayAPIClient_AcceptInvite_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_AcceptInvite_Call) RunAndReturn(run func(context.Context, *invitev1beta1.AcceptInviteRequest, ...grpc.CallOption) (*invitev1beta1.AcceptInviteResponse, error)) *MockGatewayAPIClient_AcceptInvite_Call { + _c.Call.Return(run) + return _c +} + +// AddAppProvider provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_AddAppProvider_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddAppProvider' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) AddAppProvider(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_AddAppProvider_Call { + return &MockGatewayAPIClient_AddAppProvider_Call{Call: _e.mock.On("AddAppProvider", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_AddAppProvider_Call) Run(run func(ctx context.Context, in *registryv1beta1.AddAppProviderRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_AddAppProvider_Call) Return(_a0 *registryv1beta1.AddAppProviderResponse, _a1 error) *MockGatewayAPIClient_AddAppProvider_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_AddAppProvider_Call) RunAndReturn(run func(context.Context, *registryv1beta1.AddAppProviderRequest, ...grpc.CallOption) (*registryv1beta1.AddAppProviderResponse, error)) *MockGatewayAPIClient_AddAppProvider_Call { + _c.Call.Return(run) + return _c +} + +// Authenticate provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_Authenticate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Authenticate' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) Authenticate(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_Authenticate_Call { + return &MockGatewayAPIClient_Authenticate_Call{Call: _e.mock.On("Authenticate", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_Authenticate_Call) Run(run func(ctx context.Context, in *gatewayv1beta1.AuthenticateRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_Authenticate_Call) Return(_a0 *gatewayv1beta1.AuthenticateResponse, _a1 error) *MockGatewayAPIClient_Authenticate_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_Authenticate_Call) RunAndReturn(run func(context.Context, *gatewayv1beta1.AuthenticateRequest, ...grpc.CallOption) (*gatewayv1beta1.AuthenticateResponse, error)) *MockGatewayAPIClient_Authenticate_Call { + _c.Call.Return(run) + return _c +} + +// CancelTransfer provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_CancelTransfer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelTransfer' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) CancelTransfer(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_CancelTransfer_Call { + return &MockGatewayAPIClient_CancelTransfer_Call{Call: _e.mock.On("CancelTransfer", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_CancelTransfer_Call) Run(run func(ctx context.Context, in *txv1beta1.CancelTransferRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_CancelTransfer_Call) Return(_a0 *txv1beta1.CancelTransferResponse, _a1 error) *MockGatewayAPIClient_CancelTransfer_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_CancelTransfer_Call) RunAndReturn(run func(context.Context, *txv1beta1.CancelTransferRequest, ...grpc.CallOption) (*txv1beta1.CancelTransferResponse, error)) *MockGatewayAPIClient_CancelTransfer_Call { + _c.Call.Return(run) + return _c +} + +// CheckPermission provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_CheckPermission_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckPermission' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) CheckPermission(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_CheckPermission_Call { + return &MockGatewayAPIClient_CheckPermission_Call{Call: _e.mock.On("CheckPermission", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_CheckPermission_Call) Run(run func(ctx context.Context, in *permissionsv1beta1.CheckPermissionRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_CheckPermission_Call) Return(_a0 *permissionsv1beta1.CheckPermissionResponse, _a1 error) *MockGatewayAPIClient_CheckPermission_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_CheckPermission_Call) RunAndReturn(run func(context.Context, *permissionsv1beta1.CheckPermissionRequest, ...grpc.CallOption) (*permissionsv1beta1.CheckPermissionResponse, error)) *MockGatewayAPIClient_CheckPermission_Call { + _c.Call.Return(run) + return _c +} + +// CreateContainer provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_CreateContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateContainer' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) CreateContainer(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_CreateContainer_Call { + return &MockGatewayAPIClient_CreateContainer_Call{Call: _e.mock.On("CreateContainer", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_CreateContainer_Call) Run(run func(ctx context.Context, in *providerv1beta1.CreateContainerRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_CreateContainer_Call) Return(_a0 *providerv1beta1.CreateContainerResponse, _a1 error) *MockGatewayAPIClient_CreateContainer_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_CreateContainer_Call) RunAndReturn(run func(context.Context, *providerv1beta1.CreateContainerRequest, ...grpc.CallOption) (*providerv1beta1.CreateContainerResponse, error)) *MockGatewayAPIClient_CreateContainer_Call { + _c.Call.Return(run) + return _c +} + +// CreateHome provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_CreateHome_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateHome' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) CreateHome(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_CreateHome_Call { + return &MockGatewayAPIClient_CreateHome_Call{Call: _e.mock.On("CreateHome", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_CreateHome_Call) Run(run func(ctx context.Context, in *providerv1beta1.CreateHomeRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_CreateHome_Call) Return(_a0 *providerv1beta1.CreateHomeResponse, _a1 error) *MockGatewayAPIClient_CreateHome_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_CreateHome_Call) RunAndReturn(run func(context.Context, *providerv1beta1.CreateHomeRequest, ...grpc.CallOption) (*providerv1beta1.CreateHomeResponse, error)) *MockGatewayAPIClient_CreateHome_Call { + _c.Call.Return(run) + return _c +} + +// CreateOCMCoreShare provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_CreateOCMCoreShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateOCMCoreShare' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) CreateOCMCoreShare(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_CreateOCMCoreShare_Call { + return &MockGatewayAPIClient_CreateOCMCoreShare_Call{Call: _e.mock.On("CreateOCMCoreShare", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_CreateOCMCoreShare_Call) Run(run func(ctx context.Context, in *corev1beta1.CreateOCMCoreShareRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_CreateOCMCoreShare_Call) Return(_a0 *corev1beta1.CreateOCMCoreShareResponse, _a1 error) *MockGatewayAPIClient_CreateOCMCoreShare_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_CreateOCMCoreShare_Call) RunAndReturn(run func(context.Context, *corev1beta1.CreateOCMCoreShareRequest, ...grpc.CallOption) (*corev1beta1.CreateOCMCoreShareResponse, error)) *MockGatewayAPIClient_CreateOCMCoreShare_Call { + _c.Call.Return(run) + return _c +} + +// CreateOCMShare provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_CreateOCMShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateOCMShare' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) CreateOCMShare(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_CreateOCMShare_Call { + return &MockGatewayAPIClient_CreateOCMShare_Call{Call: _e.mock.On("CreateOCMShare", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_CreateOCMShare_Call) Run(run func(ctx context.Context, in *ocmv1beta1.CreateOCMShareRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_CreateOCMShare_Call) Return(_a0 *ocmv1beta1.CreateOCMShareResponse, _a1 error) *MockGatewayAPIClient_CreateOCMShare_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_CreateOCMShare_Call) RunAndReturn(run func(context.Context, *ocmv1beta1.CreateOCMShareRequest, ...grpc.CallOption) (*ocmv1beta1.CreateOCMShareResponse, error)) *MockGatewayAPIClient_CreateOCMShare_Call { + _c.Call.Return(run) + return _c +} + +// CreatePublicShare provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_CreatePublicShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePublicShare' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) CreatePublicShare(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_CreatePublicShare_Call { + return &MockGatewayAPIClient_CreatePublicShare_Call{Call: _e.mock.On("CreatePublicShare", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_CreatePublicShare_Call) Run(run func(ctx context.Context, in *linkv1beta1.CreatePublicShareRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_CreatePublicShare_Call) Return(_a0 *linkv1beta1.CreatePublicShareResponse, _a1 error) *MockGatewayAPIClient_CreatePublicShare_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_CreatePublicShare_Call) RunAndReturn(run func(context.Context, *linkv1beta1.CreatePublicShareRequest, ...grpc.CallOption) (*linkv1beta1.CreatePublicShareResponse, error)) *MockGatewayAPIClient_CreatePublicShare_Call { + _c.Call.Return(run) + return _c +} + +// CreateShare provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_CreateShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateShare' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) CreateShare(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_CreateShare_Call { + return &MockGatewayAPIClient_CreateShare_Call{Call: _e.mock.On("CreateShare", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_CreateShare_Call) Run(run func(ctx context.Context, in *collaborationv1beta1.CreateShareRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_CreateShare_Call) Return(_a0 *collaborationv1beta1.CreateShareResponse, _a1 error) *MockGatewayAPIClient_CreateShare_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_CreateShare_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.CreateShareRequest, ...grpc.CallOption) (*collaborationv1beta1.CreateShareResponse, error)) *MockGatewayAPIClient_CreateShare_Call { + _c.Call.Return(run) + return _c +} + +// CreateStorageSpace provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_CreateStorageSpace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateStorageSpace' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) CreateStorageSpace(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_CreateStorageSpace_Call { + return &MockGatewayAPIClient_CreateStorageSpace_Call{Call: _e.mock.On("CreateStorageSpace", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_CreateStorageSpace_Call) Run(run func(ctx context.Context, in *providerv1beta1.CreateStorageSpaceRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_CreateStorageSpace_Call) Return(_a0 *providerv1beta1.CreateStorageSpaceResponse, _a1 error) *MockGatewayAPIClient_CreateStorageSpace_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_CreateStorageSpace_Call) RunAndReturn(run func(context.Context, *providerv1beta1.CreateStorageSpaceRequest, ...grpc.CallOption) (*providerv1beta1.CreateStorageSpaceResponse, error)) *MockGatewayAPIClient_CreateStorageSpace_Call { + _c.Call.Return(run) + return _c +} + +// CreateSymlink provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_CreateSymlink_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSymlink' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) CreateSymlink(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_CreateSymlink_Call { + return &MockGatewayAPIClient_CreateSymlink_Call{Call: _e.mock.On("CreateSymlink", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_CreateSymlink_Call) Run(run func(ctx context.Context, in *providerv1beta1.CreateSymlinkRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_CreateSymlink_Call) Return(_a0 *providerv1beta1.CreateSymlinkResponse, _a1 error) *MockGatewayAPIClient_CreateSymlink_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_CreateSymlink_Call) RunAndReturn(run func(context.Context, *providerv1beta1.CreateSymlinkRequest, ...grpc.CallOption) (*providerv1beta1.CreateSymlinkResponse, error)) *MockGatewayAPIClient_CreateSymlink_Call { + _c.Call.Return(run) + return _c +} + +// CreateTransfer provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_CreateTransfer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTransfer' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) CreateTransfer(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_CreateTransfer_Call { + return &MockGatewayAPIClient_CreateTransfer_Call{Call: _e.mock.On("CreateTransfer", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_CreateTransfer_Call) Run(run func(ctx context.Context, in *txv1beta1.CreateTransferRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_CreateTransfer_Call) Return(_a0 *txv1beta1.CreateTransferResponse, _a1 error) *MockGatewayAPIClient_CreateTransfer_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_CreateTransfer_Call) RunAndReturn(run func(context.Context, *txv1beta1.CreateTransferRequest, ...grpc.CallOption) (*txv1beta1.CreateTransferResponse, error)) *MockGatewayAPIClient_CreateTransfer_Call { + _c.Call.Return(run) + return _c +} + +// Delete provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) Delete(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_Delete_Call { + return &MockGatewayAPIClient_Delete_Call{Call: _e.mock.On("Delete", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_Delete_Call) Run(run func(ctx context.Context, in *providerv1beta1.DeleteRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_Delete_Call) Return(_a0 *providerv1beta1.DeleteResponse, _a1 error) *MockGatewayAPIClient_Delete_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_Delete_Call) RunAndReturn(run func(context.Context, *providerv1beta1.DeleteRequest, ...grpc.CallOption) (*providerv1beta1.DeleteResponse, error)) *MockGatewayAPIClient_Delete_Call { + _c.Call.Return(run) + return _c +} + +// DeleteAcceptedUser provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_DeleteAcceptedUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAcceptedUser' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) DeleteAcceptedUser(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_DeleteAcceptedUser_Call { + return &MockGatewayAPIClient_DeleteAcceptedUser_Call{Call: _e.mock.On("DeleteAcceptedUser", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_DeleteAcceptedUser_Call) Run(run func(ctx context.Context, in *invitev1beta1.DeleteAcceptedUserRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_DeleteAcceptedUser_Call) Return(_a0 *invitev1beta1.DeleteAcceptedUserResponse, _a1 error) *MockGatewayAPIClient_DeleteAcceptedUser_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_DeleteAcceptedUser_Call) RunAndReturn(run func(context.Context, *invitev1beta1.DeleteAcceptedUserRequest, ...grpc.CallOption) (*invitev1beta1.DeleteAcceptedUserResponse, error)) *MockGatewayAPIClient_DeleteAcceptedUser_Call { + _c.Call.Return(run) + return _c +} + +// DeleteOCMCoreShare provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_DeleteOCMCoreShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteOCMCoreShare' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) DeleteOCMCoreShare(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_DeleteOCMCoreShare_Call { + return &MockGatewayAPIClient_DeleteOCMCoreShare_Call{Call: _e.mock.On("DeleteOCMCoreShare", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_DeleteOCMCoreShare_Call) Run(run func(ctx context.Context, in *corev1beta1.DeleteOCMCoreShareRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_DeleteOCMCoreShare_Call) Return(_a0 *corev1beta1.DeleteOCMCoreShareResponse, _a1 error) *MockGatewayAPIClient_DeleteOCMCoreShare_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_DeleteOCMCoreShare_Call) RunAndReturn(run func(context.Context, *corev1beta1.DeleteOCMCoreShareRequest, ...grpc.CallOption) (*corev1beta1.DeleteOCMCoreShareResponse, error)) *MockGatewayAPIClient_DeleteOCMCoreShare_Call { + _c.Call.Return(run) + return _c +} + +// DeleteStorageSpace provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_DeleteStorageSpace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteStorageSpace' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) DeleteStorageSpace(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_DeleteStorageSpace_Call { + return &MockGatewayAPIClient_DeleteStorageSpace_Call{Call: _e.mock.On("DeleteStorageSpace", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_DeleteStorageSpace_Call) Run(run func(ctx context.Context, in *providerv1beta1.DeleteStorageSpaceRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_DeleteStorageSpace_Call) Return(_a0 *providerv1beta1.DeleteStorageSpaceResponse, _a1 error) *MockGatewayAPIClient_DeleteStorageSpace_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_DeleteStorageSpace_Call) RunAndReturn(run func(context.Context, *providerv1beta1.DeleteStorageSpaceRequest, ...grpc.CallOption) (*providerv1beta1.DeleteStorageSpaceResponse, error)) *MockGatewayAPIClient_DeleteStorageSpace_Call { + _c.Call.Return(run) + return _c +} + +// FindAcceptedUsers provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_FindAcceptedUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindAcceptedUsers' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) FindAcceptedUsers(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_FindAcceptedUsers_Call { + return &MockGatewayAPIClient_FindAcceptedUsers_Call{Call: _e.mock.On("FindAcceptedUsers", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_FindAcceptedUsers_Call) Run(run func(ctx context.Context, in *invitev1beta1.FindAcceptedUsersRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_FindAcceptedUsers_Call) Return(_a0 *invitev1beta1.FindAcceptedUsersResponse, _a1 error) *MockGatewayAPIClient_FindAcceptedUsers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_FindAcceptedUsers_Call) RunAndReturn(run func(context.Context, *invitev1beta1.FindAcceptedUsersRequest, ...grpc.CallOption) (*invitev1beta1.FindAcceptedUsersResponse, error)) *MockGatewayAPIClient_FindAcceptedUsers_Call { + _c.Call.Return(run) + return _c +} + +// FindGroups provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_FindGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindGroups' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) FindGroups(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_FindGroups_Call { + return &MockGatewayAPIClient_FindGroups_Call{Call: _e.mock.On("FindGroups", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_FindGroups_Call) Run(run func(ctx context.Context, in *groupv1beta1.FindGroupsRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_FindGroups_Call) Return(_a0 *groupv1beta1.FindGroupsResponse, _a1 error) *MockGatewayAPIClient_FindGroups_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_FindGroups_Call) RunAndReturn(run func(context.Context, *groupv1beta1.FindGroupsRequest, ...grpc.CallOption) (*groupv1beta1.FindGroupsResponse, error)) *MockGatewayAPIClient_FindGroups_Call { + _c.Call.Return(run) + return _c +} + +// FindUsers provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_FindUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindUsers' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) FindUsers(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_FindUsers_Call { + return &MockGatewayAPIClient_FindUsers_Call{Call: _e.mock.On("FindUsers", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_FindUsers_Call) Run(run func(ctx context.Context, in *userv1beta1.FindUsersRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_FindUsers_Call) Return(_a0 *userv1beta1.FindUsersResponse, _a1 error) *MockGatewayAPIClient_FindUsers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_FindUsers_Call) RunAndReturn(run func(context.Context, *userv1beta1.FindUsersRequest, ...grpc.CallOption) (*userv1beta1.FindUsersResponse, error)) *MockGatewayAPIClient_FindUsers_Call { + _c.Call.Return(run) + return _c +} + +// ForwardInvite provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ForwardInvite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ForwardInvite' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ForwardInvite(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ForwardInvite_Call { + return &MockGatewayAPIClient_ForwardInvite_Call{Call: _e.mock.On("ForwardInvite", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ForwardInvite_Call) Run(run func(ctx context.Context, in *invitev1beta1.ForwardInviteRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ForwardInvite_Call) Return(_a0 *invitev1beta1.ForwardInviteResponse, _a1 error) *MockGatewayAPIClient_ForwardInvite_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ForwardInvite_Call) RunAndReturn(run func(context.Context, *invitev1beta1.ForwardInviteRequest, ...grpc.CallOption) (*invitev1beta1.ForwardInviteResponse, error)) *MockGatewayAPIClient_ForwardInvite_Call { + _c.Call.Return(run) + return _c +} + +// GenerateAppPassword provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GenerateAppPassword_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenerateAppPassword' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GenerateAppPassword(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GenerateAppPassword_Call { + return &MockGatewayAPIClient_GenerateAppPassword_Call{Call: _e.mock.On("GenerateAppPassword", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GenerateAppPassword_Call) Run(run func(ctx context.Context, in *applicationsv1beta1.GenerateAppPasswordRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GenerateAppPassword_Call) Return(_a0 *applicationsv1beta1.GenerateAppPasswordResponse, _a1 error) *MockGatewayAPIClient_GenerateAppPassword_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GenerateAppPassword_Call) RunAndReturn(run func(context.Context, *applicationsv1beta1.GenerateAppPasswordRequest, ...grpc.CallOption) (*applicationsv1beta1.GenerateAppPasswordResponse, error)) *MockGatewayAPIClient_GenerateAppPassword_Call { + _c.Call.Return(run) + return _c +} + +// GenerateInviteToken provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GenerateInviteToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenerateInviteToken' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GenerateInviteToken(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GenerateInviteToken_Call { + return &MockGatewayAPIClient_GenerateInviteToken_Call{Call: _e.mock.On("GenerateInviteToken", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GenerateInviteToken_Call) Run(run func(ctx context.Context, in *invitev1beta1.GenerateInviteTokenRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GenerateInviteToken_Call) Return(_a0 *invitev1beta1.GenerateInviteTokenResponse, _a1 error) *MockGatewayAPIClient_GenerateInviteToken_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GenerateInviteToken_Call) RunAndReturn(run func(context.Context, *invitev1beta1.GenerateInviteTokenRequest, ...grpc.CallOption) (*invitev1beta1.GenerateInviteTokenResponse, error)) *MockGatewayAPIClient_GenerateInviteToken_Call { + _c.Call.Return(run) + return _c +} + +// GetAcceptedUser provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetAcceptedUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAcceptedUser' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetAcceptedUser(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetAcceptedUser_Call { + return &MockGatewayAPIClient_GetAcceptedUser_Call{Call: _e.mock.On("GetAcceptedUser", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetAcceptedUser_Call) Run(run func(ctx context.Context, in *invitev1beta1.GetAcceptedUserRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetAcceptedUser_Call) Return(_a0 *invitev1beta1.GetAcceptedUserResponse, _a1 error) *MockGatewayAPIClient_GetAcceptedUser_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetAcceptedUser_Call) RunAndReturn(run func(context.Context, *invitev1beta1.GetAcceptedUserRequest, ...grpc.CallOption) (*invitev1beta1.GetAcceptedUserResponse, error)) *MockGatewayAPIClient_GetAcceptedUser_Call { + _c.Call.Return(run) + return _c +} + +// GetAppPassword provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetAppPassword_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAppPassword' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetAppPassword(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetAppPassword_Call { + return &MockGatewayAPIClient_GetAppPassword_Call{Call: _e.mock.On("GetAppPassword", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetAppPassword_Call) Run(run func(ctx context.Context, in *applicationsv1beta1.GetAppPasswordRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetAppPassword_Call) Return(_a0 *applicationsv1beta1.GetAppPasswordResponse, _a1 error) *MockGatewayAPIClient_GetAppPassword_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetAppPassword_Call) RunAndReturn(run func(context.Context, *applicationsv1beta1.GetAppPasswordRequest, ...grpc.CallOption) (*applicationsv1beta1.GetAppPasswordResponse, error)) *MockGatewayAPIClient_GetAppPassword_Call { + _c.Call.Return(run) + return _c +} + +// GetAppProviders provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetAppProviders_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAppProviders' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetAppProviders(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetAppProviders_Call { + return &MockGatewayAPIClient_GetAppProviders_Call{Call: _e.mock.On("GetAppProviders", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetAppProviders_Call) Run(run func(ctx context.Context, in *registryv1beta1.GetAppProvidersRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetAppProviders_Call) Return(_a0 *registryv1beta1.GetAppProvidersResponse, _a1 error) *MockGatewayAPIClient_GetAppProviders_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetAppProviders_Call) RunAndReturn(run func(context.Context, *registryv1beta1.GetAppProvidersRequest, ...grpc.CallOption) (*registryv1beta1.GetAppProvidersResponse, error)) *MockGatewayAPIClient_GetAppProviders_Call { + _c.Call.Return(run) + return _c +} + +// GetDefaultAppProviderForMimeType provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetDefaultAppProviderForMimeType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDefaultAppProviderForMimeType' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetDefaultAppProviderForMimeType(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetDefaultAppProviderForMimeType_Call { + return &MockGatewayAPIClient_GetDefaultAppProviderForMimeType_Call{Call: _e.mock.On("GetDefaultAppProviderForMimeType", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetDefaultAppProviderForMimeType_Call) Run(run func(ctx context.Context, in *registryv1beta1.GetDefaultAppProviderForMimeTypeRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetDefaultAppProviderForMimeType_Call) Return(_a0 *registryv1beta1.GetDefaultAppProviderForMimeTypeResponse, _a1 error) *MockGatewayAPIClient_GetDefaultAppProviderForMimeType_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetDefaultAppProviderForMimeType_Call) RunAndReturn(run func(context.Context, *registryv1beta1.GetDefaultAppProviderForMimeTypeRequest, ...grpc.CallOption) (*registryv1beta1.GetDefaultAppProviderForMimeTypeResponse, error)) *MockGatewayAPIClient_GetDefaultAppProviderForMimeType_Call { + _c.Call.Return(run) + return _c +} + +// GetGroup provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGroup' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetGroup(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetGroup_Call { + return &MockGatewayAPIClient_GetGroup_Call{Call: _e.mock.On("GetGroup", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetGroup_Call) Run(run func(ctx context.Context, in *groupv1beta1.GetGroupRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetGroup_Call) Return(_a0 *groupv1beta1.GetGroupResponse, _a1 error) *MockGatewayAPIClient_GetGroup_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetGroup_Call) RunAndReturn(run func(context.Context, *groupv1beta1.GetGroupRequest, ...grpc.CallOption) (*groupv1beta1.GetGroupResponse, error)) *MockGatewayAPIClient_GetGroup_Call { + _c.Call.Return(run) + return _c +} + +// GetGroupByClaim provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetGroupByClaim_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGroupByClaim' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetGroupByClaim(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetGroupByClaim_Call { + return &MockGatewayAPIClient_GetGroupByClaim_Call{Call: _e.mock.On("GetGroupByClaim", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetGroupByClaim_Call) Run(run func(ctx context.Context, in *groupv1beta1.GetGroupByClaimRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetGroupByClaim_Call) Return(_a0 *groupv1beta1.GetGroupByClaimResponse, _a1 error) *MockGatewayAPIClient_GetGroupByClaim_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetGroupByClaim_Call) RunAndReturn(run func(context.Context, *groupv1beta1.GetGroupByClaimRequest, ...grpc.CallOption) (*groupv1beta1.GetGroupByClaimResponse, error)) *MockGatewayAPIClient_GetGroupByClaim_Call { + _c.Call.Return(run) + return _c +} + +// GetHome provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetHome_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHome' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetHome(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetHome_Call { + return &MockGatewayAPIClient_GetHome_Call{Call: _e.mock.On("GetHome", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetHome_Call) Run(run func(ctx context.Context, in *providerv1beta1.GetHomeRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetHome_Call) Return(_a0 *providerv1beta1.GetHomeResponse, _a1 error) *MockGatewayAPIClient_GetHome_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetHome_Call) RunAndReturn(run func(context.Context, *providerv1beta1.GetHomeRequest, ...grpc.CallOption) (*providerv1beta1.GetHomeResponse, error)) *MockGatewayAPIClient_GetHome_Call { + _c.Call.Return(run) + return _c +} + +// GetInfoByDomain provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetInfoByDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInfoByDomain' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetInfoByDomain(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetInfoByDomain_Call { + return &MockGatewayAPIClient_GetInfoByDomain_Call{Call: _e.mock.On("GetInfoByDomain", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetInfoByDomain_Call) Run(run func(ctx context.Context, in *v1beta1.GetInfoByDomainRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetInfoByDomain_Call) Return(_a0 *v1beta1.GetInfoByDomainResponse, _a1 error) *MockGatewayAPIClient_GetInfoByDomain_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetInfoByDomain_Call) RunAndReturn(run func(context.Context, *v1beta1.GetInfoByDomainRequest, ...grpc.CallOption) (*v1beta1.GetInfoByDomainResponse, error)) *MockGatewayAPIClient_GetInfoByDomain_Call { + _c.Call.Return(run) + return _c +} + +// GetKey provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetKey' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetKey(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetKey_Call { + return &MockGatewayAPIClient_GetKey_Call{Call: _e.mock.On("GetKey", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetKey_Call) Run(run func(ctx context.Context, in *preferencesv1beta1.GetKeyRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetKey_Call) Return(_a0 *preferencesv1beta1.GetKeyResponse, _a1 error) *MockGatewayAPIClient_GetKey_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetKey_Call) RunAndReturn(run func(context.Context, *preferencesv1beta1.GetKeyRequest, ...grpc.CallOption) (*preferencesv1beta1.GetKeyResponse, error)) *MockGatewayAPIClient_GetKey_Call { + _c.Call.Return(run) + return _c +} + +// GetLock provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetLock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLock' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetLock(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetLock_Call { + return &MockGatewayAPIClient_GetLock_Call{Call: _e.mock.On("GetLock", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetLock_Call) Run(run func(ctx context.Context, in *providerv1beta1.GetLockRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetLock_Call) Return(_a0 *providerv1beta1.GetLockResponse, _a1 error) *MockGatewayAPIClient_GetLock_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetLock_Call) RunAndReturn(run func(context.Context, *providerv1beta1.GetLockRequest, ...grpc.CallOption) (*providerv1beta1.GetLockResponse, error)) *MockGatewayAPIClient_GetLock_Call { + _c.Call.Return(run) + return _c +} + +// GetMembers provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMembers' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetMembers(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetMembers_Call { + return &MockGatewayAPIClient_GetMembers_Call{Call: _e.mock.On("GetMembers", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetMembers_Call) Run(run func(ctx context.Context, in *groupv1beta1.GetMembersRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetMembers_Call) Return(_a0 *groupv1beta1.GetMembersResponse, _a1 error) *MockGatewayAPIClient_GetMembers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetMembers_Call) RunAndReturn(run func(context.Context, *groupv1beta1.GetMembersRequest, ...grpc.CallOption) (*groupv1beta1.GetMembersResponse, error)) *MockGatewayAPIClient_GetMembers_Call { + _c.Call.Return(run) + return _c +} + +// GetOCMShare provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetOCMShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOCMShare' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetOCMShare(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetOCMShare_Call { + return &MockGatewayAPIClient_GetOCMShare_Call{Call: _e.mock.On("GetOCMShare", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetOCMShare_Call) Run(run func(ctx context.Context, in *ocmv1beta1.GetOCMShareRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetOCMShare_Call) Return(_a0 *ocmv1beta1.GetOCMShareResponse, _a1 error) *MockGatewayAPIClient_GetOCMShare_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetOCMShare_Call) RunAndReturn(run func(context.Context, *ocmv1beta1.GetOCMShareRequest, ...grpc.CallOption) (*ocmv1beta1.GetOCMShareResponse, error)) *MockGatewayAPIClient_GetOCMShare_Call { + _c.Call.Return(run) + return _c +} + +// GetOCMShareByToken provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetOCMShareByToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOCMShareByToken' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetOCMShareByToken(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetOCMShareByToken_Call { + return &MockGatewayAPIClient_GetOCMShareByToken_Call{Call: _e.mock.On("GetOCMShareByToken", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetOCMShareByToken_Call) Run(run func(ctx context.Context, in *ocmv1beta1.GetOCMShareByTokenRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetOCMShareByToken_Call) Return(_a0 *ocmv1beta1.GetOCMShareByTokenResponse, _a1 error) *MockGatewayAPIClient_GetOCMShareByToken_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetOCMShareByToken_Call) RunAndReturn(run func(context.Context, *ocmv1beta1.GetOCMShareByTokenRequest, ...grpc.CallOption) (*ocmv1beta1.GetOCMShareByTokenResponse, error)) *MockGatewayAPIClient_GetOCMShareByToken_Call { + _c.Call.Return(run) + return _c +} + +// GetPath provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetPath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPath' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetPath(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetPath_Call { + return &MockGatewayAPIClient_GetPath_Call{Call: _e.mock.On("GetPath", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetPath_Call) Run(run func(ctx context.Context, in *providerv1beta1.GetPathRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetPath_Call) Return(_a0 *providerv1beta1.GetPathResponse, _a1 error) *MockGatewayAPIClient_GetPath_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetPath_Call) RunAndReturn(run func(context.Context, *providerv1beta1.GetPathRequest, ...grpc.CallOption) (*providerv1beta1.GetPathResponse, error)) *MockGatewayAPIClient_GetPath_Call { + _c.Call.Return(run) + return _c +} + +// GetPublicShare provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetPublicShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPublicShare' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetPublicShare(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetPublicShare_Call { + return &MockGatewayAPIClient_GetPublicShare_Call{Call: _e.mock.On("GetPublicShare", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetPublicShare_Call) Run(run func(ctx context.Context, in *linkv1beta1.GetPublicShareRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetPublicShare_Call) Return(_a0 *linkv1beta1.GetPublicShareResponse, _a1 error) *MockGatewayAPIClient_GetPublicShare_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetPublicShare_Call) RunAndReturn(run func(context.Context, *linkv1beta1.GetPublicShareRequest, ...grpc.CallOption) (*linkv1beta1.GetPublicShareResponse, error)) *MockGatewayAPIClient_GetPublicShare_Call { + _c.Call.Return(run) + return _c +} + +// GetPublicShareByToken provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetPublicShareByToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPublicShareByToken' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetPublicShareByToken(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetPublicShareByToken_Call { + return &MockGatewayAPIClient_GetPublicShareByToken_Call{Call: _e.mock.On("GetPublicShareByToken", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetPublicShareByToken_Call) Run(run func(ctx context.Context, in *linkv1beta1.GetPublicShareByTokenRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetPublicShareByToken_Call) Return(_a0 *linkv1beta1.GetPublicShareByTokenResponse, _a1 error) *MockGatewayAPIClient_GetPublicShareByToken_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetPublicShareByToken_Call) RunAndReturn(run func(context.Context, *linkv1beta1.GetPublicShareByTokenRequest, ...grpc.CallOption) (*linkv1beta1.GetPublicShareByTokenResponse, error)) *MockGatewayAPIClient_GetPublicShareByToken_Call { + _c.Call.Return(run) + return _c +} + +// GetQuota provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetQuota_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetQuota' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetQuota(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetQuota_Call { + return &MockGatewayAPIClient_GetQuota_Call{Call: _e.mock.On("GetQuota", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetQuota_Call) Run(run func(ctx context.Context, in *gatewayv1beta1.GetQuotaRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetQuota_Call) Return(_a0 *providerv1beta1.GetQuotaResponse, _a1 error) *MockGatewayAPIClient_GetQuota_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetQuota_Call) RunAndReturn(run func(context.Context, *gatewayv1beta1.GetQuotaRequest, ...grpc.CallOption) (*providerv1beta1.GetQuotaResponse, error)) *MockGatewayAPIClient_GetQuota_Call { + _c.Call.Return(run) + return _c +} + +// GetReceivedOCMShare provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetReceivedOCMShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReceivedOCMShare' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetReceivedOCMShare(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetReceivedOCMShare_Call { + return &MockGatewayAPIClient_GetReceivedOCMShare_Call{Call: _e.mock.On("GetReceivedOCMShare", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetReceivedOCMShare_Call) Run(run func(ctx context.Context, in *ocmv1beta1.GetReceivedOCMShareRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetReceivedOCMShare_Call) Return(_a0 *ocmv1beta1.GetReceivedOCMShareResponse, _a1 error) *MockGatewayAPIClient_GetReceivedOCMShare_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetReceivedOCMShare_Call) RunAndReturn(run func(context.Context, *ocmv1beta1.GetReceivedOCMShareRequest, ...grpc.CallOption) (*ocmv1beta1.GetReceivedOCMShareResponse, error)) *MockGatewayAPIClient_GetReceivedOCMShare_Call { + _c.Call.Return(run) + return _c +} + +// GetReceivedShare provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetReceivedShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReceivedShare' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetReceivedShare(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetReceivedShare_Call { + return &MockGatewayAPIClient_GetReceivedShare_Call{Call: _e.mock.On("GetReceivedShare", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetReceivedShare_Call) Run(run func(ctx context.Context, in *collaborationv1beta1.GetReceivedShareRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetReceivedShare_Call) Return(_a0 *collaborationv1beta1.GetReceivedShareResponse, _a1 error) *MockGatewayAPIClient_GetReceivedShare_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetReceivedShare_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.GetReceivedShareRequest, ...grpc.CallOption) (*collaborationv1beta1.GetReceivedShareResponse, error)) *MockGatewayAPIClient_GetReceivedShare_Call { + _c.Call.Return(run) + return _c +} + +// GetShare provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShare' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetShare(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetShare_Call { + return &MockGatewayAPIClient_GetShare_Call{Call: _e.mock.On("GetShare", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetShare_Call) Run(run func(ctx context.Context, in *collaborationv1beta1.GetShareRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetShare_Call) Return(_a0 *collaborationv1beta1.GetShareResponse, _a1 error) *MockGatewayAPIClient_GetShare_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetShare_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.GetShareRequest, ...grpc.CallOption) (*collaborationv1beta1.GetShareResponse, error)) *MockGatewayAPIClient_GetShare_Call { + _c.Call.Return(run) + return _c +} + +// GetTransferStatus provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetTransferStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTransferStatus' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetTransferStatus(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetTransferStatus_Call { + return &MockGatewayAPIClient_GetTransferStatus_Call{Call: _e.mock.On("GetTransferStatus", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetTransferStatus_Call) Run(run func(ctx context.Context, in *txv1beta1.GetTransferStatusRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetTransferStatus_Call) Return(_a0 *txv1beta1.GetTransferStatusResponse, _a1 error) *MockGatewayAPIClient_GetTransferStatus_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetTransferStatus_Call) RunAndReturn(run func(context.Context, *txv1beta1.GetTransferStatusRequest, ...grpc.CallOption) (*txv1beta1.GetTransferStatusResponse, error)) *MockGatewayAPIClient_GetTransferStatus_Call { + _c.Call.Return(run) + return _c +} + +// GetUser provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUser' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetUser(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetUser_Call { + return &MockGatewayAPIClient_GetUser_Call{Call: _e.mock.On("GetUser", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetUser_Call) Run(run func(ctx context.Context, in *userv1beta1.GetUserRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetUser_Call) Return(_a0 *userv1beta1.GetUserResponse, _a1 error) *MockGatewayAPIClient_GetUser_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetUser_Call) RunAndReturn(run func(context.Context, *userv1beta1.GetUserRequest, ...grpc.CallOption) (*userv1beta1.GetUserResponse, error)) *MockGatewayAPIClient_GetUser_Call { + _c.Call.Return(run) + return _c +} + +// GetUserByClaim provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetUserByClaim_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserByClaim' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetUserByClaim(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetUserByClaim_Call { + return &MockGatewayAPIClient_GetUserByClaim_Call{Call: _e.mock.On("GetUserByClaim", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetUserByClaim_Call) Run(run func(ctx context.Context, in *userv1beta1.GetUserByClaimRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetUserByClaim_Call) Return(_a0 *userv1beta1.GetUserByClaimResponse, _a1 error) *MockGatewayAPIClient_GetUserByClaim_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetUserByClaim_Call) RunAndReturn(run func(context.Context, *userv1beta1.GetUserByClaimRequest, ...grpc.CallOption) (*userv1beta1.GetUserByClaimResponse, error)) *MockGatewayAPIClient_GetUserByClaim_Call { + _c.Call.Return(run) + return _c +} + +// GetUserGroups provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_GetUserGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserGroups' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) GetUserGroups(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_GetUserGroups_Call { + return &MockGatewayAPIClient_GetUserGroups_Call{Call: _e.mock.On("GetUserGroups", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_GetUserGroups_Call) Run(run func(ctx context.Context, in *userv1beta1.GetUserGroupsRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_GetUserGroups_Call) Return(_a0 *userv1beta1.GetUserGroupsResponse, _a1 error) *MockGatewayAPIClient_GetUserGroups_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_GetUserGroups_Call) RunAndReturn(run func(context.Context, *userv1beta1.GetUserGroupsRequest, ...grpc.CallOption) (*userv1beta1.GetUserGroupsResponse, error)) *MockGatewayAPIClient_GetUserGroups_Call { + _c.Call.Return(run) + return _c +} + +// HasMember provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_HasMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasMember' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) HasMember(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_HasMember_Call { + return &MockGatewayAPIClient_HasMember_Call{Call: _e.mock.On("HasMember", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_HasMember_Call) Run(run func(ctx context.Context, in *groupv1beta1.HasMemberRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_HasMember_Call) Return(_a0 *groupv1beta1.HasMemberResponse, _a1 error) *MockGatewayAPIClient_HasMember_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_HasMember_Call) RunAndReturn(run func(context.Context, *groupv1beta1.HasMemberRequest, ...grpc.CallOption) (*groupv1beta1.HasMemberResponse, error)) *MockGatewayAPIClient_HasMember_Call { + _c.Call.Return(run) + return _c +} + +// InitiateFileDownload provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_InitiateFileDownload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InitiateFileDownload' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) InitiateFileDownload(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_InitiateFileDownload_Call { + return &MockGatewayAPIClient_InitiateFileDownload_Call{Call: _e.mock.On("InitiateFileDownload", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_InitiateFileDownload_Call) Run(run func(ctx context.Context, in *providerv1beta1.InitiateFileDownloadRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_InitiateFileDownload_Call) Return(_a0 *gatewayv1beta1.InitiateFileDownloadResponse, _a1 error) *MockGatewayAPIClient_InitiateFileDownload_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_InitiateFileDownload_Call) RunAndReturn(run func(context.Context, *providerv1beta1.InitiateFileDownloadRequest, ...grpc.CallOption) (*gatewayv1beta1.InitiateFileDownloadResponse, error)) *MockGatewayAPIClient_InitiateFileDownload_Call { + _c.Call.Return(run) + return _c +} + +// InitiateFileUpload provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_InitiateFileUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InitiateFileUpload' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) InitiateFileUpload(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_InitiateFileUpload_Call { + return &MockGatewayAPIClient_InitiateFileUpload_Call{Call: _e.mock.On("InitiateFileUpload", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_InitiateFileUpload_Call) Run(run func(ctx context.Context, in *providerv1beta1.InitiateFileUploadRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_InitiateFileUpload_Call) Return(_a0 *gatewayv1beta1.InitiateFileUploadResponse, _a1 error) *MockGatewayAPIClient_InitiateFileUpload_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_InitiateFileUpload_Call) RunAndReturn(run func(context.Context, *providerv1beta1.InitiateFileUploadRequest, ...grpc.CallOption) (*gatewayv1beta1.InitiateFileUploadResponse, error)) *MockGatewayAPIClient_InitiateFileUpload_Call { + _c.Call.Return(run) + return _c +} + +// InvalidateAppPassword provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_InvalidateAppPassword_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InvalidateAppPassword' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) InvalidateAppPassword(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_InvalidateAppPassword_Call { + return &MockGatewayAPIClient_InvalidateAppPassword_Call{Call: _e.mock.On("InvalidateAppPassword", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_InvalidateAppPassword_Call) Run(run func(ctx context.Context, in *applicationsv1beta1.InvalidateAppPasswordRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_InvalidateAppPassword_Call) Return(_a0 *applicationsv1beta1.InvalidateAppPasswordResponse, _a1 error) *MockGatewayAPIClient_InvalidateAppPassword_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_InvalidateAppPassword_Call) RunAndReturn(run func(context.Context, *applicationsv1beta1.InvalidateAppPasswordRequest, ...grpc.CallOption) (*applicationsv1beta1.InvalidateAppPasswordResponse, error)) *MockGatewayAPIClient_InvalidateAppPassword_Call { + _c.Call.Return(run) + return _c +} + +// IsProviderAllowed provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_IsProviderAllowed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsProviderAllowed' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) IsProviderAllowed(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_IsProviderAllowed_Call { + return &MockGatewayAPIClient_IsProviderAllowed_Call{Call: _e.mock.On("IsProviderAllowed", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_IsProviderAllowed_Call) Run(run func(ctx context.Context, in *v1beta1.IsProviderAllowedRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_IsProviderAllowed_Call) Return(_a0 *v1beta1.IsProviderAllowedResponse, _a1 error) *MockGatewayAPIClient_IsProviderAllowed_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_IsProviderAllowed_Call) RunAndReturn(run func(context.Context, *v1beta1.IsProviderAllowedRequest, ...grpc.CallOption) (*v1beta1.IsProviderAllowedResponse, error)) *MockGatewayAPIClient_IsProviderAllowed_Call { + _c.Call.Return(run) + return _c +} + +// ListAllProviders provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListAllProviders_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAllProviders' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListAllProviders(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListAllProviders_Call { + return &MockGatewayAPIClient_ListAllProviders_Call{Call: _e.mock.On("ListAllProviders", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListAllProviders_Call) Run(run func(ctx context.Context, in *v1beta1.ListAllProvidersRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListAllProviders_Call) Return(_a0 *v1beta1.ListAllProvidersResponse, _a1 error) *MockGatewayAPIClient_ListAllProviders_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListAllProviders_Call) RunAndReturn(run func(context.Context, *v1beta1.ListAllProvidersRequest, ...grpc.CallOption) (*v1beta1.ListAllProvidersResponse, error)) *MockGatewayAPIClient_ListAllProviders_Call { + _c.Call.Return(run) + return _c +} + +// ListAppPasswords provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListAppPasswords_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAppPasswords' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListAppPasswords(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListAppPasswords_Call { + return &MockGatewayAPIClient_ListAppPasswords_Call{Call: _e.mock.On("ListAppPasswords", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListAppPasswords_Call) Run(run func(ctx context.Context, in *applicationsv1beta1.ListAppPasswordsRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListAppPasswords_Call) Return(_a0 *applicationsv1beta1.ListAppPasswordsResponse, _a1 error) *MockGatewayAPIClient_ListAppPasswords_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListAppPasswords_Call) RunAndReturn(run func(context.Context, *applicationsv1beta1.ListAppPasswordsRequest, ...grpc.CallOption) (*applicationsv1beta1.ListAppPasswordsResponse, error)) *MockGatewayAPIClient_ListAppPasswords_Call { + _c.Call.Return(run) + return _c +} + +// ListAppProviders provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListAppProviders_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAppProviders' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListAppProviders(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListAppProviders_Call { + return &MockGatewayAPIClient_ListAppProviders_Call{Call: _e.mock.On("ListAppProviders", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListAppProviders_Call) Run(run func(ctx context.Context, in *registryv1beta1.ListAppProvidersRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListAppProviders_Call) Return(_a0 *registryv1beta1.ListAppProvidersResponse, _a1 error) *MockGatewayAPIClient_ListAppProviders_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListAppProviders_Call) RunAndReturn(run func(context.Context, *registryv1beta1.ListAppProvidersRequest, ...grpc.CallOption) (*registryv1beta1.ListAppProvidersResponse, error)) *MockGatewayAPIClient_ListAppProviders_Call { + _c.Call.Return(run) + return _c +} + +// ListAuthProviders provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListAuthProviders_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAuthProviders' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListAuthProviders(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListAuthProviders_Call { + return &MockGatewayAPIClient_ListAuthProviders_Call{Call: _e.mock.On("ListAuthProviders", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListAuthProviders_Call) Run(run func(ctx context.Context, in *authregistryv1beta1.ListAuthProvidersRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListAuthProviders_Call) Return(_a0 *gatewayv1beta1.ListAuthProvidersResponse, _a1 error) *MockGatewayAPIClient_ListAuthProviders_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListAuthProviders_Call) RunAndReturn(run func(context.Context, *authregistryv1beta1.ListAuthProvidersRequest, ...grpc.CallOption) (*gatewayv1beta1.ListAuthProvidersResponse, error)) *MockGatewayAPIClient_ListAuthProviders_Call { + _c.Call.Return(run) + return _c +} + +// ListContainer provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListContainer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListContainer' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListContainer(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListContainer_Call { + return &MockGatewayAPIClient_ListContainer_Call{Call: _e.mock.On("ListContainer", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListContainer_Call) Run(run func(ctx context.Context, in *providerv1beta1.ListContainerRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListContainer_Call) Return(_a0 *providerv1beta1.ListContainerResponse, _a1 error) *MockGatewayAPIClient_ListContainer_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListContainer_Call) RunAndReturn(run func(context.Context, *providerv1beta1.ListContainerRequest, ...grpc.CallOption) (*providerv1beta1.ListContainerResponse, error)) *MockGatewayAPIClient_ListContainer_Call { + _c.Call.Return(run) + return _c +} + +// ListContainerStream provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListContainerStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListContainerStream' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListContainerStream(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListContainerStream_Call { + return &MockGatewayAPIClient_ListContainerStream_Call{Call: _e.mock.On("ListContainerStream", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListContainerStream_Call) Run(run func(ctx context.Context, in *providerv1beta1.ListContainerStreamRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListContainerStream_Call) Return(_a0 gatewayv1beta1.GatewayAPI_ListContainerStreamClient, _a1 error) *MockGatewayAPIClient_ListContainerStream_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListContainerStream_Call) RunAndReturn(run func(context.Context, *providerv1beta1.ListContainerStreamRequest, ...grpc.CallOption) (gatewayv1beta1.GatewayAPI_ListContainerStreamClient, error)) *MockGatewayAPIClient_ListContainerStream_Call { + _c.Call.Return(run) + return _c +} + +// ListExistingPublicShares provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListExistingPublicShares_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListExistingPublicShares' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListExistingPublicShares(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListExistingPublicShares_Call { + return &MockGatewayAPIClient_ListExistingPublicShares_Call{Call: _e.mock.On("ListExistingPublicShares", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListExistingPublicShares_Call) Run(run func(ctx context.Context, in *linkv1beta1.ListPublicSharesRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListExistingPublicShares_Call) Return(_a0 *gatewayv1beta1.ListExistingPublicSharesResponse, _a1 error) *MockGatewayAPIClient_ListExistingPublicShares_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListExistingPublicShares_Call) RunAndReturn(run func(context.Context, *linkv1beta1.ListPublicSharesRequest, ...grpc.CallOption) (*gatewayv1beta1.ListExistingPublicSharesResponse, error)) *MockGatewayAPIClient_ListExistingPublicShares_Call { + _c.Call.Return(run) + return _c +} + +// ListExistingReceivedShares provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListExistingReceivedShares_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListExistingReceivedShares' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListExistingReceivedShares(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListExistingReceivedShares_Call { + return &MockGatewayAPIClient_ListExistingReceivedShares_Call{Call: _e.mock.On("ListExistingReceivedShares", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListExistingReceivedShares_Call) Run(run func(ctx context.Context, in *collaborationv1beta1.ListReceivedSharesRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListExistingReceivedShares_Call) Return(_a0 *gatewayv1beta1.ListExistingReceivedSharesResponse, _a1 error) *MockGatewayAPIClient_ListExistingReceivedShares_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListExistingReceivedShares_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.ListReceivedSharesRequest, ...grpc.CallOption) (*gatewayv1beta1.ListExistingReceivedSharesResponse, error)) *MockGatewayAPIClient_ListExistingReceivedShares_Call { + _c.Call.Return(run) + return _c +} + +// ListExistingShares provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListExistingShares_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListExistingShares' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListExistingShares(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListExistingShares_Call { + return &MockGatewayAPIClient_ListExistingShares_Call{Call: _e.mock.On("ListExistingShares", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListExistingShares_Call) Run(run func(ctx context.Context, in *collaborationv1beta1.ListSharesRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListExistingShares_Call) Return(_a0 *gatewayv1beta1.ListExistingSharesResponse, _a1 error) *MockGatewayAPIClient_ListExistingShares_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListExistingShares_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.ListSharesRequest, ...grpc.CallOption) (*gatewayv1beta1.ListExistingSharesResponse, error)) *MockGatewayAPIClient_ListExistingShares_Call { + _c.Call.Return(run) + return _c +} + +// ListFileVersions provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListFileVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListFileVersions' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListFileVersions(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListFileVersions_Call { + return &MockGatewayAPIClient_ListFileVersions_Call{Call: _e.mock.On("ListFileVersions", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListFileVersions_Call) Run(run func(ctx context.Context, in *providerv1beta1.ListFileVersionsRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListFileVersions_Call) Return(_a0 *providerv1beta1.ListFileVersionsResponse, _a1 error) *MockGatewayAPIClient_ListFileVersions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListFileVersions_Call) RunAndReturn(run func(context.Context, *providerv1beta1.ListFileVersionsRequest, ...grpc.CallOption) (*providerv1beta1.ListFileVersionsResponse, error)) *MockGatewayAPIClient_ListFileVersions_Call { + _c.Call.Return(run) + return _c +} + +// ListInviteTokens provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListInviteTokens_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListInviteTokens' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListInviteTokens(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListInviteTokens_Call { + return &MockGatewayAPIClient_ListInviteTokens_Call{Call: _e.mock.On("ListInviteTokens", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListInviteTokens_Call) Run(run func(ctx context.Context, in *invitev1beta1.ListInviteTokensRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListInviteTokens_Call) Return(_a0 *invitev1beta1.ListInviteTokensResponse, _a1 error) *MockGatewayAPIClient_ListInviteTokens_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListInviteTokens_Call) RunAndReturn(run func(context.Context, *invitev1beta1.ListInviteTokensRequest, ...grpc.CallOption) (*invitev1beta1.ListInviteTokensResponse, error)) *MockGatewayAPIClient_ListInviteTokens_Call { + _c.Call.Return(run) + return _c +} + +// ListOCMShares provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListOCMShares_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOCMShares' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListOCMShares(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListOCMShares_Call { + return &MockGatewayAPIClient_ListOCMShares_Call{Call: _e.mock.On("ListOCMShares", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListOCMShares_Call) Run(run func(ctx context.Context, in *ocmv1beta1.ListOCMSharesRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListOCMShares_Call) Return(_a0 *ocmv1beta1.ListOCMSharesResponse, _a1 error) *MockGatewayAPIClient_ListOCMShares_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListOCMShares_Call) RunAndReturn(run func(context.Context, *ocmv1beta1.ListOCMSharesRequest, ...grpc.CallOption) (*ocmv1beta1.ListOCMSharesResponse, error)) *MockGatewayAPIClient_ListOCMShares_Call { + _c.Call.Return(run) + return _c +} + +// ListPublicShares provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListPublicShares_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPublicShares' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListPublicShares(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListPublicShares_Call { + return &MockGatewayAPIClient_ListPublicShares_Call{Call: _e.mock.On("ListPublicShares", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListPublicShares_Call) Run(run func(ctx context.Context, in *linkv1beta1.ListPublicSharesRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListPublicShares_Call) Return(_a0 *linkv1beta1.ListPublicSharesResponse, _a1 error) *MockGatewayAPIClient_ListPublicShares_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListPublicShares_Call) RunAndReturn(run func(context.Context, *linkv1beta1.ListPublicSharesRequest, ...grpc.CallOption) (*linkv1beta1.ListPublicSharesResponse, error)) *MockGatewayAPIClient_ListPublicShares_Call { + _c.Call.Return(run) + return _c +} + +// ListReceivedOCMShares provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListReceivedOCMShares_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListReceivedOCMShares' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListReceivedOCMShares(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListReceivedOCMShares_Call { + return &MockGatewayAPIClient_ListReceivedOCMShares_Call{Call: _e.mock.On("ListReceivedOCMShares", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListReceivedOCMShares_Call) Run(run func(ctx context.Context, in *ocmv1beta1.ListReceivedOCMSharesRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListReceivedOCMShares_Call) Return(_a0 *ocmv1beta1.ListReceivedOCMSharesResponse, _a1 error) *MockGatewayAPIClient_ListReceivedOCMShares_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListReceivedOCMShares_Call) RunAndReturn(run func(context.Context, *ocmv1beta1.ListReceivedOCMSharesRequest, ...grpc.CallOption) (*ocmv1beta1.ListReceivedOCMSharesResponse, error)) *MockGatewayAPIClient_ListReceivedOCMShares_Call { + _c.Call.Return(run) + return _c +} + +// ListReceivedShares provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListReceivedShares_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListReceivedShares' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListReceivedShares(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListReceivedShares_Call { + return &MockGatewayAPIClient_ListReceivedShares_Call{Call: _e.mock.On("ListReceivedShares", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListReceivedShares_Call) Run(run func(ctx context.Context, in *collaborationv1beta1.ListReceivedSharesRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListReceivedShares_Call) Return(_a0 *collaborationv1beta1.ListReceivedSharesResponse, _a1 error) *MockGatewayAPIClient_ListReceivedShares_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListReceivedShares_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.ListReceivedSharesRequest, ...grpc.CallOption) (*collaborationv1beta1.ListReceivedSharesResponse, error)) *MockGatewayAPIClient_ListReceivedShares_Call { + _c.Call.Return(run) + return _c +} + +// ListRecycle provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListRecycle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRecycle' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListRecycle(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListRecycle_Call { + return &MockGatewayAPIClient_ListRecycle_Call{Call: _e.mock.On("ListRecycle", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListRecycle_Call) Run(run func(ctx context.Context, in *providerv1beta1.ListRecycleRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListRecycle_Call) Return(_a0 *providerv1beta1.ListRecycleResponse, _a1 error) *MockGatewayAPIClient_ListRecycle_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListRecycle_Call) RunAndReturn(run func(context.Context, *providerv1beta1.ListRecycleRequest, ...grpc.CallOption) (*providerv1beta1.ListRecycleResponse, error)) *MockGatewayAPIClient_ListRecycle_Call { + _c.Call.Return(run) + return _c +} + +// ListRecycleStream provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListRecycleStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRecycleStream' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListRecycleStream(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListRecycleStream_Call { + return &MockGatewayAPIClient_ListRecycleStream_Call{Call: _e.mock.On("ListRecycleStream", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListRecycleStream_Call) Run(run func(ctx context.Context, in *providerv1beta1.ListRecycleStreamRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListRecycleStream_Call) Return(_a0 gatewayv1beta1.GatewayAPI_ListRecycleStreamClient, _a1 error) *MockGatewayAPIClient_ListRecycleStream_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListRecycleStream_Call) RunAndReturn(run func(context.Context, *providerv1beta1.ListRecycleStreamRequest, ...grpc.CallOption) (gatewayv1beta1.GatewayAPI_ListRecycleStreamClient, error)) *MockGatewayAPIClient_ListRecycleStream_Call { + _c.Call.Return(run) + return _c +} + +// ListShares provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListShares_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListShares' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListShares(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListShares_Call { + return &MockGatewayAPIClient_ListShares_Call{Call: _e.mock.On("ListShares", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListShares_Call) Run(run func(ctx context.Context, in *collaborationv1beta1.ListSharesRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListShares_Call) Return(_a0 *collaborationv1beta1.ListSharesResponse, _a1 error) *MockGatewayAPIClient_ListShares_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListShares_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.ListSharesRequest, ...grpc.CallOption) (*collaborationv1beta1.ListSharesResponse, error)) *MockGatewayAPIClient_ListShares_Call { + _c.Call.Return(run) + return _c +} + +// ListStorageSpaces provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListStorageSpaces_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListStorageSpaces' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListStorageSpaces(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListStorageSpaces_Call { + return &MockGatewayAPIClient_ListStorageSpaces_Call{Call: _e.mock.On("ListStorageSpaces", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListStorageSpaces_Call) Run(run func(ctx context.Context, in *providerv1beta1.ListStorageSpacesRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListStorageSpaces_Call) Return(_a0 *providerv1beta1.ListStorageSpacesResponse, _a1 error) *MockGatewayAPIClient_ListStorageSpaces_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListStorageSpaces_Call) RunAndReturn(run func(context.Context, *providerv1beta1.ListStorageSpacesRequest, ...grpc.CallOption) (*providerv1beta1.ListStorageSpacesResponse, error)) *MockGatewayAPIClient_ListStorageSpaces_Call { + _c.Call.Return(run) + return _c +} + +// ListSupportedMimeTypes provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListSupportedMimeTypes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSupportedMimeTypes' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListSupportedMimeTypes(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListSupportedMimeTypes_Call { + return &MockGatewayAPIClient_ListSupportedMimeTypes_Call{Call: _e.mock.On("ListSupportedMimeTypes", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListSupportedMimeTypes_Call) Run(run func(ctx context.Context, in *registryv1beta1.ListSupportedMimeTypesRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListSupportedMimeTypes_Call) Return(_a0 *registryv1beta1.ListSupportedMimeTypesResponse, _a1 error) *MockGatewayAPIClient_ListSupportedMimeTypes_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListSupportedMimeTypes_Call) RunAndReturn(run func(context.Context, *registryv1beta1.ListSupportedMimeTypesRequest, ...grpc.CallOption) (*registryv1beta1.ListSupportedMimeTypesResponse, error)) *MockGatewayAPIClient_ListSupportedMimeTypes_Call { + _c.Call.Return(run) + return _c +} + +// ListTransfers provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_ListTransfers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTransfers' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) ListTransfers(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_ListTransfers_Call { + return &MockGatewayAPIClient_ListTransfers_Call{Call: _e.mock.On("ListTransfers", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_ListTransfers_Call) Run(run func(ctx context.Context, in *txv1beta1.ListTransfersRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_ListTransfers_Call) Return(_a0 *txv1beta1.ListTransfersResponse, _a1 error) *MockGatewayAPIClient_ListTransfers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_ListTransfers_Call) RunAndReturn(run func(context.Context, *txv1beta1.ListTransfersRequest, ...grpc.CallOption) (*txv1beta1.ListTransfersResponse, error)) *MockGatewayAPIClient_ListTransfers_Call { + _c.Call.Return(run) + return _c +} + +// Move provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_Move_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Move' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) Move(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_Move_Call { + return &MockGatewayAPIClient_Move_Call{Call: _e.mock.On("Move", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_Move_Call) Run(run func(ctx context.Context, in *providerv1beta1.MoveRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_Move_Call) Return(_a0 *providerv1beta1.MoveResponse, _a1 error) *MockGatewayAPIClient_Move_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_Move_Call) RunAndReturn(run func(context.Context, *providerv1beta1.MoveRequest, ...grpc.CallOption) (*providerv1beta1.MoveResponse, error)) *MockGatewayAPIClient_Move_Call { + _c.Call.Return(run) + return _c +} + +// OpenInApp provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_OpenInApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenInApp' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) OpenInApp(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_OpenInApp_Call { + return &MockGatewayAPIClient_OpenInApp_Call{Call: _e.mock.On("OpenInApp", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_OpenInApp_Call) Run(run func(ctx context.Context, in *gatewayv1beta1.OpenInAppRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_OpenInApp_Call) Return(_a0 *appproviderv1beta1.OpenInAppResponse, _a1 error) *MockGatewayAPIClient_OpenInApp_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_OpenInApp_Call) RunAndReturn(run func(context.Context, *gatewayv1beta1.OpenInAppRequest, ...grpc.CallOption) (*appproviderv1beta1.OpenInAppResponse, error)) *MockGatewayAPIClient_OpenInApp_Call { + _c.Call.Return(run) + return _c +} + +// PurgeRecycle provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_PurgeRecycle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PurgeRecycle' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) PurgeRecycle(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_PurgeRecycle_Call { + return &MockGatewayAPIClient_PurgeRecycle_Call{Call: _e.mock.On("PurgeRecycle", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_PurgeRecycle_Call) Run(run func(ctx context.Context, in *providerv1beta1.PurgeRecycleRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_PurgeRecycle_Call) Return(_a0 *providerv1beta1.PurgeRecycleResponse, _a1 error) *MockGatewayAPIClient_PurgeRecycle_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_PurgeRecycle_Call) RunAndReturn(run func(context.Context, *providerv1beta1.PurgeRecycleRequest, ...grpc.CallOption) (*providerv1beta1.PurgeRecycleResponse, error)) *MockGatewayAPIClient_PurgeRecycle_Call { + _c.Call.Return(run) + return _c +} + +// RefreshLock provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_RefreshLock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefreshLock' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) RefreshLock(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_RefreshLock_Call { + return &MockGatewayAPIClient_RefreshLock_Call{Call: _e.mock.On("RefreshLock", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_RefreshLock_Call) Run(run func(ctx context.Context, in *providerv1beta1.RefreshLockRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_RefreshLock_Call) Return(_a0 *providerv1beta1.RefreshLockResponse, _a1 error) *MockGatewayAPIClient_RefreshLock_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_RefreshLock_Call) RunAndReturn(run func(context.Context, *providerv1beta1.RefreshLockRequest, ...grpc.CallOption) (*providerv1beta1.RefreshLockResponse, error)) *MockGatewayAPIClient_RefreshLock_Call { + _c.Call.Return(run) + return _c +} + +// RemoveOCMShare provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_RemoveOCMShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveOCMShare' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) RemoveOCMShare(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_RemoveOCMShare_Call { + return &MockGatewayAPIClient_RemoveOCMShare_Call{Call: _e.mock.On("RemoveOCMShare", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_RemoveOCMShare_Call) Run(run func(ctx context.Context, in *ocmv1beta1.RemoveOCMShareRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_RemoveOCMShare_Call) Return(_a0 *ocmv1beta1.RemoveOCMShareResponse, _a1 error) *MockGatewayAPIClient_RemoveOCMShare_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_RemoveOCMShare_Call) RunAndReturn(run func(context.Context, *ocmv1beta1.RemoveOCMShareRequest, ...grpc.CallOption) (*ocmv1beta1.RemoveOCMShareResponse, error)) *MockGatewayAPIClient_RemoveOCMShare_Call { + _c.Call.Return(run) + return _c +} + +// RemovePublicShare provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_RemovePublicShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemovePublicShare' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) RemovePublicShare(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_RemovePublicShare_Call { + return &MockGatewayAPIClient_RemovePublicShare_Call{Call: _e.mock.On("RemovePublicShare", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_RemovePublicShare_Call) Run(run func(ctx context.Context, in *linkv1beta1.RemovePublicShareRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_RemovePublicShare_Call) Return(_a0 *linkv1beta1.RemovePublicShareResponse, _a1 error) *MockGatewayAPIClient_RemovePublicShare_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_RemovePublicShare_Call) RunAndReturn(run func(context.Context, *linkv1beta1.RemovePublicShareRequest, ...grpc.CallOption) (*linkv1beta1.RemovePublicShareResponse, error)) *MockGatewayAPIClient_RemovePublicShare_Call { + _c.Call.Return(run) + return _c +} + +// RemoveShare provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_RemoveShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveShare' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) RemoveShare(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_RemoveShare_Call { + return &MockGatewayAPIClient_RemoveShare_Call{Call: _e.mock.On("RemoveShare", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_RemoveShare_Call) Run(run func(ctx context.Context, in *collaborationv1beta1.RemoveShareRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_RemoveShare_Call) Return(_a0 *collaborationv1beta1.RemoveShareResponse, _a1 error) *MockGatewayAPIClient_RemoveShare_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_RemoveShare_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.RemoveShareRequest, ...grpc.CallOption) (*collaborationv1beta1.RemoveShareResponse, error)) *MockGatewayAPIClient_RemoveShare_Call { + _c.Call.Return(run) + return _c +} + +// RestoreFileVersion provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_RestoreFileVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreFileVersion' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) RestoreFileVersion(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_RestoreFileVersion_Call { + return &MockGatewayAPIClient_RestoreFileVersion_Call{Call: _e.mock.On("RestoreFileVersion", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_RestoreFileVersion_Call) Run(run func(ctx context.Context, in *providerv1beta1.RestoreFileVersionRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_RestoreFileVersion_Call) Return(_a0 *providerv1beta1.RestoreFileVersionResponse, _a1 error) *MockGatewayAPIClient_RestoreFileVersion_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_RestoreFileVersion_Call) RunAndReturn(run func(context.Context, *providerv1beta1.RestoreFileVersionRequest, ...grpc.CallOption) (*providerv1beta1.RestoreFileVersionResponse, error)) *MockGatewayAPIClient_RestoreFileVersion_Call { + _c.Call.Return(run) + return _c +} + +// RestoreRecycleItem provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_RestoreRecycleItem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreRecycleItem' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) RestoreRecycleItem(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_RestoreRecycleItem_Call { + return &MockGatewayAPIClient_RestoreRecycleItem_Call{Call: _e.mock.On("RestoreRecycleItem", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_RestoreRecycleItem_Call) Run(run func(ctx context.Context, in *providerv1beta1.RestoreRecycleItemRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_RestoreRecycleItem_Call) Return(_a0 *providerv1beta1.RestoreRecycleItemResponse, _a1 error) *MockGatewayAPIClient_RestoreRecycleItem_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_RestoreRecycleItem_Call) RunAndReturn(run func(context.Context, *providerv1beta1.RestoreRecycleItemRequest, ...grpc.CallOption) (*providerv1beta1.RestoreRecycleItemResponse, error)) *MockGatewayAPIClient_RestoreRecycleItem_Call { + _c.Call.Return(run) + return _c +} + +// RetryTransfer provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_RetryTransfer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetryTransfer' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) RetryTransfer(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_RetryTransfer_Call { + return &MockGatewayAPIClient_RetryTransfer_Call{Call: _e.mock.On("RetryTransfer", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_RetryTransfer_Call) Run(run func(ctx context.Context, in *txv1beta1.RetryTransferRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_RetryTransfer_Call) Return(_a0 *txv1beta1.RetryTransferResponse, _a1 error) *MockGatewayAPIClient_RetryTransfer_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_RetryTransfer_Call) RunAndReturn(run func(context.Context, *txv1beta1.RetryTransferRequest, ...grpc.CallOption) (*txv1beta1.RetryTransferResponse, error)) *MockGatewayAPIClient_RetryTransfer_Call { + _c.Call.Return(run) + return _c +} + +// SetArbitraryMetadata provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_SetArbitraryMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetArbitraryMetadata' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) SetArbitraryMetadata(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_SetArbitraryMetadata_Call { + return &MockGatewayAPIClient_SetArbitraryMetadata_Call{Call: _e.mock.On("SetArbitraryMetadata", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_SetArbitraryMetadata_Call) Run(run func(ctx context.Context, in *providerv1beta1.SetArbitraryMetadataRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_SetArbitraryMetadata_Call) Return(_a0 *providerv1beta1.SetArbitraryMetadataResponse, _a1 error) *MockGatewayAPIClient_SetArbitraryMetadata_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_SetArbitraryMetadata_Call) RunAndReturn(run func(context.Context, *providerv1beta1.SetArbitraryMetadataRequest, ...grpc.CallOption) (*providerv1beta1.SetArbitraryMetadataResponse, error)) *MockGatewayAPIClient_SetArbitraryMetadata_Call { + _c.Call.Return(run) + return _c +} + +// SetDefaultAppProviderForMimeType provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_SetDefaultAppProviderForMimeType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDefaultAppProviderForMimeType' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) SetDefaultAppProviderForMimeType(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_SetDefaultAppProviderForMimeType_Call { + return &MockGatewayAPIClient_SetDefaultAppProviderForMimeType_Call{Call: _e.mock.On("SetDefaultAppProviderForMimeType", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_SetDefaultAppProviderForMimeType_Call) Run(run func(ctx context.Context, in *registryv1beta1.SetDefaultAppProviderForMimeTypeRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_SetDefaultAppProviderForMimeType_Call) Return(_a0 *registryv1beta1.SetDefaultAppProviderForMimeTypeResponse, _a1 error) *MockGatewayAPIClient_SetDefaultAppProviderForMimeType_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_SetDefaultAppProviderForMimeType_Call) RunAndReturn(run func(context.Context, *registryv1beta1.SetDefaultAppProviderForMimeTypeRequest, ...grpc.CallOption) (*registryv1beta1.SetDefaultAppProviderForMimeTypeResponse, error)) *MockGatewayAPIClient_SetDefaultAppProviderForMimeType_Call { + _c.Call.Return(run) + return _c +} + +// SetKey provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_SetKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetKey' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) SetKey(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_SetKey_Call { + return &MockGatewayAPIClient_SetKey_Call{Call: _e.mock.On("SetKey", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_SetKey_Call) Run(run func(ctx context.Context, in *preferencesv1beta1.SetKeyRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_SetKey_Call) Return(_a0 *preferencesv1beta1.SetKeyResponse, _a1 error) *MockGatewayAPIClient_SetKey_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_SetKey_Call) RunAndReturn(run func(context.Context, *preferencesv1beta1.SetKeyRequest, ...grpc.CallOption) (*preferencesv1beta1.SetKeyResponse, error)) *MockGatewayAPIClient_SetKey_Call { + _c.Call.Return(run) + return _c +} + +// SetLock provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_SetLock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetLock' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) SetLock(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_SetLock_Call { + return &MockGatewayAPIClient_SetLock_Call{Call: _e.mock.On("SetLock", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_SetLock_Call) Run(run func(ctx context.Context, in *providerv1beta1.SetLockRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_SetLock_Call) Return(_a0 *providerv1beta1.SetLockResponse, _a1 error) *MockGatewayAPIClient_SetLock_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_SetLock_Call) RunAndReturn(run func(context.Context, *providerv1beta1.SetLockRequest, ...grpc.CallOption) (*providerv1beta1.SetLockResponse, error)) *MockGatewayAPIClient_SetLock_Call { + _c.Call.Return(run) + return _c +} + +// Stat provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_Stat_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stat' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) Stat(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_Stat_Call { + return &MockGatewayAPIClient_Stat_Call{Call: _e.mock.On("Stat", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_Stat_Call) Run(run func(ctx context.Context, in *providerv1beta1.StatRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_Stat_Call) Return(_a0 *providerv1beta1.StatResponse, _a1 error) *MockGatewayAPIClient_Stat_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_Stat_Call) RunAndReturn(run func(context.Context, *providerv1beta1.StatRequest, ...grpc.CallOption) (*providerv1beta1.StatResponse, error)) *MockGatewayAPIClient_Stat_Call { + _c.Call.Return(run) + return _c +} + +// TouchFile provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_TouchFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TouchFile' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) TouchFile(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_TouchFile_Call { + return &MockGatewayAPIClient_TouchFile_Call{Call: _e.mock.On("TouchFile", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_TouchFile_Call) Run(run func(ctx context.Context, in *providerv1beta1.TouchFileRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_TouchFile_Call) Return(_a0 *providerv1beta1.TouchFileResponse, _a1 error) *MockGatewayAPIClient_TouchFile_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_TouchFile_Call) RunAndReturn(run func(context.Context, *providerv1beta1.TouchFileRequest, ...grpc.CallOption) (*providerv1beta1.TouchFileResponse, error)) *MockGatewayAPIClient_TouchFile_Call { + _c.Call.Return(run) + return _c +} + +// Unlock provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_Unlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unlock' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) Unlock(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_Unlock_Call { + return &MockGatewayAPIClient_Unlock_Call{Call: _e.mock.On("Unlock", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_Unlock_Call) Run(run func(ctx context.Context, in *providerv1beta1.UnlockRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_Unlock_Call) Return(_a0 *providerv1beta1.UnlockResponse, _a1 error) *MockGatewayAPIClient_Unlock_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_Unlock_Call) RunAndReturn(run func(context.Context, *providerv1beta1.UnlockRequest, ...grpc.CallOption) (*providerv1beta1.UnlockResponse, error)) *MockGatewayAPIClient_Unlock_Call { + _c.Call.Return(run) + return _c +} + +// UnsetArbitraryMetadata provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_UnsetArbitraryMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnsetArbitraryMetadata' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) UnsetArbitraryMetadata(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_UnsetArbitraryMetadata_Call { + return &MockGatewayAPIClient_UnsetArbitraryMetadata_Call{Call: _e.mock.On("UnsetArbitraryMetadata", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_UnsetArbitraryMetadata_Call) Run(run func(ctx context.Context, in *providerv1beta1.UnsetArbitraryMetadataRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_UnsetArbitraryMetadata_Call) Return(_a0 *providerv1beta1.UnsetArbitraryMetadataResponse, _a1 error) *MockGatewayAPIClient_UnsetArbitraryMetadata_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_UnsetArbitraryMetadata_Call) RunAndReturn(run func(context.Context, *providerv1beta1.UnsetArbitraryMetadataRequest, ...grpc.CallOption) (*providerv1beta1.UnsetArbitraryMetadataResponse, error)) *MockGatewayAPIClient_UnsetArbitraryMetadata_Call { + _c.Call.Return(run) + return _c +} + +// UpdateOCMCoreShare provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_UpdateOCMCoreShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateOCMCoreShare' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) UpdateOCMCoreShare(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_UpdateOCMCoreShare_Call { + return &MockGatewayAPIClient_UpdateOCMCoreShare_Call{Call: _e.mock.On("UpdateOCMCoreShare", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_UpdateOCMCoreShare_Call) Run(run func(ctx context.Context, in *corev1beta1.UpdateOCMCoreShareRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_UpdateOCMCoreShare_Call) Return(_a0 *corev1beta1.UpdateOCMCoreShareResponse, _a1 error) *MockGatewayAPIClient_UpdateOCMCoreShare_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_UpdateOCMCoreShare_Call) RunAndReturn(run func(context.Context, *corev1beta1.UpdateOCMCoreShareRequest, ...grpc.CallOption) (*corev1beta1.UpdateOCMCoreShareResponse, error)) *MockGatewayAPIClient_UpdateOCMCoreShare_Call { + _c.Call.Return(run) + return _c +} + +// UpdateOCMShare provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_UpdateOCMShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateOCMShare' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) UpdateOCMShare(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_UpdateOCMShare_Call { + return &MockGatewayAPIClient_UpdateOCMShare_Call{Call: _e.mock.On("UpdateOCMShare", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_UpdateOCMShare_Call) Run(run func(ctx context.Context, in *ocmv1beta1.UpdateOCMShareRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_UpdateOCMShare_Call) Return(_a0 *ocmv1beta1.UpdateOCMShareResponse, _a1 error) *MockGatewayAPIClient_UpdateOCMShare_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_UpdateOCMShare_Call) RunAndReturn(run func(context.Context, *ocmv1beta1.UpdateOCMShareRequest, ...grpc.CallOption) (*ocmv1beta1.UpdateOCMShareResponse, error)) *MockGatewayAPIClient_UpdateOCMShare_Call { + _c.Call.Return(run) + return _c +} + +// UpdatePublicShare provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_UpdatePublicShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePublicShare' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) UpdatePublicShare(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_UpdatePublicShare_Call { + return &MockGatewayAPIClient_UpdatePublicShare_Call{Call: _e.mock.On("UpdatePublicShare", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_UpdatePublicShare_Call) Run(run func(ctx context.Context, in *linkv1beta1.UpdatePublicShareRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_UpdatePublicShare_Call) Return(_a0 *linkv1beta1.UpdatePublicShareResponse, _a1 error) *MockGatewayAPIClient_UpdatePublicShare_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_UpdatePublicShare_Call) RunAndReturn(run func(context.Context, *linkv1beta1.UpdatePublicShareRequest, ...grpc.CallOption) (*linkv1beta1.UpdatePublicShareResponse, error)) *MockGatewayAPIClient_UpdatePublicShare_Call { + _c.Call.Return(run) + return _c +} + +// UpdateReceivedOCMShare provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_UpdateReceivedOCMShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateReceivedOCMShare' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) UpdateReceivedOCMShare(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_UpdateReceivedOCMShare_Call { + return &MockGatewayAPIClient_UpdateReceivedOCMShare_Call{Call: _e.mock.On("UpdateReceivedOCMShare", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_UpdateReceivedOCMShare_Call) Run(run func(ctx context.Context, in *ocmv1beta1.UpdateReceivedOCMShareRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_UpdateReceivedOCMShare_Call) Return(_a0 *ocmv1beta1.UpdateReceivedOCMShareResponse, _a1 error) *MockGatewayAPIClient_UpdateReceivedOCMShare_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_UpdateReceivedOCMShare_Call) RunAndReturn(run func(context.Context, *ocmv1beta1.UpdateReceivedOCMShareRequest, ...grpc.CallOption) (*ocmv1beta1.UpdateReceivedOCMShareResponse, error)) *MockGatewayAPIClient_UpdateReceivedOCMShare_Call { + _c.Call.Return(run) + return _c +} + +// UpdateReceivedShare provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_UpdateReceivedShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateReceivedShare' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) UpdateReceivedShare(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_UpdateReceivedShare_Call { + return &MockGatewayAPIClient_UpdateReceivedShare_Call{Call: _e.mock.On("UpdateReceivedShare", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_UpdateReceivedShare_Call) Run(run func(ctx context.Context, in *collaborationv1beta1.UpdateReceivedShareRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_UpdateReceivedShare_Call) Return(_a0 *collaborationv1beta1.UpdateReceivedShareResponse, _a1 error) *MockGatewayAPIClient_UpdateReceivedShare_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_UpdateReceivedShare_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.UpdateReceivedShareRequest, ...grpc.CallOption) (*collaborationv1beta1.UpdateReceivedShareResponse, error)) *MockGatewayAPIClient_UpdateReceivedShare_Call { + _c.Call.Return(run) + return _c +} + +// UpdateShare provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_UpdateShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateShare' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) UpdateShare(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_UpdateShare_Call { + return &MockGatewayAPIClient_UpdateShare_Call{Call: _e.mock.On("UpdateShare", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_UpdateShare_Call) Run(run func(ctx context.Context, in *collaborationv1beta1.UpdateShareRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_UpdateShare_Call) Return(_a0 *collaborationv1beta1.UpdateShareResponse, _a1 error) *MockGatewayAPIClient_UpdateShare_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_UpdateShare_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.UpdateShareRequest, ...grpc.CallOption) (*collaborationv1beta1.UpdateShareResponse, error)) *MockGatewayAPIClient_UpdateShare_Call { + _c.Call.Return(run) + return _c +} + +// UpdateStorageSpace provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_UpdateStorageSpace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateStorageSpace' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) UpdateStorageSpace(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_UpdateStorageSpace_Call { + return &MockGatewayAPIClient_UpdateStorageSpace_Call{Call: _e.mock.On("UpdateStorageSpace", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_UpdateStorageSpace_Call) Run(run func(ctx context.Context, in *providerv1beta1.UpdateStorageSpaceRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_UpdateStorageSpace_Call) Return(_a0 *providerv1beta1.UpdateStorageSpaceResponse, _a1 error) *MockGatewayAPIClient_UpdateStorageSpace_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_UpdateStorageSpace_Call) RunAndReturn(run func(context.Context, *providerv1beta1.UpdateStorageSpaceRequest, ...grpc.CallOption) (*providerv1beta1.UpdateStorageSpaceResponse, error)) *MockGatewayAPIClient_UpdateStorageSpace_Call { + _c.Call.Return(run) + return _c +} + +// WhoAmI provides a mock function with given fields: ctx, in, opts +func (_m *MockGatewayAPIClient) 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 +} + +// MockGatewayAPIClient_WhoAmI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WhoAmI' +type MockGatewayAPIClient_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 *MockGatewayAPIClient_Expecter) WhoAmI(ctx interface{}, in interface{}, opts ...interface{}) *MockGatewayAPIClient_WhoAmI_Call { + return &MockGatewayAPIClient_WhoAmI_Call{Call: _e.mock.On("WhoAmI", + append([]interface{}{ctx, in}, opts...)...)} +} + +func (_c *MockGatewayAPIClient_WhoAmI_Call) Run(run func(ctx context.Context, in *gatewayv1beta1.WhoAmIRequest, opts ...grpc.CallOption)) *MockGatewayAPIClient_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 *MockGatewayAPIClient_WhoAmI_Call) Return(_a0 *gatewayv1beta1.WhoAmIResponse, _a1 error) *MockGatewayAPIClient_WhoAmI_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockGatewayAPIClient_WhoAmI_Call) RunAndReturn(run func(context.Context, *gatewayv1beta1.WhoAmIRequest, ...grpc.CallOption) (*gatewayv1beta1.WhoAmIResponse, error)) *MockGatewayAPIClient_WhoAmI_Call { + _c.Call.Return(run) + return _c +} + +// NewMockGatewayAPIClient creates a new instance of MockGatewayAPIClient. 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 NewMockGatewayAPIClient(t interface { + mock.TestingT + Cleanup(func()) +}) *MockGatewayAPIClient { + mock := &MockGatewayAPIClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +}