From 559e05f0f4a4483fe335430c80f317187bac5f0c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Du=C5=A1an=20Borov=C4=8Danin?= Date: Tue, 10 Dec 2024 14:23:35 +0100 Subject: [PATCH] NOISSUE - Move SDK to pkg (#2583) Signed-off-by: Dusan Borovcanin --- .github/workflows/build.yml | 2 +- .github/workflows/check-generated-files.yml | 2 +- .github/workflows/tests.yml | 2 +- bootstrap/events/producer/streams_test.go | 2 +- bootstrap/service.go | 2 +- bootstrap/service_test.go | 2 +- certs/service.go | 2 +- certs/service_test.go | 2 +- channels/mocks/repository.go | 8 +- cli/bootstrap.go | 2 +- cli/bootstrap_test.go | 2 +- cli/certs_test.go | 2 +- cli/channels.go | 2 +- cli/channels_test.go | 2 +- cli/clients.go | 2 +- cli/clients_test.go | 2 +- cli/config.go | 2 +- cli/consumers.go | 2 +- cli/consumers_test.go | 2 +- cli/domains.go | 2 +- cli/domains_test.go | 2 +- cli/groups.go | 2 +- cli/groups_test.go | 2 +- cli/health_test.go | 2 +- cli/invitations.go | 2 +- cli/invitations_test.go | 2 +- cli/journal.go | 2 +- cli/journal_test.go | 2 +- cli/message.go | 2 +- cli/message_test.go | 2 +- cli/provision.go | 2 +- cli/sdk.go | 2 +- cli/users.go | 2 +- cli/users_test.go | 2 +- clients/mocks/repository.go | 8 +- cmd/bootstrap/main.go | 2 +- cmd/certs/main.go | 2 +- cmd/cli/main.go | 2 +- cmd/invitations/main.go | 2 +- cmd/provision/main.go | 2 +- doc.go | 1 + domains/mocks/repository.go | 8 +- groups/mocks/repository.go | 8 +- invitations/service.go | 2 +- pkg/mocks/sdk.go | 3021 +++++++++++++++++ pkg/roles/mocks/rolesRepo.go | 8 +- pkg/sdk/README.md | 87 +- pkg/sdk/{go => }/bootstrap.go | 0 pkg/sdk/{go => }/bootstrap_test.go | 2 +- pkg/sdk/{go => }/certs.go | 0 pkg/sdk/{go => }/certs_test.go | 2 +- pkg/sdk/{go => }/channels.go | 0 pkg/sdk/{go => }/channels_test.go | 2 +- pkg/sdk/{go => }/clients.go | 0 pkg/sdk/{go => }/clients_test.go | 2 +- pkg/sdk/{go => }/consumers.go | 0 pkg/sdk/{go => }/consumers_test.go | 2 +- pkg/sdk/{go => }/doc.go | 0 pkg/sdk/{go => }/domains.go | 0 pkg/sdk/{go => }/domains_test.go | 2 +- pkg/sdk/go/README.md | 84 - pkg/sdk/{go => }/groups.go | 0 pkg/sdk/{go => }/groups_test.go | 2 +- pkg/sdk/{go => }/health.go | 0 pkg/sdk/{go => }/health_test.go | 2 +- pkg/sdk/{go => }/invitations.go | 0 pkg/sdk/{go => }/invitations_test.go | 2 +- pkg/sdk/{go => }/journal.go | 0 pkg/sdk/{go => }/journal_test.go | 2 +- pkg/sdk/{go => }/message.go | 0 pkg/sdk/{go => }/message_test.go | 2 +- pkg/sdk/{go => }/metadata.go | 0 pkg/sdk/mocks/sdk.go | 3351 ++++++++++++++++++- pkg/sdk/{go => }/requests.go | 0 pkg/sdk/{go => }/responses.go | 0 pkg/sdk/{go => }/sdk.go | 0 pkg/sdk/{go => }/setup_test.go | 2 +- pkg/sdk/{go => }/tokens.go | 0 pkg/sdk/{go => }/tokens_test.go | 2 +- pkg/sdk/{go => }/users.go | 0 pkg/sdk/{go => }/users_test.go | 2 +- provision/api/responses.go | 2 +- provision/service.go | 2 +- provision/service_test.go | 2 +- tools/config/mockery.yaml | 7 + tools/e2e/e2e.go | 2 +- tools/provision/provision.go | 2 +- 87 files changed, 6532 insertions(+), 175 deletions(-) create mode 100644 pkg/mocks/sdk.go rename pkg/sdk/{go => }/bootstrap.go (100%) rename pkg/sdk/{go => }/bootstrap_test.go (99%) rename pkg/sdk/{go => }/certs.go (100%) rename pkg/sdk/{go => }/certs_test.go (99%) rename pkg/sdk/{go => }/channels.go (100%) rename pkg/sdk/{go => }/channels_test.go (99%) rename pkg/sdk/{go => }/clients.go (100%) rename pkg/sdk/{go => }/clients_test.go (99%) rename pkg/sdk/{go => }/consumers.go (100%) rename pkg/sdk/{go => }/consumers_test.go (99%) rename pkg/sdk/{go => }/doc.go (100%) rename pkg/sdk/{go => }/domains.go (100%) rename pkg/sdk/{go => }/domains_test.go (99%) delete mode 100644 pkg/sdk/go/README.md rename pkg/sdk/{go => }/groups.go (100%) rename pkg/sdk/{go => }/groups_test.go (99%) rename pkg/sdk/{go => }/health.go (100%) rename pkg/sdk/{go => }/health_test.go (98%) rename pkg/sdk/{go => }/invitations.go (100%) rename pkg/sdk/{go => }/invitations_test.go (99%) rename pkg/sdk/{go => }/journal.go (100%) rename pkg/sdk/{go => }/journal_test.go (99%) rename pkg/sdk/{go => }/message.go (100%) rename pkg/sdk/{go => }/message_test.go (99%) rename pkg/sdk/{go => }/metadata.go (100%) rename pkg/sdk/{go => }/requests.go (100%) rename pkg/sdk/{go => }/responses.go (100%) rename pkg/sdk/{go => }/sdk.go (100%) rename pkg/sdk/{go => }/setup_test.go (99%) rename pkg/sdk/{go => }/tokens.go (100%) rename pkg/sdk/{go => }/tokens_test.go (99%) rename pkg/sdk/{go => }/users.go (100%) rename pkg/sdk/{go => }/users_test.go (99%) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index e86699d088..b60a6ec4ea 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -36,7 +36,7 @@ jobs: with: token: ${{ secrets.CODECOV }} files: ./coverage/*.out - codecov_yml_path: tools/codecov.yml + codecov_yml_path: tools/config/codecov.yml verbose: true - name: Set up Docker Build diff --git a/.github/workflows/check-generated-files.yml b/.github/workflows/check-generated-files.yml index 41faa44917..bdf121770b 100644 --- a/.github/workflows/check-generated-files.yml +++ b/.github/workflows/check-generated-files.yml @@ -44,7 +44,7 @@ jobs: mocks: - ".github/workflows/check-generated-files.yml" - - "pkg/sdk/go/sdk.go" + - "pkg/sdk/sdk.go" - "users/postgres/clients.go" - "users/clients.go" - "pkg/clients/clients.go" diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index d4dfdafb41..616c634ca7 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -386,5 +386,5 @@ jobs: with: token: ${{ secrets.CODECOV }} files: ./coverage/*.out - codecov_yml_path: tools/codecov.yml + codecov_yml_path: tools/config/codecov.yml verbose: true diff --git a/bootstrap/events/producer/streams_test.go b/bootstrap/events/producer/streams_test.go index 33730addd3..6d69188f13 100644 --- a/bootstrap/events/producer/streams_test.go +++ b/bootstrap/events/producer/streams_test.go @@ -22,7 +22,7 @@ import ( "github.com/absmach/supermq/pkg/events/store" policysvc "github.com/absmach/supermq/pkg/policies" policymocks "github.com/absmach/supermq/pkg/policies/mocks" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" sdkmocks "github.com/absmach/supermq/pkg/sdk/mocks" "github.com/absmach/supermq/pkg/uuid" "github.com/redis/go-redis/v9" diff --git a/bootstrap/service.go b/bootstrap/service.go index f4b49eb231..7755229a13 100644 --- a/bootstrap/service.go +++ b/bootstrap/service.go @@ -15,7 +15,7 @@ import ( repoerr "github.com/absmach/supermq/pkg/errors/repository" svcerr "github.com/absmach/supermq/pkg/errors/service" "github.com/absmach/supermq/pkg/policies" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" ) var ( diff --git a/bootstrap/service_test.go b/bootstrap/service_test.go index 8ebf95af69..253ef4aa15 100644 --- a/bootstrap/service_test.go +++ b/bootstrap/service_test.go @@ -22,7 +22,7 @@ import ( svcerr "github.com/absmach/supermq/pkg/errors/service" policysvc "github.com/absmach/supermq/pkg/policies" policymocks "github.com/absmach/supermq/pkg/policies/mocks" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" sdkmocks "github.com/absmach/supermq/pkg/sdk/mocks" "github.com/absmach/supermq/pkg/uuid" "github.com/stretchr/testify/assert" diff --git a/certs/service.go b/certs/service.go index 4cd08271c8..729bad794b 100644 --- a/certs/service.go +++ b/certs/service.go @@ -11,7 +11,7 @@ import ( pki "github.com/absmach/supermq/certs/pki/amcerts" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" ) var ( diff --git a/certs/service_test.go b/certs/service_test.go index 88c5693fb0..1641e82a12 100644 --- a/certs/service_test.go +++ b/certs/service_test.go @@ -14,7 +14,7 @@ import ( mgcrt "github.com/absmach/supermq/certs/pki/amcerts" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" sdkmocks "github.com/absmach/supermq/pkg/sdk/mocks" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" diff --git a/channels/mocks/repository.go b/channels/mocks/repository.go index b29bdcbd33..6feb79682f 100644 --- a/channels/mocks/repository.go +++ b/channels/mocks/repository.go @@ -266,9 +266,9 @@ func (_m *Repository) RemoveConnections(ctx context.Context, conns []channels.Co return r0 } -// RemoveMemberFromAllRoles provides a mock function with given fields: ctx, members -func (_m *Repository) RemoveMemberFromAllRoles(ctx context.Context, members string) error { - ret := _m.Called(ctx, members) +// RemoveMemberFromAllRoles provides a mock function with given fields: ctx, memberID +func (_m *Repository) RemoveMemberFromAllRoles(ctx context.Context, memberID string) error { + ret := _m.Called(ctx, memberID) if len(ret) == 0 { panic("no return value specified for RemoveMemberFromAllRoles") @@ -276,7 +276,7 @@ func (_m *Repository) RemoveMemberFromAllRoles(ctx context.Context, members stri var r0 error if rf, ok := ret.Get(0).(func(context.Context, string) error); ok { - r0 = rf(ctx, members) + r0 = rf(ctx, memberID) } else { r0 = ret.Error(0) } diff --git a/cli/bootstrap.go b/cli/bootstrap.go index 4eee279d5e..94c06be210 100644 --- a/cli/bootstrap.go +++ b/cli/bootstrap.go @@ -6,7 +6,7 @@ package cli import ( "encoding/json" - smqsdk "github.com/absmach/supermq/pkg/sdk/go" + smqsdk "github.com/absmach/supermq/pkg/sdk" "github.com/spf13/cobra" ) diff --git a/cli/bootstrap_test.go b/cli/bootstrap_test.go index 2f0c445d97..d64117b111 100644 --- a/cli/bootstrap_test.go +++ b/cli/bootstrap_test.go @@ -13,7 +13,7 @@ import ( "github.com/absmach/supermq/cli" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" sdkmocks "github.com/absmach/supermq/pkg/sdk/mocks" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" diff --git a/cli/certs_test.go b/cli/certs_test.go index b536d59dd4..1175b55cb5 100644 --- a/cli/certs_test.go +++ b/cli/certs_test.go @@ -14,7 +14,7 @@ import ( "github.com/absmach/supermq/cli" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" sdkmocks "github.com/absmach/supermq/pkg/sdk/mocks" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" diff --git a/cli/channels.go b/cli/channels.go index 6b61252b5e..7ddf38c368 100644 --- a/cli/channels.go +++ b/cli/channels.go @@ -6,7 +6,7 @@ package cli import ( "encoding/json" - smqsdk "github.com/absmach/supermq/pkg/sdk/go" + smqsdk "github.com/absmach/supermq/pkg/sdk" "github.com/spf13/cobra" ) diff --git a/cli/channels_test.go b/cli/channels_test.go index 49e2055aff..9852179d69 100644 --- a/cli/channels_test.go +++ b/cli/channels_test.go @@ -14,7 +14,7 @@ import ( "github.com/absmach/supermq/internal/testsutil" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" sdkmocks "github.com/absmach/supermq/pkg/sdk/mocks" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" diff --git a/cli/clients.go b/cli/clients.go index 2ff8854b3d..56d5be2b1e 100644 --- a/cli/clients.go +++ b/cli/clients.go @@ -7,7 +7,7 @@ import ( "encoding/json" "github.com/absmach/supermq/clients" - smqsdk "github.com/absmach/supermq/pkg/sdk/go" + smqsdk "github.com/absmach/supermq/pkg/sdk" "github.com/spf13/cobra" ) diff --git a/cli/clients_test.go b/cli/clients_test.go index 3a201e7f35..99160d3400 100644 --- a/cli/clients_test.go +++ b/cli/clients_test.go @@ -16,7 +16,7 @@ import ( "github.com/absmach/supermq/pkg/apiutil" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" sdkmocks "github.com/absmach/supermq/pkg/sdk/mocks" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" diff --git a/cli/config.go b/cli/config.go index 9bd7f3d59c..7a42a4eb0f 100644 --- a/cli/config.go +++ b/cli/config.go @@ -12,7 +12,7 @@ import ( "strings" "github.com/absmach/supermq/pkg/errors" - smqsdk "github.com/absmach/supermq/pkg/sdk/go" + smqsdk "github.com/absmach/supermq/pkg/sdk" "github.com/pelletier/go-toml" "github.com/spf13/cobra" ) diff --git a/cli/consumers.go b/cli/consumers.go index b50fa61d82..9b7ac20f62 100644 --- a/cli/consumers.go +++ b/cli/consumers.go @@ -4,7 +4,7 @@ package cli import ( - smqsdk "github.com/absmach/supermq/pkg/sdk/go" + smqsdk "github.com/absmach/supermq/pkg/sdk" "github.com/spf13/cobra" ) diff --git a/cli/consumers_test.go b/cli/consumers_test.go index 2376429d5a..0fb866a83d 100644 --- a/cli/consumers_test.go +++ b/cli/consumers_test.go @@ -14,7 +14,7 @@ import ( "github.com/absmach/supermq/internal/testsutil" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" sdkmocks "github.com/absmach/supermq/pkg/sdk/mocks" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" diff --git a/cli/domains.go b/cli/domains.go index 84cc3b8ea1..005eeb53bb 100644 --- a/cli/domains.go +++ b/cli/domains.go @@ -6,7 +6,7 @@ package cli import ( "encoding/json" - smqsdk "github.com/absmach/supermq/pkg/sdk/go" + smqsdk "github.com/absmach/supermq/pkg/sdk" "github.com/spf13/cobra" ) diff --git a/cli/domains_test.go b/cli/domains_test.go index 1d9eb5a8e2..bfc158d0d5 100644 --- a/cli/domains_test.go +++ b/cli/domains_test.go @@ -14,7 +14,7 @@ import ( "github.com/absmach/supermq/internal/testsutil" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" sdkmocks "github.com/absmach/supermq/pkg/sdk/mocks" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" diff --git a/cli/groups.go b/cli/groups.go index b35446b675..310a714b0f 100644 --- a/cli/groups.go +++ b/cli/groups.go @@ -7,7 +7,7 @@ import ( "encoding/json" "github.com/absmach/supermq/groups" - smqsdk "github.com/absmach/supermq/pkg/sdk/go" + smqsdk "github.com/absmach/supermq/pkg/sdk" "github.com/spf13/cobra" ) diff --git a/cli/groups_test.go b/cli/groups_test.go index 03f82ed46d..36ef2218de 100644 --- a/cli/groups_test.go +++ b/cli/groups_test.go @@ -14,7 +14,7 @@ import ( "github.com/absmach/supermq/internal/testsutil" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" sdkmocks "github.com/absmach/supermq/pkg/sdk/mocks" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" diff --git a/cli/health_test.go b/cli/health_test.go index 88b6455822..7cc04465ec 100644 --- a/cli/health_test.go +++ b/cli/health_test.go @@ -11,7 +11,7 @@ import ( "github.com/absmach/supermq/cli" "github.com/absmach/supermq/pkg/errors" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" sdkmocks "github.com/absmach/supermq/pkg/sdk/mocks" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" diff --git a/cli/invitations.go b/cli/invitations.go index 2b8fb6ceac..2afc36a36f 100644 --- a/cli/invitations.go +++ b/cli/invitations.go @@ -4,7 +4,7 @@ package cli import ( - smqsdk "github.com/absmach/supermq/pkg/sdk/go" + smqsdk "github.com/absmach/supermq/pkg/sdk" "github.com/spf13/cobra" ) diff --git a/cli/invitations_test.go b/cli/invitations_test.go index c3d7229ea4..2768b7b212 100644 --- a/cli/invitations_test.go +++ b/cli/invitations_test.go @@ -14,7 +14,7 @@ import ( "github.com/absmach/supermq/internal/testsutil" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" sdkmocks "github.com/absmach/supermq/pkg/sdk/mocks" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" diff --git a/cli/journal.go b/cli/journal.go index 84aebadbbd..ace2f9dffc 100644 --- a/cli/journal.go +++ b/cli/journal.go @@ -4,7 +4,7 @@ package cli import ( - smqsdk "github.com/absmach/supermq/pkg/sdk/go" + smqsdk "github.com/absmach/supermq/pkg/sdk" "github.com/spf13/cobra" ) diff --git a/cli/journal_test.go b/cli/journal_test.go index 964680a735..8963e75e43 100644 --- a/cli/journal_test.go +++ b/cli/journal_test.go @@ -14,7 +14,7 @@ import ( "github.com/absmach/supermq/internal/testsutil" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" sdkmocks "github.com/absmach/supermq/pkg/sdk/mocks" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" diff --git a/cli/message.go b/cli/message.go index 9b6b73a4f2..ceb6c6b561 100644 --- a/cli/message.go +++ b/cli/message.go @@ -4,7 +4,7 @@ package cli import ( - smqsdk "github.com/absmach/supermq/pkg/sdk/go" + smqsdk "github.com/absmach/supermq/pkg/sdk" "github.com/spf13/cobra" ) diff --git a/cli/message_test.go b/cli/message_test.go index 206a68b07a..14b92e0d89 100644 --- a/cli/message_test.go +++ b/cli/message_test.go @@ -13,7 +13,7 @@ import ( "github.com/absmach/supermq/cli" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" sdkmocks "github.com/absmach/supermq/pkg/sdk/mocks" "github.com/absmach/supermq/pkg/transformers/senml" "github.com/stretchr/testify/assert" diff --git a/cli/provision.go b/cli/provision.go index 315fc92d6c..ec722c830f 100644 --- a/cli/provision.go +++ b/cli/provision.go @@ -15,7 +15,7 @@ import ( "time" "github.com/0x6flab/namegenerator" - smqsdk "github.com/absmach/supermq/pkg/sdk/go" + smqsdk "github.com/absmach/supermq/pkg/sdk" "github.com/spf13/cobra" ) diff --git a/cli/sdk.go b/cli/sdk.go index 7443906674..9b7afa18b0 100644 --- a/cli/sdk.go +++ b/cli/sdk.go @@ -3,7 +3,7 @@ package cli -import smqsdk "github.com/absmach/supermq/pkg/sdk/go" +import smqsdk "github.com/absmach/supermq/pkg/sdk" // Keep SDK handle in global var. var sdk smqsdk.SDK diff --git a/cli/users.go b/cli/users.go index 7db0dc3954..b36272a5b3 100644 --- a/cli/users.go +++ b/cli/users.go @@ -9,7 +9,7 @@ import ( "net/url" "strconv" - smqsdk "github.com/absmach/supermq/pkg/sdk/go" + smqsdk "github.com/absmach/supermq/pkg/sdk" "github.com/absmach/supermq/users" "github.com/spf13/cobra" ) diff --git a/cli/users_test.go b/cli/users_test.go index 60314c323d..caae31fdaa 100644 --- a/cli/users_test.go +++ b/cli/users_test.go @@ -14,7 +14,7 @@ import ( "github.com/absmach/supermq/internal/testsutil" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" sdkmocks "github.com/absmach/supermq/pkg/sdk/mocks" "github.com/absmach/supermq/users" "github.com/stretchr/testify/assert" diff --git a/clients/mocks/repository.go b/clients/mocks/repository.go index 9d7312852a..22f57e651d 100644 --- a/clients/mocks/repository.go +++ b/clients/mocks/repository.go @@ -230,9 +230,9 @@ func (_m *Repository) RemoveConnections(ctx context.Context, conns []clients.Con return r0 } -// RemoveMemberFromAllRoles provides a mock function with given fields: ctx, members -func (_m *Repository) RemoveMemberFromAllRoles(ctx context.Context, members string) error { - ret := _m.Called(ctx, members) +// RemoveMemberFromAllRoles provides a mock function with given fields: ctx, memberID +func (_m *Repository) RemoveMemberFromAllRoles(ctx context.Context, memberID string) error { + ret := _m.Called(ctx, memberID) if len(ret) == 0 { panic("no return value specified for RemoveMemberFromAllRoles") @@ -240,7 +240,7 @@ func (_m *Repository) RemoveMemberFromAllRoles(ctx context.Context, members stri var r0 error if rf, ok := ret.Get(0).(func(context.Context, string) error); ok { - r0 = rf(ctx, members) + r0 = rf(ctx, memberID) } else { r0 = ret.Error(0) } diff --git a/cmd/bootstrap/main.go b/cmd/bootstrap/main.go index 7b93a0b030..dc8af3baf3 100644 --- a/cmd/bootstrap/main.go +++ b/cmd/bootstrap/main.go @@ -33,7 +33,7 @@ import ( "github.com/absmach/supermq/pkg/policies/spicedb" pgclient "github.com/absmach/supermq/pkg/postgres" "github.com/absmach/supermq/pkg/prometheus" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" "github.com/absmach/supermq/pkg/server" httpserver "github.com/absmach/supermq/pkg/server/http" "github.com/absmach/supermq/pkg/uuid" diff --git a/cmd/certs/main.go b/cmd/certs/main.go index b2e3337565..325561dbdb 100644 --- a/cmd/certs/main.go +++ b/cmd/certs/main.go @@ -23,7 +23,7 @@ import ( "github.com/absmach/supermq/pkg/grpcclient" jaegerclient "github.com/absmach/supermq/pkg/jaeger" "github.com/absmach/supermq/pkg/prometheus" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" "github.com/absmach/supermq/pkg/server" httpserver "github.com/absmach/supermq/pkg/server/http" "github.com/absmach/supermq/pkg/uuid" diff --git a/cmd/cli/main.go b/cmd/cli/main.go index ef7d402587..a261527887 100644 --- a/cmd/cli/main.go +++ b/cmd/cli/main.go @@ -8,7 +8,7 @@ import ( "log" "github.com/absmach/supermq/cli" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" "github.com/spf13/cobra" ) diff --git a/cmd/invitations/main.go b/cmd/invitations/main.go index 98c15c3176..eec7cc5c20 100644 --- a/cmd/invitations/main.go +++ b/cmd/invitations/main.go @@ -28,7 +28,7 @@ import ( "github.com/absmach/supermq/pkg/postgres" clientspg "github.com/absmach/supermq/pkg/postgres" "github.com/absmach/supermq/pkg/prometheus" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" "github.com/absmach/supermq/pkg/server" "github.com/absmach/supermq/pkg/server/http" "github.com/absmach/supermq/pkg/uuid" diff --git a/cmd/provision/main.go b/cmd/provision/main.go index adbbf713bf..b4b93175f7 100644 --- a/cmd/provision/main.go +++ b/cmd/provision/main.go @@ -18,7 +18,7 @@ import ( "github.com/absmach/supermq/clients" smqlog "github.com/absmach/supermq/logger" "github.com/absmach/supermq/pkg/errors" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" "github.com/absmach/supermq/pkg/server" httpserver "github.com/absmach/supermq/pkg/server/http" "github.com/absmach/supermq/pkg/uuid" diff --git a/doc.go b/doc.go index cbb0f98f68..9bb2ab04f9 100644 --- a/doc.go +++ b/doc.go @@ -3,4 +3,5 @@ // Package supermq acts as an umbrella package containing multiple different // microservices and defines all shared domain concepts. +// For detailed documentation of the platform, please visit https://docs.supermq.abstractmachines.fr. package supermq diff --git a/domains/mocks/repository.go b/domains/mocks/repository.go index 16c18d7b12..fae44c2405 100644 --- a/domains/mocks/repository.go +++ b/domains/mocks/repository.go @@ -94,9 +94,9 @@ func (_m *Repository) ListDomains(ctx context.Context, pm domains.Page) (domains return r0, r1 } -// RemoveMemberFromAllRoles provides a mock function with given fields: ctx, members -func (_m *Repository) RemoveMemberFromAllRoles(ctx context.Context, members string) error { - ret := _m.Called(ctx, members) +// RemoveMemberFromAllRoles provides a mock function with given fields: ctx, memberID +func (_m *Repository) RemoveMemberFromAllRoles(ctx context.Context, memberID string) error { + ret := _m.Called(ctx, memberID) if len(ret) == 0 { panic("no return value specified for RemoveMemberFromAllRoles") @@ -104,7 +104,7 @@ func (_m *Repository) RemoveMemberFromAllRoles(ctx context.Context, members stri var r0 error if rf, ok := ret.Get(0).(func(context.Context, string) error); ok { - r0 = rf(ctx, members) + r0 = rf(ctx, memberID) } else { r0 = ret.Error(0) } diff --git a/groups/mocks/repository.go b/groups/mocks/repository.go index 0118d87625..867680c2ca 100644 --- a/groups/mocks/repository.go +++ b/groups/mocks/repository.go @@ -112,9 +112,9 @@ func (_m *Repository) Delete(ctx context.Context, groupID string) error { return r0 } -// RemoveMemberFromAllRoles provides a mock function with given fields: ctx, members -func (_m *Repository) RemoveMemberFromAllRoles(ctx context.Context, members string) error { - ret := _m.Called(ctx, members) +// RemoveMemberFromAllRoles provides a mock function with given fields: ctx, memberID +func (_m *Repository) RemoveMemberFromAllRoles(ctx context.Context, memberID string) error { + ret := _m.Called(ctx, memberID) if len(ret) == 0 { panic("no return value specified for RemoveMemberFromAllRoles") @@ -122,7 +122,7 @@ func (_m *Repository) RemoveMemberFromAllRoles(ctx context.Context, members stri var r0 error if rf, ok := ret.Get(0).(func(context.Context, string) error); ok { - r0 = rf(ctx, members) + r0 = rf(ctx, memberID) } else { r0 = ret.Error(0) } diff --git a/invitations/service.go b/invitations/service.go index 3d2680a5ad..b31237c09d 100644 --- a/invitations/service.go +++ b/invitations/service.go @@ -11,7 +11,7 @@ import ( grpcTokenV1 "github.com/absmach/supermq/internal/grpc/token/v1" "github.com/absmach/supermq/pkg/authn" svcerr "github.com/absmach/supermq/pkg/errors/service" - mgsdk "github.com/absmach/supermq/pkg/sdk/go" + mgsdk "github.com/absmach/supermq/pkg/sdk" ) type service struct { diff --git a/pkg/mocks/sdk.go b/pkg/mocks/sdk.go new file mode 100644 index 0000000000..4a9548e711 --- /dev/null +++ b/pkg/mocks/sdk.go @@ -0,0 +1,3021 @@ +// Code generated by mockery v2.43.2. DO NOT EDIT. + +// Copyright (c) Abstract Machines + +package mocks + +import ( + errors "github.com/absmach/supermq/pkg/errors" + mock "github.com/stretchr/testify/mock" + + sdk "github.com/absmach/supermq/pkg/sdk" + + time "time" +) + +// SDK is an autogenerated mock type for the SDK type +type SDK struct { + mock.Mock +} + +// AcceptInvitation provides a mock function with given fields: domainID, token +func (_m *SDK) AcceptInvitation(domainID string, token string) error { + ret := _m.Called(domainID, token) + + if len(ret) == 0 { + panic("no return value specified for AcceptInvitation") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, string) error); ok { + r0 = rf(domainID, token) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AddBootstrap provides a mock function with given fields: cfg, domainID, token +func (_m *SDK) AddBootstrap(cfg sdk.BootstrapConfig, domainID string, token string) (string, errors.SDKError) { + ret := _m.Called(cfg, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for AddBootstrap") + } + + var r0 string + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.BootstrapConfig, string, string) (string, errors.SDKError)); ok { + return rf(cfg, domainID, token) + } + if rf, ok := ret.Get(0).(func(sdk.BootstrapConfig, string, string) string); ok { + r0 = rf(cfg, domainID, token) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(sdk.BootstrapConfig, string, string) errors.SDKError); ok { + r1 = rf(cfg, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// AddUserGroupToChannel provides a mock function with given fields: channelID, req, domainID, token +func (_m *SDK) AddUserGroupToChannel(channelID string, req sdk.UserGroupsRequest, domainID string, token string) errors.SDKError { + ret := _m.Called(channelID, req, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for AddUserGroupToChannel") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.UserGroupsRequest, string, string) errors.SDKError); ok { + r0 = rf(channelID, req, domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// AddUserToChannel provides a mock function with given fields: channelID, req, domainID, token +func (_m *SDK) AddUserToChannel(channelID string, req sdk.UsersRelationRequest, domainID string, token string) errors.SDKError { + ret := _m.Called(channelID, req, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for AddUserToChannel") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.UsersRelationRequest, string, string) errors.SDKError); ok { + r0 = rf(channelID, req, domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// AddUserToDomain provides a mock function with given fields: domainID, req, token +func (_m *SDK) AddUserToDomain(domainID string, req sdk.UsersRelationRequest, token string) errors.SDKError { + ret := _m.Called(domainID, req, token) + + if len(ret) == 0 { + panic("no return value specified for AddUserToDomain") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.UsersRelationRequest, string) errors.SDKError); ok { + r0 = rf(domainID, req, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// AddUserToGroup provides a mock function with given fields: groupID, req, domainID, token +func (_m *SDK) AddUserToGroup(groupID string, req sdk.UsersRelationRequest, domainID string, token string) errors.SDKError { + ret := _m.Called(groupID, req, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for AddUserToGroup") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.UsersRelationRequest, string, string) errors.SDKError); ok { + r0 = rf(groupID, req, domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// Bootstrap provides a mock function with given fields: externalID, externalKey +func (_m *SDK) Bootstrap(externalID string, externalKey string) (sdk.BootstrapConfig, errors.SDKError) { + ret := _m.Called(externalID, externalKey) + + if len(ret) == 0 { + panic("no return value specified for Bootstrap") + } + + var r0 sdk.BootstrapConfig + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string) (sdk.BootstrapConfig, errors.SDKError)); ok { + return rf(externalID, externalKey) + } + if rf, ok := ret.Get(0).(func(string, string) sdk.BootstrapConfig); ok { + r0 = rf(externalID, externalKey) + } else { + r0 = ret.Get(0).(sdk.BootstrapConfig) + } + + if rf, ok := ret.Get(1).(func(string, string) errors.SDKError); ok { + r1 = rf(externalID, externalKey) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// BootstrapSecure provides a mock function with given fields: externalID, externalKey, cryptoKey +func (_m *SDK) BootstrapSecure(externalID string, externalKey string, cryptoKey string) (sdk.BootstrapConfig, errors.SDKError) { + ret := _m.Called(externalID, externalKey, cryptoKey) + + if len(ret) == 0 { + panic("no return value specified for BootstrapSecure") + } + + var r0 sdk.BootstrapConfig + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) (sdk.BootstrapConfig, errors.SDKError)); ok { + return rf(externalID, externalKey, cryptoKey) + } + if rf, ok := ret.Get(0).(func(string, string, string) sdk.BootstrapConfig); ok { + r0 = rf(externalID, externalKey, cryptoKey) + } else { + r0 = ret.Get(0).(sdk.BootstrapConfig) + } + + if rf, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok { + r1 = rf(externalID, externalKey, cryptoKey) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// Bootstraps provides a mock function with given fields: pm, domainID, token +func (_m *SDK) Bootstraps(pm sdk.PageMetadata, domainID string, token string) (sdk.BootstrapPage, errors.SDKError) { + ret := _m.Called(pm, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for Bootstraps") + } + + var r0 sdk.BootstrapPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string, string) (sdk.BootstrapPage, errors.SDKError)); ok { + return rf(pm, domainID, token) + } + if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string, string) sdk.BootstrapPage); ok { + r0 = rf(pm, domainID, token) + } else { + r0 = ret.Get(0).(sdk.BootstrapPage) + } + + if rf, ok := ret.Get(1).(func(sdk.PageMetadata, string, string) errors.SDKError); ok { + r1 = rf(pm, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// Channel provides a mock function with given fields: id, domainID, token +func (_m *SDK) Channel(id string, domainID string, token string) (sdk.Channel, errors.SDKError) { + ret := _m.Called(id, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for Channel") + } + + var r0 sdk.Channel + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) (sdk.Channel, errors.SDKError)); ok { + return rf(id, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string, string) sdk.Channel); ok { + r0 = rf(id, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Channel) + } + + if rf, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok { + r1 = rf(id, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// ChannelPermissions provides a mock function with given fields: id, domainID, token +func (_m *SDK) ChannelPermissions(id string, domainID string, token string) (sdk.Channel, errors.SDKError) { + ret := _m.Called(id, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for ChannelPermissions") + } + + var r0 sdk.Channel + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) (sdk.Channel, errors.SDKError)); ok { + return rf(id, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string, string) sdk.Channel); ok { + r0 = rf(id, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Channel) + } + + if rf, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok { + r1 = rf(id, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// Channels provides a mock function with given fields: pm, domainID, token +func (_m *SDK) Channels(pm sdk.PageMetadata, domainID string, token string) (sdk.ChannelsPage, errors.SDKError) { + ret := _m.Called(pm, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for Channels") + } + + var r0 sdk.ChannelsPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string, string) (sdk.ChannelsPage, errors.SDKError)); ok { + return rf(pm, domainID, token) + } + if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string, string) sdk.ChannelsPage); ok { + r0 = rf(pm, domainID, token) + } else { + r0 = ret.Get(0).(sdk.ChannelsPage) + } + + if rf, ok := ret.Get(1).(func(sdk.PageMetadata, string, string) errors.SDKError); ok { + r1 = rf(pm, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// ChannelsByClient provides a mock function with given fields: clientID, pm, domainID, token +func (_m *SDK) ChannelsByClient(clientID string, pm sdk.PageMetadata, domainID string, token string) (sdk.ChannelsPage, errors.SDKError) { + ret := _m.Called(clientID, pm, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for ChannelsByClient") + } + + var r0 sdk.ChannelsPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) (sdk.ChannelsPage, errors.SDKError)); ok { + return rf(clientID, pm, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) sdk.ChannelsPage); ok { + r0 = rf(clientID, pm, domainID, token) + } else { + r0 = ret.Get(0).(sdk.ChannelsPage) + } + + if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string, string) errors.SDKError); ok { + r1 = rf(clientID, pm, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// Children provides a mock function with given fields: id, pm, domainID, token +func (_m *SDK) Children(id string, pm sdk.PageMetadata, domainID string, token string) (sdk.GroupsPage, errors.SDKError) { + ret := _m.Called(id, pm, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for Children") + } + + var r0 sdk.GroupsPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) (sdk.GroupsPage, errors.SDKError)); ok { + return rf(id, pm, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) sdk.GroupsPage); ok { + r0 = rf(id, pm, domainID, token) + } else { + r0 = ret.Get(0).(sdk.GroupsPage) + } + + if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string, string) errors.SDKError); ok { + r1 = rf(id, pm, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// Client provides a mock function with given fields: id, domainID, token +func (_m *SDK) Client(id string, domainID string, token string) (sdk.Client, errors.SDKError) { + ret := _m.Called(id, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for Client") + } + + var r0 sdk.Client + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) (sdk.Client, errors.SDKError)); ok { + return rf(id, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string, string) sdk.Client); ok { + r0 = rf(id, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Client) + } + + if rf, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok { + r1 = rf(id, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// ClientPermissions provides a mock function with given fields: id, domainID, token +func (_m *SDK) ClientPermissions(id string, domainID string, token string) (sdk.Client, errors.SDKError) { + ret := _m.Called(id, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for ClientPermissions") + } + + var r0 sdk.Client + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) (sdk.Client, errors.SDKError)); ok { + return rf(id, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string, string) sdk.Client); ok { + r0 = rf(id, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Client) + } + + if rf, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok { + r1 = rf(id, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// Clients provides a mock function with given fields: pm, domainID, token +func (_m *SDK) Clients(pm sdk.PageMetadata, domainID string, token string) (sdk.ClientsPage, errors.SDKError) { + ret := _m.Called(pm, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for Clients") + } + + var r0 sdk.ClientsPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string, string) (sdk.ClientsPage, errors.SDKError)); ok { + return rf(pm, domainID, token) + } + if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string, string) sdk.ClientsPage); ok { + r0 = rf(pm, domainID, token) + } else { + r0 = ret.Get(0).(sdk.ClientsPage) + } + + if rf, ok := ret.Get(1).(func(sdk.PageMetadata, string, string) errors.SDKError); ok { + r1 = rf(pm, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// ClientsByChannel provides a mock function with given fields: chanID, pm, domainID, token +func (_m *SDK) ClientsByChannel(chanID string, pm sdk.PageMetadata, domainID string, token string) (sdk.ClientsPage, errors.SDKError) { + ret := _m.Called(chanID, pm, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for ClientsByChannel") + } + + var r0 sdk.ClientsPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) (sdk.ClientsPage, errors.SDKError)); ok { + return rf(chanID, pm, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) sdk.ClientsPage); ok { + r0 = rf(chanID, pm, domainID, token) + } else { + r0 = ret.Get(0).(sdk.ClientsPage) + } + + if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string, string) errors.SDKError); ok { + r1 = rf(chanID, pm, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// Connect provides a mock function with given fields: conns, domainID, token +func (_m *SDK) Connect(conns sdk.Connection, domainID string, token string) errors.SDKError { + ret := _m.Called(conns, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for Connect") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.Connection, string, string) errors.SDKError); ok { + r0 = rf(conns, domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// ConnectClient provides a mock function with given fields: clientID, chanID, connTypes, domainID, token +func (_m *SDK) ConnectClient(clientID string, chanID string, connTypes []string, domainID string, token string) errors.SDKError { + ret := _m.Called(clientID, chanID, connTypes, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for ConnectClient") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, []string, string, string) errors.SDKError); ok { + r0 = rf(clientID, chanID, connTypes, domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// CreateChannel provides a mock function with given fields: channel, domainID, token +func (_m *SDK) CreateChannel(channel sdk.Channel, domainID string, token string) (sdk.Channel, errors.SDKError) { + ret := _m.Called(channel, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for CreateChannel") + } + + var r0 sdk.Channel + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.Channel, string, string) (sdk.Channel, errors.SDKError)); ok { + return rf(channel, domainID, token) + } + if rf, ok := ret.Get(0).(func(sdk.Channel, string, string) sdk.Channel); ok { + r0 = rf(channel, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Channel) + } + + if rf, ok := ret.Get(1).(func(sdk.Channel, string, string) errors.SDKError); ok { + r1 = rf(channel, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// CreateClient provides a mock function with given fields: client, domainID, token +func (_m *SDK) CreateClient(client sdk.Client, domainID string, token string) (sdk.Client, errors.SDKError) { + ret := _m.Called(client, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for CreateClient") + } + + var r0 sdk.Client + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.Client, string, string) (sdk.Client, errors.SDKError)); ok { + return rf(client, domainID, token) + } + if rf, ok := ret.Get(0).(func(sdk.Client, string, string) sdk.Client); ok { + r0 = rf(client, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Client) + } + + if rf, ok := ret.Get(1).(func(sdk.Client, string, string) errors.SDKError); ok { + r1 = rf(client, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// CreateClients provides a mock function with given fields: client, domainID, token +func (_m *SDK) CreateClients(client []sdk.Client, domainID string, token string) ([]sdk.Client, errors.SDKError) { + ret := _m.Called(client, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for CreateClients") + } + + var r0 []sdk.Client + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func([]sdk.Client, string, string) ([]sdk.Client, errors.SDKError)); ok { + return rf(client, domainID, token) + } + if rf, ok := ret.Get(0).(func([]sdk.Client, string, string) []sdk.Client); ok { + r0 = rf(client, domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]sdk.Client) + } + } + + if rf, ok := ret.Get(1).(func([]sdk.Client, string, string) errors.SDKError); ok { + r1 = rf(client, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// CreateDomain provides a mock function with given fields: d, token +func (_m *SDK) CreateDomain(d sdk.Domain, token string) (sdk.Domain, errors.SDKError) { + ret := _m.Called(d, token) + + if len(ret) == 0 { + panic("no return value specified for CreateDomain") + } + + var r0 sdk.Domain + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.Domain, string) (sdk.Domain, errors.SDKError)); ok { + return rf(d, token) + } + if rf, ok := ret.Get(0).(func(sdk.Domain, string) sdk.Domain); ok { + r0 = rf(d, token) + } else { + r0 = ret.Get(0).(sdk.Domain) + } + + if rf, ok := ret.Get(1).(func(sdk.Domain, string) errors.SDKError); ok { + r1 = rf(d, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// CreateGroup provides a mock function with given fields: group, domainID, token +func (_m *SDK) CreateGroup(group sdk.Group, domainID string, token string) (sdk.Group, errors.SDKError) { + ret := _m.Called(group, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for CreateGroup") + } + + var r0 sdk.Group + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.Group, string, string) (sdk.Group, errors.SDKError)); ok { + return rf(group, domainID, token) + } + if rf, ok := ret.Get(0).(func(sdk.Group, string, string) sdk.Group); ok { + r0 = rf(group, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Group) + } + + if rf, ok := ret.Get(1).(func(sdk.Group, string, string) errors.SDKError); ok { + r1 = rf(group, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// CreateSubscription provides a mock function with given fields: topic, contact, token +func (_m *SDK) CreateSubscription(topic string, contact string, token string) (string, errors.SDKError) { + ret := _m.Called(topic, contact, token) + + if len(ret) == 0 { + panic("no return value specified for CreateSubscription") + } + + var r0 string + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) (string, errors.SDKError)); ok { + return rf(topic, contact, token) + } + if rf, ok := ret.Get(0).(func(string, string, string) string); ok { + r0 = rf(topic, contact, token) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok { + r1 = rf(topic, contact, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// CreateToken provides a mock function with given fields: lt +func (_m *SDK) CreateToken(lt sdk.Login) (sdk.Token, errors.SDKError) { + ret := _m.Called(lt) + + if len(ret) == 0 { + panic("no return value specified for CreateToken") + } + + var r0 sdk.Token + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.Login) (sdk.Token, errors.SDKError)); ok { + return rf(lt) + } + if rf, ok := ret.Get(0).(func(sdk.Login) sdk.Token); ok { + r0 = rf(lt) + } else { + r0 = ret.Get(0).(sdk.Token) + } + + if rf, ok := ret.Get(1).(func(sdk.Login) errors.SDKError); ok { + r1 = rf(lt) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// CreateUser provides a mock function with given fields: user, token +func (_m *SDK) CreateUser(user sdk.User, token string) (sdk.User, errors.SDKError) { + ret := _m.Called(user, token) + + if len(ret) == 0 { + panic("no return value specified for CreateUser") + } + + var r0 sdk.User + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.User, string) (sdk.User, errors.SDKError)); ok { + return rf(user, token) + } + if rf, ok := ret.Get(0).(func(sdk.User, string) sdk.User); ok { + r0 = rf(user, token) + } else { + r0 = ret.Get(0).(sdk.User) + } + + if rf, ok := ret.Get(1).(func(sdk.User, string) errors.SDKError); ok { + r1 = rf(user, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// DeleteChannel provides a mock function with given fields: id, domainID, token +func (_m *SDK) DeleteChannel(id string, domainID string, token string) errors.SDKError { + ret := _m.Called(id, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for DeleteChannel") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) errors.SDKError); ok { + r0 = rf(id, domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// DeleteClient provides a mock function with given fields: id, domainID, token +func (_m *SDK) DeleteClient(id string, domainID string, token string) errors.SDKError { + ret := _m.Called(id, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for DeleteClient") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) errors.SDKError); ok { + r0 = rf(id, domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// DeleteGroup provides a mock function with given fields: id, domainID, token +func (_m *SDK) DeleteGroup(id string, domainID string, token string) errors.SDKError { + ret := _m.Called(id, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for DeleteGroup") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) errors.SDKError); ok { + r0 = rf(id, domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// DeleteInvitation provides a mock function with given fields: userID, domainID, token +func (_m *SDK) DeleteInvitation(userID string, domainID string, token string) error { + ret := _m.Called(userID, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for DeleteInvitation") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, string, string) error); ok { + r0 = rf(userID, domainID, token) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// DeleteSubscription provides a mock function with given fields: id, token +func (_m *SDK) DeleteSubscription(id string, token string) errors.SDKError { + ret := _m.Called(id, token) + + if len(ret) == 0 { + panic("no return value specified for DeleteSubscription") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string) errors.SDKError); ok { + r0 = rf(id, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// DeleteUser provides a mock function with given fields: id, token +func (_m *SDK) DeleteUser(id string, token string) errors.SDKError { + ret := _m.Called(id, token) + + if len(ret) == 0 { + panic("no return value specified for DeleteUser") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string) errors.SDKError); ok { + r0 = rf(id, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// DisableChannel provides a mock function with given fields: id, domainID, token +func (_m *SDK) DisableChannel(id string, domainID string, token string) (sdk.Channel, errors.SDKError) { + ret := _m.Called(id, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for DisableChannel") + } + + var r0 sdk.Channel + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) (sdk.Channel, errors.SDKError)); ok { + return rf(id, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string, string) sdk.Channel); ok { + r0 = rf(id, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Channel) + } + + if rf, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok { + r1 = rf(id, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// DisableClient provides a mock function with given fields: id, domainID, token +func (_m *SDK) DisableClient(id string, domainID string, token string) (sdk.Client, errors.SDKError) { + ret := _m.Called(id, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for DisableClient") + } + + var r0 sdk.Client + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) (sdk.Client, errors.SDKError)); ok { + return rf(id, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string, string) sdk.Client); ok { + r0 = rf(id, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Client) + } + + if rf, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok { + r1 = rf(id, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// DisableDomain provides a mock function with given fields: domainID, token +func (_m *SDK) DisableDomain(domainID string, token string) errors.SDKError { + ret := _m.Called(domainID, token) + + if len(ret) == 0 { + panic("no return value specified for DisableDomain") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string) errors.SDKError); ok { + r0 = rf(domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// DisableGroup provides a mock function with given fields: id, domainID, token +func (_m *SDK) DisableGroup(id string, domainID string, token string) (sdk.Group, errors.SDKError) { + ret := _m.Called(id, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for DisableGroup") + } + + var r0 sdk.Group + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) (sdk.Group, errors.SDKError)); ok { + return rf(id, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string, string) sdk.Group); ok { + r0 = rf(id, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Group) + } + + if rf, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok { + r1 = rf(id, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// DisableUser provides a mock function with given fields: id, token +func (_m *SDK) DisableUser(id string, token string) (sdk.User, errors.SDKError) { + ret := _m.Called(id, token) + + if len(ret) == 0 { + panic("no return value specified for DisableUser") + } + + var r0 sdk.User + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string) (sdk.User, errors.SDKError)); ok { + return rf(id, token) + } + if rf, ok := ret.Get(0).(func(string, string) sdk.User); ok { + r0 = rf(id, token) + } else { + r0 = ret.Get(0).(sdk.User) + } + + if rf, ok := ret.Get(1).(func(string, string) errors.SDKError); ok { + r1 = rf(id, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// Disconnect provides a mock function with given fields: connIDs, domainID, token +func (_m *SDK) Disconnect(connIDs sdk.Connection, domainID string, token string) errors.SDKError { + ret := _m.Called(connIDs, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for Disconnect") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.Connection, string, string) errors.SDKError); ok { + r0 = rf(connIDs, domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// DisconnectClient provides a mock function with given fields: clientID, chanID, connTypes, domainID, token +func (_m *SDK) DisconnectClient(clientID string, chanID string, connTypes []string, domainID string, token string) errors.SDKError { + ret := _m.Called(clientID, chanID, connTypes, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for DisconnectClient") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, []string, string, string) errors.SDKError); ok { + r0 = rf(clientID, chanID, connTypes, domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// Domain provides a mock function with given fields: domainID, token +func (_m *SDK) Domain(domainID string, token string) (sdk.Domain, errors.SDKError) { + ret := _m.Called(domainID, token) + + if len(ret) == 0 { + panic("no return value specified for Domain") + } + + var r0 sdk.Domain + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string) (sdk.Domain, errors.SDKError)); ok { + return rf(domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string) sdk.Domain); ok { + r0 = rf(domainID, token) + } else { + r0 = ret.Get(0).(sdk.Domain) + } + + if rf, ok := ret.Get(1).(func(string, string) errors.SDKError); ok { + r1 = rf(domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// DomainPermissions provides a mock function with given fields: domainID, token +func (_m *SDK) DomainPermissions(domainID string, token string) (sdk.Domain, errors.SDKError) { + ret := _m.Called(domainID, token) + + if len(ret) == 0 { + panic("no return value specified for DomainPermissions") + } + + var r0 sdk.Domain + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string) (sdk.Domain, errors.SDKError)); ok { + return rf(domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string) sdk.Domain); ok { + r0 = rf(domainID, token) + } else { + r0 = ret.Get(0).(sdk.Domain) + } + + if rf, ok := ret.Get(1).(func(string, string) errors.SDKError); ok { + r1 = rf(domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// Domains provides a mock function with given fields: pm, token +func (_m *SDK) Domains(pm sdk.PageMetadata, token string) (sdk.DomainsPage, errors.SDKError) { + ret := _m.Called(pm, token) + + if len(ret) == 0 { + panic("no return value specified for Domains") + } + + var r0 sdk.DomainsPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) (sdk.DomainsPage, errors.SDKError)); ok { + return rf(pm, token) + } + if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) sdk.DomainsPage); ok { + r0 = rf(pm, token) + } else { + r0 = ret.Get(0).(sdk.DomainsPage) + } + + if rf, ok := ret.Get(1).(func(sdk.PageMetadata, string) errors.SDKError); ok { + r1 = rf(pm, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// EnableChannel provides a mock function with given fields: id, domainID, token +func (_m *SDK) EnableChannel(id string, domainID string, token string) (sdk.Channel, errors.SDKError) { + ret := _m.Called(id, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for EnableChannel") + } + + var r0 sdk.Channel + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) (sdk.Channel, errors.SDKError)); ok { + return rf(id, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string, string) sdk.Channel); ok { + r0 = rf(id, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Channel) + } + + if rf, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok { + r1 = rf(id, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// EnableClient provides a mock function with given fields: id, domainID, token +func (_m *SDK) EnableClient(id string, domainID string, token string) (sdk.Client, errors.SDKError) { + ret := _m.Called(id, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for EnableClient") + } + + var r0 sdk.Client + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) (sdk.Client, errors.SDKError)); ok { + return rf(id, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string, string) sdk.Client); ok { + r0 = rf(id, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Client) + } + + if rf, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok { + r1 = rf(id, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// EnableDomain provides a mock function with given fields: domainID, token +func (_m *SDK) EnableDomain(domainID string, token string) errors.SDKError { + ret := _m.Called(domainID, token) + + if len(ret) == 0 { + panic("no return value specified for EnableDomain") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string) errors.SDKError); ok { + r0 = rf(domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// EnableGroup provides a mock function with given fields: id, domainID, token +func (_m *SDK) EnableGroup(id string, domainID string, token string) (sdk.Group, errors.SDKError) { + ret := _m.Called(id, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for EnableGroup") + } + + var r0 sdk.Group + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) (sdk.Group, errors.SDKError)); ok { + return rf(id, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string, string) sdk.Group); ok { + r0 = rf(id, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Group) + } + + if rf, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok { + r1 = rf(id, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// EnableUser provides a mock function with given fields: id, token +func (_m *SDK) EnableUser(id string, token string) (sdk.User, errors.SDKError) { + ret := _m.Called(id, token) + + if len(ret) == 0 { + panic("no return value specified for EnableUser") + } + + var r0 sdk.User + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string) (sdk.User, errors.SDKError)); ok { + return rf(id, token) + } + if rf, ok := ret.Get(0).(func(string, string) sdk.User); ok { + r0 = rf(id, token) + } else { + r0 = ret.Get(0).(sdk.User) + } + + if rf, ok := ret.Get(1).(func(string, string) errors.SDKError); ok { + r1 = rf(id, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// Group provides a mock function with given fields: id, domainID, token +func (_m *SDK) Group(id string, domainID string, token string) (sdk.Group, errors.SDKError) { + ret := _m.Called(id, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for Group") + } + + var r0 sdk.Group + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) (sdk.Group, errors.SDKError)); ok { + return rf(id, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string, string) sdk.Group); ok { + r0 = rf(id, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Group) + } + + if rf, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok { + r1 = rf(id, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// GroupPermissions provides a mock function with given fields: id, domainID, token +func (_m *SDK) GroupPermissions(id string, domainID string, token string) (sdk.Group, errors.SDKError) { + ret := _m.Called(id, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for GroupPermissions") + } + + var r0 sdk.Group + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) (sdk.Group, errors.SDKError)); ok { + return rf(id, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string, string) sdk.Group); ok { + r0 = rf(id, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Group) + } + + if rf, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok { + r1 = rf(id, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// Groups provides a mock function with given fields: pm, domainID, token +func (_m *SDK) Groups(pm sdk.PageMetadata, domainID string, token string) (sdk.GroupsPage, errors.SDKError) { + ret := _m.Called(pm, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for Groups") + } + + var r0 sdk.GroupsPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string, string) (sdk.GroupsPage, errors.SDKError)); ok { + return rf(pm, domainID, token) + } + if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string, string) sdk.GroupsPage); ok { + r0 = rf(pm, domainID, token) + } else { + r0 = ret.Get(0).(sdk.GroupsPage) + } + + if rf, ok := ret.Get(1).(func(sdk.PageMetadata, string, string) errors.SDKError); ok { + r1 = rf(pm, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// Health provides a mock function with given fields: service +func (_m *SDK) Health(service string) (sdk.HealthInfo, errors.SDKError) { + ret := _m.Called(service) + + if len(ret) == 0 { + panic("no return value specified for Health") + } + + var r0 sdk.HealthInfo + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string) (sdk.HealthInfo, errors.SDKError)); ok { + return rf(service) + } + if rf, ok := ret.Get(0).(func(string) sdk.HealthInfo); ok { + r0 = rf(service) + } else { + r0 = ret.Get(0).(sdk.HealthInfo) + } + + if rf, ok := ret.Get(1).(func(string) errors.SDKError); ok { + r1 = rf(service) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// Invitation provides a mock function with given fields: userID, domainID, token +func (_m *SDK) Invitation(userID string, domainID string, token string) (sdk.Invitation, error) { + ret := _m.Called(userID, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for Invitation") + } + + var r0 sdk.Invitation + var r1 error + if rf, ok := ret.Get(0).(func(string, string, string) (sdk.Invitation, error)); ok { + return rf(userID, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string, string) sdk.Invitation); ok { + r0 = rf(userID, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Invitation) + } + + if rf, ok := ret.Get(1).(func(string, string, string) error); ok { + r1 = rf(userID, domainID, token) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Invitations provides a mock function with given fields: pm, token +func (_m *SDK) Invitations(pm sdk.PageMetadata, token string) (sdk.InvitationPage, error) { + ret := _m.Called(pm, token) + + if len(ret) == 0 { + panic("no return value specified for Invitations") + } + + var r0 sdk.InvitationPage + var r1 error + if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) (sdk.InvitationPage, error)); ok { + return rf(pm, token) + } + if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) sdk.InvitationPage); ok { + r0 = rf(pm, token) + } else { + r0 = ret.Get(0).(sdk.InvitationPage) + } + + if rf, ok := ret.Get(1).(func(sdk.PageMetadata, string) error); ok { + r1 = rf(pm, token) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// IssueCert provides a mock function with given fields: clientID, validity, domainID, token +func (_m *SDK) IssueCert(clientID string, validity string, domainID string, token string) (sdk.Cert, errors.SDKError) { + ret := _m.Called(clientID, validity, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for IssueCert") + } + + var r0 sdk.Cert + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string, string) (sdk.Cert, errors.SDKError)); ok { + return rf(clientID, validity, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string, string, string) sdk.Cert); ok { + r0 = rf(clientID, validity, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Cert) + } + + if rf, ok := ret.Get(1).(func(string, string, string, string) errors.SDKError); ok { + r1 = rf(clientID, validity, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// Journal provides a mock function with given fields: entityType, entityID, domainID, pm, token +func (_m *SDK) Journal(entityType string, entityID string, domainID string, pm sdk.PageMetadata, token string) (sdk.JournalsPage, error) { + ret := _m.Called(entityType, entityID, domainID, pm, token) + + if len(ret) == 0 { + panic("no return value specified for Journal") + } + + var r0 sdk.JournalsPage + var r1 error + if rf, ok := ret.Get(0).(func(string, string, string, sdk.PageMetadata, string) (sdk.JournalsPage, error)); ok { + return rf(entityType, entityID, domainID, pm, token) + } + if rf, ok := ret.Get(0).(func(string, string, string, sdk.PageMetadata, string) sdk.JournalsPage); ok { + r0 = rf(entityType, entityID, domainID, pm, token) + } else { + r0 = ret.Get(0).(sdk.JournalsPage) + } + + if rf, ok := ret.Get(1).(func(string, string, string, sdk.PageMetadata, string) error); ok { + r1 = rf(entityType, entityID, domainID, pm, token) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ListChannelUserGroups provides a mock function with given fields: channelID, pm, domainID, token +func (_m *SDK) ListChannelUserGroups(channelID string, pm sdk.PageMetadata, domainID string, token string) (sdk.GroupsPage, errors.SDKError) { + ret := _m.Called(channelID, pm, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for ListChannelUserGroups") + } + + var r0 sdk.GroupsPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) (sdk.GroupsPage, errors.SDKError)); ok { + return rf(channelID, pm, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) sdk.GroupsPage); ok { + r0 = rf(channelID, pm, domainID, token) + } else { + r0 = ret.Get(0).(sdk.GroupsPage) + } + + if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string, string) errors.SDKError); ok { + r1 = rf(channelID, pm, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// ListChannelUsers provides a mock function with given fields: channelID, pm, domainID, token +func (_m *SDK) ListChannelUsers(channelID string, pm sdk.PageMetadata, domainID string, token string) (sdk.UsersPage, errors.SDKError) { + ret := _m.Called(channelID, pm, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for ListChannelUsers") + } + + var r0 sdk.UsersPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) (sdk.UsersPage, errors.SDKError)); ok { + return rf(channelID, pm, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) sdk.UsersPage); ok { + r0 = rf(channelID, pm, domainID, token) + } else { + r0 = ret.Get(0).(sdk.UsersPage) + } + + if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string, string) errors.SDKError); ok { + r1 = rf(channelID, pm, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// ListClientUsers provides a mock function with given fields: id, pm, domainID, token +func (_m *SDK) ListClientUsers(id string, pm sdk.PageMetadata, domainID string, token string) (sdk.UsersPage, errors.SDKError) { + ret := _m.Called(id, pm, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for ListClientUsers") + } + + var r0 sdk.UsersPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) (sdk.UsersPage, errors.SDKError)); ok { + return rf(id, pm, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) sdk.UsersPage); ok { + r0 = rf(id, pm, domainID, token) + } else { + r0 = ret.Get(0).(sdk.UsersPage) + } + + if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string, string) errors.SDKError); ok { + r1 = rf(id, pm, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// ListDomainUsers provides a mock function with given fields: domainID, pm, token +func (_m *SDK) ListDomainUsers(domainID string, pm sdk.PageMetadata, token string) (sdk.UsersPage, errors.SDKError) { + ret := _m.Called(domainID, pm, token) + + if len(ret) == 0 { + panic("no return value specified for ListDomainUsers") + } + + var r0 sdk.UsersPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) (sdk.UsersPage, errors.SDKError)); ok { + return rf(domainID, pm, token) + } + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) sdk.UsersPage); ok { + r0 = rf(domainID, pm, token) + } else { + r0 = ret.Get(0).(sdk.UsersPage) + } + + if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string) errors.SDKError); ok { + r1 = rf(domainID, pm, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// ListGroupChannels provides a mock function with given fields: groupID, pm, domainID, token +func (_m *SDK) ListGroupChannels(groupID string, pm sdk.PageMetadata, domainID string, token string) (sdk.ChannelsPage, errors.SDKError) { + ret := _m.Called(groupID, pm, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for ListGroupChannels") + } + + var r0 sdk.ChannelsPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) (sdk.ChannelsPage, errors.SDKError)); ok { + return rf(groupID, pm, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) sdk.ChannelsPage); ok { + r0 = rf(groupID, pm, domainID, token) + } else { + r0 = ret.Get(0).(sdk.ChannelsPage) + } + + if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string, string) errors.SDKError); ok { + r1 = rf(groupID, pm, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// ListGroupUsers provides a mock function with given fields: groupID, pm, domainID, token +func (_m *SDK) ListGroupUsers(groupID string, pm sdk.PageMetadata, domainID string, token string) (sdk.UsersPage, errors.SDKError) { + ret := _m.Called(groupID, pm, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for ListGroupUsers") + } + + var r0 sdk.UsersPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) (sdk.UsersPage, errors.SDKError)); ok { + return rf(groupID, pm, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) sdk.UsersPage); ok { + r0 = rf(groupID, pm, domainID, token) + } else { + r0 = ret.Get(0).(sdk.UsersPage) + } + + if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string, string) errors.SDKError); ok { + r1 = rf(groupID, pm, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// ListSubscriptions provides a mock function with given fields: pm, token +func (_m *SDK) ListSubscriptions(pm sdk.PageMetadata, token string) (sdk.SubscriptionPage, errors.SDKError) { + ret := _m.Called(pm, token) + + if len(ret) == 0 { + panic("no return value specified for ListSubscriptions") + } + + var r0 sdk.SubscriptionPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) (sdk.SubscriptionPage, errors.SDKError)); ok { + return rf(pm, token) + } + if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) sdk.SubscriptionPage); ok { + r0 = rf(pm, token) + } else { + r0 = ret.Get(0).(sdk.SubscriptionPage) + } + + if rf, ok := ret.Get(1).(func(sdk.PageMetadata, string) errors.SDKError); ok { + r1 = rf(pm, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// ListUserChannels provides a mock function with given fields: userID, pm, token +func (_m *SDK) ListUserChannels(userID string, pm sdk.PageMetadata, token string) (sdk.ChannelsPage, errors.SDKError) { + ret := _m.Called(userID, pm, token) + + if len(ret) == 0 { + panic("no return value specified for ListUserChannels") + } + + var r0 sdk.ChannelsPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) (sdk.ChannelsPage, errors.SDKError)); ok { + return rf(userID, pm, token) + } + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) sdk.ChannelsPage); ok { + r0 = rf(userID, pm, token) + } else { + r0 = ret.Get(0).(sdk.ChannelsPage) + } + + if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string) errors.SDKError); ok { + r1 = rf(userID, pm, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// ListUserClients provides a mock function with given fields: userID, pm, token +func (_m *SDK) ListUserClients(userID string, pm sdk.PageMetadata, token string) (sdk.ClientsPage, errors.SDKError) { + ret := _m.Called(userID, pm, token) + + if len(ret) == 0 { + panic("no return value specified for ListUserClients") + } + + var r0 sdk.ClientsPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) (sdk.ClientsPage, errors.SDKError)); ok { + return rf(userID, pm, token) + } + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) sdk.ClientsPage); ok { + r0 = rf(userID, pm, token) + } else { + r0 = ret.Get(0).(sdk.ClientsPage) + } + + if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string) errors.SDKError); ok { + r1 = rf(userID, pm, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// ListUserDomains provides a mock function with given fields: userID, pm, token +func (_m *SDK) ListUserDomains(userID string, pm sdk.PageMetadata, token string) (sdk.DomainsPage, errors.SDKError) { + ret := _m.Called(userID, pm, token) + + if len(ret) == 0 { + panic("no return value specified for ListUserDomains") + } + + var r0 sdk.DomainsPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) (sdk.DomainsPage, errors.SDKError)); ok { + return rf(userID, pm, token) + } + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) sdk.DomainsPage); ok { + r0 = rf(userID, pm, token) + } else { + r0 = ret.Get(0).(sdk.DomainsPage) + } + + if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string) errors.SDKError); ok { + r1 = rf(userID, pm, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// ListUserGroups provides a mock function with given fields: userID, pm, token +func (_m *SDK) ListUserGroups(userID string, pm sdk.PageMetadata, token string) (sdk.GroupsPage, errors.SDKError) { + ret := _m.Called(userID, pm, token) + + if len(ret) == 0 { + panic("no return value specified for ListUserGroups") + } + + var r0 sdk.GroupsPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) (sdk.GroupsPage, errors.SDKError)); ok { + return rf(userID, pm, token) + } + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) sdk.GroupsPage); ok { + r0 = rf(userID, pm, token) + } else { + r0 = ret.Get(0).(sdk.GroupsPage) + } + + if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string) errors.SDKError); ok { + r1 = rf(userID, pm, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// Members provides a mock function with given fields: groupID, meta, token +func (_m *SDK) Members(groupID string, meta sdk.PageMetadata, token string) (sdk.UsersPage, errors.SDKError) { + ret := _m.Called(groupID, meta, token) + + if len(ret) == 0 { + panic("no return value specified for Members") + } + + var r0 sdk.UsersPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) (sdk.UsersPage, errors.SDKError)); ok { + return rf(groupID, meta, token) + } + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string) sdk.UsersPage); ok { + r0 = rf(groupID, meta, token) + } else { + r0 = ret.Get(0).(sdk.UsersPage) + } + + if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string) errors.SDKError); ok { + r1 = rf(groupID, meta, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// Parents provides a mock function with given fields: id, pm, domainID, token +func (_m *SDK) Parents(id string, pm sdk.PageMetadata, domainID string, token string) (sdk.GroupsPage, errors.SDKError) { + ret := _m.Called(id, pm, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for Parents") + } + + var r0 sdk.GroupsPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) (sdk.GroupsPage, errors.SDKError)); ok { + return rf(id, pm, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, sdk.PageMetadata, string, string) sdk.GroupsPage); ok { + r0 = rf(id, pm, domainID, token) + } else { + r0 = ret.Get(0).(sdk.GroupsPage) + } + + if rf, ok := ret.Get(1).(func(string, sdk.PageMetadata, string, string) errors.SDKError); ok { + r1 = rf(id, pm, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// ReadMessages provides a mock function with given fields: pm, chanID, domainID, token +func (_m *SDK) ReadMessages(pm sdk.MessagePageMetadata, chanID string, domainID string, token string) (sdk.MessagesPage, errors.SDKError) { + ret := _m.Called(pm, chanID, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for ReadMessages") + } + + var r0 sdk.MessagesPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.MessagePageMetadata, string, string, string) (sdk.MessagesPage, errors.SDKError)); ok { + return rf(pm, chanID, domainID, token) + } + if rf, ok := ret.Get(0).(func(sdk.MessagePageMetadata, string, string, string) sdk.MessagesPage); ok { + r0 = rf(pm, chanID, domainID, token) + } else { + r0 = ret.Get(0).(sdk.MessagesPage) + } + + if rf, ok := ret.Get(1).(func(sdk.MessagePageMetadata, string, string, string) errors.SDKError); ok { + r1 = rf(pm, chanID, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// RefreshToken provides a mock function with given fields: token +func (_m *SDK) RefreshToken(token string) (sdk.Token, errors.SDKError) { + ret := _m.Called(token) + + if len(ret) == 0 { + panic("no return value specified for RefreshToken") + } + + var r0 sdk.Token + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string) (sdk.Token, errors.SDKError)); ok { + return rf(token) + } + if rf, ok := ret.Get(0).(func(string) sdk.Token); ok { + r0 = rf(token) + } else { + r0 = ret.Get(0).(sdk.Token) + } + + if rf, ok := ret.Get(1).(func(string) errors.SDKError); ok { + r1 = rf(token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// RejectInvitation provides a mock function with given fields: domainID, token +func (_m *SDK) RejectInvitation(domainID string, token string) error { + ret := _m.Called(domainID, token) + + if len(ret) == 0 { + panic("no return value specified for RejectInvitation") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string, string) error); ok { + r0 = rf(domainID, token) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RemoveBootstrap provides a mock function with given fields: id, domainID, token +func (_m *SDK) RemoveBootstrap(id string, domainID string, token string) errors.SDKError { + ret := _m.Called(id, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for RemoveBootstrap") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) errors.SDKError); ok { + r0 = rf(id, domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// RemoveUserFromChannel provides a mock function with given fields: channelID, req, domainID, token +func (_m *SDK) RemoveUserFromChannel(channelID string, req sdk.UsersRelationRequest, domainID string, token string) errors.SDKError { + ret := _m.Called(channelID, req, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for RemoveUserFromChannel") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.UsersRelationRequest, string, string) errors.SDKError); ok { + r0 = rf(channelID, req, domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// RemoveUserFromDomain provides a mock function with given fields: domainID, userID, token +func (_m *SDK) RemoveUserFromDomain(domainID string, userID string, token string) errors.SDKError { + ret := _m.Called(domainID, userID, token) + + if len(ret) == 0 { + panic("no return value specified for RemoveUserFromDomain") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) errors.SDKError); ok { + r0 = rf(domainID, userID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// RemoveUserFromGroup provides a mock function with given fields: groupID, req, domainID, token +func (_m *SDK) RemoveUserFromGroup(groupID string, req sdk.UsersRelationRequest, domainID string, token string) errors.SDKError { + ret := _m.Called(groupID, req, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for RemoveUserFromGroup") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.UsersRelationRequest, string, string) errors.SDKError); ok { + r0 = rf(groupID, req, domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// RemoveUserGroupFromChannel provides a mock function with given fields: channelID, req, domainID, token +func (_m *SDK) RemoveUserGroupFromChannel(channelID string, req sdk.UserGroupsRequest, domainID string, token string) errors.SDKError { + ret := _m.Called(channelID, req, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for RemoveUserGroupFromChannel") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.UserGroupsRequest, string, string) errors.SDKError); ok { + r0 = rf(channelID, req, domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// ResetPassword provides a mock function with given fields: password, confPass, token +func (_m *SDK) ResetPassword(password string, confPass string, token string) errors.SDKError { + ret := _m.Called(password, confPass, token) + + if len(ret) == 0 { + panic("no return value specified for ResetPassword") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) errors.SDKError); ok { + r0 = rf(password, confPass, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// ResetPasswordRequest provides a mock function with given fields: email +func (_m *SDK) ResetPasswordRequest(email string) errors.SDKError { + ret := _m.Called(email) + + if len(ret) == 0 { + panic("no return value specified for ResetPasswordRequest") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string) errors.SDKError); ok { + r0 = rf(email) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// RevokeCert provides a mock function with given fields: clientID, domainID, token +func (_m *SDK) RevokeCert(clientID string, domainID string, token string) (time.Time, errors.SDKError) { + ret := _m.Called(clientID, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for RevokeCert") + } + + var r0 time.Time + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) (time.Time, errors.SDKError)); ok { + return rf(clientID, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string, string) time.Time); ok { + r0 = rf(clientID, domainID, token) + } else { + r0 = ret.Get(0).(time.Time) + } + + if rf, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok { + r1 = rf(clientID, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// SearchUsers provides a mock function with given fields: pm, token +func (_m *SDK) SearchUsers(pm sdk.PageMetadata, token string) (sdk.UsersPage, errors.SDKError) { + ret := _m.Called(pm, token) + + if len(ret) == 0 { + panic("no return value specified for SearchUsers") + } + + var r0 sdk.UsersPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) (sdk.UsersPage, errors.SDKError)); ok { + return rf(pm, token) + } + if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) sdk.UsersPage); ok { + r0 = rf(pm, token) + } else { + r0 = ret.Get(0).(sdk.UsersPage) + } + + if rf, ok := ret.Get(1).(func(sdk.PageMetadata, string) errors.SDKError); ok { + r1 = rf(pm, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// SendInvitation provides a mock function with given fields: invitation, token +func (_m *SDK) SendInvitation(invitation sdk.Invitation, token string) error { + ret := _m.Called(invitation, token) + + if len(ret) == 0 { + panic("no return value specified for SendInvitation") + } + + var r0 error + if rf, ok := ret.Get(0).(func(sdk.Invitation, string) error); ok { + r0 = rf(invitation, token) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// SendMessage provides a mock function with given fields: chanID, msg, key +func (_m *SDK) SendMessage(chanID string, msg string, key string) errors.SDKError { + ret := _m.Called(chanID, msg, key) + + if len(ret) == 0 { + panic("no return value specified for SendMessage") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) errors.SDKError); ok { + r0 = rf(chanID, msg, key) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// SetContentType provides a mock function with given fields: ct +func (_m *SDK) SetContentType(ct sdk.ContentType) errors.SDKError { + ret := _m.Called(ct) + + if len(ret) == 0 { + panic("no return value specified for SetContentType") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.ContentType) errors.SDKError); ok { + r0 = rf(ct) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// ShareClient provides a mock function with given fields: id, req, domainID, token +func (_m *SDK) ShareClient(id string, req sdk.UsersRelationRequest, domainID string, token string) errors.SDKError { + ret := _m.Called(id, req, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for ShareClient") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.UsersRelationRequest, string, string) errors.SDKError); ok { + r0 = rf(id, req, domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// UnshareClient provides a mock function with given fields: id, req, domainID, token +func (_m *SDK) UnshareClient(id string, req sdk.UsersRelationRequest, domainID string, token string) errors.SDKError { + ret := _m.Called(id, req, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for UnshareClient") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, sdk.UsersRelationRequest, string, string) errors.SDKError); ok { + r0 = rf(id, req, domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// UpdateBootstrap provides a mock function with given fields: cfg, domainID, token +func (_m *SDK) UpdateBootstrap(cfg sdk.BootstrapConfig, domainID string, token string) errors.SDKError { + ret := _m.Called(cfg, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for UpdateBootstrap") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.BootstrapConfig, string, string) errors.SDKError); ok { + r0 = rf(cfg, domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// UpdateBootstrapCerts provides a mock function with given fields: id, clientCert, clientKey, ca, domainID, token +func (_m *SDK) UpdateBootstrapCerts(id string, clientCert string, clientKey string, ca string, domainID string, token string) (sdk.BootstrapConfig, errors.SDKError) { + ret := _m.Called(id, clientCert, clientKey, ca, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for UpdateBootstrapCerts") + } + + var r0 sdk.BootstrapConfig + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string, string, string, string) (sdk.BootstrapConfig, errors.SDKError)); ok { + return rf(id, clientCert, clientKey, ca, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string, string, string, string, string) sdk.BootstrapConfig); ok { + r0 = rf(id, clientCert, clientKey, ca, domainID, token) + } else { + r0 = ret.Get(0).(sdk.BootstrapConfig) + } + + if rf, ok := ret.Get(1).(func(string, string, string, string, string, string) errors.SDKError); ok { + r1 = rf(id, clientCert, clientKey, ca, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// UpdateBootstrapConnection provides a mock function with given fields: id, channels, domainID, token +func (_m *SDK) UpdateBootstrapConnection(id string, channels []string, domainID string, token string) errors.SDKError { + ret := _m.Called(id, channels, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for UpdateBootstrapConnection") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, []string, string, string) errors.SDKError); ok { + r0 = rf(id, channels, domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// UpdateChannel provides a mock function with given fields: channel, domainID, token +func (_m *SDK) UpdateChannel(channel sdk.Channel, domainID string, token string) (sdk.Channel, errors.SDKError) { + ret := _m.Called(channel, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for UpdateChannel") + } + + var r0 sdk.Channel + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.Channel, string, string) (sdk.Channel, errors.SDKError)); ok { + return rf(channel, domainID, token) + } + if rf, ok := ret.Get(0).(func(sdk.Channel, string, string) sdk.Channel); ok { + r0 = rf(channel, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Channel) + } + + if rf, ok := ret.Get(1).(func(sdk.Channel, string, string) errors.SDKError); ok { + r1 = rf(channel, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// UpdateClient provides a mock function with given fields: client, domainID, token +func (_m *SDK) UpdateClient(client sdk.Client, domainID string, token string) (sdk.Client, errors.SDKError) { + ret := _m.Called(client, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for UpdateClient") + } + + var r0 sdk.Client + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.Client, string, string) (sdk.Client, errors.SDKError)); ok { + return rf(client, domainID, token) + } + if rf, ok := ret.Get(0).(func(sdk.Client, string, string) sdk.Client); ok { + r0 = rf(client, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Client) + } + + if rf, ok := ret.Get(1).(func(sdk.Client, string, string) errors.SDKError); ok { + r1 = rf(client, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// UpdateClientSecret provides a mock function with given fields: id, secret, domainID, token +func (_m *SDK) UpdateClientSecret(id string, secret string, domainID string, token string) (sdk.Client, errors.SDKError) { + ret := _m.Called(id, secret, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for UpdateClientSecret") + } + + var r0 sdk.Client + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string, string) (sdk.Client, errors.SDKError)); ok { + return rf(id, secret, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string, string, string) sdk.Client); ok { + r0 = rf(id, secret, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Client) + } + + if rf, ok := ret.Get(1).(func(string, string, string, string) errors.SDKError); ok { + r1 = rf(id, secret, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// UpdateClientTags provides a mock function with given fields: client, domainID, token +func (_m *SDK) UpdateClientTags(client sdk.Client, domainID string, token string) (sdk.Client, errors.SDKError) { + ret := _m.Called(client, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for UpdateClientTags") + } + + var r0 sdk.Client + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.Client, string, string) (sdk.Client, errors.SDKError)); ok { + return rf(client, domainID, token) + } + if rf, ok := ret.Get(0).(func(sdk.Client, string, string) sdk.Client); ok { + r0 = rf(client, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Client) + } + + if rf, ok := ret.Get(1).(func(sdk.Client, string, string) errors.SDKError); ok { + r1 = rf(client, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// UpdateDomain provides a mock function with given fields: d, token +func (_m *SDK) UpdateDomain(d sdk.Domain, token string) (sdk.Domain, errors.SDKError) { + ret := _m.Called(d, token) + + if len(ret) == 0 { + panic("no return value specified for UpdateDomain") + } + + var r0 sdk.Domain + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.Domain, string) (sdk.Domain, errors.SDKError)); ok { + return rf(d, token) + } + if rf, ok := ret.Get(0).(func(sdk.Domain, string) sdk.Domain); ok { + r0 = rf(d, token) + } else { + r0 = ret.Get(0).(sdk.Domain) + } + + if rf, ok := ret.Get(1).(func(sdk.Domain, string) errors.SDKError); ok { + r1 = rf(d, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// UpdateGroup provides a mock function with given fields: group, domainID, token +func (_m *SDK) UpdateGroup(group sdk.Group, domainID string, token string) (sdk.Group, errors.SDKError) { + ret := _m.Called(group, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for UpdateGroup") + } + + var r0 sdk.Group + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.Group, string, string) (sdk.Group, errors.SDKError)); ok { + return rf(group, domainID, token) + } + if rf, ok := ret.Get(0).(func(sdk.Group, string, string) sdk.Group); ok { + r0 = rf(group, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Group) + } + + if rf, ok := ret.Get(1).(func(sdk.Group, string, string) errors.SDKError); ok { + r1 = rf(group, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// UpdatePassword provides a mock function with given fields: oldPass, newPass, token +func (_m *SDK) UpdatePassword(oldPass string, newPass string, token string) (sdk.User, errors.SDKError) { + ret := _m.Called(oldPass, newPass, token) + + if len(ret) == 0 { + panic("no return value specified for UpdatePassword") + } + + var r0 sdk.User + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) (sdk.User, errors.SDKError)); ok { + return rf(oldPass, newPass, token) + } + if rf, ok := ret.Get(0).(func(string, string, string) sdk.User); ok { + r0 = rf(oldPass, newPass, token) + } else { + r0 = ret.Get(0).(sdk.User) + } + + if rf, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok { + r1 = rf(oldPass, newPass, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// UpdateProfilePicture provides a mock function with given fields: user, token +func (_m *SDK) UpdateProfilePicture(user sdk.User, token string) (sdk.User, errors.SDKError) { + ret := _m.Called(user, token) + + if len(ret) == 0 { + panic("no return value specified for UpdateProfilePicture") + } + + var r0 sdk.User + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.User, string) (sdk.User, errors.SDKError)); ok { + return rf(user, token) + } + if rf, ok := ret.Get(0).(func(sdk.User, string) sdk.User); ok { + r0 = rf(user, token) + } else { + r0 = ret.Get(0).(sdk.User) + } + + if rf, ok := ret.Get(1).(func(sdk.User, string) errors.SDKError); ok { + r1 = rf(user, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// UpdateUser provides a mock function with given fields: user, token +func (_m *SDK) UpdateUser(user sdk.User, token string) (sdk.User, errors.SDKError) { + ret := _m.Called(user, token) + + if len(ret) == 0 { + panic("no return value specified for UpdateUser") + } + + var r0 sdk.User + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.User, string) (sdk.User, errors.SDKError)); ok { + return rf(user, token) + } + if rf, ok := ret.Get(0).(func(sdk.User, string) sdk.User); ok { + r0 = rf(user, token) + } else { + r0 = ret.Get(0).(sdk.User) + } + + if rf, ok := ret.Get(1).(func(sdk.User, string) errors.SDKError); ok { + r1 = rf(user, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// UpdateUserEmail provides a mock function with given fields: user, token +func (_m *SDK) UpdateUserEmail(user sdk.User, token string) (sdk.User, errors.SDKError) { + ret := _m.Called(user, token) + + if len(ret) == 0 { + panic("no return value specified for UpdateUserEmail") + } + + var r0 sdk.User + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.User, string) (sdk.User, errors.SDKError)); ok { + return rf(user, token) + } + if rf, ok := ret.Get(0).(func(sdk.User, string) sdk.User); ok { + r0 = rf(user, token) + } else { + r0 = ret.Get(0).(sdk.User) + } + + if rf, ok := ret.Get(1).(func(sdk.User, string) errors.SDKError); ok { + r1 = rf(user, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// UpdateUserRole provides a mock function with given fields: user, token +func (_m *SDK) UpdateUserRole(user sdk.User, token string) (sdk.User, errors.SDKError) { + ret := _m.Called(user, token) + + if len(ret) == 0 { + panic("no return value specified for UpdateUserRole") + } + + var r0 sdk.User + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.User, string) (sdk.User, errors.SDKError)); ok { + return rf(user, token) + } + if rf, ok := ret.Get(0).(func(sdk.User, string) sdk.User); ok { + r0 = rf(user, token) + } else { + r0 = ret.Get(0).(sdk.User) + } + + if rf, ok := ret.Get(1).(func(sdk.User, string) errors.SDKError); ok { + r1 = rf(user, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// UpdateUserTags provides a mock function with given fields: user, token +func (_m *SDK) UpdateUserTags(user sdk.User, token string) (sdk.User, errors.SDKError) { + ret := _m.Called(user, token) + + if len(ret) == 0 { + panic("no return value specified for UpdateUserTags") + } + + var r0 sdk.User + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.User, string) (sdk.User, errors.SDKError)); ok { + return rf(user, token) + } + if rf, ok := ret.Get(0).(func(sdk.User, string) sdk.User); ok { + r0 = rf(user, token) + } else { + r0 = ret.Get(0).(sdk.User) + } + + if rf, ok := ret.Get(1).(func(sdk.User, string) errors.SDKError); ok { + r1 = rf(user, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// UpdateUsername provides a mock function with given fields: user, token +func (_m *SDK) UpdateUsername(user sdk.User, token string) (sdk.User, errors.SDKError) { + ret := _m.Called(user, token) + + if len(ret) == 0 { + panic("no return value specified for UpdateUsername") + } + + var r0 sdk.User + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.User, string) (sdk.User, errors.SDKError)); ok { + return rf(user, token) + } + if rf, ok := ret.Get(0).(func(sdk.User, string) sdk.User); ok { + r0 = rf(user, token) + } else { + r0 = ret.Get(0).(sdk.User) + } + + if rf, ok := ret.Get(1).(func(sdk.User, string) errors.SDKError); ok { + r1 = rf(user, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// User provides a mock function with given fields: id, token +func (_m *SDK) User(id string, token string) (sdk.User, errors.SDKError) { + ret := _m.Called(id, token) + + if len(ret) == 0 { + panic("no return value specified for User") + } + + var r0 sdk.User + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string) (sdk.User, errors.SDKError)); ok { + return rf(id, token) + } + if rf, ok := ret.Get(0).(func(string, string) sdk.User); ok { + r0 = rf(id, token) + } else { + r0 = ret.Get(0).(sdk.User) + } + + if rf, ok := ret.Get(1).(func(string, string) errors.SDKError); ok { + r1 = rf(id, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// UserProfile provides a mock function with given fields: token +func (_m *SDK) UserProfile(token string) (sdk.User, errors.SDKError) { + ret := _m.Called(token) + + if len(ret) == 0 { + panic("no return value specified for UserProfile") + } + + var r0 sdk.User + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string) (sdk.User, errors.SDKError)); ok { + return rf(token) + } + if rf, ok := ret.Get(0).(func(string) sdk.User); ok { + r0 = rf(token) + } else { + r0 = ret.Get(0).(sdk.User) + } + + if rf, ok := ret.Get(1).(func(string) errors.SDKError); ok { + r1 = rf(token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// Users provides a mock function with given fields: pm, token +func (_m *SDK) Users(pm sdk.PageMetadata, token string) (sdk.UsersPage, errors.SDKError) { + ret := _m.Called(pm, token) + + if len(ret) == 0 { + panic("no return value specified for Users") + } + + var r0 sdk.UsersPage + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) (sdk.UsersPage, errors.SDKError)); ok { + return rf(pm, token) + } + if rf, ok := ret.Get(0).(func(sdk.PageMetadata, string) sdk.UsersPage); ok { + r0 = rf(pm, token) + } else { + r0 = ret.Get(0).(sdk.UsersPage) + } + + if rf, ok := ret.Get(1).(func(sdk.PageMetadata, string) errors.SDKError); ok { + r1 = rf(pm, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// ViewBootstrap provides a mock function with given fields: id, domainID, token +func (_m *SDK) ViewBootstrap(id string, domainID string, token string) (sdk.BootstrapConfig, errors.SDKError) { + ret := _m.Called(id, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for ViewBootstrap") + } + + var r0 sdk.BootstrapConfig + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) (sdk.BootstrapConfig, errors.SDKError)); ok { + return rf(id, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string, string) sdk.BootstrapConfig); ok { + r0 = rf(id, domainID, token) + } else { + r0 = ret.Get(0).(sdk.BootstrapConfig) + } + + if rf, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok { + r1 = rf(id, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// ViewCert provides a mock function with given fields: certID, domainID, token +func (_m *SDK) ViewCert(certID string, domainID string, token string) (sdk.Cert, errors.SDKError) { + ret := _m.Called(certID, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for ViewCert") + } + + var r0 sdk.Cert + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) (sdk.Cert, errors.SDKError)); ok { + return rf(certID, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string, string) sdk.Cert); ok { + r0 = rf(certID, domainID, token) + } else { + r0 = ret.Get(0).(sdk.Cert) + } + + if rf, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok { + r1 = rf(certID, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// ViewCertByClient provides a mock function with given fields: clientID, domainID, token +func (_m *SDK) ViewCertByClient(clientID string, domainID string, token string) (sdk.CertSerials, errors.SDKError) { + ret := _m.Called(clientID, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for ViewCertByClient") + } + + var r0 sdk.CertSerials + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string, string) (sdk.CertSerials, errors.SDKError)); ok { + return rf(clientID, domainID, token) + } + if rf, ok := ret.Get(0).(func(string, string, string) sdk.CertSerials); ok { + r0 = rf(clientID, domainID, token) + } else { + r0 = ret.Get(0).(sdk.CertSerials) + } + + if rf, ok := ret.Get(1).(func(string, string, string) errors.SDKError); ok { + r1 = rf(clientID, domainID, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// ViewSubscription provides a mock function with given fields: id, token +func (_m *SDK) ViewSubscription(id string, token string) (sdk.Subscription, errors.SDKError) { + ret := _m.Called(id, token) + + if len(ret) == 0 { + panic("no return value specified for ViewSubscription") + } + + var r0 sdk.Subscription + var r1 errors.SDKError + if rf, ok := ret.Get(0).(func(string, string) (sdk.Subscription, errors.SDKError)); ok { + return rf(id, token) + } + if rf, ok := ret.Get(0).(func(string, string) sdk.Subscription); ok { + r0 = rf(id, token) + } else { + r0 = ret.Get(0).(sdk.Subscription) + } + + if rf, ok := ret.Get(1).(func(string, string) errors.SDKError); ok { + r1 = rf(id, token) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(errors.SDKError) + } + } + + return r0, r1 +} + +// Whitelist provides a mock function with given fields: clientID, state, domainID, token +func (_m *SDK) Whitelist(clientID string, state int, domainID string, token string) errors.SDKError { + ret := _m.Called(clientID, state, domainID, token) + + if len(ret) == 0 { + panic("no return value specified for Whitelist") + } + + var r0 errors.SDKError + if rf, ok := ret.Get(0).(func(string, int, string, string) errors.SDKError); ok { + r0 = rf(clientID, state, domainID, token) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(errors.SDKError) + } + } + + return r0 +} + +// NewSDK creates a new instance of SDK. 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 NewSDK(t interface { + mock.TestingT + Cleanup(func()) +}) *SDK { + mock := &SDK{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/pkg/roles/mocks/rolesRepo.go b/pkg/roles/mocks/rolesRepo.go index e6927a3f02..995c629f20 100644 --- a/pkg/roles/mocks/rolesRepo.go +++ b/pkg/roles/mocks/rolesRepo.go @@ -46,9 +46,9 @@ func (_m *Repository) AddRoles(ctx context.Context, rps []roles.RoleProvision) ( return r0, r1 } -// RemoveMemberFromAllRoles provides a mock function with given fields: ctx, members -func (_m *Repository) RemoveMemberFromAllRoles(ctx context.Context, members string) error { - ret := _m.Called(ctx, members) +// RemoveMemberFromAllRoles provides a mock function with given fields: ctx, memberID +func (_m *Repository) RemoveMemberFromAllRoles(ctx context.Context, memberID string) error { + ret := _m.Called(ctx, memberID) if len(ret) == 0 { panic("no return value specified for RemoveMemberFromAllRoles") @@ -56,7 +56,7 @@ func (_m *Repository) RemoveMemberFromAllRoles(ctx context.Context, members stri var r0 error if rf, ok := ret.Get(0).(func(context.Context, string) error); ok { - r0 = rf(ctx, members) + r0 = rf(ctx, memberID) } else { r0 = ret.Error(0) } diff --git a/pkg/sdk/README.md b/pkg/sdk/README.md index 93e635b7a3..1c01ac8d7f 100644 --- a/pkg/sdk/README.md +++ b/pkg/sdk/README.md @@ -1,5 +1,86 @@ -# SuperMQ SDK kits +# SuperMQ Go SDK -This directory contains drivers for SuperMQ HTTP API. Drivers facilitate system administration - CRUD operations on clients, channels and their connections, i.e. provision of SuperMQ entities. They can be used also for messaging. +Go SDK, a Go driver for SuperMQ HTTP API. -Drivers are written in different languages in order to enable the faster application development in the respective language. +Does both system administration (provisioning) and messaging. + +## Installation + +Import `"github.com/absmach/supermq/sdk"` in your Go package. + +```go +import "github.com/absmach/supermq/pkg/sdk" +``` + +You can check [SuperMQ CLI](https://github.com/absmach/supermq/tree/main/cli) as an example of SDK usage. + +Then call SDK Go functions to interact with the system. + +## API Reference + +```go +FUNCTIONS + +func NewMgxSDK(host, port string, tls bool) *MgxSDK + +func (sdk *MgxSDK) Channel(id, token string) (clients.Channel, error) + Channel - gets channel by ID + +func (sdk *MgxSDK) Channels(token string) ([]clients.Channel, error) + Channels - gets all channels + +func (sdk *MgxSDK) Connect(struct{[]string, []string}, token string) error + Connect - connect clients to channels + +func (sdk *MgxSDK) CreateChannel(data, token string) (string, error) + CreateChannel - creates new channel and generates UUID + +func (sdk *MgxSDK) CreateClient(data, token string) (string, error) + CreateClient - creates new client and generates client UUID + +func (sdk *MgxSDK) CreateToken(user, pwd string) (string, error) + CreateToken - create user token + +func (sdk *MgxSDK) CreateUser(user, pwd string) error + CreateUser - create user + +func (sdk *MgxSDK) User(pwd string) (user, error) + User - gets user + +func (sdk *MgxSDK) UpdateUser(user, pwd string) error + UpdateUser - update user + +func (sdk *MgxSDK) UpdatePassword(user, pwd string) error + UpdatePassword - update user password + +func (sdk *MgxSDK) DeleteChannel(id, token string) error + DeleteChannel - removes channel + +func (sdk *MgxSDK) DeleteClient(id, token string) error + DeleteClient - removes client + +func (sdk *MgxSDK) DisconnectClient(clientID, chanID, token string) error + DisconnectClient - connect client to a channel + +func (sdk *MgxSDK) SendMessage(chanID, msg, token string) error + SendMessage - send message on SuperMQ channel + +func (sdk *MgxSDK) SetContentType(ct ContentType) error + SetContentType - set message content type. Available options are SenML + JSON, custom JSON and custom binary (octet-stream). + +func (sdk *MgxSDK) Client(id, token string) (Client, error) + Client - gets client by ID + +func (sdk *MgxSDK) Clients(token string) ([]Client, error) + Clients - gets all clients + +func (sdk *MgxSDK) UpdateChannel(channel Channel, token string) error + UpdateChannel - update a channel + +func (sdk *MgxSDK) UpdateClient(client Client, token string) error + UpdateClient - updates client by ID + +func (sdk *MgxSDK) Health() (supermq.Health, error) + Health - clients service health check +``` diff --git a/pkg/sdk/go/bootstrap.go b/pkg/sdk/bootstrap.go similarity index 100% rename from pkg/sdk/go/bootstrap.go rename to pkg/sdk/bootstrap.go diff --git a/pkg/sdk/go/bootstrap_test.go b/pkg/sdk/bootstrap_test.go similarity index 99% rename from pkg/sdk/go/bootstrap_test.go rename to pkg/sdk/bootstrap_test.go index 37591f989f..815bf48f94 100644 --- a/pkg/sdk/go/bootstrap_test.go +++ b/pkg/sdk/bootstrap_test.go @@ -24,7 +24,7 @@ import ( authnmocks "github.com/absmach/supermq/pkg/authn/mocks" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" ) diff --git a/pkg/sdk/go/certs.go b/pkg/sdk/certs.go similarity index 100% rename from pkg/sdk/go/certs.go rename to pkg/sdk/certs.go diff --git a/pkg/sdk/go/certs_test.go b/pkg/sdk/certs_test.go similarity index 99% rename from pkg/sdk/go/certs_test.go rename to pkg/sdk/certs_test.go index c4df78ee7f..71e5915844 100644 --- a/pkg/sdk/go/certs_test.go +++ b/pkg/sdk/certs_test.go @@ -21,7 +21,7 @@ import ( "github.com/absmach/supermq/pkg/errors" repoerr "github.com/absmach/supermq/pkg/errors/repository" svcerr "github.com/absmach/supermq/pkg/errors/service" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" ) diff --git a/pkg/sdk/go/channels.go b/pkg/sdk/channels.go similarity index 100% rename from pkg/sdk/go/channels.go rename to pkg/sdk/channels.go diff --git a/pkg/sdk/go/channels_test.go b/pkg/sdk/channels_test.go similarity index 99% rename from pkg/sdk/go/channels_test.go rename to pkg/sdk/channels_test.go index 9f3a1e494b..c3c21d91d6 100644 --- a/pkg/sdk/go/channels_test.go +++ b/pkg/sdk/channels_test.go @@ -23,7 +23,7 @@ import ( "github.com/absmach/supermq/pkg/connections" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" "github.com/go-chi/chi/v5" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" diff --git a/pkg/sdk/go/clients.go b/pkg/sdk/clients.go similarity index 100% rename from pkg/sdk/go/clients.go rename to pkg/sdk/clients.go diff --git a/pkg/sdk/go/clients_test.go b/pkg/sdk/clients_test.go similarity index 99% rename from pkg/sdk/go/clients_test.go rename to pkg/sdk/clients_test.go index 85c1619932..34edee522e 100644 --- a/pkg/sdk/go/clients_test.go +++ b/pkg/sdk/clients_test.go @@ -21,7 +21,7 @@ import ( authnmocks "github.com/absmach/supermq/pkg/authn/mocks" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" "github.com/go-chi/chi/v5" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" diff --git a/pkg/sdk/go/consumers.go b/pkg/sdk/consumers.go similarity index 100% rename from pkg/sdk/go/consumers.go rename to pkg/sdk/consumers.go diff --git a/pkg/sdk/go/consumers_test.go b/pkg/sdk/consumers_test.go similarity index 99% rename from pkg/sdk/go/consumers_test.go rename to pkg/sdk/consumers_test.go index 0f477ac577..ae38227808 100644 --- a/pkg/sdk/go/consumers_test.go +++ b/pkg/sdk/consumers_test.go @@ -17,7 +17,7 @@ import ( "github.com/absmach/supermq/pkg/apiutil" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" ) diff --git a/pkg/sdk/go/doc.go b/pkg/sdk/doc.go similarity index 100% rename from pkg/sdk/go/doc.go rename to pkg/sdk/doc.go diff --git a/pkg/sdk/go/domains.go b/pkg/sdk/domains.go similarity index 100% rename from pkg/sdk/go/domains.go rename to pkg/sdk/domains.go diff --git a/pkg/sdk/go/domains_test.go b/pkg/sdk/domains_test.go similarity index 99% rename from pkg/sdk/go/domains_test.go rename to pkg/sdk/domains_test.go index 36a8506f7a..fbaf0ec4e4 100644 --- a/pkg/sdk/go/domains_test.go +++ b/pkg/sdk/domains_test.go @@ -21,7 +21,7 @@ import ( authnmocks "github.com/absmach/supermq/pkg/authn/mocks" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" "github.com/go-chi/chi/v5" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" diff --git a/pkg/sdk/go/README.md b/pkg/sdk/go/README.md deleted file mode 100644 index d6c06e91c9..0000000000 --- a/pkg/sdk/go/README.md +++ /dev/null @@ -1,84 +0,0 @@ -# SuperMQ Go SDK - -Go SDK, a Go driver for SuperMQ HTTP API. - -Does both system administration (provisioning) and messaging. - -## Installation - -Import `"github.com/absmach/supermq/sdk/go"` in your Go package. - -```go -import "github.com/absmach/supermq/pkg/sdk/go" -``` - -Then call SDK Go functions to interact with the system. - -## API Reference - -```go -FUNCTIONS - -func NewMgxSDK(host, port string, tls bool) *MgxSDK - -func (sdk *MgxSDK) Channel(id, token string) (clients.Channel, error) - Channel - gets channel by ID - -func (sdk *MgxSDK) Channels(token string) ([]clients.Channel, error) - Channels - gets all channels - -func (sdk *MgxSDK) Connect(struct{[]string, []string}, token string) error - Connect - connect clients to channels - -func (sdk *MgxSDK) CreateChannel(data, token string) (string, error) - CreateChannel - creates new channel and generates UUID - -func (sdk *MgxSDK) CreateClient(data, token string) (string, error) - CreateClient - creates new client and generates client UUID - -func (sdk *MgxSDK) CreateToken(user, pwd string) (string, error) - CreateToken - create user token - -func (sdk *MgxSDK) CreateUser(user, pwd string) error - CreateUser - create user - -func (sdk *MgxSDK) User(pwd string) (user, error) - User - gets user - -func (sdk *MgxSDK) UpdateUser(user, pwd string) error - UpdateUser - update user - -func (sdk *MgxSDK) UpdatePassword(user, pwd string) error - UpdatePassword - update user password - -func (sdk *MgxSDK) DeleteChannel(id, token string) error - DeleteChannel - removes channel - -func (sdk *MgxSDK) DeleteClient(id, token string) error - DeleteClient - removes client - -func (sdk *MgxSDK) DisconnectClient(clientID, chanID, token string) error - DisconnectClient - connect client to a channel - -func (sdk *MgxSDK) SendMessage(chanID, msg, token string) error - SendMessage - send message on SuperMQ channel - -func (sdk *MgxSDK) SetContentType(ct ContentType) error - SetContentType - set message content type. Available options are SenML - JSON, custom JSON and custom binary (octet-stream). - -func (sdk *MgxSDK) Client(id, token string) (Client, error) - Client - gets client by ID - -func (sdk *MgxSDK) Clients(token string) ([]Client, error) - Clients - gets all clients - -func (sdk *MgxSDK) UpdateChannel(channel Channel, token string) error - UpdateChannel - update a channel - -func (sdk *MgxSDK) UpdateClient(client Client, token string) error - UpdateClient - updates client by ID - -func (sdk *MgxSDK) Health() (supermq.Health, error) - Health - clients service health check -``` diff --git a/pkg/sdk/go/groups.go b/pkg/sdk/groups.go similarity index 100% rename from pkg/sdk/go/groups.go rename to pkg/sdk/groups.go diff --git a/pkg/sdk/go/groups_test.go b/pkg/sdk/groups_test.go similarity index 99% rename from pkg/sdk/go/groups_test.go rename to pkg/sdk/groups_test.go index 33fc2e9a83..236a2ef984 100644 --- a/pkg/sdk/go/groups_test.go +++ b/pkg/sdk/groups_test.go @@ -22,7 +22,7 @@ import ( "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" oauth2mocks "github.com/absmach/supermq/pkg/oauth2/mocks" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" "github.com/go-chi/chi/v5" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" diff --git a/pkg/sdk/go/health.go b/pkg/sdk/health.go similarity index 100% rename from pkg/sdk/go/health.go rename to pkg/sdk/health.go diff --git a/pkg/sdk/go/health_test.go b/pkg/sdk/health_test.go similarity index 98% rename from pkg/sdk/go/health_test.go rename to pkg/sdk/health_test.go index 15e9c33279..25087bc548 100644 --- a/pkg/sdk/go/health_test.go +++ b/pkg/sdk/health_test.go @@ -16,7 +16,7 @@ import ( smqlog "github.com/absmach/supermq/logger" authnmocks "github.com/absmach/supermq/pkg/authn/mocks" "github.com/absmach/supermq/pkg/errors" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" readersapi "github.com/absmach/supermq/readers/api" readersmocks "github.com/absmach/supermq/readers/mocks" "github.com/stretchr/testify/assert" diff --git a/pkg/sdk/go/invitations.go b/pkg/sdk/invitations.go similarity index 100% rename from pkg/sdk/go/invitations.go rename to pkg/sdk/invitations.go diff --git a/pkg/sdk/go/invitations_test.go b/pkg/sdk/invitations_test.go similarity index 99% rename from pkg/sdk/go/invitations_test.go rename to pkg/sdk/invitations_test.go index e25ee10172..11cac6283d 100644 --- a/pkg/sdk/go/invitations_test.go +++ b/pkg/sdk/invitations_test.go @@ -21,7 +21,7 @@ import ( "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" policies "github.com/absmach/supermq/pkg/policies" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" ) diff --git a/pkg/sdk/go/journal.go b/pkg/sdk/journal.go similarity index 100% rename from pkg/sdk/go/journal.go rename to pkg/sdk/journal.go diff --git a/pkg/sdk/go/journal_test.go b/pkg/sdk/journal_test.go similarity index 99% rename from pkg/sdk/go/journal_test.go rename to pkg/sdk/journal_test.go index 012ae6d768..1342bdf9d1 100644 --- a/pkg/sdk/go/journal_test.go +++ b/pkg/sdk/journal_test.go @@ -19,7 +19,7 @@ import ( authnmocks "github.com/absmach/supermq/pkg/authn/mocks" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" ) diff --git a/pkg/sdk/go/message.go b/pkg/sdk/message.go similarity index 100% rename from pkg/sdk/go/message.go rename to pkg/sdk/message.go diff --git a/pkg/sdk/go/message_test.go b/pkg/sdk/message_test.go similarity index 99% rename from pkg/sdk/go/message_test.go rename to pkg/sdk/message_test.go index bdd04e6c70..2faabe6159 100644 --- a/pkg/sdk/go/message_test.go +++ b/pkg/sdk/message_test.go @@ -24,7 +24,7 @@ import ( "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" pubsub "github.com/absmach/supermq/pkg/messaging/mocks" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" "github.com/absmach/supermq/pkg/transformers/senml" "github.com/absmach/supermq/readers" readersapi "github.com/absmach/supermq/readers/api" diff --git a/pkg/sdk/go/metadata.go b/pkg/sdk/metadata.go similarity index 100% rename from pkg/sdk/go/metadata.go rename to pkg/sdk/metadata.go diff --git a/pkg/sdk/mocks/sdk.go b/pkg/sdk/mocks/sdk.go index 9b3f5258d2..0dd00ab818 100644 --- a/pkg/sdk/mocks/sdk.go +++ b/pkg/sdk/mocks/sdk.go @@ -1,14 +1,16 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. - // Copyright (c) Abstract Machines +// SPDX-License-Identifier: Apache-2.0 + +// Code generated by mockery v2.43.2. DO NOT EDIT. + package mocks import ( errors "github.com/absmach/supermq/pkg/errors" mock "github.com/stretchr/testify/mock" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" time "time" ) @@ -18,6 +20,14 @@ type SDK struct { mock.Mock } +type SDK_Expecter struct { + mock *mock.Mock +} + +func (_m *SDK) EXPECT() *SDK_Expecter { + return &SDK_Expecter{mock: &_m.Mock} +} + // AcceptInvitation provides a mock function with given fields: domainID, token func (_m *SDK) AcceptInvitation(domainID string, token string) error { ret := _m.Called(domainID, token) @@ -36,6 +46,35 @@ func (_m *SDK) AcceptInvitation(domainID string, token string) error { return r0 } +// SDK_AcceptInvitation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AcceptInvitation' +type SDK_AcceptInvitation_Call struct { + *mock.Call +} + +// AcceptInvitation is a helper method to define mock.On call +// - domainID string +// - token string +func (_e *SDK_Expecter) AcceptInvitation(domainID interface{}, token interface{}) *SDK_AcceptInvitation_Call { + return &SDK_AcceptInvitation_Call{Call: _e.mock.On("AcceptInvitation", domainID, token)} +} + +func (_c *SDK_AcceptInvitation_Call) Run(run func(domainID string, token string)) *SDK_AcceptInvitation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_AcceptInvitation_Call) Return(err error) *SDK_AcceptInvitation_Call { + _c.Call.Return(err) + return _c +} + +func (_c *SDK_AcceptInvitation_Call) RunAndReturn(run func(string, string) error) *SDK_AcceptInvitation_Call { + _c.Call.Return(run) + return _c +} + // AddBootstrap provides a mock function with given fields: cfg, domainID, token func (_m *SDK) AddBootstrap(cfg sdk.BootstrapConfig, domainID string, token string) (string, errors.SDKError) { ret := _m.Called(cfg, domainID, token) @@ -66,6 +105,36 @@ func (_m *SDK) AddBootstrap(cfg sdk.BootstrapConfig, domainID string, token stri return r0, r1 } +// SDK_AddBootstrap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddBootstrap' +type SDK_AddBootstrap_Call struct { + *mock.Call +} + +// AddBootstrap is a helper method to define mock.On call +// - cfg sdk.BootstrapConfig +// - domainID string +// - token string +func (_e *SDK_Expecter) AddBootstrap(cfg interface{}, domainID interface{}, token interface{}) *SDK_AddBootstrap_Call { + return &SDK_AddBootstrap_Call{Call: _e.mock.On("AddBootstrap", cfg, domainID, token)} +} + +func (_c *SDK_AddBootstrap_Call) Run(run func(cfg sdk.BootstrapConfig, domainID string, token string)) *SDK_AddBootstrap_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.BootstrapConfig), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_AddBootstrap_Call) Return(_a0 string, _a1 errors.SDKError) *SDK_AddBootstrap_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_AddBootstrap_Call) RunAndReturn(run func(sdk.BootstrapConfig, string, string) (string, errors.SDKError)) *SDK_AddBootstrap_Call { + _c.Call.Return(run) + return _c +} + // AddUserGroupToChannel provides a mock function with given fields: channelID, req, domainID, token func (_m *SDK) AddUserGroupToChannel(channelID string, req sdk.UserGroupsRequest, domainID string, token string) errors.SDKError { ret := _m.Called(channelID, req, domainID, token) @@ -86,6 +155,37 @@ func (_m *SDK) AddUserGroupToChannel(channelID string, req sdk.UserGroupsRequest return r0 } +// SDK_AddUserGroupToChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUserGroupToChannel' +type SDK_AddUserGroupToChannel_Call struct { + *mock.Call +} + +// AddUserGroupToChannel is a helper method to define mock.On call +// - channelID string +// - req sdk.UserGroupsRequest +// - domainID string +// - token string +func (_e *SDK_Expecter) AddUserGroupToChannel(channelID interface{}, req interface{}, domainID interface{}, token interface{}) *SDK_AddUserGroupToChannel_Call { + return &SDK_AddUserGroupToChannel_Call{Call: _e.mock.On("AddUserGroupToChannel", channelID, req, domainID, token)} +} + +func (_c *SDK_AddUserGroupToChannel_Call) Run(run func(channelID string, req sdk.UserGroupsRequest, domainID string, token string)) *SDK_AddUserGroupToChannel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.UserGroupsRequest), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_AddUserGroupToChannel_Call) Return(_a0 errors.SDKError) *SDK_AddUserGroupToChannel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_AddUserGroupToChannel_Call) RunAndReturn(run func(string, sdk.UserGroupsRequest, string, string) errors.SDKError) *SDK_AddUserGroupToChannel_Call { + _c.Call.Return(run) + return _c +} + // AddUserToChannel provides a mock function with given fields: channelID, req, domainID, token func (_m *SDK) AddUserToChannel(channelID string, req sdk.UsersRelationRequest, domainID string, token string) errors.SDKError { ret := _m.Called(channelID, req, domainID, token) @@ -106,6 +206,37 @@ func (_m *SDK) AddUserToChannel(channelID string, req sdk.UsersRelationRequest, return r0 } +// SDK_AddUserToChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUserToChannel' +type SDK_AddUserToChannel_Call struct { + *mock.Call +} + +// AddUserToChannel is a helper method to define mock.On call +// - channelID string +// - req sdk.UsersRelationRequest +// - domainID string +// - token string +func (_e *SDK_Expecter) AddUserToChannel(channelID interface{}, req interface{}, domainID interface{}, token interface{}) *SDK_AddUserToChannel_Call { + return &SDK_AddUserToChannel_Call{Call: _e.mock.On("AddUserToChannel", channelID, req, domainID, token)} +} + +func (_c *SDK_AddUserToChannel_Call) Run(run func(channelID string, req sdk.UsersRelationRequest, domainID string, token string)) *SDK_AddUserToChannel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.UsersRelationRequest), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_AddUserToChannel_Call) Return(_a0 errors.SDKError) *SDK_AddUserToChannel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_AddUserToChannel_Call) RunAndReturn(run func(string, sdk.UsersRelationRequest, string, string) errors.SDKError) *SDK_AddUserToChannel_Call { + _c.Call.Return(run) + return _c +} + // AddUserToDomain provides a mock function with given fields: domainID, req, token func (_m *SDK) AddUserToDomain(domainID string, req sdk.UsersRelationRequest, token string) errors.SDKError { ret := _m.Called(domainID, req, token) @@ -126,6 +257,36 @@ func (_m *SDK) AddUserToDomain(domainID string, req sdk.UsersRelationRequest, to return r0 } +// SDK_AddUserToDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUserToDomain' +type SDK_AddUserToDomain_Call struct { + *mock.Call +} + +// AddUserToDomain is a helper method to define mock.On call +// - domainID string +// - req sdk.UsersRelationRequest +// - token string +func (_e *SDK_Expecter) AddUserToDomain(domainID interface{}, req interface{}, token interface{}) *SDK_AddUserToDomain_Call { + return &SDK_AddUserToDomain_Call{Call: _e.mock.On("AddUserToDomain", domainID, req, token)} +} + +func (_c *SDK_AddUserToDomain_Call) Run(run func(domainID string, req sdk.UsersRelationRequest, token string)) *SDK_AddUserToDomain_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.UsersRelationRequest), args[2].(string)) + }) + return _c +} + +func (_c *SDK_AddUserToDomain_Call) Return(_a0 errors.SDKError) *SDK_AddUserToDomain_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_AddUserToDomain_Call) RunAndReturn(run func(string, sdk.UsersRelationRequest, string) errors.SDKError) *SDK_AddUserToDomain_Call { + _c.Call.Return(run) + return _c +} + // AddUserToGroup provides a mock function with given fields: groupID, req, domainID, token func (_m *SDK) AddUserToGroup(groupID string, req sdk.UsersRelationRequest, domainID string, token string) errors.SDKError { ret := _m.Called(groupID, req, domainID, token) @@ -146,6 +307,37 @@ func (_m *SDK) AddUserToGroup(groupID string, req sdk.UsersRelationRequest, doma return r0 } +// SDK_AddUserToGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUserToGroup' +type SDK_AddUserToGroup_Call struct { + *mock.Call +} + +// AddUserToGroup is a helper method to define mock.On call +// - groupID string +// - req sdk.UsersRelationRequest +// - domainID string +// - token string +func (_e *SDK_Expecter) AddUserToGroup(groupID interface{}, req interface{}, domainID interface{}, token interface{}) *SDK_AddUserToGroup_Call { + return &SDK_AddUserToGroup_Call{Call: _e.mock.On("AddUserToGroup", groupID, req, domainID, token)} +} + +func (_c *SDK_AddUserToGroup_Call) Run(run func(groupID string, req sdk.UsersRelationRequest, domainID string, token string)) *SDK_AddUserToGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.UsersRelationRequest), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_AddUserToGroup_Call) Return(_a0 errors.SDKError) *SDK_AddUserToGroup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_AddUserToGroup_Call) RunAndReturn(run func(string, sdk.UsersRelationRequest, string, string) errors.SDKError) *SDK_AddUserToGroup_Call { + _c.Call.Return(run) + return _c +} + // Bootstrap provides a mock function with given fields: externalID, externalKey func (_m *SDK) Bootstrap(externalID string, externalKey string) (sdk.BootstrapConfig, errors.SDKError) { ret := _m.Called(externalID, externalKey) @@ -176,6 +368,35 @@ func (_m *SDK) Bootstrap(externalID string, externalKey string) (sdk.BootstrapCo return r0, r1 } +// SDK_Bootstrap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bootstrap' +type SDK_Bootstrap_Call struct { + *mock.Call +} + +// Bootstrap is a helper method to define mock.On call +// - externalID string +// - externalKey string +func (_e *SDK_Expecter) Bootstrap(externalID interface{}, externalKey interface{}) *SDK_Bootstrap_Call { + return &SDK_Bootstrap_Call{Call: _e.mock.On("Bootstrap", externalID, externalKey)} +} + +func (_c *SDK_Bootstrap_Call) Run(run func(externalID string, externalKey string)) *SDK_Bootstrap_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_Bootstrap_Call) Return(_a0 sdk.BootstrapConfig, _a1 errors.SDKError) *SDK_Bootstrap_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Bootstrap_Call) RunAndReturn(run func(string, string) (sdk.BootstrapConfig, errors.SDKError)) *SDK_Bootstrap_Call { + _c.Call.Return(run) + return _c +} + // BootstrapSecure provides a mock function with given fields: externalID, externalKey, cryptoKey func (_m *SDK) BootstrapSecure(externalID string, externalKey string, cryptoKey string) (sdk.BootstrapConfig, errors.SDKError) { ret := _m.Called(externalID, externalKey, cryptoKey) @@ -206,6 +427,36 @@ func (_m *SDK) BootstrapSecure(externalID string, externalKey string, cryptoKey return r0, r1 } +// SDK_BootstrapSecure_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BootstrapSecure' +type SDK_BootstrapSecure_Call struct { + *mock.Call +} + +// BootstrapSecure is a helper method to define mock.On call +// - externalID string +// - externalKey string +// - cryptoKey string +func (_e *SDK_Expecter) BootstrapSecure(externalID interface{}, externalKey interface{}, cryptoKey interface{}) *SDK_BootstrapSecure_Call { + return &SDK_BootstrapSecure_Call{Call: _e.mock.On("BootstrapSecure", externalID, externalKey, cryptoKey)} +} + +func (_c *SDK_BootstrapSecure_Call) Run(run func(externalID string, externalKey string, cryptoKey string)) *SDK_BootstrapSecure_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_BootstrapSecure_Call) Return(_a0 sdk.BootstrapConfig, _a1 errors.SDKError) *SDK_BootstrapSecure_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_BootstrapSecure_Call) RunAndReturn(run func(string, string, string) (sdk.BootstrapConfig, errors.SDKError)) *SDK_BootstrapSecure_Call { + _c.Call.Return(run) + return _c +} + // Bootstraps provides a mock function with given fields: pm, domainID, token func (_m *SDK) Bootstraps(pm sdk.PageMetadata, domainID string, token string) (sdk.BootstrapPage, errors.SDKError) { ret := _m.Called(pm, domainID, token) @@ -236,6 +487,36 @@ func (_m *SDK) Bootstraps(pm sdk.PageMetadata, domainID string, token string) (s return r0, r1 } +// SDK_Bootstraps_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bootstraps' +type SDK_Bootstraps_Call struct { + *mock.Call +} + +// Bootstraps is a helper method to define mock.On call +// - pm sdk.PageMetadata +// - domainID string +// - token string +func (_e *SDK_Expecter) Bootstraps(pm interface{}, domainID interface{}, token interface{}) *SDK_Bootstraps_Call { + return &SDK_Bootstraps_Call{Call: _e.mock.On("Bootstraps", pm, domainID, token)} +} + +func (_c *SDK_Bootstraps_Call) Run(run func(pm sdk.PageMetadata, domainID string, token string)) *SDK_Bootstraps_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.PageMetadata), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Bootstraps_Call) Return(_a0 sdk.BootstrapPage, _a1 errors.SDKError) *SDK_Bootstraps_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Bootstraps_Call) RunAndReturn(run func(sdk.PageMetadata, string, string) (sdk.BootstrapPage, errors.SDKError)) *SDK_Bootstraps_Call { + _c.Call.Return(run) + return _c +} + // Channel provides a mock function with given fields: id, domainID, token func (_m *SDK) Channel(id string, domainID string, token string) (sdk.Channel, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -266,6 +547,36 @@ func (_m *SDK) Channel(id string, domainID string, token string) (sdk.Channel, e return r0, r1 } +// SDK_Channel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Channel' +type SDK_Channel_Call struct { + *mock.Call +} + +// Channel is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) Channel(id interface{}, domainID interface{}, token interface{}) *SDK_Channel_Call { + return &SDK_Channel_Call{Call: _e.mock.On("Channel", id, domainID, token)} +} + +func (_c *SDK_Channel_Call) Run(run func(id string, domainID string, token string)) *SDK_Channel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Channel_Call) Return(_a0 sdk.Channel, _a1 errors.SDKError) *SDK_Channel_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Channel_Call) RunAndReturn(run func(string, string, string) (sdk.Channel, errors.SDKError)) *SDK_Channel_Call { + _c.Call.Return(run) + return _c +} + // ChannelPermissions provides a mock function with given fields: id, domainID, token func (_m *SDK) ChannelPermissions(id string, domainID string, token string) (sdk.Channel, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -296,6 +607,36 @@ func (_m *SDK) ChannelPermissions(id string, domainID string, token string) (sdk return r0, r1 } +// SDK_ChannelPermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChannelPermissions' +type SDK_ChannelPermissions_Call struct { + *mock.Call +} + +// ChannelPermissions is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) ChannelPermissions(id interface{}, domainID interface{}, token interface{}) *SDK_ChannelPermissions_Call { + return &SDK_ChannelPermissions_Call{Call: _e.mock.On("ChannelPermissions", id, domainID, token)} +} + +func (_c *SDK_ChannelPermissions_Call) Run(run func(id string, domainID string, token string)) *SDK_ChannelPermissions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_ChannelPermissions_Call) Return(_a0 sdk.Channel, _a1 errors.SDKError) *SDK_ChannelPermissions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ChannelPermissions_Call) RunAndReturn(run func(string, string, string) (sdk.Channel, errors.SDKError)) *SDK_ChannelPermissions_Call { + _c.Call.Return(run) + return _c +} + // Channels provides a mock function with given fields: pm, domainID, token func (_m *SDK) Channels(pm sdk.PageMetadata, domainID string, token string) (sdk.ChannelsPage, errors.SDKError) { ret := _m.Called(pm, domainID, token) @@ -326,6 +667,36 @@ func (_m *SDK) Channels(pm sdk.PageMetadata, domainID string, token string) (sdk return r0, r1 } +// SDK_Channels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Channels' +type SDK_Channels_Call struct { + *mock.Call +} + +// Channels is a helper method to define mock.On call +// - pm sdk.PageMetadata +// - domainID string +// - token string +func (_e *SDK_Expecter) Channels(pm interface{}, domainID interface{}, token interface{}) *SDK_Channels_Call { + return &SDK_Channels_Call{Call: _e.mock.On("Channels", pm, domainID, token)} +} + +func (_c *SDK_Channels_Call) Run(run func(pm sdk.PageMetadata, domainID string, token string)) *SDK_Channels_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.PageMetadata), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Channels_Call) Return(_a0 sdk.ChannelsPage, _a1 errors.SDKError) *SDK_Channels_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Channels_Call) RunAndReturn(run func(sdk.PageMetadata, string, string) (sdk.ChannelsPage, errors.SDKError)) *SDK_Channels_Call { + _c.Call.Return(run) + return _c +} + // ChannelsByClient provides a mock function with given fields: clientID, pm, domainID, token func (_m *SDK) ChannelsByClient(clientID string, pm sdk.PageMetadata, domainID string, token string) (sdk.ChannelsPage, errors.SDKError) { ret := _m.Called(clientID, pm, domainID, token) @@ -356,6 +727,37 @@ func (_m *SDK) ChannelsByClient(clientID string, pm sdk.PageMetadata, domainID s return r0, r1 } +// SDK_ChannelsByClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChannelsByClient' +type SDK_ChannelsByClient_Call struct { + *mock.Call +} + +// ChannelsByClient is a helper method to define mock.On call +// - clientID string +// - pm sdk.PageMetadata +// - domainID string +// - token string +func (_e *SDK_Expecter) ChannelsByClient(clientID interface{}, pm interface{}, domainID interface{}, token interface{}) *SDK_ChannelsByClient_Call { + return &SDK_ChannelsByClient_Call{Call: _e.mock.On("ChannelsByClient", clientID, pm, domainID, token)} +} + +func (_c *SDK_ChannelsByClient_Call) Run(run func(clientID string, pm sdk.PageMetadata, domainID string, token string)) *SDK_ChannelsByClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.PageMetadata), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_ChannelsByClient_Call) Return(_a0 sdk.ChannelsPage, _a1 errors.SDKError) *SDK_ChannelsByClient_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ChannelsByClient_Call) RunAndReturn(run func(string, sdk.PageMetadata, string, string) (sdk.ChannelsPage, errors.SDKError)) *SDK_ChannelsByClient_Call { + _c.Call.Return(run) + return _c +} + // Children provides a mock function with given fields: id, pm, domainID, token func (_m *SDK) Children(id string, pm sdk.PageMetadata, domainID string, token string) (sdk.GroupsPage, errors.SDKError) { ret := _m.Called(id, pm, domainID, token) @@ -386,6 +788,37 @@ func (_m *SDK) Children(id string, pm sdk.PageMetadata, domainID string, token s return r0, r1 } +// SDK_Children_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Children' +type SDK_Children_Call struct { + *mock.Call +} + +// Children is a helper method to define mock.On call +// - id string +// - pm sdk.PageMetadata +// - domainID string +// - token string +func (_e *SDK_Expecter) Children(id interface{}, pm interface{}, domainID interface{}, token interface{}) *SDK_Children_Call { + return &SDK_Children_Call{Call: _e.mock.On("Children", id, pm, domainID, token)} +} + +func (_c *SDK_Children_Call) Run(run func(id string, pm sdk.PageMetadata, domainID string, token string)) *SDK_Children_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.PageMetadata), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_Children_Call) Return(_a0 sdk.GroupsPage, _a1 errors.SDKError) *SDK_Children_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Children_Call) RunAndReturn(run func(string, sdk.PageMetadata, string, string) (sdk.GroupsPage, errors.SDKError)) *SDK_Children_Call { + _c.Call.Return(run) + return _c +} + // Client provides a mock function with given fields: id, domainID, token func (_m *SDK) Client(id string, domainID string, token string) (sdk.Client, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -416,6 +849,36 @@ func (_m *SDK) Client(id string, domainID string, token string) (sdk.Client, err return r0, r1 } +// SDK_Client_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Client' +type SDK_Client_Call struct { + *mock.Call +} + +// Client is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) Client(id interface{}, domainID interface{}, token interface{}) *SDK_Client_Call { + return &SDK_Client_Call{Call: _e.mock.On("Client", id, domainID, token)} +} + +func (_c *SDK_Client_Call) Run(run func(id string, domainID string, token string)) *SDK_Client_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Client_Call) Return(_a0 sdk.Client, _a1 errors.SDKError) *SDK_Client_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Client_Call) RunAndReturn(run func(string, string, string) (sdk.Client, errors.SDKError)) *SDK_Client_Call { + _c.Call.Return(run) + return _c +} + // ClientPermissions provides a mock function with given fields: id, domainID, token func (_m *SDK) ClientPermissions(id string, domainID string, token string) (sdk.Client, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -446,6 +909,36 @@ func (_m *SDK) ClientPermissions(id string, domainID string, token string) (sdk. return r0, r1 } +// SDK_ClientPermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientPermissions' +type SDK_ClientPermissions_Call struct { + *mock.Call +} + +// ClientPermissions is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) ClientPermissions(id interface{}, domainID interface{}, token interface{}) *SDK_ClientPermissions_Call { + return &SDK_ClientPermissions_Call{Call: _e.mock.On("ClientPermissions", id, domainID, token)} +} + +func (_c *SDK_ClientPermissions_Call) Run(run func(id string, domainID string, token string)) *SDK_ClientPermissions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_ClientPermissions_Call) Return(_a0 sdk.Client, _a1 errors.SDKError) *SDK_ClientPermissions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ClientPermissions_Call) RunAndReturn(run func(string, string, string) (sdk.Client, errors.SDKError)) *SDK_ClientPermissions_Call { + _c.Call.Return(run) + return _c +} + // Clients provides a mock function with given fields: pm, domainID, token func (_m *SDK) Clients(pm sdk.PageMetadata, domainID string, token string) (sdk.ClientsPage, errors.SDKError) { ret := _m.Called(pm, domainID, token) @@ -476,6 +969,36 @@ func (_m *SDK) Clients(pm sdk.PageMetadata, domainID string, token string) (sdk. return r0, r1 } +// SDK_Clients_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Clients' +type SDK_Clients_Call struct { + *mock.Call +} + +// Clients is a helper method to define mock.On call +// - pm sdk.PageMetadata +// - domainID string +// - token string +func (_e *SDK_Expecter) Clients(pm interface{}, domainID interface{}, token interface{}) *SDK_Clients_Call { + return &SDK_Clients_Call{Call: _e.mock.On("Clients", pm, domainID, token)} +} + +func (_c *SDK_Clients_Call) Run(run func(pm sdk.PageMetadata, domainID string, token string)) *SDK_Clients_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.PageMetadata), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Clients_Call) Return(_a0 sdk.ClientsPage, _a1 errors.SDKError) *SDK_Clients_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Clients_Call) RunAndReturn(run func(sdk.PageMetadata, string, string) (sdk.ClientsPage, errors.SDKError)) *SDK_Clients_Call { + _c.Call.Return(run) + return _c +} + // ClientsByChannel provides a mock function with given fields: chanID, pm, domainID, token func (_m *SDK) ClientsByChannel(chanID string, pm sdk.PageMetadata, domainID string, token string) (sdk.ClientsPage, errors.SDKError) { ret := _m.Called(chanID, pm, domainID, token) @@ -506,6 +1029,37 @@ func (_m *SDK) ClientsByChannel(chanID string, pm sdk.PageMetadata, domainID str return r0, r1 } +// SDK_ClientsByChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientsByChannel' +type SDK_ClientsByChannel_Call struct { + *mock.Call +} + +// ClientsByChannel is a helper method to define mock.On call +// - chanID string +// - pm sdk.PageMetadata +// - domainID string +// - token string +func (_e *SDK_Expecter) ClientsByChannel(chanID interface{}, pm interface{}, domainID interface{}, token interface{}) *SDK_ClientsByChannel_Call { + return &SDK_ClientsByChannel_Call{Call: _e.mock.On("ClientsByChannel", chanID, pm, domainID, token)} +} + +func (_c *SDK_ClientsByChannel_Call) Run(run func(chanID string, pm sdk.PageMetadata, domainID string, token string)) *SDK_ClientsByChannel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.PageMetadata), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_ClientsByChannel_Call) Return(_a0 sdk.ClientsPage, _a1 errors.SDKError) *SDK_ClientsByChannel_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ClientsByChannel_Call) RunAndReturn(run func(string, sdk.PageMetadata, string, string) (sdk.ClientsPage, errors.SDKError)) *SDK_ClientsByChannel_Call { + _c.Call.Return(run) + return _c +} + // Connect provides a mock function with given fields: conns, domainID, token func (_m *SDK) Connect(conns sdk.Connection, domainID string, token string) errors.SDKError { ret := _m.Called(conns, domainID, token) @@ -526,6 +1080,36 @@ func (_m *SDK) Connect(conns sdk.Connection, domainID string, token string) erro return r0 } +// SDK_Connect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Connect' +type SDK_Connect_Call struct { + *mock.Call +} + +// Connect is a helper method to define mock.On call +// - conns sdk.Connection +// - domainID string +// - token string +func (_e *SDK_Expecter) Connect(conns interface{}, domainID interface{}, token interface{}) *SDK_Connect_Call { + return &SDK_Connect_Call{Call: _e.mock.On("Connect", conns, domainID, token)} +} + +func (_c *SDK_Connect_Call) Run(run func(conns sdk.Connection, domainID string, token string)) *SDK_Connect_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.Connection), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Connect_Call) Return(_a0 errors.SDKError) *SDK_Connect_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_Connect_Call) RunAndReturn(run func(sdk.Connection, string, string) errors.SDKError) *SDK_Connect_Call { + _c.Call.Return(run) + return _c +} + // ConnectClient provides a mock function with given fields: clientID, chanID, connTypes, domainID, token func (_m *SDK) ConnectClient(clientID string, chanID string, connTypes []string, domainID string, token string) errors.SDKError { ret := _m.Called(clientID, chanID, connTypes, domainID, token) @@ -546,6 +1130,38 @@ func (_m *SDK) ConnectClient(clientID string, chanID string, connTypes []string, return r0 } +// SDK_ConnectClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectClient' +type SDK_ConnectClient_Call struct { + *mock.Call +} + +// ConnectClient is a helper method to define mock.On call +// - clientID string +// - chanID string +// - connTypes []string +// - domainID string +// - token string +func (_e *SDK_Expecter) ConnectClient(clientID interface{}, chanID interface{}, connTypes interface{}, domainID interface{}, token interface{}) *SDK_ConnectClient_Call { + return &SDK_ConnectClient_Call{Call: _e.mock.On("ConnectClient", clientID, chanID, connTypes, domainID, token)} +} + +func (_c *SDK_ConnectClient_Call) Run(run func(clientID string, chanID string, connTypes []string, domainID string, token string)) *SDK_ConnectClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].([]string), args[3].(string), args[4].(string)) + }) + return _c +} + +func (_c *SDK_ConnectClient_Call) Return(_a0 errors.SDKError) *SDK_ConnectClient_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_ConnectClient_Call) RunAndReturn(run func(string, string, []string, string, string) errors.SDKError) *SDK_ConnectClient_Call { + _c.Call.Return(run) + return _c +} + // CreateChannel provides a mock function with given fields: channel, domainID, token func (_m *SDK) CreateChannel(channel sdk.Channel, domainID string, token string) (sdk.Channel, errors.SDKError) { ret := _m.Called(channel, domainID, token) @@ -576,6 +1192,36 @@ func (_m *SDK) CreateChannel(channel sdk.Channel, domainID string, token string) return r0, r1 } +// SDK_CreateChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateChannel' +type SDK_CreateChannel_Call struct { + *mock.Call +} + +// CreateChannel is a helper method to define mock.On call +// - channel sdk.Channel +// - domainID string +// - token string +func (_e *SDK_Expecter) CreateChannel(channel interface{}, domainID interface{}, token interface{}) *SDK_CreateChannel_Call { + return &SDK_CreateChannel_Call{Call: _e.mock.On("CreateChannel", channel, domainID, token)} +} + +func (_c *SDK_CreateChannel_Call) Run(run func(channel sdk.Channel, domainID string, token string)) *SDK_CreateChannel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.Channel), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_CreateChannel_Call) Return(_a0 sdk.Channel, _a1 errors.SDKError) *SDK_CreateChannel_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_CreateChannel_Call) RunAndReturn(run func(sdk.Channel, string, string) (sdk.Channel, errors.SDKError)) *SDK_CreateChannel_Call { + _c.Call.Return(run) + return _c +} + // CreateClient provides a mock function with given fields: client, domainID, token func (_m *SDK) CreateClient(client sdk.Client, domainID string, token string) (sdk.Client, errors.SDKError) { ret := _m.Called(client, domainID, token) @@ -606,6 +1252,36 @@ func (_m *SDK) CreateClient(client sdk.Client, domainID string, token string) (s return r0, r1 } +// SDK_CreateClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateClient' +type SDK_CreateClient_Call struct { + *mock.Call +} + +// CreateClient is a helper method to define mock.On call +// - client sdk.Client +// - domainID string +// - token string +func (_e *SDK_Expecter) CreateClient(client interface{}, domainID interface{}, token interface{}) *SDK_CreateClient_Call { + return &SDK_CreateClient_Call{Call: _e.mock.On("CreateClient", client, domainID, token)} +} + +func (_c *SDK_CreateClient_Call) Run(run func(client sdk.Client, domainID string, token string)) *SDK_CreateClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.Client), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_CreateClient_Call) Return(_a0 sdk.Client, _a1 errors.SDKError) *SDK_CreateClient_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_CreateClient_Call) RunAndReturn(run func(sdk.Client, string, string) (sdk.Client, errors.SDKError)) *SDK_CreateClient_Call { + _c.Call.Return(run) + return _c +} + // CreateClients provides a mock function with given fields: client, domainID, token func (_m *SDK) CreateClients(client []sdk.Client, domainID string, token string) ([]sdk.Client, errors.SDKError) { ret := _m.Called(client, domainID, token) @@ -638,6 +1314,36 @@ func (_m *SDK) CreateClients(client []sdk.Client, domainID string, token string) return r0, r1 } +// SDK_CreateClients_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateClients' +type SDK_CreateClients_Call struct { + *mock.Call +} + +// CreateClients is a helper method to define mock.On call +// - client []sdk.Client +// - domainID string +// - token string +func (_e *SDK_Expecter) CreateClients(client interface{}, domainID interface{}, token interface{}) *SDK_CreateClients_Call { + return &SDK_CreateClients_Call{Call: _e.mock.On("CreateClients", client, domainID, token)} +} + +func (_c *SDK_CreateClients_Call) Run(run func(client []sdk.Client, domainID string, token string)) *SDK_CreateClients_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]sdk.Client), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_CreateClients_Call) Return(_a0 []sdk.Client, _a1 errors.SDKError) *SDK_CreateClients_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_CreateClients_Call) RunAndReturn(run func([]sdk.Client, string, string) ([]sdk.Client, errors.SDKError)) *SDK_CreateClients_Call { + _c.Call.Return(run) + return _c +} + // CreateDomain provides a mock function with given fields: d, token func (_m *SDK) CreateDomain(d sdk.Domain, token string) (sdk.Domain, errors.SDKError) { ret := _m.Called(d, token) @@ -668,6 +1374,35 @@ func (_m *SDK) CreateDomain(d sdk.Domain, token string) (sdk.Domain, errors.SDKE return r0, r1 } +// SDK_CreateDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateDomain' +type SDK_CreateDomain_Call struct { + *mock.Call +} + +// CreateDomain is a helper method to define mock.On call +// - d sdk.Domain +// - token string +func (_e *SDK_Expecter) CreateDomain(d interface{}, token interface{}) *SDK_CreateDomain_Call { + return &SDK_CreateDomain_Call{Call: _e.mock.On("CreateDomain", d, token)} +} + +func (_c *SDK_CreateDomain_Call) Run(run func(d sdk.Domain, token string)) *SDK_CreateDomain_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.Domain), args[1].(string)) + }) + return _c +} + +func (_c *SDK_CreateDomain_Call) Return(_a0 sdk.Domain, _a1 errors.SDKError) *SDK_CreateDomain_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_CreateDomain_Call) RunAndReturn(run func(sdk.Domain, string) (sdk.Domain, errors.SDKError)) *SDK_CreateDomain_Call { + _c.Call.Return(run) + return _c +} + // CreateGroup provides a mock function with given fields: group, domainID, token func (_m *SDK) CreateGroup(group sdk.Group, domainID string, token string) (sdk.Group, errors.SDKError) { ret := _m.Called(group, domainID, token) @@ -698,13 +1433,43 @@ func (_m *SDK) CreateGroup(group sdk.Group, domainID string, token string) (sdk. return r0, r1 } -// CreateSubscription provides a mock function with given fields: topic, contact, token -func (_m *SDK) CreateSubscription(topic string, contact string, token string) (string, errors.SDKError) { - ret := _m.Called(topic, contact, token) +// SDK_CreateGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateGroup' +type SDK_CreateGroup_Call struct { + *mock.Call +} - if len(ret) == 0 { - panic("no return value specified for CreateSubscription") - } +// CreateGroup is a helper method to define mock.On call +// - group sdk.Group +// - domainID string +// - token string +func (_e *SDK_Expecter) CreateGroup(group interface{}, domainID interface{}, token interface{}) *SDK_CreateGroup_Call { + return &SDK_CreateGroup_Call{Call: _e.mock.On("CreateGroup", group, domainID, token)} +} + +func (_c *SDK_CreateGroup_Call) Run(run func(group sdk.Group, domainID string, token string)) *SDK_CreateGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.Group), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_CreateGroup_Call) Return(_a0 sdk.Group, _a1 errors.SDKError) *SDK_CreateGroup_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_CreateGroup_Call) RunAndReturn(run func(sdk.Group, string, string) (sdk.Group, errors.SDKError)) *SDK_CreateGroup_Call { + _c.Call.Return(run) + return _c +} + +// CreateSubscription provides a mock function with given fields: topic, contact, token +func (_m *SDK) CreateSubscription(topic string, contact string, token string) (string, errors.SDKError) { + ret := _m.Called(topic, contact, token) + + if len(ret) == 0 { + panic("no return value specified for CreateSubscription") + } var r0 string var r1 errors.SDKError @@ -728,6 +1493,36 @@ func (_m *SDK) CreateSubscription(topic string, contact string, token string) (s return r0, r1 } +// SDK_CreateSubscription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSubscription' +type SDK_CreateSubscription_Call struct { + *mock.Call +} + +// CreateSubscription is a helper method to define mock.On call +// - topic string +// - contact string +// - token string +func (_e *SDK_Expecter) CreateSubscription(topic interface{}, contact interface{}, token interface{}) *SDK_CreateSubscription_Call { + return &SDK_CreateSubscription_Call{Call: _e.mock.On("CreateSubscription", topic, contact, token)} +} + +func (_c *SDK_CreateSubscription_Call) Run(run func(topic string, contact string, token string)) *SDK_CreateSubscription_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_CreateSubscription_Call) Return(_a0 string, _a1 errors.SDKError) *SDK_CreateSubscription_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_CreateSubscription_Call) RunAndReturn(run func(string, string, string) (string, errors.SDKError)) *SDK_CreateSubscription_Call { + _c.Call.Return(run) + return _c +} + // CreateToken provides a mock function with given fields: lt func (_m *SDK) CreateToken(lt sdk.Login) (sdk.Token, errors.SDKError) { ret := _m.Called(lt) @@ -758,6 +1553,34 @@ func (_m *SDK) CreateToken(lt sdk.Login) (sdk.Token, errors.SDKError) { return r0, r1 } +// SDK_CreateToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateToken' +type SDK_CreateToken_Call struct { + *mock.Call +} + +// CreateToken is a helper method to define mock.On call +// - lt sdk.Login +func (_e *SDK_Expecter) CreateToken(lt interface{}) *SDK_CreateToken_Call { + return &SDK_CreateToken_Call{Call: _e.mock.On("CreateToken", lt)} +} + +func (_c *SDK_CreateToken_Call) Run(run func(lt sdk.Login)) *SDK_CreateToken_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.Login)) + }) + return _c +} + +func (_c *SDK_CreateToken_Call) Return(_a0 sdk.Token, _a1 errors.SDKError) *SDK_CreateToken_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_CreateToken_Call) RunAndReturn(run func(sdk.Login) (sdk.Token, errors.SDKError)) *SDK_CreateToken_Call { + _c.Call.Return(run) + return _c +} + // CreateUser provides a mock function with given fields: user, token func (_m *SDK) CreateUser(user sdk.User, token string) (sdk.User, errors.SDKError) { ret := _m.Called(user, token) @@ -788,6 +1611,35 @@ func (_m *SDK) CreateUser(user sdk.User, token string) (sdk.User, errors.SDKErro return r0, r1 } +// SDK_CreateUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateUser' +type SDK_CreateUser_Call struct { + *mock.Call +} + +// CreateUser is a helper method to define mock.On call +// - user sdk.User +// - token string +func (_e *SDK_Expecter) CreateUser(user interface{}, token interface{}) *SDK_CreateUser_Call { + return &SDK_CreateUser_Call{Call: _e.mock.On("CreateUser", user, token)} +} + +func (_c *SDK_CreateUser_Call) Run(run func(user sdk.User, token string)) *SDK_CreateUser_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.User), args[1].(string)) + }) + return _c +} + +func (_c *SDK_CreateUser_Call) Return(_a0 sdk.User, _a1 errors.SDKError) *SDK_CreateUser_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_CreateUser_Call) RunAndReturn(run func(sdk.User, string) (sdk.User, errors.SDKError)) *SDK_CreateUser_Call { + _c.Call.Return(run) + return _c +} + // DeleteChannel provides a mock function with given fields: id, domainID, token func (_m *SDK) DeleteChannel(id string, domainID string, token string) errors.SDKError { ret := _m.Called(id, domainID, token) @@ -808,6 +1660,36 @@ func (_m *SDK) DeleteChannel(id string, domainID string, token string) errors.SD return r0 } +// SDK_DeleteChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteChannel' +type SDK_DeleteChannel_Call struct { + *mock.Call +} + +// DeleteChannel is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) DeleteChannel(id interface{}, domainID interface{}, token interface{}) *SDK_DeleteChannel_Call { + return &SDK_DeleteChannel_Call{Call: _e.mock.On("DeleteChannel", id, domainID, token)} +} + +func (_c *SDK_DeleteChannel_Call) Run(run func(id string, domainID string, token string)) *SDK_DeleteChannel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_DeleteChannel_Call) Return(_a0 errors.SDKError) *SDK_DeleteChannel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_DeleteChannel_Call) RunAndReturn(run func(string, string, string) errors.SDKError) *SDK_DeleteChannel_Call { + _c.Call.Return(run) + return _c +} + // DeleteClient provides a mock function with given fields: id, domainID, token func (_m *SDK) DeleteClient(id string, domainID string, token string) errors.SDKError { ret := _m.Called(id, domainID, token) @@ -828,6 +1710,36 @@ func (_m *SDK) DeleteClient(id string, domainID string, token string) errors.SDK return r0 } +// SDK_DeleteClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteClient' +type SDK_DeleteClient_Call struct { + *mock.Call +} + +// DeleteClient is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) DeleteClient(id interface{}, domainID interface{}, token interface{}) *SDK_DeleteClient_Call { + return &SDK_DeleteClient_Call{Call: _e.mock.On("DeleteClient", id, domainID, token)} +} + +func (_c *SDK_DeleteClient_Call) Run(run func(id string, domainID string, token string)) *SDK_DeleteClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_DeleteClient_Call) Return(_a0 errors.SDKError) *SDK_DeleteClient_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_DeleteClient_Call) RunAndReturn(run func(string, string, string) errors.SDKError) *SDK_DeleteClient_Call { + _c.Call.Return(run) + return _c +} + // DeleteGroup provides a mock function with given fields: id, domainID, token func (_m *SDK) DeleteGroup(id string, domainID string, token string) errors.SDKError { ret := _m.Called(id, domainID, token) @@ -848,6 +1760,36 @@ func (_m *SDK) DeleteGroup(id string, domainID string, token string) errors.SDKE return r0 } +// SDK_DeleteGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteGroup' +type SDK_DeleteGroup_Call struct { + *mock.Call +} + +// DeleteGroup is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) DeleteGroup(id interface{}, domainID interface{}, token interface{}) *SDK_DeleteGroup_Call { + return &SDK_DeleteGroup_Call{Call: _e.mock.On("DeleteGroup", id, domainID, token)} +} + +func (_c *SDK_DeleteGroup_Call) Run(run func(id string, domainID string, token string)) *SDK_DeleteGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_DeleteGroup_Call) Return(_a0 errors.SDKError) *SDK_DeleteGroup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_DeleteGroup_Call) RunAndReturn(run func(string, string, string) errors.SDKError) *SDK_DeleteGroup_Call { + _c.Call.Return(run) + return _c +} + // DeleteInvitation provides a mock function with given fields: userID, domainID, token func (_m *SDK) DeleteInvitation(userID string, domainID string, token string) error { ret := _m.Called(userID, domainID, token) @@ -866,6 +1808,36 @@ func (_m *SDK) DeleteInvitation(userID string, domainID string, token string) er return r0 } +// SDK_DeleteInvitation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteInvitation' +type SDK_DeleteInvitation_Call struct { + *mock.Call +} + +// DeleteInvitation is a helper method to define mock.On call +// - userID string +// - domainID string +// - token string +func (_e *SDK_Expecter) DeleteInvitation(userID interface{}, domainID interface{}, token interface{}) *SDK_DeleteInvitation_Call { + return &SDK_DeleteInvitation_Call{Call: _e.mock.On("DeleteInvitation", userID, domainID, token)} +} + +func (_c *SDK_DeleteInvitation_Call) Run(run func(userID string, domainID string, token string)) *SDK_DeleteInvitation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_DeleteInvitation_Call) Return(err error) *SDK_DeleteInvitation_Call { + _c.Call.Return(err) + return _c +} + +func (_c *SDK_DeleteInvitation_Call) RunAndReturn(run func(string, string, string) error) *SDK_DeleteInvitation_Call { + _c.Call.Return(run) + return _c +} + // DeleteSubscription provides a mock function with given fields: id, token func (_m *SDK) DeleteSubscription(id string, token string) errors.SDKError { ret := _m.Called(id, token) @@ -886,6 +1858,35 @@ func (_m *SDK) DeleteSubscription(id string, token string) errors.SDKError { return r0 } +// SDK_DeleteSubscription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSubscription' +type SDK_DeleteSubscription_Call struct { + *mock.Call +} + +// DeleteSubscription is a helper method to define mock.On call +// - id string +// - token string +func (_e *SDK_Expecter) DeleteSubscription(id interface{}, token interface{}) *SDK_DeleteSubscription_Call { + return &SDK_DeleteSubscription_Call{Call: _e.mock.On("DeleteSubscription", id, token)} +} + +func (_c *SDK_DeleteSubscription_Call) Run(run func(id string, token string)) *SDK_DeleteSubscription_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_DeleteSubscription_Call) Return(_a0 errors.SDKError) *SDK_DeleteSubscription_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_DeleteSubscription_Call) RunAndReturn(run func(string, string) errors.SDKError) *SDK_DeleteSubscription_Call { + _c.Call.Return(run) + return _c +} + // DeleteUser provides a mock function with given fields: id, token func (_m *SDK) DeleteUser(id string, token string) errors.SDKError { ret := _m.Called(id, token) @@ -906,6 +1907,35 @@ func (_m *SDK) DeleteUser(id string, token string) errors.SDKError { return r0 } +// SDK_DeleteUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUser' +type SDK_DeleteUser_Call struct { + *mock.Call +} + +// DeleteUser is a helper method to define mock.On call +// - id string +// - token string +func (_e *SDK_Expecter) DeleteUser(id interface{}, token interface{}) *SDK_DeleteUser_Call { + return &SDK_DeleteUser_Call{Call: _e.mock.On("DeleteUser", id, token)} +} + +func (_c *SDK_DeleteUser_Call) Run(run func(id string, token string)) *SDK_DeleteUser_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_DeleteUser_Call) Return(_a0 errors.SDKError) *SDK_DeleteUser_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_DeleteUser_Call) RunAndReturn(run func(string, string) errors.SDKError) *SDK_DeleteUser_Call { + _c.Call.Return(run) + return _c +} + // DisableChannel provides a mock function with given fields: id, domainID, token func (_m *SDK) DisableChannel(id string, domainID string, token string) (sdk.Channel, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -936,6 +1966,36 @@ func (_m *SDK) DisableChannel(id string, domainID string, token string) (sdk.Cha return r0, r1 } +// SDK_DisableChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableChannel' +type SDK_DisableChannel_Call struct { + *mock.Call +} + +// DisableChannel is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) DisableChannel(id interface{}, domainID interface{}, token interface{}) *SDK_DisableChannel_Call { + return &SDK_DisableChannel_Call{Call: _e.mock.On("DisableChannel", id, domainID, token)} +} + +func (_c *SDK_DisableChannel_Call) Run(run func(id string, domainID string, token string)) *SDK_DisableChannel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_DisableChannel_Call) Return(_a0 sdk.Channel, _a1 errors.SDKError) *SDK_DisableChannel_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_DisableChannel_Call) RunAndReturn(run func(string, string, string) (sdk.Channel, errors.SDKError)) *SDK_DisableChannel_Call { + _c.Call.Return(run) + return _c +} + // DisableClient provides a mock function with given fields: id, domainID, token func (_m *SDK) DisableClient(id string, domainID string, token string) (sdk.Client, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -966,6 +2026,36 @@ func (_m *SDK) DisableClient(id string, domainID string, token string) (sdk.Clie return r0, r1 } +// SDK_DisableClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableClient' +type SDK_DisableClient_Call struct { + *mock.Call +} + +// DisableClient is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) DisableClient(id interface{}, domainID interface{}, token interface{}) *SDK_DisableClient_Call { + return &SDK_DisableClient_Call{Call: _e.mock.On("DisableClient", id, domainID, token)} +} + +func (_c *SDK_DisableClient_Call) Run(run func(id string, domainID string, token string)) *SDK_DisableClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_DisableClient_Call) Return(_a0 sdk.Client, _a1 errors.SDKError) *SDK_DisableClient_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_DisableClient_Call) RunAndReturn(run func(string, string, string) (sdk.Client, errors.SDKError)) *SDK_DisableClient_Call { + _c.Call.Return(run) + return _c +} + // DisableDomain provides a mock function with given fields: domainID, token func (_m *SDK) DisableDomain(domainID string, token string) errors.SDKError { ret := _m.Called(domainID, token) @@ -986,6 +2076,35 @@ func (_m *SDK) DisableDomain(domainID string, token string) errors.SDKError { return r0 } +// SDK_DisableDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableDomain' +type SDK_DisableDomain_Call struct { + *mock.Call +} + +// DisableDomain is a helper method to define mock.On call +// - domainID string +// - token string +func (_e *SDK_Expecter) DisableDomain(domainID interface{}, token interface{}) *SDK_DisableDomain_Call { + return &SDK_DisableDomain_Call{Call: _e.mock.On("DisableDomain", domainID, token)} +} + +func (_c *SDK_DisableDomain_Call) Run(run func(domainID string, token string)) *SDK_DisableDomain_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_DisableDomain_Call) Return(_a0 errors.SDKError) *SDK_DisableDomain_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_DisableDomain_Call) RunAndReturn(run func(string, string) errors.SDKError) *SDK_DisableDomain_Call { + _c.Call.Return(run) + return _c +} + // DisableGroup provides a mock function with given fields: id, domainID, token func (_m *SDK) DisableGroup(id string, domainID string, token string) (sdk.Group, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -1016,6 +2135,36 @@ func (_m *SDK) DisableGroup(id string, domainID string, token string) (sdk.Group return r0, r1 } +// SDK_DisableGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableGroup' +type SDK_DisableGroup_Call struct { + *mock.Call +} + +// DisableGroup is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) DisableGroup(id interface{}, domainID interface{}, token interface{}) *SDK_DisableGroup_Call { + return &SDK_DisableGroup_Call{Call: _e.mock.On("DisableGroup", id, domainID, token)} +} + +func (_c *SDK_DisableGroup_Call) Run(run func(id string, domainID string, token string)) *SDK_DisableGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_DisableGroup_Call) Return(_a0 sdk.Group, _a1 errors.SDKError) *SDK_DisableGroup_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_DisableGroup_Call) RunAndReturn(run func(string, string, string) (sdk.Group, errors.SDKError)) *SDK_DisableGroup_Call { + _c.Call.Return(run) + return _c +} + // DisableUser provides a mock function with given fields: id, token func (_m *SDK) DisableUser(id string, token string) (sdk.User, errors.SDKError) { ret := _m.Called(id, token) @@ -1046,6 +2195,35 @@ func (_m *SDK) DisableUser(id string, token string) (sdk.User, errors.SDKError) return r0, r1 } +// SDK_DisableUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableUser' +type SDK_DisableUser_Call struct { + *mock.Call +} + +// DisableUser is a helper method to define mock.On call +// - id string +// - token string +func (_e *SDK_Expecter) DisableUser(id interface{}, token interface{}) *SDK_DisableUser_Call { + return &SDK_DisableUser_Call{Call: _e.mock.On("DisableUser", id, token)} +} + +func (_c *SDK_DisableUser_Call) Run(run func(id string, token string)) *SDK_DisableUser_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_DisableUser_Call) Return(_a0 sdk.User, _a1 errors.SDKError) *SDK_DisableUser_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_DisableUser_Call) RunAndReturn(run func(string, string) (sdk.User, errors.SDKError)) *SDK_DisableUser_Call { + _c.Call.Return(run) + return _c +} + // Disconnect provides a mock function with given fields: connIDs, domainID, token func (_m *SDK) Disconnect(connIDs sdk.Connection, domainID string, token string) errors.SDKError { ret := _m.Called(connIDs, domainID, token) @@ -1066,6 +2244,36 @@ func (_m *SDK) Disconnect(connIDs sdk.Connection, domainID string, token string) return r0 } +// SDK_Disconnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Disconnect' +type SDK_Disconnect_Call struct { + *mock.Call +} + +// Disconnect is a helper method to define mock.On call +// - connIDs sdk.Connection +// - domainID string +// - token string +func (_e *SDK_Expecter) Disconnect(connIDs interface{}, domainID interface{}, token interface{}) *SDK_Disconnect_Call { + return &SDK_Disconnect_Call{Call: _e.mock.On("Disconnect", connIDs, domainID, token)} +} + +func (_c *SDK_Disconnect_Call) Run(run func(connIDs sdk.Connection, domainID string, token string)) *SDK_Disconnect_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.Connection), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Disconnect_Call) Return(_a0 errors.SDKError) *SDK_Disconnect_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_Disconnect_Call) RunAndReturn(run func(sdk.Connection, string, string) errors.SDKError) *SDK_Disconnect_Call { + _c.Call.Return(run) + return _c +} + // DisconnectClient provides a mock function with given fields: clientID, chanID, connTypes, domainID, token func (_m *SDK) DisconnectClient(clientID string, chanID string, connTypes []string, domainID string, token string) errors.SDKError { ret := _m.Called(clientID, chanID, connTypes, domainID, token) @@ -1086,6 +2294,38 @@ func (_m *SDK) DisconnectClient(clientID string, chanID string, connTypes []stri return r0 } +// SDK_DisconnectClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisconnectClient' +type SDK_DisconnectClient_Call struct { + *mock.Call +} + +// DisconnectClient is a helper method to define mock.On call +// - clientID string +// - chanID string +// - connTypes []string +// - domainID string +// - token string +func (_e *SDK_Expecter) DisconnectClient(clientID interface{}, chanID interface{}, connTypes interface{}, domainID interface{}, token interface{}) *SDK_DisconnectClient_Call { + return &SDK_DisconnectClient_Call{Call: _e.mock.On("DisconnectClient", clientID, chanID, connTypes, domainID, token)} +} + +func (_c *SDK_DisconnectClient_Call) Run(run func(clientID string, chanID string, connTypes []string, domainID string, token string)) *SDK_DisconnectClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].([]string), args[3].(string), args[4].(string)) + }) + return _c +} + +func (_c *SDK_DisconnectClient_Call) Return(_a0 errors.SDKError) *SDK_DisconnectClient_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_DisconnectClient_Call) RunAndReturn(run func(string, string, []string, string, string) errors.SDKError) *SDK_DisconnectClient_Call { + _c.Call.Return(run) + return _c +} + // Domain provides a mock function with given fields: domainID, token func (_m *SDK) Domain(domainID string, token string) (sdk.Domain, errors.SDKError) { ret := _m.Called(domainID, token) @@ -1116,6 +2356,35 @@ func (_m *SDK) Domain(domainID string, token string) (sdk.Domain, errors.SDKErro return r0, r1 } +// SDK_Domain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Domain' +type SDK_Domain_Call struct { + *mock.Call +} + +// Domain is a helper method to define mock.On call +// - domainID string +// - token string +func (_e *SDK_Expecter) Domain(domainID interface{}, token interface{}) *SDK_Domain_Call { + return &SDK_Domain_Call{Call: _e.mock.On("Domain", domainID, token)} +} + +func (_c *SDK_Domain_Call) Run(run func(domainID string, token string)) *SDK_Domain_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_Domain_Call) Return(_a0 sdk.Domain, _a1 errors.SDKError) *SDK_Domain_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Domain_Call) RunAndReturn(run func(string, string) (sdk.Domain, errors.SDKError)) *SDK_Domain_Call { + _c.Call.Return(run) + return _c +} + // DomainPermissions provides a mock function with given fields: domainID, token func (_m *SDK) DomainPermissions(domainID string, token string) (sdk.Domain, errors.SDKError) { ret := _m.Called(domainID, token) @@ -1146,6 +2415,35 @@ func (_m *SDK) DomainPermissions(domainID string, token string) (sdk.Domain, err return r0, r1 } +// SDK_DomainPermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DomainPermissions' +type SDK_DomainPermissions_Call struct { + *mock.Call +} + +// DomainPermissions is a helper method to define mock.On call +// - domainID string +// - token string +func (_e *SDK_Expecter) DomainPermissions(domainID interface{}, token interface{}) *SDK_DomainPermissions_Call { + return &SDK_DomainPermissions_Call{Call: _e.mock.On("DomainPermissions", domainID, token)} +} + +func (_c *SDK_DomainPermissions_Call) Run(run func(domainID string, token string)) *SDK_DomainPermissions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_DomainPermissions_Call) Return(_a0 sdk.Domain, _a1 errors.SDKError) *SDK_DomainPermissions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_DomainPermissions_Call) RunAndReturn(run func(string, string) (sdk.Domain, errors.SDKError)) *SDK_DomainPermissions_Call { + _c.Call.Return(run) + return _c +} + // Domains provides a mock function with given fields: pm, token func (_m *SDK) Domains(pm sdk.PageMetadata, token string) (sdk.DomainsPage, errors.SDKError) { ret := _m.Called(pm, token) @@ -1176,6 +2474,35 @@ func (_m *SDK) Domains(pm sdk.PageMetadata, token string) (sdk.DomainsPage, erro return r0, r1 } +// SDK_Domains_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Domains' +type SDK_Domains_Call struct { + *mock.Call +} + +// Domains is a helper method to define mock.On call +// - pm sdk.PageMetadata +// - token string +func (_e *SDK_Expecter) Domains(pm interface{}, token interface{}) *SDK_Domains_Call { + return &SDK_Domains_Call{Call: _e.mock.On("Domains", pm, token)} +} + +func (_c *SDK_Domains_Call) Run(run func(pm sdk.PageMetadata, token string)) *SDK_Domains_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.PageMetadata), args[1].(string)) + }) + return _c +} + +func (_c *SDK_Domains_Call) Return(_a0 sdk.DomainsPage, _a1 errors.SDKError) *SDK_Domains_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Domains_Call) RunAndReturn(run func(sdk.PageMetadata, string) (sdk.DomainsPage, errors.SDKError)) *SDK_Domains_Call { + _c.Call.Return(run) + return _c +} + // EnableChannel provides a mock function with given fields: id, domainID, token func (_m *SDK) EnableChannel(id string, domainID string, token string) (sdk.Channel, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -1206,6 +2533,36 @@ func (_m *SDK) EnableChannel(id string, domainID string, token string) (sdk.Chan return r0, r1 } +// SDK_EnableChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableChannel' +type SDK_EnableChannel_Call struct { + *mock.Call +} + +// EnableChannel is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) EnableChannel(id interface{}, domainID interface{}, token interface{}) *SDK_EnableChannel_Call { + return &SDK_EnableChannel_Call{Call: _e.mock.On("EnableChannel", id, domainID, token)} +} + +func (_c *SDK_EnableChannel_Call) Run(run func(id string, domainID string, token string)) *SDK_EnableChannel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_EnableChannel_Call) Return(_a0 sdk.Channel, _a1 errors.SDKError) *SDK_EnableChannel_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_EnableChannel_Call) RunAndReturn(run func(string, string, string) (sdk.Channel, errors.SDKError)) *SDK_EnableChannel_Call { + _c.Call.Return(run) + return _c +} + // EnableClient provides a mock function with given fields: id, domainID, token func (_m *SDK) EnableClient(id string, domainID string, token string) (sdk.Client, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -1236,6 +2593,36 @@ func (_m *SDK) EnableClient(id string, domainID string, token string) (sdk.Clien return r0, r1 } +// SDK_EnableClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableClient' +type SDK_EnableClient_Call struct { + *mock.Call +} + +// EnableClient is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) EnableClient(id interface{}, domainID interface{}, token interface{}) *SDK_EnableClient_Call { + return &SDK_EnableClient_Call{Call: _e.mock.On("EnableClient", id, domainID, token)} +} + +func (_c *SDK_EnableClient_Call) Run(run func(id string, domainID string, token string)) *SDK_EnableClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_EnableClient_Call) Return(_a0 sdk.Client, _a1 errors.SDKError) *SDK_EnableClient_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_EnableClient_Call) RunAndReturn(run func(string, string, string) (sdk.Client, errors.SDKError)) *SDK_EnableClient_Call { + _c.Call.Return(run) + return _c +} + // EnableDomain provides a mock function with given fields: domainID, token func (_m *SDK) EnableDomain(domainID string, token string) errors.SDKError { ret := _m.Called(domainID, token) @@ -1256,6 +2643,35 @@ func (_m *SDK) EnableDomain(domainID string, token string) errors.SDKError { return r0 } +// SDK_EnableDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableDomain' +type SDK_EnableDomain_Call struct { + *mock.Call +} + +// EnableDomain is a helper method to define mock.On call +// - domainID string +// - token string +func (_e *SDK_Expecter) EnableDomain(domainID interface{}, token interface{}) *SDK_EnableDomain_Call { + return &SDK_EnableDomain_Call{Call: _e.mock.On("EnableDomain", domainID, token)} +} + +func (_c *SDK_EnableDomain_Call) Run(run func(domainID string, token string)) *SDK_EnableDomain_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_EnableDomain_Call) Return(_a0 errors.SDKError) *SDK_EnableDomain_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_EnableDomain_Call) RunAndReturn(run func(string, string) errors.SDKError) *SDK_EnableDomain_Call { + _c.Call.Return(run) + return _c +} + // EnableGroup provides a mock function with given fields: id, domainID, token func (_m *SDK) EnableGroup(id string, domainID string, token string) (sdk.Group, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -1286,6 +2702,36 @@ func (_m *SDK) EnableGroup(id string, domainID string, token string) (sdk.Group, return r0, r1 } +// SDK_EnableGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableGroup' +type SDK_EnableGroup_Call struct { + *mock.Call +} + +// EnableGroup is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) EnableGroup(id interface{}, domainID interface{}, token interface{}) *SDK_EnableGroup_Call { + return &SDK_EnableGroup_Call{Call: _e.mock.On("EnableGroup", id, domainID, token)} +} + +func (_c *SDK_EnableGroup_Call) Run(run func(id string, domainID string, token string)) *SDK_EnableGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_EnableGroup_Call) Return(_a0 sdk.Group, _a1 errors.SDKError) *SDK_EnableGroup_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_EnableGroup_Call) RunAndReturn(run func(string, string, string) (sdk.Group, errors.SDKError)) *SDK_EnableGroup_Call { + _c.Call.Return(run) + return _c +} + // EnableUser provides a mock function with given fields: id, token func (_m *SDK) EnableUser(id string, token string) (sdk.User, errors.SDKError) { ret := _m.Called(id, token) @@ -1316,6 +2762,35 @@ func (_m *SDK) EnableUser(id string, token string) (sdk.User, errors.SDKError) { return r0, r1 } +// SDK_EnableUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableUser' +type SDK_EnableUser_Call struct { + *mock.Call +} + +// EnableUser is a helper method to define mock.On call +// - id string +// - token string +func (_e *SDK_Expecter) EnableUser(id interface{}, token interface{}) *SDK_EnableUser_Call { + return &SDK_EnableUser_Call{Call: _e.mock.On("EnableUser", id, token)} +} + +func (_c *SDK_EnableUser_Call) Run(run func(id string, token string)) *SDK_EnableUser_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_EnableUser_Call) Return(_a0 sdk.User, _a1 errors.SDKError) *SDK_EnableUser_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_EnableUser_Call) RunAndReturn(run func(string, string) (sdk.User, errors.SDKError)) *SDK_EnableUser_Call { + _c.Call.Return(run) + return _c +} + // Group provides a mock function with given fields: id, domainID, token func (_m *SDK) Group(id string, domainID string, token string) (sdk.Group, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -1346,6 +2821,36 @@ func (_m *SDK) Group(id string, domainID string, token string) (sdk.Group, error return r0, r1 } +// SDK_Group_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Group' +type SDK_Group_Call struct { + *mock.Call +} + +// Group is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) Group(id interface{}, domainID interface{}, token interface{}) *SDK_Group_Call { + return &SDK_Group_Call{Call: _e.mock.On("Group", id, domainID, token)} +} + +func (_c *SDK_Group_Call) Run(run func(id string, domainID string, token string)) *SDK_Group_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Group_Call) Return(_a0 sdk.Group, _a1 errors.SDKError) *SDK_Group_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Group_Call) RunAndReturn(run func(string, string, string) (sdk.Group, errors.SDKError)) *SDK_Group_Call { + _c.Call.Return(run) + return _c +} + // GroupPermissions provides a mock function with given fields: id, domainID, token func (_m *SDK) GroupPermissions(id string, domainID string, token string) (sdk.Group, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -1376,6 +2881,36 @@ func (_m *SDK) GroupPermissions(id string, domainID string, token string) (sdk.G return r0, r1 } +// SDK_GroupPermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GroupPermissions' +type SDK_GroupPermissions_Call struct { + *mock.Call +} + +// GroupPermissions is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) GroupPermissions(id interface{}, domainID interface{}, token interface{}) *SDK_GroupPermissions_Call { + return &SDK_GroupPermissions_Call{Call: _e.mock.On("GroupPermissions", id, domainID, token)} +} + +func (_c *SDK_GroupPermissions_Call) Run(run func(id string, domainID string, token string)) *SDK_GroupPermissions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_GroupPermissions_Call) Return(_a0 sdk.Group, _a1 errors.SDKError) *SDK_GroupPermissions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_GroupPermissions_Call) RunAndReturn(run func(string, string, string) (sdk.Group, errors.SDKError)) *SDK_GroupPermissions_Call { + _c.Call.Return(run) + return _c +} + // Groups provides a mock function with given fields: pm, domainID, token func (_m *SDK) Groups(pm sdk.PageMetadata, domainID string, token string) (sdk.GroupsPage, errors.SDKError) { ret := _m.Called(pm, domainID, token) @@ -1406,6 +2941,36 @@ func (_m *SDK) Groups(pm sdk.PageMetadata, domainID string, token string) (sdk.G return r0, r1 } +// SDK_Groups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Groups' +type SDK_Groups_Call struct { + *mock.Call +} + +// Groups is a helper method to define mock.On call +// - pm sdk.PageMetadata +// - domainID string +// - token string +func (_e *SDK_Expecter) Groups(pm interface{}, domainID interface{}, token interface{}) *SDK_Groups_Call { + return &SDK_Groups_Call{Call: _e.mock.On("Groups", pm, domainID, token)} +} + +func (_c *SDK_Groups_Call) Run(run func(pm sdk.PageMetadata, domainID string, token string)) *SDK_Groups_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.PageMetadata), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Groups_Call) Return(_a0 sdk.GroupsPage, _a1 errors.SDKError) *SDK_Groups_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Groups_Call) RunAndReturn(run func(sdk.PageMetadata, string, string) (sdk.GroupsPage, errors.SDKError)) *SDK_Groups_Call { + _c.Call.Return(run) + return _c +} + // Health provides a mock function with given fields: service func (_m *SDK) Health(service string) (sdk.HealthInfo, errors.SDKError) { ret := _m.Called(service) @@ -1436,6 +3001,34 @@ func (_m *SDK) Health(service string) (sdk.HealthInfo, errors.SDKError) { return r0, r1 } +// SDK_Health_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Health' +type SDK_Health_Call struct { + *mock.Call +} + +// Health is a helper method to define mock.On call +// - service string +func (_e *SDK_Expecter) Health(service interface{}) *SDK_Health_Call { + return &SDK_Health_Call{Call: _e.mock.On("Health", service)} +} + +func (_c *SDK_Health_Call) Run(run func(service string)) *SDK_Health_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *SDK_Health_Call) Return(_a0 sdk.HealthInfo, _a1 errors.SDKError) *SDK_Health_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Health_Call) RunAndReturn(run func(string) (sdk.HealthInfo, errors.SDKError)) *SDK_Health_Call { + _c.Call.Return(run) + return _c +} + // Invitation provides a mock function with given fields: userID, domainID, token func (_m *SDK) Invitation(userID string, domainID string, token string) (sdk.Invitation, error) { ret := _m.Called(userID, domainID, token) @@ -1464,6 +3057,36 @@ func (_m *SDK) Invitation(userID string, domainID string, token string) (sdk.Inv return r0, r1 } +// SDK_Invitation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Invitation' +type SDK_Invitation_Call struct { + *mock.Call +} + +// Invitation is a helper method to define mock.On call +// - userID string +// - domainID string +// - token string +func (_e *SDK_Expecter) Invitation(userID interface{}, domainID interface{}, token interface{}) *SDK_Invitation_Call { + return &SDK_Invitation_Call{Call: _e.mock.On("Invitation", userID, domainID, token)} +} + +func (_c *SDK_Invitation_Call) Run(run func(userID string, domainID string, token string)) *SDK_Invitation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Invitation_Call) Return(invitation sdk.Invitation, err error) *SDK_Invitation_Call { + _c.Call.Return(invitation, err) + return _c +} + +func (_c *SDK_Invitation_Call) RunAndReturn(run func(string, string, string) (sdk.Invitation, error)) *SDK_Invitation_Call { + _c.Call.Return(run) + return _c +} + // Invitations provides a mock function with given fields: pm, token func (_m *SDK) Invitations(pm sdk.PageMetadata, token string) (sdk.InvitationPage, error) { ret := _m.Called(pm, token) @@ -1492,6 +3115,35 @@ func (_m *SDK) Invitations(pm sdk.PageMetadata, token string) (sdk.InvitationPag return r0, r1 } +// SDK_Invitations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Invitations' +type SDK_Invitations_Call struct { + *mock.Call +} + +// Invitations is a helper method to define mock.On call +// - pm sdk.PageMetadata +// - token string +func (_e *SDK_Expecter) Invitations(pm interface{}, token interface{}) *SDK_Invitations_Call { + return &SDK_Invitations_Call{Call: _e.mock.On("Invitations", pm, token)} +} + +func (_c *SDK_Invitations_Call) Run(run func(pm sdk.PageMetadata, token string)) *SDK_Invitations_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.PageMetadata), args[1].(string)) + }) + return _c +} + +func (_c *SDK_Invitations_Call) Return(invitations sdk.InvitationPage, err error) *SDK_Invitations_Call { + _c.Call.Return(invitations, err) + return _c +} + +func (_c *SDK_Invitations_Call) RunAndReturn(run func(sdk.PageMetadata, string) (sdk.InvitationPage, error)) *SDK_Invitations_Call { + _c.Call.Return(run) + return _c +} + // IssueCert provides a mock function with given fields: clientID, validity, domainID, token func (_m *SDK) IssueCert(clientID string, validity string, domainID string, token string) (sdk.Cert, errors.SDKError) { ret := _m.Called(clientID, validity, domainID, token) @@ -1522,6 +3174,37 @@ func (_m *SDK) IssueCert(clientID string, validity string, domainID string, toke return r0, r1 } +// SDK_IssueCert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IssueCert' +type SDK_IssueCert_Call struct { + *mock.Call +} + +// IssueCert is a helper method to define mock.On call +// - clientID string +// - validity string +// - domainID string +// - token string +func (_e *SDK_Expecter) IssueCert(clientID interface{}, validity interface{}, domainID interface{}, token interface{}) *SDK_IssueCert_Call { + return &SDK_IssueCert_Call{Call: _e.mock.On("IssueCert", clientID, validity, domainID, token)} +} + +func (_c *SDK_IssueCert_Call) Run(run func(clientID string, validity string, domainID string, token string)) *SDK_IssueCert_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_IssueCert_Call) Return(_a0 sdk.Cert, _a1 errors.SDKError) *SDK_IssueCert_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_IssueCert_Call) RunAndReturn(run func(string, string, string, string) (sdk.Cert, errors.SDKError)) *SDK_IssueCert_Call { + _c.Call.Return(run) + return _c +} + // Journal provides a mock function with given fields: entityType, entityID, domainID, pm, token func (_m *SDK) Journal(entityType string, entityID string, domainID string, pm sdk.PageMetadata, token string) (sdk.JournalsPage, error) { ret := _m.Called(entityType, entityID, domainID, pm, token) @@ -1550,6 +3233,38 @@ func (_m *SDK) Journal(entityType string, entityID string, domainID string, pm s return r0, r1 } +// SDK_Journal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Journal' +type SDK_Journal_Call struct { + *mock.Call +} + +// Journal is a helper method to define mock.On call +// - entityType string +// - entityID string +// - domainID string +// - pm sdk.PageMetadata +// - token string +func (_e *SDK_Expecter) Journal(entityType interface{}, entityID interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_Journal_Call { + return &SDK_Journal_Call{Call: _e.mock.On("Journal", entityType, entityID, domainID, pm, token)} +} + +func (_c *SDK_Journal_Call) Run(run func(entityType string, entityID string, domainID string, pm sdk.PageMetadata, token string)) *SDK_Journal_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(sdk.PageMetadata), args[4].(string)) + }) + return _c +} + +func (_c *SDK_Journal_Call) Return(journal sdk.JournalsPage, err error) *SDK_Journal_Call { + _c.Call.Return(journal, err) + return _c +} + +func (_c *SDK_Journal_Call) RunAndReturn(run func(string, string, string, sdk.PageMetadata, string) (sdk.JournalsPage, error)) *SDK_Journal_Call { + _c.Call.Return(run) + return _c +} + // ListChannelUserGroups provides a mock function with given fields: channelID, pm, domainID, token func (_m *SDK) ListChannelUserGroups(channelID string, pm sdk.PageMetadata, domainID string, token string) (sdk.GroupsPage, errors.SDKError) { ret := _m.Called(channelID, pm, domainID, token) @@ -1580,6 +3295,37 @@ func (_m *SDK) ListChannelUserGroups(channelID string, pm sdk.PageMetadata, doma return r0, r1 } +// SDK_ListChannelUserGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListChannelUserGroups' +type SDK_ListChannelUserGroups_Call struct { + *mock.Call +} + +// ListChannelUserGroups is a helper method to define mock.On call +// - channelID string +// - pm sdk.PageMetadata +// - domainID string +// - token string +func (_e *SDK_Expecter) ListChannelUserGroups(channelID interface{}, pm interface{}, domainID interface{}, token interface{}) *SDK_ListChannelUserGroups_Call { + return &SDK_ListChannelUserGroups_Call{Call: _e.mock.On("ListChannelUserGroups", channelID, pm, domainID, token)} +} + +func (_c *SDK_ListChannelUserGroups_Call) Run(run func(channelID string, pm sdk.PageMetadata, domainID string, token string)) *SDK_ListChannelUserGroups_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.PageMetadata), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_ListChannelUserGroups_Call) Return(_a0 sdk.GroupsPage, _a1 errors.SDKError) *SDK_ListChannelUserGroups_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ListChannelUserGroups_Call) RunAndReturn(run func(string, sdk.PageMetadata, string, string) (sdk.GroupsPage, errors.SDKError)) *SDK_ListChannelUserGroups_Call { + _c.Call.Return(run) + return _c +} + // ListChannelUsers provides a mock function with given fields: channelID, pm, domainID, token func (_m *SDK) ListChannelUsers(channelID string, pm sdk.PageMetadata, domainID string, token string) (sdk.UsersPage, errors.SDKError) { ret := _m.Called(channelID, pm, domainID, token) @@ -1610,6 +3356,37 @@ func (_m *SDK) ListChannelUsers(channelID string, pm sdk.PageMetadata, domainID return r0, r1 } +// SDK_ListChannelUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListChannelUsers' +type SDK_ListChannelUsers_Call struct { + *mock.Call +} + +// ListChannelUsers is a helper method to define mock.On call +// - channelID string +// - pm sdk.PageMetadata +// - domainID string +// - token string +func (_e *SDK_Expecter) ListChannelUsers(channelID interface{}, pm interface{}, domainID interface{}, token interface{}) *SDK_ListChannelUsers_Call { + return &SDK_ListChannelUsers_Call{Call: _e.mock.On("ListChannelUsers", channelID, pm, domainID, token)} +} + +func (_c *SDK_ListChannelUsers_Call) Run(run func(channelID string, pm sdk.PageMetadata, domainID string, token string)) *SDK_ListChannelUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.PageMetadata), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_ListChannelUsers_Call) Return(_a0 sdk.UsersPage, _a1 errors.SDKError) *SDK_ListChannelUsers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ListChannelUsers_Call) RunAndReturn(run func(string, sdk.PageMetadata, string, string) (sdk.UsersPage, errors.SDKError)) *SDK_ListChannelUsers_Call { + _c.Call.Return(run) + return _c +} + // ListClientUsers provides a mock function with given fields: id, pm, domainID, token func (_m *SDK) ListClientUsers(id string, pm sdk.PageMetadata, domainID string, token string) (sdk.UsersPage, errors.SDKError) { ret := _m.Called(id, pm, domainID, token) @@ -1640,6 +3417,37 @@ func (_m *SDK) ListClientUsers(id string, pm sdk.PageMetadata, domainID string, return r0, r1 } +// SDK_ListClientUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClientUsers' +type SDK_ListClientUsers_Call struct { + *mock.Call +} + +// ListClientUsers is a helper method to define mock.On call +// - id string +// - pm sdk.PageMetadata +// - domainID string +// - token string +func (_e *SDK_Expecter) ListClientUsers(id interface{}, pm interface{}, domainID interface{}, token interface{}) *SDK_ListClientUsers_Call { + return &SDK_ListClientUsers_Call{Call: _e.mock.On("ListClientUsers", id, pm, domainID, token)} +} + +func (_c *SDK_ListClientUsers_Call) Run(run func(id string, pm sdk.PageMetadata, domainID string, token string)) *SDK_ListClientUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.PageMetadata), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_ListClientUsers_Call) Return(_a0 sdk.UsersPage, _a1 errors.SDKError) *SDK_ListClientUsers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ListClientUsers_Call) RunAndReturn(run func(string, sdk.PageMetadata, string, string) (sdk.UsersPage, errors.SDKError)) *SDK_ListClientUsers_Call { + _c.Call.Return(run) + return _c +} + // ListDomainUsers provides a mock function with given fields: domainID, pm, token func (_m *SDK) ListDomainUsers(domainID string, pm sdk.PageMetadata, token string) (sdk.UsersPage, errors.SDKError) { ret := _m.Called(domainID, pm, token) @@ -1670,6 +3478,36 @@ func (_m *SDK) ListDomainUsers(domainID string, pm sdk.PageMetadata, token strin return r0, r1 } +// SDK_ListDomainUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDomainUsers' +type SDK_ListDomainUsers_Call struct { + *mock.Call +} + +// ListDomainUsers is a helper method to define mock.On call +// - domainID string +// - pm sdk.PageMetadata +// - token string +func (_e *SDK_Expecter) ListDomainUsers(domainID interface{}, pm interface{}, token interface{}) *SDK_ListDomainUsers_Call { + return &SDK_ListDomainUsers_Call{Call: _e.mock.On("ListDomainUsers", domainID, pm, token)} +} + +func (_c *SDK_ListDomainUsers_Call) Run(run func(domainID string, pm sdk.PageMetadata, token string)) *SDK_ListDomainUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.PageMetadata), args[2].(string)) + }) + return _c +} + +func (_c *SDK_ListDomainUsers_Call) Return(_a0 sdk.UsersPage, _a1 errors.SDKError) *SDK_ListDomainUsers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ListDomainUsers_Call) RunAndReturn(run func(string, sdk.PageMetadata, string) (sdk.UsersPage, errors.SDKError)) *SDK_ListDomainUsers_Call { + _c.Call.Return(run) + return _c +} + // ListGroupChannels provides a mock function with given fields: groupID, pm, domainID, token func (_m *SDK) ListGroupChannels(groupID string, pm sdk.PageMetadata, domainID string, token string) (sdk.ChannelsPage, errors.SDKError) { ret := _m.Called(groupID, pm, domainID, token) @@ -1700,6 +3538,37 @@ func (_m *SDK) ListGroupChannels(groupID string, pm sdk.PageMetadata, domainID s return r0, r1 } +// SDK_ListGroupChannels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListGroupChannels' +type SDK_ListGroupChannels_Call struct { + *mock.Call +} + +// ListGroupChannels is a helper method to define mock.On call +// - groupID string +// - pm sdk.PageMetadata +// - domainID string +// - token string +func (_e *SDK_Expecter) ListGroupChannels(groupID interface{}, pm interface{}, domainID interface{}, token interface{}) *SDK_ListGroupChannels_Call { + return &SDK_ListGroupChannels_Call{Call: _e.mock.On("ListGroupChannels", groupID, pm, domainID, token)} +} + +func (_c *SDK_ListGroupChannels_Call) Run(run func(groupID string, pm sdk.PageMetadata, domainID string, token string)) *SDK_ListGroupChannels_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.PageMetadata), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_ListGroupChannels_Call) Return(_a0 sdk.ChannelsPage, _a1 errors.SDKError) *SDK_ListGroupChannels_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ListGroupChannels_Call) RunAndReturn(run func(string, sdk.PageMetadata, string, string) (sdk.ChannelsPage, errors.SDKError)) *SDK_ListGroupChannels_Call { + _c.Call.Return(run) + return _c +} + // ListGroupUsers provides a mock function with given fields: groupID, pm, domainID, token func (_m *SDK) ListGroupUsers(groupID string, pm sdk.PageMetadata, domainID string, token string) (sdk.UsersPage, errors.SDKError) { ret := _m.Called(groupID, pm, domainID, token) @@ -1730,6 +3599,37 @@ func (_m *SDK) ListGroupUsers(groupID string, pm sdk.PageMetadata, domainID stri return r0, r1 } +// SDK_ListGroupUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListGroupUsers' +type SDK_ListGroupUsers_Call struct { + *mock.Call +} + +// ListGroupUsers is a helper method to define mock.On call +// - groupID string +// - pm sdk.PageMetadata +// - domainID string +// - token string +func (_e *SDK_Expecter) ListGroupUsers(groupID interface{}, pm interface{}, domainID interface{}, token interface{}) *SDK_ListGroupUsers_Call { + return &SDK_ListGroupUsers_Call{Call: _e.mock.On("ListGroupUsers", groupID, pm, domainID, token)} +} + +func (_c *SDK_ListGroupUsers_Call) Run(run func(groupID string, pm sdk.PageMetadata, domainID string, token string)) *SDK_ListGroupUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.PageMetadata), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_ListGroupUsers_Call) Return(_a0 sdk.UsersPage, _a1 errors.SDKError) *SDK_ListGroupUsers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ListGroupUsers_Call) RunAndReturn(run func(string, sdk.PageMetadata, string, string) (sdk.UsersPage, errors.SDKError)) *SDK_ListGroupUsers_Call { + _c.Call.Return(run) + return _c +} + // ListSubscriptions provides a mock function with given fields: pm, token func (_m *SDK) ListSubscriptions(pm sdk.PageMetadata, token string) (sdk.SubscriptionPage, errors.SDKError) { ret := _m.Called(pm, token) @@ -1760,6 +3660,35 @@ func (_m *SDK) ListSubscriptions(pm sdk.PageMetadata, token string) (sdk.Subscri return r0, r1 } +// SDK_ListSubscriptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSubscriptions' +type SDK_ListSubscriptions_Call struct { + *mock.Call +} + +// ListSubscriptions is a helper method to define mock.On call +// - pm sdk.PageMetadata +// - token string +func (_e *SDK_Expecter) ListSubscriptions(pm interface{}, token interface{}) *SDK_ListSubscriptions_Call { + return &SDK_ListSubscriptions_Call{Call: _e.mock.On("ListSubscriptions", pm, token)} +} + +func (_c *SDK_ListSubscriptions_Call) Run(run func(pm sdk.PageMetadata, token string)) *SDK_ListSubscriptions_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.PageMetadata), args[1].(string)) + }) + return _c +} + +func (_c *SDK_ListSubscriptions_Call) Return(_a0 sdk.SubscriptionPage, _a1 errors.SDKError) *SDK_ListSubscriptions_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ListSubscriptions_Call) RunAndReturn(run func(sdk.PageMetadata, string) (sdk.SubscriptionPage, errors.SDKError)) *SDK_ListSubscriptions_Call { + _c.Call.Return(run) + return _c +} + // ListUserChannels provides a mock function with given fields: userID, pm, token func (_m *SDK) ListUserChannels(userID string, pm sdk.PageMetadata, token string) (sdk.ChannelsPage, errors.SDKError) { ret := _m.Called(userID, pm, token) @@ -1790,6 +3719,36 @@ func (_m *SDK) ListUserChannels(userID string, pm sdk.PageMetadata, token string return r0, r1 } +// SDK_ListUserChannels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListUserChannels' +type SDK_ListUserChannels_Call struct { + *mock.Call +} + +// ListUserChannels is a helper method to define mock.On call +// - userID string +// - pm sdk.PageMetadata +// - token string +func (_e *SDK_Expecter) ListUserChannels(userID interface{}, pm interface{}, token interface{}) *SDK_ListUserChannels_Call { + return &SDK_ListUserChannels_Call{Call: _e.mock.On("ListUserChannels", userID, pm, token)} +} + +func (_c *SDK_ListUserChannels_Call) Run(run func(userID string, pm sdk.PageMetadata, token string)) *SDK_ListUserChannels_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.PageMetadata), args[2].(string)) + }) + return _c +} + +func (_c *SDK_ListUserChannels_Call) Return(_a0 sdk.ChannelsPage, _a1 errors.SDKError) *SDK_ListUserChannels_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ListUserChannels_Call) RunAndReturn(run func(string, sdk.PageMetadata, string) (sdk.ChannelsPage, errors.SDKError)) *SDK_ListUserChannels_Call { + _c.Call.Return(run) + return _c +} + // ListUserClients provides a mock function with given fields: userID, pm, token func (_m *SDK) ListUserClients(userID string, pm sdk.PageMetadata, token string) (sdk.ClientsPage, errors.SDKError) { ret := _m.Called(userID, pm, token) @@ -1820,6 +3779,36 @@ func (_m *SDK) ListUserClients(userID string, pm sdk.PageMetadata, token string) return r0, r1 } +// SDK_ListUserClients_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListUserClients' +type SDK_ListUserClients_Call struct { + *mock.Call +} + +// ListUserClients is a helper method to define mock.On call +// - userID string +// - pm sdk.PageMetadata +// - token string +func (_e *SDK_Expecter) ListUserClients(userID interface{}, pm interface{}, token interface{}) *SDK_ListUserClients_Call { + return &SDK_ListUserClients_Call{Call: _e.mock.On("ListUserClients", userID, pm, token)} +} + +func (_c *SDK_ListUserClients_Call) Run(run func(userID string, pm sdk.PageMetadata, token string)) *SDK_ListUserClients_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.PageMetadata), args[2].(string)) + }) + return _c +} + +func (_c *SDK_ListUserClients_Call) Return(_a0 sdk.ClientsPage, _a1 errors.SDKError) *SDK_ListUserClients_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ListUserClients_Call) RunAndReturn(run func(string, sdk.PageMetadata, string) (sdk.ClientsPage, errors.SDKError)) *SDK_ListUserClients_Call { + _c.Call.Return(run) + return _c +} + // ListUserDomains provides a mock function with given fields: userID, pm, token func (_m *SDK) ListUserDomains(userID string, pm sdk.PageMetadata, token string) (sdk.DomainsPage, errors.SDKError) { ret := _m.Called(userID, pm, token) @@ -1850,6 +3839,36 @@ func (_m *SDK) ListUserDomains(userID string, pm sdk.PageMetadata, token string) return r0, r1 } +// SDK_ListUserDomains_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListUserDomains' +type SDK_ListUserDomains_Call struct { + *mock.Call +} + +// ListUserDomains is a helper method to define mock.On call +// - userID string +// - pm sdk.PageMetadata +// - token string +func (_e *SDK_Expecter) ListUserDomains(userID interface{}, pm interface{}, token interface{}) *SDK_ListUserDomains_Call { + return &SDK_ListUserDomains_Call{Call: _e.mock.On("ListUserDomains", userID, pm, token)} +} + +func (_c *SDK_ListUserDomains_Call) Run(run func(userID string, pm sdk.PageMetadata, token string)) *SDK_ListUserDomains_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.PageMetadata), args[2].(string)) + }) + return _c +} + +func (_c *SDK_ListUserDomains_Call) Return(_a0 sdk.DomainsPage, _a1 errors.SDKError) *SDK_ListUserDomains_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ListUserDomains_Call) RunAndReturn(run func(string, sdk.PageMetadata, string) (sdk.DomainsPage, errors.SDKError)) *SDK_ListUserDomains_Call { + _c.Call.Return(run) + return _c +} + // ListUserGroups provides a mock function with given fields: userID, pm, token func (_m *SDK) ListUserGroups(userID string, pm sdk.PageMetadata, token string) (sdk.GroupsPage, errors.SDKError) { ret := _m.Called(userID, pm, token) @@ -1880,6 +3899,36 @@ func (_m *SDK) ListUserGroups(userID string, pm sdk.PageMetadata, token string) return r0, r1 } +// SDK_ListUserGroups_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListUserGroups' +type SDK_ListUserGroups_Call struct { + *mock.Call +} + +// ListUserGroups is a helper method to define mock.On call +// - userID string +// - pm sdk.PageMetadata +// - token string +func (_e *SDK_Expecter) ListUserGroups(userID interface{}, pm interface{}, token interface{}) *SDK_ListUserGroups_Call { + return &SDK_ListUserGroups_Call{Call: _e.mock.On("ListUserGroups", userID, pm, token)} +} + +func (_c *SDK_ListUserGroups_Call) Run(run func(userID string, pm sdk.PageMetadata, token string)) *SDK_ListUserGroups_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.PageMetadata), args[2].(string)) + }) + return _c +} + +func (_c *SDK_ListUserGroups_Call) Return(_a0 sdk.GroupsPage, _a1 errors.SDKError) *SDK_ListUserGroups_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ListUserGroups_Call) RunAndReturn(run func(string, sdk.PageMetadata, string) (sdk.GroupsPage, errors.SDKError)) *SDK_ListUserGroups_Call { + _c.Call.Return(run) + return _c +} + // Members provides a mock function with given fields: groupID, meta, token func (_m *SDK) Members(groupID string, meta sdk.PageMetadata, token string) (sdk.UsersPage, errors.SDKError) { ret := _m.Called(groupID, meta, token) @@ -1910,6 +3959,36 @@ func (_m *SDK) Members(groupID string, meta sdk.PageMetadata, token string) (sdk return r0, r1 } +// SDK_Members_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Members' +type SDK_Members_Call struct { + *mock.Call +} + +// Members is a helper method to define mock.On call +// - groupID string +// - meta sdk.PageMetadata +// - token string +func (_e *SDK_Expecter) Members(groupID interface{}, meta interface{}, token interface{}) *SDK_Members_Call { + return &SDK_Members_Call{Call: _e.mock.On("Members", groupID, meta, token)} +} + +func (_c *SDK_Members_Call) Run(run func(groupID string, meta sdk.PageMetadata, token string)) *SDK_Members_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.PageMetadata), args[2].(string)) + }) + return _c +} + +func (_c *SDK_Members_Call) Return(_a0 sdk.UsersPage, _a1 errors.SDKError) *SDK_Members_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Members_Call) RunAndReturn(run func(string, sdk.PageMetadata, string) (sdk.UsersPage, errors.SDKError)) *SDK_Members_Call { + _c.Call.Return(run) + return _c +} + // Parents provides a mock function with given fields: id, pm, domainID, token func (_m *SDK) Parents(id string, pm sdk.PageMetadata, domainID string, token string) (sdk.GroupsPage, errors.SDKError) { ret := _m.Called(id, pm, domainID, token) @@ -1940,6 +4019,37 @@ func (_m *SDK) Parents(id string, pm sdk.PageMetadata, domainID string, token st return r0, r1 } +// SDK_Parents_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Parents' +type SDK_Parents_Call struct { + *mock.Call +} + +// Parents is a helper method to define mock.On call +// - id string +// - pm sdk.PageMetadata +// - domainID string +// - token string +func (_e *SDK_Expecter) Parents(id interface{}, pm interface{}, domainID interface{}, token interface{}) *SDK_Parents_Call { + return &SDK_Parents_Call{Call: _e.mock.On("Parents", id, pm, domainID, token)} +} + +func (_c *SDK_Parents_Call) Run(run func(id string, pm sdk.PageMetadata, domainID string, token string)) *SDK_Parents_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.PageMetadata), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_Parents_Call) Return(_a0 sdk.GroupsPage, _a1 errors.SDKError) *SDK_Parents_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Parents_Call) RunAndReturn(run func(string, sdk.PageMetadata, string, string) (sdk.GroupsPage, errors.SDKError)) *SDK_Parents_Call { + _c.Call.Return(run) + return _c +} + // ReadMessages provides a mock function with given fields: pm, chanID, domainID, token func (_m *SDK) ReadMessages(pm sdk.MessagePageMetadata, chanID string, domainID string, token string) (sdk.MessagesPage, errors.SDKError) { ret := _m.Called(pm, chanID, domainID, token) @@ -1970,6 +4080,37 @@ func (_m *SDK) ReadMessages(pm sdk.MessagePageMetadata, chanID string, domainID return r0, r1 } +// SDK_ReadMessages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadMessages' +type SDK_ReadMessages_Call struct { + *mock.Call +} + +// ReadMessages is a helper method to define mock.On call +// - pm sdk.MessagePageMetadata +// - chanID string +// - domainID string +// - token string +func (_e *SDK_Expecter) ReadMessages(pm interface{}, chanID interface{}, domainID interface{}, token interface{}) *SDK_ReadMessages_Call { + return &SDK_ReadMessages_Call{Call: _e.mock.On("ReadMessages", pm, chanID, domainID, token)} +} + +func (_c *SDK_ReadMessages_Call) Run(run func(pm sdk.MessagePageMetadata, chanID string, domainID string, token string)) *SDK_ReadMessages_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.MessagePageMetadata), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_ReadMessages_Call) Return(_a0 sdk.MessagesPage, _a1 errors.SDKError) *SDK_ReadMessages_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ReadMessages_Call) RunAndReturn(run func(sdk.MessagePageMetadata, string, string, string) (sdk.MessagesPage, errors.SDKError)) *SDK_ReadMessages_Call { + _c.Call.Return(run) + return _c +} + // RefreshToken provides a mock function with given fields: token func (_m *SDK) RefreshToken(token string) (sdk.Token, errors.SDKError) { ret := _m.Called(token) @@ -2000,6 +4141,34 @@ func (_m *SDK) RefreshToken(token string) (sdk.Token, errors.SDKError) { return r0, r1 } +// SDK_RefreshToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefreshToken' +type SDK_RefreshToken_Call struct { + *mock.Call +} + +// RefreshToken is a helper method to define mock.On call +// - token string +func (_e *SDK_Expecter) RefreshToken(token interface{}) *SDK_RefreshToken_Call { + return &SDK_RefreshToken_Call{Call: _e.mock.On("RefreshToken", token)} +} + +func (_c *SDK_RefreshToken_Call) Run(run func(token string)) *SDK_RefreshToken_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *SDK_RefreshToken_Call) Return(_a0 sdk.Token, _a1 errors.SDKError) *SDK_RefreshToken_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_RefreshToken_Call) RunAndReturn(run func(string) (sdk.Token, errors.SDKError)) *SDK_RefreshToken_Call { + _c.Call.Return(run) + return _c +} + // RejectInvitation provides a mock function with given fields: domainID, token func (_m *SDK) RejectInvitation(domainID string, token string) error { ret := _m.Called(domainID, token) @@ -2018,6 +4187,35 @@ func (_m *SDK) RejectInvitation(domainID string, token string) error { return r0 } +// SDK_RejectInvitation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RejectInvitation' +type SDK_RejectInvitation_Call struct { + *mock.Call +} + +// RejectInvitation is a helper method to define mock.On call +// - domainID string +// - token string +func (_e *SDK_Expecter) RejectInvitation(domainID interface{}, token interface{}) *SDK_RejectInvitation_Call { + return &SDK_RejectInvitation_Call{Call: _e.mock.On("RejectInvitation", domainID, token)} +} + +func (_c *SDK_RejectInvitation_Call) Run(run func(domainID string, token string)) *SDK_RejectInvitation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_RejectInvitation_Call) Return(err error) *SDK_RejectInvitation_Call { + _c.Call.Return(err) + return _c +} + +func (_c *SDK_RejectInvitation_Call) RunAndReturn(run func(string, string) error) *SDK_RejectInvitation_Call { + _c.Call.Return(run) + return _c +} + // RemoveBootstrap provides a mock function with given fields: id, domainID, token func (_m *SDK) RemoveBootstrap(id string, domainID string, token string) errors.SDKError { ret := _m.Called(id, domainID, token) @@ -2038,6 +4236,36 @@ func (_m *SDK) RemoveBootstrap(id string, domainID string, token string) errors. return r0 } +// SDK_RemoveBootstrap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveBootstrap' +type SDK_RemoveBootstrap_Call struct { + *mock.Call +} + +// RemoveBootstrap is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) RemoveBootstrap(id interface{}, domainID interface{}, token interface{}) *SDK_RemoveBootstrap_Call { + return &SDK_RemoveBootstrap_Call{Call: _e.mock.On("RemoveBootstrap", id, domainID, token)} +} + +func (_c *SDK_RemoveBootstrap_Call) Run(run func(id string, domainID string, token string)) *SDK_RemoveBootstrap_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_RemoveBootstrap_Call) Return(_a0 errors.SDKError) *SDK_RemoveBootstrap_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveBootstrap_Call) RunAndReturn(run func(string, string, string) errors.SDKError) *SDK_RemoveBootstrap_Call { + _c.Call.Return(run) + return _c +} + // RemoveUserFromChannel provides a mock function with given fields: channelID, req, domainID, token func (_m *SDK) RemoveUserFromChannel(channelID string, req sdk.UsersRelationRequest, domainID string, token string) errors.SDKError { ret := _m.Called(channelID, req, domainID, token) @@ -2058,6 +4286,37 @@ func (_m *SDK) RemoveUserFromChannel(channelID string, req sdk.UsersRelationRequ return r0 } +// SDK_RemoveUserFromChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveUserFromChannel' +type SDK_RemoveUserFromChannel_Call struct { + *mock.Call +} + +// RemoveUserFromChannel is a helper method to define mock.On call +// - channelID string +// - req sdk.UsersRelationRequest +// - domainID string +// - token string +func (_e *SDK_Expecter) RemoveUserFromChannel(channelID interface{}, req interface{}, domainID interface{}, token interface{}) *SDK_RemoveUserFromChannel_Call { + return &SDK_RemoveUserFromChannel_Call{Call: _e.mock.On("RemoveUserFromChannel", channelID, req, domainID, token)} +} + +func (_c *SDK_RemoveUserFromChannel_Call) Run(run func(channelID string, req sdk.UsersRelationRequest, domainID string, token string)) *SDK_RemoveUserFromChannel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.UsersRelationRequest), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_RemoveUserFromChannel_Call) Return(_a0 errors.SDKError) *SDK_RemoveUserFromChannel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveUserFromChannel_Call) RunAndReturn(run func(string, sdk.UsersRelationRequest, string, string) errors.SDKError) *SDK_RemoveUserFromChannel_Call { + _c.Call.Return(run) + return _c +} + // RemoveUserFromDomain provides a mock function with given fields: domainID, userID, token func (_m *SDK) RemoveUserFromDomain(domainID string, userID string, token string) errors.SDKError { ret := _m.Called(domainID, userID, token) @@ -2078,6 +4337,36 @@ func (_m *SDK) RemoveUserFromDomain(domainID string, userID string, token string return r0 } +// SDK_RemoveUserFromDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveUserFromDomain' +type SDK_RemoveUserFromDomain_Call struct { + *mock.Call +} + +// RemoveUserFromDomain is a helper method to define mock.On call +// - domainID string +// - userID string +// - token string +func (_e *SDK_Expecter) RemoveUserFromDomain(domainID interface{}, userID interface{}, token interface{}) *SDK_RemoveUserFromDomain_Call { + return &SDK_RemoveUserFromDomain_Call{Call: _e.mock.On("RemoveUserFromDomain", domainID, userID, token)} +} + +func (_c *SDK_RemoveUserFromDomain_Call) Run(run func(domainID string, userID string, token string)) *SDK_RemoveUserFromDomain_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_RemoveUserFromDomain_Call) Return(_a0 errors.SDKError) *SDK_RemoveUserFromDomain_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveUserFromDomain_Call) RunAndReturn(run func(string, string, string) errors.SDKError) *SDK_RemoveUserFromDomain_Call { + _c.Call.Return(run) + return _c +} + // RemoveUserFromGroup provides a mock function with given fields: groupID, req, domainID, token func (_m *SDK) RemoveUserFromGroup(groupID string, req sdk.UsersRelationRequest, domainID string, token string) errors.SDKError { ret := _m.Called(groupID, req, domainID, token) @@ -2098,6 +4387,37 @@ func (_m *SDK) RemoveUserFromGroup(groupID string, req sdk.UsersRelationRequest, return r0 } +// SDK_RemoveUserFromGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveUserFromGroup' +type SDK_RemoveUserFromGroup_Call struct { + *mock.Call +} + +// RemoveUserFromGroup is a helper method to define mock.On call +// - groupID string +// - req sdk.UsersRelationRequest +// - domainID string +// - token string +func (_e *SDK_Expecter) RemoveUserFromGroup(groupID interface{}, req interface{}, domainID interface{}, token interface{}) *SDK_RemoveUserFromGroup_Call { + return &SDK_RemoveUserFromGroup_Call{Call: _e.mock.On("RemoveUserFromGroup", groupID, req, domainID, token)} +} + +func (_c *SDK_RemoveUserFromGroup_Call) Run(run func(groupID string, req sdk.UsersRelationRequest, domainID string, token string)) *SDK_RemoveUserFromGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.UsersRelationRequest), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_RemoveUserFromGroup_Call) Return(_a0 errors.SDKError) *SDK_RemoveUserFromGroup_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveUserFromGroup_Call) RunAndReturn(run func(string, sdk.UsersRelationRequest, string, string) errors.SDKError) *SDK_RemoveUserFromGroup_Call { + _c.Call.Return(run) + return _c +} + // RemoveUserGroupFromChannel provides a mock function with given fields: channelID, req, domainID, token func (_m *SDK) RemoveUserGroupFromChannel(channelID string, req sdk.UserGroupsRequest, domainID string, token string) errors.SDKError { ret := _m.Called(channelID, req, domainID, token) @@ -2118,6 +4438,37 @@ func (_m *SDK) RemoveUserGroupFromChannel(channelID string, req sdk.UserGroupsRe return r0 } +// SDK_RemoveUserGroupFromChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveUserGroupFromChannel' +type SDK_RemoveUserGroupFromChannel_Call struct { + *mock.Call +} + +// RemoveUserGroupFromChannel is a helper method to define mock.On call +// - channelID string +// - req sdk.UserGroupsRequest +// - domainID string +// - token string +func (_e *SDK_Expecter) RemoveUserGroupFromChannel(channelID interface{}, req interface{}, domainID interface{}, token interface{}) *SDK_RemoveUserGroupFromChannel_Call { + return &SDK_RemoveUserGroupFromChannel_Call{Call: _e.mock.On("RemoveUserGroupFromChannel", channelID, req, domainID, token)} +} + +func (_c *SDK_RemoveUserGroupFromChannel_Call) Run(run func(channelID string, req sdk.UserGroupsRequest, domainID string, token string)) *SDK_RemoveUserGroupFromChannel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.UserGroupsRequest), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_RemoveUserGroupFromChannel_Call) Return(_a0 errors.SDKError) *SDK_RemoveUserGroupFromChannel_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_RemoveUserGroupFromChannel_Call) RunAndReturn(run func(string, sdk.UserGroupsRequest, string, string) errors.SDKError) *SDK_RemoveUserGroupFromChannel_Call { + _c.Call.Return(run) + return _c +} + // ResetPassword provides a mock function with given fields: password, confPass, token func (_m *SDK) ResetPassword(password string, confPass string, token string) errors.SDKError { ret := _m.Called(password, confPass, token) @@ -2138,6 +4489,36 @@ func (_m *SDK) ResetPassword(password string, confPass string, token string) err return r0 } +// SDK_ResetPassword_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetPassword' +type SDK_ResetPassword_Call struct { + *mock.Call +} + +// ResetPassword is a helper method to define mock.On call +// - password string +// - confPass string +// - token string +func (_e *SDK_Expecter) ResetPassword(password interface{}, confPass interface{}, token interface{}) *SDK_ResetPassword_Call { + return &SDK_ResetPassword_Call{Call: _e.mock.On("ResetPassword", password, confPass, token)} +} + +func (_c *SDK_ResetPassword_Call) Run(run func(password string, confPass string, token string)) *SDK_ResetPassword_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_ResetPassword_Call) Return(_a0 errors.SDKError) *SDK_ResetPassword_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_ResetPassword_Call) RunAndReturn(run func(string, string, string) errors.SDKError) *SDK_ResetPassword_Call { + _c.Call.Return(run) + return _c +} + // ResetPasswordRequest provides a mock function with given fields: email func (_m *SDK) ResetPasswordRequest(email string) errors.SDKError { ret := _m.Called(email) @@ -2158,6 +4539,34 @@ func (_m *SDK) ResetPasswordRequest(email string) errors.SDKError { return r0 } +// SDK_ResetPasswordRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetPasswordRequest' +type SDK_ResetPasswordRequest_Call struct { + *mock.Call +} + +// ResetPasswordRequest is a helper method to define mock.On call +// - email string +func (_e *SDK_Expecter) ResetPasswordRequest(email interface{}) *SDK_ResetPasswordRequest_Call { + return &SDK_ResetPasswordRequest_Call{Call: _e.mock.On("ResetPasswordRequest", email)} +} + +func (_c *SDK_ResetPasswordRequest_Call) Run(run func(email string)) *SDK_ResetPasswordRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *SDK_ResetPasswordRequest_Call) Return(_a0 errors.SDKError) *SDK_ResetPasswordRequest_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_ResetPasswordRequest_Call) RunAndReturn(run func(string) errors.SDKError) *SDK_ResetPasswordRequest_Call { + _c.Call.Return(run) + return _c +} + // RevokeCert provides a mock function with given fields: clientID, domainID, token func (_m *SDK) RevokeCert(clientID string, domainID string, token string) (time.Time, errors.SDKError) { ret := _m.Called(clientID, domainID, token) @@ -2188,6 +4597,36 @@ func (_m *SDK) RevokeCert(clientID string, domainID string, token string) (time. return r0, r1 } +// SDK_RevokeCert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevokeCert' +type SDK_RevokeCert_Call struct { + *mock.Call +} + +// RevokeCert is a helper method to define mock.On call +// - clientID string +// - domainID string +// - token string +func (_e *SDK_Expecter) RevokeCert(clientID interface{}, domainID interface{}, token interface{}) *SDK_RevokeCert_Call { + return &SDK_RevokeCert_Call{Call: _e.mock.On("RevokeCert", clientID, domainID, token)} +} + +func (_c *SDK_RevokeCert_Call) Run(run func(clientID string, domainID string, token string)) *SDK_RevokeCert_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_RevokeCert_Call) Return(_a0 time.Time, _a1 errors.SDKError) *SDK_RevokeCert_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_RevokeCert_Call) RunAndReturn(run func(string, string, string) (time.Time, errors.SDKError)) *SDK_RevokeCert_Call { + _c.Call.Return(run) + return _c +} + // SearchUsers provides a mock function with given fields: pm, token func (_m *SDK) SearchUsers(pm sdk.PageMetadata, token string) (sdk.UsersPage, errors.SDKError) { ret := _m.Called(pm, token) @@ -2218,6 +4657,35 @@ func (_m *SDK) SearchUsers(pm sdk.PageMetadata, token string) (sdk.UsersPage, er return r0, r1 } +// SDK_SearchUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchUsers' +type SDK_SearchUsers_Call struct { + *mock.Call +} + +// SearchUsers is a helper method to define mock.On call +// - pm sdk.PageMetadata +// - token string +func (_e *SDK_Expecter) SearchUsers(pm interface{}, token interface{}) *SDK_SearchUsers_Call { + return &SDK_SearchUsers_Call{Call: _e.mock.On("SearchUsers", pm, token)} +} + +func (_c *SDK_SearchUsers_Call) Run(run func(pm sdk.PageMetadata, token string)) *SDK_SearchUsers_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.PageMetadata), args[1].(string)) + }) + return _c +} + +func (_c *SDK_SearchUsers_Call) Return(_a0 sdk.UsersPage, _a1 errors.SDKError) *SDK_SearchUsers_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_SearchUsers_Call) RunAndReturn(run func(sdk.PageMetadata, string) (sdk.UsersPage, errors.SDKError)) *SDK_SearchUsers_Call { + _c.Call.Return(run) + return _c +} + // SendInvitation provides a mock function with given fields: invitation, token func (_m *SDK) SendInvitation(invitation sdk.Invitation, token string) error { ret := _m.Called(invitation, token) @@ -2236,6 +4704,35 @@ func (_m *SDK) SendInvitation(invitation sdk.Invitation, token string) error { return r0 } +// SDK_SendInvitation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendInvitation' +type SDK_SendInvitation_Call struct { + *mock.Call +} + +// SendInvitation is a helper method to define mock.On call +// - invitation sdk.Invitation +// - token string +func (_e *SDK_Expecter) SendInvitation(invitation interface{}, token interface{}) *SDK_SendInvitation_Call { + return &SDK_SendInvitation_Call{Call: _e.mock.On("SendInvitation", invitation, token)} +} + +func (_c *SDK_SendInvitation_Call) Run(run func(invitation sdk.Invitation, token string)) *SDK_SendInvitation_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.Invitation), args[1].(string)) + }) + return _c +} + +func (_c *SDK_SendInvitation_Call) Return(err error) *SDK_SendInvitation_Call { + _c.Call.Return(err) + return _c +} + +func (_c *SDK_SendInvitation_Call) RunAndReturn(run func(sdk.Invitation, string) error) *SDK_SendInvitation_Call { + _c.Call.Return(run) + return _c +} + // SendMessage provides a mock function with given fields: chanID, msg, key func (_m *SDK) SendMessage(chanID string, msg string, key string) errors.SDKError { ret := _m.Called(chanID, msg, key) @@ -2256,6 +4753,36 @@ func (_m *SDK) SendMessage(chanID string, msg string, key string) errors.SDKErro return r0 } +// SDK_SendMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMessage' +type SDK_SendMessage_Call struct { + *mock.Call +} + +// SendMessage is a helper method to define mock.On call +// - chanID string +// - msg string +// - key string +func (_e *SDK_Expecter) SendMessage(chanID interface{}, msg interface{}, key interface{}) *SDK_SendMessage_Call { + return &SDK_SendMessage_Call{Call: _e.mock.On("SendMessage", chanID, msg, key)} +} + +func (_c *SDK_SendMessage_Call) Run(run func(chanID string, msg string, key string)) *SDK_SendMessage_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_SendMessage_Call) Return(_a0 errors.SDKError) *SDK_SendMessage_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_SendMessage_Call) RunAndReturn(run func(string, string, string) errors.SDKError) *SDK_SendMessage_Call { + _c.Call.Return(run) + return _c +} + // SetContentType provides a mock function with given fields: ct func (_m *SDK) SetContentType(ct sdk.ContentType) errors.SDKError { ret := _m.Called(ct) @@ -2276,6 +4803,34 @@ func (_m *SDK) SetContentType(ct sdk.ContentType) errors.SDKError { return r0 } +// SDK_SetContentType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetContentType' +type SDK_SetContentType_Call struct { + *mock.Call +} + +// SetContentType is a helper method to define mock.On call +// - ct sdk.ContentType +func (_e *SDK_Expecter) SetContentType(ct interface{}) *SDK_SetContentType_Call { + return &SDK_SetContentType_Call{Call: _e.mock.On("SetContentType", ct)} +} + +func (_c *SDK_SetContentType_Call) Run(run func(ct sdk.ContentType)) *SDK_SetContentType_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.ContentType)) + }) + return _c +} + +func (_c *SDK_SetContentType_Call) Return(_a0 errors.SDKError) *SDK_SetContentType_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_SetContentType_Call) RunAndReturn(run func(sdk.ContentType) errors.SDKError) *SDK_SetContentType_Call { + _c.Call.Return(run) + return _c +} + // ShareClient provides a mock function with given fields: id, req, domainID, token func (_m *SDK) ShareClient(id string, req sdk.UsersRelationRequest, domainID string, token string) errors.SDKError { ret := _m.Called(id, req, domainID, token) @@ -2293,7 +4848,38 @@ func (_m *SDK) ShareClient(id string, req sdk.UsersRelationRequest, domainID str } } - return r0 + return r0 +} + +// SDK_ShareClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShareClient' +type SDK_ShareClient_Call struct { + *mock.Call +} + +// ShareClient is a helper method to define mock.On call +// - id string +// - req sdk.UsersRelationRequest +// - domainID string +// - token string +func (_e *SDK_Expecter) ShareClient(id interface{}, req interface{}, domainID interface{}, token interface{}) *SDK_ShareClient_Call { + return &SDK_ShareClient_Call{Call: _e.mock.On("ShareClient", id, req, domainID, token)} +} + +func (_c *SDK_ShareClient_Call) Run(run func(id string, req sdk.UsersRelationRequest, domainID string, token string)) *SDK_ShareClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.UsersRelationRequest), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_ShareClient_Call) Return(_a0 errors.SDKError) *SDK_ShareClient_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_ShareClient_Call) RunAndReturn(run func(string, sdk.UsersRelationRequest, string, string) errors.SDKError) *SDK_ShareClient_Call { + _c.Call.Return(run) + return _c } // UnshareClient provides a mock function with given fields: id, req, domainID, token @@ -2316,6 +4902,37 @@ func (_m *SDK) UnshareClient(id string, req sdk.UsersRelationRequest, domainID s return r0 } +// SDK_UnshareClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnshareClient' +type SDK_UnshareClient_Call struct { + *mock.Call +} + +// UnshareClient is a helper method to define mock.On call +// - id string +// - req sdk.UsersRelationRequest +// - domainID string +// - token string +func (_e *SDK_Expecter) UnshareClient(id interface{}, req interface{}, domainID interface{}, token interface{}) *SDK_UnshareClient_Call { + return &SDK_UnshareClient_Call{Call: _e.mock.On("UnshareClient", id, req, domainID, token)} +} + +func (_c *SDK_UnshareClient_Call) Run(run func(id string, req sdk.UsersRelationRequest, domainID string, token string)) *SDK_UnshareClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(sdk.UsersRelationRequest), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_UnshareClient_Call) Return(_a0 errors.SDKError) *SDK_UnshareClient_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_UnshareClient_Call) RunAndReturn(run func(string, sdk.UsersRelationRequest, string, string) errors.SDKError) *SDK_UnshareClient_Call { + _c.Call.Return(run) + return _c +} + // UpdateBootstrap provides a mock function with given fields: cfg, domainID, token func (_m *SDK) UpdateBootstrap(cfg sdk.BootstrapConfig, domainID string, token string) errors.SDKError { ret := _m.Called(cfg, domainID, token) @@ -2336,6 +4953,36 @@ func (_m *SDK) UpdateBootstrap(cfg sdk.BootstrapConfig, domainID string, token s return r0 } +// SDK_UpdateBootstrap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateBootstrap' +type SDK_UpdateBootstrap_Call struct { + *mock.Call +} + +// UpdateBootstrap is a helper method to define mock.On call +// - cfg sdk.BootstrapConfig +// - domainID string +// - token string +func (_e *SDK_Expecter) UpdateBootstrap(cfg interface{}, domainID interface{}, token interface{}) *SDK_UpdateBootstrap_Call { + return &SDK_UpdateBootstrap_Call{Call: _e.mock.On("UpdateBootstrap", cfg, domainID, token)} +} + +func (_c *SDK_UpdateBootstrap_Call) Run(run func(cfg sdk.BootstrapConfig, domainID string, token string)) *SDK_UpdateBootstrap_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.BootstrapConfig), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_UpdateBootstrap_Call) Return(_a0 errors.SDKError) *SDK_UpdateBootstrap_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_UpdateBootstrap_Call) RunAndReturn(run func(sdk.BootstrapConfig, string, string) errors.SDKError) *SDK_UpdateBootstrap_Call { + _c.Call.Return(run) + return _c +} + // UpdateBootstrapCerts provides a mock function with given fields: id, clientCert, clientKey, ca, domainID, token func (_m *SDK) UpdateBootstrapCerts(id string, clientCert string, clientKey string, ca string, domainID string, token string) (sdk.BootstrapConfig, errors.SDKError) { ret := _m.Called(id, clientCert, clientKey, ca, domainID, token) @@ -2366,6 +5013,39 @@ func (_m *SDK) UpdateBootstrapCerts(id string, clientCert string, clientKey stri return r0, r1 } +// SDK_UpdateBootstrapCerts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateBootstrapCerts' +type SDK_UpdateBootstrapCerts_Call struct { + *mock.Call +} + +// UpdateBootstrapCerts is a helper method to define mock.On call +// - id string +// - clientCert string +// - clientKey string +// - ca string +// - domainID string +// - token string +func (_e *SDK_Expecter) UpdateBootstrapCerts(id interface{}, clientCert interface{}, clientKey interface{}, ca interface{}, domainID interface{}, token interface{}) *SDK_UpdateBootstrapCerts_Call { + return &SDK_UpdateBootstrapCerts_Call{Call: _e.mock.On("UpdateBootstrapCerts", id, clientCert, clientKey, ca, domainID, token)} +} + +func (_c *SDK_UpdateBootstrapCerts_Call) Run(run func(id string, clientCert string, clientKey string, ca string, domainID string, token string)) *SDK_UpdateBootstrapCerts_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(string)) + }) + return _c +} + +func (_c *SDK_UpdateBootstrapCerts_Call) Return(_a0 sdk.BootstrapConfig, _a1 errors.SDKError) *SDK_UpdateBootstrapCerts_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateBootstrapCerts_Call) RunAndReturn(run func(string, string, string, string, string, string) (sdk.BootstrapConfig, errors.SDKError)) *SDK_UpdateBootstrapCerts_Call { + _c.Call.Return(run) + return _c +} + // UpdateBootstrapConnection provides a mock function with given fields: id, channels, domainID, token func (_m *SDK) UpdateBootstrapConnection(id string, channels []string, domainID string, token string) errors.SDKError { ret := _m.Called(id, channels, domainID, token) @@ -2386,6 +5066,37 @@ func (_m *SDK) UpdateBootstrapConnection(id string, channels []string, domainID return r0 } +// SDK_UpdateBootstrapConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateBootstrapConnection' +type SDK_UpdateBootstrapConnection_Call struct { + *mock.Call +} + +// UpdateBootstrapConnection is a helper method to define mock.On call +// - id string +// - channels []string +// - domainID string +// - token string +func (_e *SDK_Expecter) UpdateBootstrapConnection(id interface{}, channels interface{}, domainID interface{}, token interface{}) *SDK_UpdateBootstrapConnection_Call { + return &SDK_UpdateBootstrapConnection_Call{Call: _e.mock.On("UpdateBootstrapConnection", id, channels, domainID, token)} +} + +func (_c *SDK_UpdateBootstrapConnection_Call) Run(run func(id string, channels []string, domainID string, token string)) *SDK_UpdateBootstrapConnection_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].([]string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_UpdateBootstrapConnection_Call) Return(_a0 errors.SDKError) *SDK_UpdateBootstrapConnection_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_UpdateBootstrapConnection_Call) RunAndReturn(run func(string, []string, string, string) errors.SDKError) *SDK_UpdateBootstrapConnection_Call { + _c.Call.Return(run) + return _c +} + // UpdateChannel provides a mock function with given fields: channel, domainID, token func (_m *SDK) UpdateChannel(channel sdk.Channel, domainID string, token string) (sdk.Channel, errors.SDKError) { ret := _m.Called(channel, domainID, token) @@ -2416,6 +5127,36 @@ func (_m *SDK) UpdateChannel(channel sdk.Channel, domainID string, token string) return r0, r1 } +// SDK_UpdateChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateChannel' +type SDK_UpdateChannel_Call struct { + *mock.Call +} + +// UpdateChannel is a helper method to define mock.On call +// - channel sdk.Channel +// - domainID string +// - token string +func (_e *SDK_Expecter) UpdateChannel(channel interface{}, domainID interface{}, token interface{}) *SDK_UpdateChannel_Call { + return &SDK_UpdateChannel_Call{Call: _e.mock.On("UpdateChannel", channel, domainID, token)} +} + +func (_c *SDK_UpdateChannel_Call) Run(run func(channel sdk.Channel, domainID string, token string)) *SDK_UpdateChannel_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.Channel), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_UpdateChannel_Call) Return(_a0 sdk.Channel, _a1 errors.SDKError) *SDK_UpdateChannel_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateChannel_Call) RunAndReturn(run func(sdk.Channel, string, string) (sdk.Channel, errors.SDKError)) *SDK_UpdateChannel_Call { + _c.Call.Return(run) + return _c +} + // UpdateClient provides a mock function with given fields: client, domainID, token func (_m *SDK) UpdateClient(client sdk.Client, domainID string, token string) (sdk.Client, errors.SDKError) { ret := _m.Called(client, domainID, token) @@ -2446,6 +5187,36 @@ func (_m *SDK) UpdateClient(client sdk.Client, domainID string, token string) (s return r0, r1 } +// SDK_UpdateClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateClient' +type SDK_UpdateClient_Call struct { + *mock.Call +} + +// UpdateClient is a helper method to define mock.On call +// - client sdk.Client +// - domainID string +// - token string +func (_e *SDK_Expecter) UpdateClient(client interface{}, domainID interface{}, token interface{}) *SDK_UpdateClient_Call { + return &SDK_UpdateClient_Call{Call: _e.mock.On("UpdateClient", client, domainID, token)} +} + +func (_c *SDK_UpdateClient_Call) Run(run func(client sdk.Client, domainID string, token string)) *SDK_UpdateClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.Client), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_UpdateClient_Call) Return(_a0 sdk.Client, _a1 errors.SDKError) *SDK_UpdateClient_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateClient_Call) RunAndReturn(run func(sdk.Client, string, string) (sdk.Client, errors.SDKError)) *SDK_UpdateClient_Call { + _c.Call.Return(run) + return _c +} + // UpdateClientSecret provides a mock function with given fields: id, secret, domainID, token func (_m *SDK) UpdateClientSecret(id string, secret string, domainID string, token string) (sdk.Client, errors.SDKError) { ret := _m.Called(id, secret, domainID, token) @@ -2476,6 +5247,37 @@ func (_m *SDK) UpdateClientSecret(id string, secret string, domainID string, tok return r0, r1 } +// SDK_UpdateClientSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateClientSecret' +type SDK_UpdateClientSecret_Call struct { + *mock.Call +} + +// UpdateClientSecret is a helper method to define mock.On call +// - id string +// - secret string +// - domainID string +// - token string +func (_e *SDK_Expecter) UpdateClientSecret(id interface{}, secret interface{}, domainID interface{}, token interface{}) *SDK_UpdateClientSecret_Call { + return &SDK_UpdateClientSecret_Call{Call: _e.mock.On("UpdateClientSecret", id, secret, domainID, token)} +} + +func (_c *SDK_UpdateClientSecret_Call) Run(run func(id string, secret string, domainID string, token string)) *SDK_UpdateClientSecret_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_UpdateClientSecret_Call) Return(_a0 sdk.Client, _a1 errors.SDKError) *SDK_UpdateClientSecret_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateClientSecret_Call) RunAndReturn(run func(string, string, string, string) (sdk.Client, errors.SDKError)) *SDK_UpdateClientSecret_Call { + _c.Call.Return(run) + return _c +} + // UpdateClientTags provides a mock function with given fields: client, domainID, token func (_m *SDK) UpdateClientTags(client sdk.Client, domainID string, token string) (sdk.Client, errors.SDKError) { ret := _m.Called(client, domainID, token) @@ -2506,6 +5308,36 @@ func (_m *SDK) UpdateClientTags(client sdk.Client, domainID string, token string return r0, r1 } +// SDK_UpdateClientTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateClientTags' +type SDK_UpdateClientTags_Call struct { + *mock.Call +} + +// UpdateClientTags is a helper method to define mock.On call +// - client sdk.Client +// - domainID string +// - token string +func (_e *SDK_Expecter) UpdateClientTags(client interface{}, domainID interface{}, token interface{}) *SDK_UpdateClientTags_Call { + return &SDK_UpdateClientTags_Call{Call: _e.mock.On("UpdateClientTags", client, domainID, token)} +} + +func (_c *SDK_UpdateClientTags_Call) Run(run func(client sdk.Client, domainID string, token string)) *SDK_UpdateClientTags_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.Client), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_UpdateClientTags_Call) Return(_a0 sdk.Client, _a1 errors.SDKError) *SDK_UpdateClientTags_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateClientTags_Call) RunAndReturn(run func(sdk.Client, string, string) (sdk.Client, errors.SDKError)) *SDK_UpdateClientTags_Call { + _c.Call.Return(run) + return _c +} + // UpdateDomain provides a mock function with given fields: d, token func (_m *SDK) UpdateDomain(d sdk.Domain, token string) (sdk.Domain, errors.SDKError) { ret := _m.Called(d, token) @@ -2536,6 +5368,35 @@ func (_m *SDK) UpdateDomain(d sdk.Domain, token string) (sdk.Domain, errors.SDKE return r0, r1 } +// SDK_UpdateDomain_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDomain' +type SDK_UpdateDomain_Call struct { + *mock.Call +} + +// UpdateDomain is a helper method to define mock.On call +// - d sdk.Domain +// - token string +func (_e *SDK_Expecter) UpdateDomain(d interface{}, token interface{}) *SDK_UpdateDomain_Call { + return &SDK_UpdateDomain_Call{Call: _e.mock.On("UpdateDomain", d, token)} +} + +func (_c *SDK_UpdateDomain_Call) Run(run func(d sdk.Domain, token string)) *SDK_UpdateDomain_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.Domain), args[1].(string)) + }) + return _c +} + +func (_c *SDK_UpdateDomain_Call) Return(_a0 sdk.Domain, _a1 errors.SDKError) *SDK_UpdateDomain_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateDomain_Call) RunAndReturn(run func(sdk.Domain, string) (sdk.Domain, errors.SDKError)) *SDK_UpdateDomain_Call { + _c.Call.Return(run) + return _c +} + // UpdateGroup provides a mock function with given fields: group, domainID, token func (_m *SDK) UpdateGroup(group sdk.Group, domainID string, token string) (sdk.Group, errors.SDKError) { ret := _m.Called(group, domainID, token) @@ -2566,6 +5427,36 @@ func (_m *SDK) UpdateGroup(group sdk.Group, domainID string, token string) (sdk. return r0, r1 } +// SDK_UpdateGroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateGroup' +type SDK_UpdateGroup_Call struct { + *mock.Call +} + +// UpdateGroup is a helper method to define mock.On call +// - group sdk.Group +// - domainID string +// - token string +func (_e *SDK_Expecter) UpdateGroup(group interface{}, domainID interface{}, token interface{}) *SDK_UpdateGroup_Call { + return &SDK_UpdateGroup_Call{Call: _e.mock.On("UpdateGroup", group, domainID, token)} +} + +func (_c *SDK_UpdateGroup_Call) Run(run func(group sdk.Group, domainID string, token string)) *SDK_UpdateGroup_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.Group), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_UpdateGroup_Call) Return(_a0 sdk.Group, _a1 errors.SDKError) *SDK_UpdateGroup_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateGroup_Call) RunAndReturn(run func(sdk.Group, string, string) (sdk.Group, errors.SDKError)) *SDK_UpdateGroup_Call { + _c.Call.Return(run) + return _c +} + // UpdatePassword provides a mock function with given fields: oldPass, newPass, token func (_m *SDK) UpdatePassword(oldPass string, newPass string, token string) (sdk.User, errors.SDKError) { ret := _m.Called(oldPass, newPass, token) @@ -2596,6 +5487,36 @@ func (_m *SDK) UpdatePassword(oldPass string, newPass string, token string) (sdk return r0, r1 } +// SDK_UpdatePassword_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePassword' +type SDK_UpdatePassword_Call struct { + *mock.Call +} + +// UpdatePassword is a helper method to define mock.On call +// - oldPass string +// - newPass string +// - token string +func (_e *SDK_Expecter) UpdatePassword(oldPass interface{}, newPass interface{}, token interface{}) *SDK_UpdatePassword_Call { + return &SDK_UpdatePassword_Call{Call: _e.mock.On("UpdatePassword", oldPass, newPass, token)} +} + +func (_c *SDK_UpdatePassword_Call) Run(run func(oldPass string, newPass string, token string)) *SDK_UpdatePassword_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_UpdatePassword_Call) Return(_a0 sdk.User, _a1 errors.SDKError) *SDK_UpdatePassword_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdatePassword_Call) RunAndReturn(run func(string, string, string) (sdk.User, errors.SDKError)) *SDK_UpdatePassword_Call { + _c.Call.Return(run) + return _c +} + // UpdateProfilePicture provides a mock function with given fields: user, token func (_m *SDK) UpdateProfilePicture(user sdk.User, token string) (sdk.User, errors.SDKError) { ret := _m.Called(user, token) @@ -2626,6 +5547,35 @@ func (_m *SDK) UpdateProfilePicture(user sdk.User, token string) (sdk.User, erro return r0, r1 } +// SDK_UpdateProfilePicture_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProfilePicture' +type SDK_UpdateProfilePicture_Call struct { + *mock.Call +} + +// UpdateProfilePicture is a helper method to define mock.On call +// - user sdk.User +// - token string +func (_e *SDK_Expecter) UpdateProfilePicture(user interface{}, token interface{}) *SDK_UpdateProfilePicture_Call { + return &SDK_UpdateProfilePicture_Call{Call: _e.mock.On("UpdateProfilePicture", user, token)} +} + +func (_c *SDK_UpdateProfilePicture_Call) Run(run func(user sdk.User, token string)) *SDK_UpdateProfilePicture_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.User), args[1].(string)) + }) + return _c +} + +func (_c *SDK_UpdateProfilePicture_Call) Return(_a0 sdk.User, _a1 errors.SDKError) *SDK_UpdateProfilePicture_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateProfilePicture_Call) RunAndReturn(run func(sdk.User, string) (sdk.User, errors.SDKError)) *SDK_UpdateProfilePicture_Call { + _c.Call.Return(run) + return _c +} + // UpdateUser provides a mock function with given fields: user, token func (_m *SDK) UpdateUser(user sdk.User, token string) (sdk.User, errors.SDKError) { ret := _m.Called(user, token) @@ -2656,6 +5606,35 @@ func (_m *SDK) UpdateUser(user sdk.User, token string) (sdk.User, errors.SDKErro return r0, r1 } +// SDK_UpdateUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUser' +type SDK_UpdateUser_Call struct { + *mock.Call +} + +// UpdateUser is a helper method to define mock.On call +// - user sdk.User +// - token string +func (_e *SDK_Expecter) UpdateUser(user interface{}, token interface{}) *SDK_UpdateUser_Call { + return &SDK_UpdateUser_Call{Call: _e.mock.On("UpdateUser", user, token)} +} + +func (_c *SDK_UpdateUser_Call) Run(run func(user sdk.User, token string)) *SDK_UpdateUser_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.User), args[1].(string)) + }) + return _c +} + +func (_c *SDK_UpdateUser_Call) Return(_a0 sdk.User, _a1 errors.SDKError) *SDK_UpdateUser_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateUser_Call) RunAndReturn(run func(sdk.User, string) (sdk.User, errors.SDKError)) *SDK_UpdateUser_Call { + _c.Call.Return(run) + return _c +} + // UpdateUserEmail provides a mock function with given fields: user, token func (_m *SDK) UpdateUserEmail(user sdk.User, token string) (sdk.User, errors.SDKError) { ret := _m.Called(user, token) @@ -2686,6 +5665,35 @@ func (_m *SDK) UpdateUserEmail(user sdk.User, token string) (sdk.User, errors.SD return r0, r1 } +// SDK_UpdateUserEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUserEmail' +type SDK_UpdateUserEmail_Call struct { + *mock.Call +} + +// UpdateUserEmail is a helper method to define mock.On call +// - user sdk.User +// - token string +func (_e *SDK_Expecter) UpdateUserEmail(user interface{}, token interface{}) *SDK_UpdateUserEmail_Call { + return &SDK_UpdateUserEmail_Call{Call: _e.mock.On("UpdateUserEmail", user, token)} +} + +func (_c *SDK_UpdateUserEmail_Call) Run(run func(user sdk.User, token string)) *SDK_UpdateUserEmail_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.User), args[1].(string)) + }) + return _c +} + +func (_c *SDK_UpdateUserEmail_Call) Return(_a0 sdk.User, _a1 errors.SDKError) *SDK_UpdateUserEmail_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateUserEmail_Call) RunAndReturn(run func(sdk.User, string) (sdk.User, errors.SDKError)) *SDK_UpdateUserEmail_Call { + _c.Call.Return(run) + return _c +} + // UpdateUserRole provides a mock function with given fields: user, token func (_m *SDK) UpdateUserRole(user sdk.User, token string) (sdk.User, errors.SDKError) { ret := _m.Called(user, token) @@ -2716,6 +5724,35 @@ func (_m *SDK) UpdateUserRole(user sdk.User, token string) (sdk.User, errors.SDK return r0, r1 } +// SDK_UpdateUserRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUserRole' +type SDK_UpdateUserRole_Call struct { + *mock.Call +} + +// UpdateUserRole is a helper method to define mock.On call +// - user sdk.User +// - token string +func (_e *SDK_Expecter) UpdateUserRole(user interface{}, token interface{}) *SDK_UpdateUserRole_Call { + return &SDK_UpdateUserRole_Call{Call: _e.mock.On("UpdateUserRole", user, token)} +} + +func (_c *SDK_UpdateUserRole_Call) Run(run func(user sdk.User, token string)) *SDK_UpdateUserRole_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.User), args[1].(string)) + }) + return _c +} + +func (_c *SDK_UpdateUserRole_Call) Return(_a0 sdk.User, _a1 errors.SDKError) *SDK_UpdateUserRole_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateUserRole_Call) RunAndReturn(run func(sdk.User, string) (sdk.User, errors.SDKError)) *SDK_UpdateUserRole_Call { + _c.Call.Return(run) + return _c +} + // UpdateUserTags provides a mock function with given fields: user, token func (_m *SDK) UpdateUserTags(user sdk.User, token string) (sdk.User, errors.SDKError) { ret := _m.Called(user, token) @@ -2746,6 +5783,35 @@ func (_m *SDK) UpdateUserTags(user sdk.User, token string) (sdk.User, errors.SDK return r0, r1 } +// SDK_UpdateUserTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUserTags' +type SDK_UpdateUserTags_Call struct { + *mock.Call +} + +// UpdateUserTags is a helper method to define mock.On call +// - user sdk.User +// - token string +func (_e *SDK_Expecter) UpdateUserTags(user interface{}, token interface{}) *SDK_UpdateUserTags_Call { + return &SDK_UpdateUserTags_Call{Call: _e.mock.On("UpdateUserTags", user, token)} +} + +func (_c *SDK_UpdateUserTags_Call) Run(run func(user sdk.User, token string)) *SDK_UpdateUserTags_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.User), args[1].(string)) + }) + return _c +} + +func (_c *SDK_UpdateUserTags_Call) Return(_a0 sdk.User, _a1 errors.SDKError) *SDK_UpdateUserTags_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateUserTags_Call) RunAndReturn(run func(sdk.User, string) (sdk.User, errors.SDKError)) *SDK_UpdateUserTags_Call { + _c.Call.Return(run) + return _c +} + // UpdateUsername provides a mock function with given fields: user, token func (_m *SDK) UpdateUsername(user sdk.User, token string) (sdk.User, errors.SDKError) { ret := _m.Called(user, token) @@ -2776,6 +5842,35 @@ func (_m *SDK) UpdateUsername(user sdk.User, token string) (sdk.User, errors.SDK return r0, r1 } +// SDK_UpdateUsername_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUsername' +type SDK_UpdateUsername_Call struct { + *mock.Call +} + +// UpdateUsername is a helper method to define mock.On call +// - user sdk.User +// - token string +func (_e *SDK_Expecter) UpdateUsername(user interface{}, token interface{}) *SDK_UpdateUsername_Call { + return &SDK_UpdateUsername_Call{Call: _e.mock.On("UpdateUsername", user, token)} +} + +func (_c *SDK_UpdateUsername_Call) Run(run func(user sdk.User, token string)) *SDK_UpdateUsername_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.User), args[1].(string)) + }) + return _c +} + +func (_c *SDK_UpdateUsername_Call) Return(_a0 sdk.User, _a1 errors.SDKError) *SDK_UpdateUsername_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UpdateUsername_Call) RunAndReturn(run func(sdk.User, string) (sdk.User, errors.SDKError)) *SDK_UpdateUsername_Call { + _c.Call.Return(run) + return _c +} + // User provides a mock function with given fields: id, token func (_m *SDK) User(id string, token string) (sdk.User, errors.SDKError) { ret := _m.Called(id, token) @@ -2806,6 +5901,35 @@ func (_m *SDK) User(id string, token string) (sdk.User, errors.SDKError) { return r0, r1 } +// SDK_User_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'User' +type SDK_User_Call struct { + *mock.Call +} + +// User is a helper method to define mock.On call +// - id string +// - token string +func (_e *SDK_Expecter) User(id interface{}, token interface{}) *SDK_User_Call { + return &SDK_User_Call{Call: _e.mock.On("User", id, token)} +} + +func (_c *SDK_User_Call) Run(run func(id string, token string)) *SDK_User_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_User_Call) Return(_a0 sdk.User, _a1 errors.SDKError) *SDK_User_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_User_Call) RunAndReturn(run func(string, string) (sdk.User, errors.SDKError)) *SDK_User_Call { + _c.Call.Return(run) + return _c +} + // UserProfile provides a mock function with given fields: token func (_m *SDK) UserProfile(token string) (sdk.User, errors.SDKError) { ret := _m.Called(token) @@ -2836,6 +5960,34 @@ func (_m *SDK) UserProfile(token string) (sdk.User, errors.SDKError) { return r0, r1 } +// SDK_UserProfile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UserProfile' +type SDK_UserProfile_Call struct { + *mock.Call +} + +// UserProfile is a helper method to define mock.On call +// - token string +func (_e *SDK_Expecter) UserProfile(token interface{}) *SDK_UserProfile_Call { + return &SDK_UserProfile_Call{Call: _e.mock.On("UserProfile", token)} +} + +func (_c *SDK_UserProfile_Call) Run(run func(token string)) *SDK_UserProfile_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *SDK_UserProfile_Call) Return(_a0 sdk.User, _a1 errors.SDKError) *SDK_UserProfile_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_UserProfile_Call) RunAndReturn(run func(string) (sdk.User, errors.SDKError)) *SDK_UserProfile_Call { + _c.Call.Return(run) + return _c +} + // Users provides a mock function with given fields: pm, token func (_m *SDK) Users(pm sdk.PageMetadata, token string) (sdk.UsersPage, errors.SDKError) { ret := _m.Called(pm, token) @@ -2866,6 +6018,35 @@ func (_m *SDK) Users(pm sdk.PageMetadata, token string) (sdk.UsersPage, errors.S return r0, r1 } +// SDK_Users_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Users' +type SDK_Users_Call struct { + *mock.Call +} + +// Users is a helper method to define mock.On call +// - pm sdk.PageMetadata +// - token string +func (_e *SDK_Expecter) Users(pm interface{}, token interface{}) *SDK_Users_Call { + return &SDK_Users_Call{Call: _e.mock.On("Users", pm, token)} +} + +func (_c *SDK_Users_Call) Run(run func(pm sdk.PageMetadata, token string)) *SDK_Users_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(sdk.PageMetadata), args[1].(string)) + }) + return _c +} + +func (_c *SDK_Users_Call) Return(_a0 sdk.UsersPage, _a1 errors.SDKError) *SDK_Users_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_Users_Call) RunAndReturn(run func(sdk.PageMetadata, string) (sdk.UsersPage, errors.SDKError)) *SDK_Users_Call { + _c.Call.Return(run) + return _c +} + // ViewBootstrap provides a mock function with given fields: id, domainID, token func (_m *SDK) ViewBootstrap(id string, domainID string, token string) (sdk.BootstrapConfig, errors.SDKError) { ret := _m.Called(id, domainID, token) @@ -2896,6 +6077,36 @@ func (_m *SDK) ViewBootstrap(id string, domainID string, token string) (sdk.Boot return r0, r1 } +// SDK_ViewBootstrap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ViewBootstrap' +type SDK_ViewBootstrap_Call struct { + *mock.Call +} + +// ViewBootstrap is a helper method to define mock.On call +// - id string +// - domainID string +// - token string +func (_e *SDK_Expecter) ViewBootstrap(id interface{}, domainID interface{}, token interface{}) *SDK_ViewBootstrap_Call { + return &SDK_ViewBootstrap_Call{Call: _e.mock.On("ViewBootstrap", id, domainID, token)} +} + +func (_c *SDK_ViewBootstrap_Call) Run(run func(id string, domainID string, token string)) *SDK_ViewBootstrap_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_ViewBootstrap_Call) Return(_a0 sdk.BootstrapConfig, _a1 errors.SDKError) *SDK_ViewBootstrap_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ViewBootstrap_Call) RunAndReturn(run func(string, string, string) (sdk.BootstrapConfig, errors.SDKError)) *SDK_ViewBootstrap_Call { + _c.Call.Return(run) + return _c +} + // ViewCert provides a mock function with given fields: certID, domainID, token func (_m *SDK) ViewCert(certID string, domainID string, token string) (sdk.Cert, errors.SDKError) { ret := _m.Called(certID, domainID, token) @@ -2926,6 +6137,36 @@ func (_m *SDK) ViewCert(certID string, domainID string, token string) (sdk.Cert, return r0, r1 } +// SDK_ViewCert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ViewCert' +type SDK_ViewCert_Call struct { + *mock.Call +} + +// ViewCert is a helper method to define mock.On call +// - certID string +// - domainID string +// - token string +func (_e *SDK_Expecter) ViewCert(certID interface{}, domainID interface{}, token interface{}) *SDK_ViewCert_Call { + return &SDK_ViewCert_Call{Call: _e.mock.On("ViewCert", certID, domainID, token)} +} + +func (_c *SDK_ViewCert_Call) Run(run func(certID string, domainID string, token string)) *SDK_ViewCert_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_ViewCert_Call) Return(_a0 sdk.Cert, _a1 errors.SDKError) *SDK_ViewCert_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ViewCert_Call) RunAndReturn(run func(string, string, string) (sdk.Cert, errors.SDKError)) *SDK_ViewCert_Call { + _c.Call.Return(run) + return _c +} + // ViewCertByClient provides a mock function with given fields: clientID, domainID, token func (_m *SDK) ViewCertByClient(clientID string, domainID string, token string) (sdk.CertSerials, errors.SDKError) { ret := _m.Called(clientID, domainID, token) @@ -2956,6 +6197,36 @@ func (_m *SDK) ViewCertByClient(clientID string, domainID string, token string) return r0, r1 } +// SDK_ViewCertByClient_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ViewCertByClient' +type SDK_ViewCertByClient_Call struct { + *mock.Call +} + +// ViewCertByClient is a helper method to define mock.On call +// - clientID string +// - domainID string +// - token string +func (_e *SDK_Expecter) ViewCertByClient(clientID interface{}, domainID interface{}, token interface{}) *SDK_ViewCertByClient_Call { + return &SDK_ViewCertByClient_Call{Call: _e.mock.On("ViewCertByClient", clientID, domainID, token)} +} + +func (_c *SDK_ViewCertByClient_Call) Run(run func(clientID string, domainID string, token string)) *SDK_ViewCertByClient_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string), args[2].(string)) + }) + return _c +} + +func (_c *SDK_ViewCertByClient_Call) Return(_a0 sdk.CertSerials, _a1 errors.SDKError) *SDK_ViewCertByClient_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ViewCertByClient_Call) RunAndReturn(run func(string, string, string) (sdk.CertSerials, errors.SDKError)) *SDK_ViewCertByClient_Call { + _c.Call.Return(run) + return _c +} + // ViewSubscription provides a mock function with given fields: id, token func (_m *SDK) ViewSubscription(id string, token string) (sdk.Subscription, errors.SDKError) { ret := _m.Called(id, token) @@ -2986,6 +6257,35 @@ func (_m *SDK) ViewSubscription(id string, token string) (sdk.Subscription, erro return r0, r1 } +// SDK_ViewSubscription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ViewSubscription' +type SDK_ViewSubscription_Call struct { + *mock.Call +} + +// ViewSubscription is a helper method to define mock.On call +// - id string +// - token string +func (_e *SDK_Expecter) ViewSubscription(id interface{}, token interface{}) *SDK_ViewSubscription_Call { + return &SDK_ViewSubscription_Call{Call: _e.mock.On("ViewSubscription", id, token)} +} + +func (_c *SDK_ViewSubscription_Call) Run(run func(id string, token string)) *SDK_ViewSubscription_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(string)) + }) + return _c +} + +func (_c *SDK_ViewSubscription_Call) Return(_a0 sdk.Subscription, _a1 errors.SDKError) *SDK_ViewSubscription_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *SDK_ViewSubscription_Call) RunAndReturn(run func(string, string) (sdk.Subscription, errors.SDKError)) *SDK_ViewSubscription_Call { + _c.Call.Return(run) + return _c +} + // Whitelist provides a mock function with given fields: clientID, state, domainID, token func (_m *SDK) Whitelist(clientID string, state int, domainID string, token string) errors.SDKError { ret := _m.Called(clientID, state, domainID, token) @@ -3006,6 +6306,37 @@ func (_m *SDK) Whitelist(clientID string, state int, domainID string, token stri return r0 } +// SDK_Whitelist_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Whitelist' +type SDK_Whitelist_Call struct { + *mock.Call +} + +// Whitelist is a helper method to define mock.On call +// - clientID string +// - state int +// - domainID string +// - token string +func (_e *SDK_Expecter) Whitelist(clientID interface{}, state interface{}, domainID interface{}, token interface{}) *SDK_Whitelist_Call { + return &SDK_Whitelist_Call{Call: _e.mock.On("Whitelist", clientID, state, domainID, token)} +} + +func (_c *SDK_Whitelist_Call) Run(run func(clientID string, state int, domainID string, token string)) *SDK_Whitelist_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string), args[1].(int), args[2].(string), args[3].(string)) + }) + return _c +} + +func (_c *SDK_Whitelist_Call) Return(_a0 errors.SDKError) *SDK_Whitelist_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *SDK_Whitelist_Call) RunAndReturn(run func(string, int, string, string) errors.SDKError) *SDK_Whitelist_Call { + _c.Call.Return(run) + return _c +} + // NewSDK creates a new instance of SDK. 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 NewSDK(t interface { diff --git a/pkg/sdk/go/requests.go b/pkg/sdk/requests.go similarity index 100% rename from pkg/sdk/go/requests.go rename to pkg/sdk/requests.go diff --git a/pkg/sdk/go/responses.go b/pkg/sdk/responses.go similarity index 100% rename from pkg/sdk/go/responses.go rename to pkg/sdk/responses.go diff --git a/pkg/sdk/go/sdk.go b/pkg/sdk/sdk.go similarity index 100% rename from pkg/sdk/go/sdk.go rename to pkg/sdk/sdk.go diff --git a/pkg/sdk/go/setup_test.go b/pkg/sdk/setup_test.go similarity index 99% rename from pkg/sdk/go/setup_test.go rename to pkg/sdk/setup_test.go index e20f4e93a1..2f5112bd73 100644 --- a/pkg/sdk/go/setup_test.go +++ b/pkg/sdk/setup_test.go @@ -16,7 +16,7 @@ import ( "github.com/absmach/supermq/internal/testsutil" "github.com/absmach/supermq/invitations" "github.com/absmach/supermq/journal" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" "github.com/absmach/supermq/pkg/uuid" "github.com/absmach/supermq/users" "github.com/stretchr/testify/assert" diff --git a/pkg/sdk/go/tokens.go b/pkg/sdk/tokens.go similarity index 100% rename from pkg/sdk/go/tokens.go rename to pkg/sdk/tokens.go diff --git a/pkg/sdk/go/tokens_test.go b/pkg/sdk/tokens_test.go similarity index 99% rename from pkg/sdk/go/tokens_test.go rename to pkg/sdk/tokens_test.go index 0759c82707..fdccadced6 100644 --- a/pkg/sdk/go/tokens_test.go +++ b/pkg/sdk/tokens_test.go @@ -13,7 +13,7 @@ import ( smqauthn "github.com/absmach/supermq/pkg/authn" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" ) diff --git a/pkg/sdk/go/users.go b/pkg/sdk/users.go similarity index 100% rename from pkg/sdk/go/users.go rename to pkg/sdk/users.go diff --git a/pkg/sdk/go/users_test.go b/pkg/sdk/users_test.go similarity index 99% rename from pkg/sdk/go/users_test.go rename to pkg/sdk/users_test.go index 29e812b0da..84eb41eb9e 100644 --- a/pkg/sdk/go/users_test.go +++ b/pkg/sdk/users_test.go @@ -21,7 +21,7 @@ import ( "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" oauth2mocks "github.com/absmach/supermq/pkg/oauth2/mocks" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" "github.com/absmach/supermq/users" "github.com/absmach/supermq/users/api" umocks "github.com/absmach/supermq/users/mocks" diff --git a/provision/api/responses.go b/provision/api/responses.go index 7383417f42..8f85e8d079 100644 --- a/provision/api/responses.go +++ b/provision/api/responses.go @@ -8,7 +8,7 @@ import ( "net/http" "github.com/absmach/supermq" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" ) var _ supermq.Response = (*provisionRes)(nil) diff --git a/provision/service.go b/provision/service.go index 75c378a44c..520a7bb4e0 100644 --- a/provision/service.go +++ b/provision/service.go @@ -9,7 +9,7 @@ import ( "log/slog" "github.com/absmach/supermq/pkg/errors" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" ) const ( diff --git a/provision/service_test.go b/provision/service_test.go index 833cbd2d15..d5ed1efb10 100644 --- a/provision/service_test.go +++ b/provision/service_test.go @@ -12,7 +12,7 @@ import ( "github.com/absmach/supermq/pkg/errors" repoerr "github.com/absmach/supermq/pkg/errors/repository" svcerr "github.com/absmach/supermq/pkg/errors/service" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" sdkmocks "github.com/absmach/supermq/pkg/sdk/mocks" "github.com/absmach/supermq/provision" "github.com/stretchr/testify/assert" diff --git a/tools/config/mockery.yaml b/tools/config/mockery.yaml index 5d9bad3245..6b83ab7f6d 100644 --- a/tools/config/mockery.yaml +++ b/tools/config/mockery.yaml @@ -41,6 +41,13 @@ packages: dir: "./groups/mocks" mockname: "GroupsServiceClient" filename: "groups_client.go" + github.com/absmach/supermq/pkg/sdk: + interfaces: + SDK: + config: + dir: "./pkg/sdk/mocks" + mockname: "SDK" + filename: "sdk.go" github.com/absmach/supermq/certs/pki/amcerts: interfaces: diff --git a/tools/e2e/e2e.go b/tools/e2e/e2e.go index e2f27e50e7..66785b1a80 100644 --- a/tools/e2e/e2e.go +++ b/tools/e2e/e2e.go @@ -14,7 +14,7 @@ import ( "time" "github.com/0x6flab/namegenerator" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" "github.com/gookit/color" "github.com/gorilla/websocket" "golang.org/x/sync/errgroup" diff --git a/tools/provision/provision.go b/tools/provision/provision.go index f83737dba5..e21c7ab45d 100644 --- a/tools/provision/provision.go +++ b/tools/provision/provision.go @@ -21,7 +21,7 @@ import ( "time" "github.com/0x6flab/namegenerator" - sdk "github.com/absmach/supermq/pkg/sdk/go" + sdk "github.com/absmach/supermq/pkg/sdk" ) const (