supermq/pkg/sdk/mocks/sdk.go

// Copyright (c) Abstract Machines

// SPDX-License-Identifier: Apache-2.0

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

package mocks

import (
	"context"
	"time"

	"github.com/absmach/magistrala/pkg/sdk"
	"github.com/absmach/supermq/pkg/errors"
	sdk0 "github.com/absmach/supermq/pkg/sdk"
	mock "github.com/stretchr/testify/mock"
)

// 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
}

// SDK is an autogenerated mock type for the SDK type
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 for the type SDK
func (_mock *SDK) AcceptInvitation(ctx context.Context, domainID string, token string) error {
	ret := _mock.Called(ctx, domainID, token)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, domainID, token)
	} else {
		r0 = ret.Error(0)
	}
	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
//   - ctx context.Context
//   - domainID string
//   - token string
func (_e *SDK_Expecter) AcceptInvitation(ctx interface{}, domainID interface{}, token interface{}) *SDK_AcceptInvitation_Call {
	return &SDK_AcceptInvitation_Call{Call: _e.mock.On("AcceptInvitation", ctx, domainID, token)}
}

func (_c *SDK_AcceptInvitation_Call) Run(run func(ctx context.Context, domainID string, token string)) *SDK_AcceptInvitation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	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(ctx context.Context, domainID string, token string) error) *SDK_AcceptInvitation_Call {
	_c.Call.Return(run)
	return _c
}

// AddBootstrap provides a mock function for the type SDK
func (_mock *SDK) AddBootstrap(ctx context.Context, cfg sdk.BootstrapConfig, domainID string, token string) (string, errors.SDKError) {
	ret := _mock.Called(ctx, cfg, domainID, token)

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

	var r0 string
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.BootstrapConfig, string, string) (string, errors.SDKError)); ok {
		return returnFunc(ctx, cfg, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.BootstrapConfig, string, string) string); ok {
		r0 = returnFunc(ctx, cfg, domainID, token)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.BootstrapConfig, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, cfg, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - cfg sdk.BootstrapConfig
//   - domainID string
//   - token string
func (_e *SDK_Expecter) AddBootstrap(ctx interface{}, cfg interface{}, domainID interface{}, token interface{}) *SDK_AddBootstrap_Call {
	return &SDK_AddBootstrap_Call{Call: _e.mock.On("AddBootstrap", ctx, cfg, domainID, token)}
}

func (_c *SDK_AddBootstrap_Call) Run(run func(ctx context.Context, cfg sdk.BootstrapConfig, domainID string, token string)) *SDK_AddBootstrap_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk.BootstrapConfig
		if args[1] != nil {
			arg1 = args[1].(sdk.BootstrapConfig)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_AddBootstrap_Call) Return(s string, sDKError errors.SDKError) *SDK_AddBootstrap_Call {
	_c.Call.Return(s, sDKError)
	return _c
}

func (_c *SDK_AddBootstrap_Call) RunAndReturn(run func(ctx context.Context, cfg sdk.BootstrapConfig, domainID string, token string) (string, errors.SDKError)) *SDK_AddBootstrap_Call {
	_c.Call.Return(run)
	return _c
}

// AddChildren provides a mock function for the type SDK
func (_mock *SDK) AddChildren(ctx context.Context, id string, domainID string, groupIDs []string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, domainID, groupIDs, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, domainID, groupIDs, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// AddChildren is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - domainID string
//   - groupIDs []string
//   - token string
func (_e *SDK_Expecter) AddChildren(ctx interface{}, id interface{}, domainID interface{}, groupIDs interface{}, token interface{}) *SDK_AddChildren_Call {
	return &SDK_AddChildren_Call{Call: _e.mock.On("AddChildren", ctx, id, domainID, groupIDs, token)}
}

func (_c *SDK_AddChildren_Call) Run(run func(ctx context.Context, id string, domainID string, groupIDs []string, token string)) *SDK_AddChildren_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 []string
		if args[3] != nil {
			arg3 = args[3].([]string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_AddChildren_Call) Return(sDKError errors.SDKError) *SDK_AddChildren_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_AddChildren_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, groupIDs []string, token string) errors.SDKError) *SDK_AddChildren_Call {
	_c.Call.Return(run)
	return _c
}

// AddClientRoleActions provides a mock function for the type SDK
func (_mock *SDK) AddClientRoleActions(ctx context.Context, id string, roleID string, domainID string, actions []string, token string) ([]string, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, domainID, actions, token)

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

	var r0 []string
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, []string, string) ([]string, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, domainID, actions, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, []string, string) []string); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, actions, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, []string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, roleID, domainID, actions, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// AddClientRoleActions is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - domainID string
//   - actions []string
//   - token string
func (_e *SDK_Expecter) AddClientRoleActions(ctx interface{}, id interface{}, roleID interface{}, domainID interface{}, actions interface{}, token interface{}) *SDK_AddClientRoleActions_Call {
	return &SDK_AddClientRoleActions_Call{Call: _e.mock.On("AddClientRoleActions", ctx, id, roleID, domainID, actions, token)}
}

func (_c *SDK_AddClientRoleActions_Call) Run(run func(ctx context.Context, id string, roleID string, domainID string, actions []string, token string)) *SDK_AddClientRoleActions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 []string
		if args[4] != nil {
			arg4 = args[4].([]string)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *SDK_AddClientRoleActions_Call) Return(strings []string, sDKError errors.SDKError) *SDK_AddClientRoleActions_Call {
	_c.Call.Return(strings, sDKError)
	return _c
}

func (_c *SDK_AddClientRoleActions_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, domainID string, actions []string, token string) ([]string, errors.SDKError)) *SDK_AddClientRoleActions_Call {
	_c.Call.Return(run)
	return _c
}

// AddClientRoleMembers provides a mock function for the type SDK
func (_mock *SDK) AddClientRoleMembers(ctx context.Context, id string, roleID string, domainID string, members []string, token string) ([]string, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, domainID, members, token)

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

	var r0 []string
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, []string, string) ([]string, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, domainID, members, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, []string, string) []string); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, members, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, []string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, roleID, domainID, members, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// AddClientRoleMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - domainID string
//   - members []string
//   - token string
func (_e *SDK_Expecter) AddClientRoleMembers(ctx interface{}, id interface{}, roleID interface{}, domainID interface{}, members interface{}, token interface{}) *SDK_AddClientRoleMembers_Call {
	return &SDK_AddClientRoleMembers_Call{Call: _e.mock.On("AddClientRoleMembers", ctx, id, roleID, domainID, members, token)}
}

func (_c *SDK_AddClientRoleMembers_Call) Run(run func(ctx context.Context, id string, roleID string, domainID string, members []string, token string)) *SDK_AddClientRoleMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 []string
		if args[4] != nil {
			arg4 = args[4].([]string)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *SDK_AddClientRoleMembers_Call) Return(strings []string, sDKError errors.SDKError) *SDK_AddClientRoleMembers_Call {
	_c.Call.Return(strings, sDKError)
	return _c
}

func (_c *SDK_AddClientRoleMembers_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, domainID string, members []string, token string) ([]string, errors.SDKError)) *SDK_AddClientRoleMembers_Call {
	_c.Call.Return(run)
	return _c
}

// AddDomainRoleActions provides a mock function for the type SDK
func (_mock *SDK) AddDomainRoleActions(ctx context.Context, id string, roleID string, actions []string, token string) ([]string, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, actions, token)

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

	var r0 []string
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string, string) ([]string, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, actions, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string, string) []string); ok {
		r0 = returnFunc(ctx, id, roleID, actions, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, []string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, roleID, actions, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// AddDomainRoleActions is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - actions []string
//   - token string
func (_e *SDK_Expecter) AddDomainRoleActions(ctx interface{}, id interface{}, roleID interface{}, actions interface{}, token interface{}) *SDK_AddDomainRoleActions_Call {
	return &SDK_AddDomainRoleActions_Call{Call: _e.mock.On("AddDomainRoleActions", ctx, id, roleID, actions, token)}
}

func (_c *SDK_AddDomainRoleActions_Call) Run(run func(ctx context.Context, id string, roleID string, actions []string, token string)) *SDK_AddDomainRoleActions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 []string
		if args[3] != nil {
			arg3 = args[3].([]string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_AddDomainRoleActions_Call) Return(strings []string, sDKError errors.SDKError) *SDK_AddDomainRoleActions_Call {
	_c.Call.Return(strings, sDKError)
	return _c
}

func (_c *SDK_AddDomainRoleActions_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, actions []string, token string) ([]string, errors.SDKError)) *SDK_AddDomainRoleActions_Call {
	_c.Call.Return(run)
	return _c
}

// AddDomainRoleMembers provides a mock function for the type SDK
func (_mock *SDK) AddDomainRoleMembers(ctx context.Context, id string, roleID string, members []string, token string) ([]string, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, members, token)

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

	var r0 []string
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string, string) ([]string, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, members, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string, string) []string); ok {
		r0 = returnFunc(ctx, id, roleID, members, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, []string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, roleID, members, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// AddDomainRoleMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - members []string
//   - token string
func (_e *SDK_Expecter) AddDomainRoleMembers(ctx interface{}, id interface{}, roleID interface{}, members interface{}, token interface{}) *SDK_AddDomainRoleMembers_Call {
	return &SDK_AddDomainRoleMembers_Call{Call: _e.mock.On("AddDomainRoleMembers", ctx, id, roleID, members, token)}
}

func (_c *SDK_AddDomainRoleMembers_Call) Run(run func(ctx context.Context, id string, roleID string, members []string, token string)) *SDK_AddDomainRoleMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 []string
		if args[3] != nil {
			arg3 = args[3].([]string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_AddDomainRoleMembers_Call) Return(strings []string, sDKError errors.SDKError) *SDK_AddDomainRoleMembers_Call {
	_c.Call.Return(strings, sDKError)
	return _c
}

func (_c *SDK_AddDomainRoleMembers_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, members []string, token string) ([]string, errors.SDKError)) *SDK_AddDomainRoleMembers_Call {
	_c.Call.Return(run)
	return _c
}

// AddGroupRoleActions provides a mock function for the type SDK
func (_mock *SDK) AddGroupRoleActions(ctx context.Context, id string, roleID string, domainID string, actions []string, token string) ([]string, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, domainID, actions, token)

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

	var r0 []string
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, []string, string) ([]string, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, domainID, actions, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, []string, string) []string); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, actions, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, []string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, roleID, domainID, actions, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// AddGroupRoleActions is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - domainID string
//   - actions []string
//   - token string
func (_e *SDK_Expecter) AddGroupRoleActions(ctx interface{}, id interface{}, roleID interface{}, domainID interface{}, actions interface{}, token interface{}) *SDK_AddGroupRoleActions_Call {
	return &SDK_AddGroupRoleActions_Call{Call: _e.mock.On("AddGroupRoleActions", ctx, id, roleID, domainID, actions, token)}
}

func (_c *SDK_AddGroupRoleActions_Call) Run(run func(ctx context.Context, id string, roleID string, domainID string, actions []string, token string)) *SDK_AddGroupRoleActions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 []string
		if args[4] != nil {
			arg4 = args[4].([]string)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *SDK_AddGroupRoleActions_Call) Return(strings []string, sDKError errors.SDKError) *SDK_AddGroupRoleActions_Call {
	_c.Call.Return(strings, sDKError)
	return _c
}

func (_c *SDK_AddGroupRoleActions_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, domainID string, actions []string, token string) ([]string, errors.SDKError)) *SDK_AddGroupRoleActions_Call {
	_c.Call.Return(run)
	return _c
}

// AddGroupRoleMembers provides a mock function for the type SDK
func (_mock *SDK) AddGroupRoleMembers(ctx context.Context, id string, roleID string, domainID string, members []string, token string) ([]string, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, domainID, members, token)

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

	var r0 []string
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, []string, string) ([]string, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, domainID, members, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, []string, string) []string); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, members, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, []string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, roleID, domainID, members, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// AddGroupRoleMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - domainID string
//   - members []string
//   - token string
func (_e *SDK_Expecter) AddGroupRoleMembers(ctx interface{}, id interface{}, roleID interface{}, domainID interface{}, members interface{}, token interface{}) *SDK_AddGroupRoleMembers_Call {
	return &SDK_AddGroupRoleMembers_Call{Call: _e.mock.On("AddGroupRoleMembers", ctx, id, roleID, domainID, members, token)}
}

func (_c *SDK_AddGroupRoleMembers_Call) Run(run func(ctx context.Context, id string, roleID string, domainID string, members []string, token string)) *SDK_AddGroupRoleMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 []string
		if args[4] != nil {
			arg4 = args[4].([]string)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *SDK_AddGroupRoleMembers_Call) Return(strings []string, sDKError errors.SDKError) *SDK_AddGroupRoleMembers_Call {
	_c.Call.Return(strings, sDKError)
	return _c
}

func (_c *SDK_AddGroupRoleMembers_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, domainID string, members []string, token string) ([]string, errors.SDKError)) *SDK_AddGroupRoleMembers_Call {
	_c.Call.Return(run)
	return _c
}

// AvailableClientRoleActions provides a mock function for the type SDK
func (_mock *SDK) AvailableClientRoleActions(ctx context.Context, domainID string, token string) ([]string, errors.SDKError) {
	ret := _mock.Called(ctx, domainID, token)

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

	var r0 []string
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]string, errors.SDKError)); ok {
		return returnFunc(ctx, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []string); ok {
		r0 = returnFunc(ctx, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// AvailableClientRoleActions is a helper method to define mock.On call
//   - ctx context.Context
//   - domainID string
//   - token string
func (_e *SDK_Expecter) AvailableClientRoleActions(ctx interface{}, domainID interface{}, token interface{}) *SDK_AvailableClientRoleActions_Call {
	return &SDK_AvailableClientRoleActions_Call{Call: _e.mock.On("AvailableClientRoleActions", ctx, domainID, token)}
}

func (_c *SDK_AvailableClientRoleActions_Call) Run(run func(ctx context.Context, domainID string, token string)) *SDK_AvailableClientRoleActions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_AvailableClientRoleActions_Call) Return(strings []string, sDKError errors.SDKError) *SDK_AvailableClientRoleActions_Call {
	_c.Call.Return(strings, sDKError)
	return _c
}

func (_c *SDK_AvailableClientRoleActions_Call) RunAndReturn(run func(ctx context.Context, domainID string, token string) ([]string, errors.SDKError)) *SDK_AvailableClientRoleActions_Call {
	_c.Call.Return(run)
	return _c
}

// AvailableDomainRoleActions provides a mock function for the type SDK
func (_mock *SDK) AvailableDomainRoleActions(ctx context.Context, token string) ([]string, errors.SDKError) {
	ret := _mock.Called(ctx, token)

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

	var r0 []string
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]string, errors.SDKError)); ok {
		return returnFunc(ctx, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []string); ok {
		r0 = returnFunc(ctx, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// AvailableDomainRoleActions is a helper method to define mock.On call
//   - ctx context.Context
//   - token string
func (_e *SDK_Expecter) AvailableDomainRoleActions(ctx interface{}, token interface{}) *SDK_AvailableDomainRoleActions_Call {
	return &SDK_AvailableDomainRoleActions_Call{Call: _e.mock.On("AvailableDomainRoleActions", ctx, token)}
}

func (_c *SDK_AvailableDomainRoleActions_Call) Run(run func(ctx context.Context, token string)) *SDK_AvailableDomainRoleActions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *SDK_AvailableDomainRoleActions_Call) Return(strings []string, sDKError errors.SDKError) *SDK_AvailableDomainRoleActions_Call {
	_c.Call.Return(strings, sDKError)
	return _c
}

func (_c *SDK_AvailableDomainRoleActions_Call) RunAndReturn(run func(ctx context.Context, token string) ([]string, errors.SDKError)) *SDK_AvailableDomainRoleActions_Call {
	_c.Call.Return(run)
	return _c
}

// AvailableGroupRoleActions provides a mock function for the type SDK
func (_mock *SDK) AvailableGroupRoleActions(ctx context.Context, id string, token string) ([]string, errors.SDKError) {
	ret := _mock.Called(ctx, id, token)

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

	var r0 []string
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]string, errors.SDKError)); ok {
		return returnFunc(ctx, id, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []string); ok {
		r0 = returnFunc(ctx, id, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// AvailableGroupRoleActions is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - token string
func (_e *SDK_Expecter) AvailableGroupRoleActions(ctx interface{}, id interface{}, token interface{}) *SDK_AvailableGroupRoleActions_Call {
	return &SDK_AvailableGroupRoleActions_Call{Call: _e.mock.On("AvailableGroupRoleActions", ctx, id, token)}
}

func (_c *SDK_AvailableGroupRoleActions_Call) Run(run func(ctx context.Context, id string, token string)) *SDK_AvailableGroupRoleActions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_AvailableGroupRoleActions_Call) Return(strings []string, sDKError errors.SDKError) *SDK_AvailableGroupRoleActions_Call {
	_c.Call.Return(strings, sDKError)
	return _c
}

func (_c *SDK_AvailableGroupRoleActions_Call) RunAndReturn(run func(ctx context.Context, id string, token string) ([]string, errors.SDKError)) *SDK_AvailableGroupRoleActions_Call {
	_c.Call.Return(run)
	return _c
}

// Bootstrap provides a mock function for the type SDK
func (_mock *SDK) Bootstrap(ctx context.Context, externalID string, externalKey string) (sdk.BootstrapConfig, errors.SDKError) {
	ret := _mock.Called(ctx, externalID, externalKey)

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

	var r0 sdk.BootstrapConfig
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (sdk.BootstrapConfig, errors.SDKError)); ok {
		return returnFunc(ctx, externalID, externalKey)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) sdk.BootstrapConfig); ok {
		r0 = returnFunc(ctx, externalID, externalKey)
	} else {
		r0 = ret.Get(0).(sdk.BootstrapConfig)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, externalID, externalKey)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - externalID string
//   - externalKey string
func (_e *SDK_Expecter) Bootstrap(ctx interface{}, externalID interface{}, externalKey interface{}) *SDK_Bootstrap_Call {
	return &SDK_Bootstrap_Call{Call: _e.mock.On("Bootstrap", ctx, externalID, externalKey)}
}

func (_c *SDK_Bootstrap_Call) Run(run func(ctx context.Context, externalID string, externalKey string)) *SDK_Bootstrap_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_Bootstrap_Call) Return(bootstrapConfig sdk.BootstrapConfig, sDKError errors.SDKError) *SDK_Bootstrap_Call {
	_c.Call.Return(bootstrapConfig, sDKError)
	return _c
}

func (_c *SDK_Bootstrap_Call) RunAndReturn(run func(ctx context.Context, externalID string, externalKey string) (sdk.BootstrapConfig, errors.SDKError)) *SDK_Bootstrap_Call {
	_c.Call.Return(run)
	return _c
}

// BootstrapSecure provides a mock function for the type SDK
func (_mock *SDK) BootstrapSecure(ctx context.Context, externalID string, externalKey string, cryptoKey string) (sdk.BootstrapConfig, errors.SDKError) {
	ret := _mock.Called(ctx, externalID, externalKey, cryptoKey)

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

	var r0 sdk.BootstrapConfig
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.BootstrapConfig, errors.SDKError)); ok {
		return returnFunc(ctx, externalID, externalKey, cryptoKey)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.BootstrapConfig); ok {
		r0 = returnFunc(ctx, externalID, externalKey, cryptoKey)
	} else {
		r0 = ret.Get(0).(sdk.BootstrapConfig)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, externalID, externalKey, cryptoKey)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - externalID string
//   - externalKey string
//   - cryptoKey string
func (_e *SDK_Expecter) BootstrapSecure(ctx interface{}, externalID interface{}, externalKey interface{}, cryptoKey interface{}) *SDK_BootstrapSecure_Call {
	return &SDK_BootstrapSecure_Call{Call: _e.mock.On("BootstrapSecure", ctx, externalID, externalKey, cryptoKey)}
}

func (_c *SDK_BootstrapSecure_Call) Run(run func(ctx context.Context, externalID string, externalKey string, cryptoKey string)) *SDK_BootstrapSecure_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_BootstrapSecure_Call) Return(bootstrapConfig sdk.BootstrapConfig, sDKError errors.SDKError) *SDK_BootstrapSecure_Call {
	_c.Call.Return(bootstrapConfig, sDKError)
	return _c
}

func (_c *SDK_BootstrapSecure_Call) RunAndReturn(run func(ctx context.Context, externalID string, externalKey string, cryptoKey string) (sdk.BootstrapConfig, errors.SDKError)) *SDK_BootstrapSecure_Call {
	_c.Call.Return(run)
	return _c
}

// Bootstraps provides a mock function for the type SDK
func (_mock *SDK) Bootstraps(ctx context.Context, pm sdk.PageMetadata, domainID string, token string) (sdk.BootstrapPage, errors.SDKError) {
	ret := _mock.Called(ctx, pm, domainID, token)

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

	var r0 sdk.BootstrapPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string, string) (sdk.BootstrapPage, errors.SDKError)); ok {
		return returnFunc(ctx, pm, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string, string) sdk.BootstrapPage); ok {
		r0 = returnFunc(ctx, pm, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.BootstrapPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.PageMetadata, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, pm, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - pm sdk.PageMetadata
//   - domainID string
//   - token string
func (_e *SDK_Expecter) Bootstraps(ctx interface{}, pm interface{}, domainID interface{}, token interface{}) *SDK_Bootstraps_Call {
	return &SDK_Bootstraps_Call{Call: _e.mock.On("Bootstraps", ctx, pm, domainID, token)}
}

func (_c *SDK_Bootstraps_Call) Run(run func(ctx context.Context, pm sdk.PageMetadata, domainID string, token string)) *SDK_Bootstraps_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk.PageMetadata
		if args[1] != nil {
			arg1 = args[1].(sdk.PageMetadata)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_Bootstraps_Call) Return(bootstrapPage sdk.BootstrapPage, sDKError errors.SDKError) *SDK_Bootstraps_Call {
	_c.Call.Return(bootstrapPage, sDKError)
	return _c
}

func (_c *SDK_Bootstraps_Call) RunAndReturn(run func(ctx context.Context, pm sdk.PageMetadata, domainID string, token string) (sdk.BootstrapPage, errors.SDKError)) *SDK_Bootstraps_Call {
	_c.Call.Return(run)
	return _c
}

// Channel provides a mock function for the type SDK
func (_mock *SDK) Channel(ctx context.Context, id string, domainID string, token string) (sdk0.Channel, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 sdk0.Channel
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk0.Channel, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk0.Channel); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Channel)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - id string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) Channel(ctx interface{}, id interface{}, domainID interface{}, token interface{}) *SDK_Channel_Call {
	return &SDK_Channel_Call{Call: _e.mock.On("Channel", ctx, id, domainID, token)}
}

func (_c *SDK_Channel_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_Channel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_Channel_Call) Return(channel sdk0.Channel, sDKError errors.SDKError) *SDK_Channel_Call {
	_c.Call.Return(channel, sDKError)
	return _c
}

func (_c *SDK_Channel_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) (sdk0.Channel, errors.SDKError)) *SDK_Channel_Call {
	_c.Call.Return(run)
	return _c
}

// Channels provides a mock function for the type SDK
func (_mock *SDK) Channels(ctx context.Context, pm sdk0.PageMetadata, domainID string, token string) (sdk0.ChannelsPage, errors.SDKError) {
	ret := _mock.Called(ctx, pm, domainID, token)

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

	var r0 sdk0.ChannelsPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.PageMetadata, string, string) (sdk0.ChannelsPage, errors.SDKError)); ok {
		return returnFunc(ctx, pm, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.PageMetadata, string, string) sdk0.ChannelsPage); ok {
		r0 = returnFunc(ctx, pm, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.ChannelsPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.PageMetadata, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, pm, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - pm sdk0.PageMetadata
//   - domainID string
//   - token string
func (_e *SDK_Expecter) Channels(ctx interface{}, pm interface{}, domainID interface{}, token interface{}) *SDK_Channels_Call {
	return &SDK_Channels_Call{Call: _e.mock.On("Channels", ctx, pm, domainID, token)}
}

func (_c *SDK_Channels_Call) Run(run func(ctx context.Context, pm sdk0.PageMetadata, domainID string, token string)) *SDK_Channels_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.PageMetadata
		if args[1] != nil {
			arg1 = args[1].(sdk0.PageMetadata)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_Channels_Call) Return(channelsPage sdk0.ChannelsPage, sDKError errors.SDKError) *SDK_Channels_Call {
	_c.Call.Return(channelsPage, sDKError)
	return _c
}

func (_c *SDK_Channels_Call) RunAndReturn(run func(ctx context.Context, pm sdk0.PageMetadata, domainID string, token string) (sdk0.ChannelsPage, errors.SDKError)) *SDK_Channels_Call {
	_c.Call.Return(run)
	return _c
}

// Children provides a mock function for the type SDK
func (_mock *SDK) Children(ctx context.Context, id string, domainID string, pm sdk0.PageMetadata, token string) (sdk0.GroupsPage, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, pm, token)

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

	var r0 sdk0.GroupsPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk0.PageMetadata, string) (sdk0.GroupsPage, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk0.PageMetadata, string) sdk0.GroupsPage); ok {
		r0 = returnFunc(ctx, id, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk0.GroupsPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, sdk0.PageMetadata, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, domainID, pm, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - id string
//   - domainID string
//   - pm sdk0.PageMetadata
//   - token string
func (_e *SDK_Expecter) Children(ctx interface{}, id interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_Children_Call {
	return &SDK_Children_Call{Call: _e.mock.On("Children", ctx, id, domainID, pm, token)}
}

func (_c *SDK_Children_Call) Run(run func(ctx context.Context, id string, domainID string, pm sdk0.PageMetadata, token string)) *SDK_Children_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 sdk0.PageMetadata
		if args[3] != nil {
			arg3 = args[3].(sdk0.PageMetadata)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_Children_Call) Return(groupsPage sdk0.GroupsPage, sDKError errors.SDKError) *SDK_Children_Call {
	_c.Call.Return(groupsPage, sDKError)
	return _c
}

func (_c *SDK_Children_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, pm sdk0.PageMetadata, token string) (sdk0.GroupsPage, errors.SDKError)) *SDK_Children_Call {
	_c.Call.Return(run)
	return _c
}

// Client provides a mock function for the type SDK
func (_mock *SDK) Client(ctx context.Context, id string, domainID string, token string) (sdk0.Client, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 sdk0.Client
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk0.Client, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk0.Client); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Client)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - id string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) Client(ctx interface{}, id interface{}, domainID interface{}, token interface{}) *SDK_Client_Call {
	return &SDK_Client_Call{Call: _e.mock.On("Client", ctx, id, domainID, token)}
}

func (_c *SDK_Client_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_Client_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_Client_Call) Return(client sdk0.Client, sDKError errors.SDKError) *SDK_Client_Call {
	_c.Call.Return(client, sDKError)
	return _c
}

func (_c *SDK_Client_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) (sdk0.Client, errors.SDKError)) *SDK_Client_Call {
	_c.Call.Return(run)
	return _c
}

// ClientRole provides a mock function for the type SDK
func (_mock *SDK) ClientRole(ctx context.Context, id string, roleID string, domainID string, token string) (sdk0.Role, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, domainID, token)

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

	var r0 sdk0.Role
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (sdk0.Role, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) sdk0.Role); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Role)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, roleID, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// ClientRole is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) ClientRole(ctx interface{}, id interface{}, roleID interface{}, domainID interface{}, token interface{}) *SDK_ClientRole_Call {
	return &SDK_ClientRole_Call{Call: _e.mock.On("ClientRole", ctx, id, roleID, domainID, token)}
}

func (_c *SDK_ClientRole_Call) Run(run func(ctx context.Context, id string, roleID string, domainID string, token string)) *SDK_ClientRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_ClientRole_Call) Return(role sdk0.Role, sDKError errors.SDKError) *SDK_ClientRole_Call {
	_c.Call.Return(role, sDKError)
	return _c
}

func (_c *SDK_ClientRole_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, domainID string, token string) (sdk0.Role, errors.SDKError)) *SDK_ClientRole_Call {
	_c.Call.Return(run)
	return _c
}

// ClientRoleActions provides a mock function for the type SDK
func (_mock *SDK) ClientRoleActions(ctx context.Context, id string, roleID string, domainID string, token string) ([]string, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, domainID, token)

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

	var r0 []string
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) ([]string, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) []string); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, roleID, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// ClientRoleActions is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) ClientRoleActions(ctx interface{}, id interface{}, roleID interface{}, domainID interface{}, token interface{}) *SDK_ClientRoleActions_Call {
	return &SDK_ClientRoleActions_Call{Call: _e.mock.On("ClientRoleActions", ctx, id, roleID, domainID, token)}
}

func (_c *SDK_ClientRoleActions_Call) Run(run func(ctx context.Context, id string, roleID string, domainID string, token string)) *SDK_ClientRoleActions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_ClientRoleActions_Call) Return(strings []string, sDKError errors.SDKError) *SDK_ClientRoleActions_Call {
	_c.Call.Return(strings, sDKError)
	return _c
}

func (_c *SDK_ClientRoleActions_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, domainID string, token string) ([]string, errors.SDKError)) *SDK_ClientRoleActions_Call {
	_c.Call.Return(run)
	return _c
}

// ClientRoleMembers provides a mock function for the type SDK
func (_mock *SDK) ClientRoleMembers(ctx context.Context, id string, roleID string, domainID string, pm sdk0.PageMetadata, token string) (sdk0.RoleMembersPage, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, domainID, pm, token)

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

	var r0 sdk0.RoleMembersPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, sdk0.PageMetadata, string) (sdk0.RoleMembersPage, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, sdk0.PageMetadata, string) sdk0.RoleMembersPage); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk0.RoleMembersPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, sdk0.PageMetadata, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, roleID, domainID, pm, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// ClientRoleMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - domainID string
//   - pm sdk0.PageMetadata
//   - token string
func (_e *SDK_Expecter) ClientRoleMembers(ctx interface{}, id interface{}, roleID interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_ClientRoleMembers_Call {
	return &SDK_ClientRoleMembers_Call{Call: _e.mock.On("ClientRoleMembers", ctx, id, roleID, domainID, pm, token)}
}

func (_c *SDK_ClientRoleMembers_Call) Run(run func(ctx context.Context, id string, roleID string, domainID string, pm sdk0.PageMetadata, token string)) *SDK_ClientRoleMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 sdk0.PageMetadata
		if args[4] != nil {
			arg4 = args[4].(sdk0.PageMetadata)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *SDK_ClientRoleMembers_Call) Return(roleMembersPage sdk0.RoleMembersPage, sDKError errors.SDKError) *SDK_ClientRoleMembers_Call {
	_c.Call.Return(roleMembersPage, sDKError)
	return _c
}

func (_c *SDK_ClientRoleMembers_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, domainID string, pm sdk0.PageMetadata, token string) (sdk0.RoleMembersPage, errors.SDKError)) *SDK_ClientRoleMembers_Call {
	_c.Call.Return(run)
	return _c
}

// ClientRoles provides a mock function for the type SDK
func (_mock *SDK) ClientRoles(ctx context.Context, id string, domainID string, pm sdk0.PageMetadata, token string) (sdk0.RolesPage, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, pm, token)

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

	var r0 sdk0.RolesPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk0.PageMetadata, string) (sdk0.RolesPage, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk0.PageMetadata, string) sdk0.RolesPage); ok {
		r0 = returnFunc(ctx, id, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk0.RolesPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, sdk0.PageMetadata, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, domainID, pm, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// ClientRoles is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - domainID string
//   - pm sdk0.PageMetadata
//   - token string
func (_e *SDK_Expecter) ClientRoles(ctx interface{}, id interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_ClientRoles_Call {
	return &SDK_ClientRoles_Call{Call: _e.mock.On("ClientRoles", ctx, id, domainID, pm, token)}
}

func (_c *SDK_ClientRoles_Call) Run(run func(ctx context.Context, id string, domainID string, pm sdk0.PageMetadata, token string)) *SDK_ClientRoles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 sdk0.PageMetadata
		if args[3] != nil {
			arg3 = args[3].(sdk0.PageMetadata)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_ClientRoles_Call) Return(rolesPage sdk0.RolesPage, sDKError errors.SDKError) *SDK_ClientRoles_Call {
	_c.Call.Return(rolesPage, sDKError)
	return _c
}

func (_c *SDK_ClientRoles_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, pm sdk0.PageMetadata, token string) (sdk0.RolesPage, errors.SDKError)) *SDK_ClientRoles_Call {
	_c.Call.Return(run)
	return _c
}

// Clients provides a mock function for the type SDK
func (_mock *SDK) Clients(ctx context.Context, pm sdk0.PageMetadata, domainID string, token string) (sdk0.ClientsPage, errors.SDKError) {
	ret := _mock.Called(ctx, pm, domainID, token)

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

	var r0 sdk0.ClientsPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.PageMetadata, string, string) (sdk0.ClientsPage, errors.SDKError)); ok {
		return returnFunc(ctx, pm, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.PageMetadata, string, string) sdk0.ClientsPage); ok {
		r0 = returnFunc(ctx, pm, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.ClientsPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.PageMetadata, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, pm, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - pm sdk0.PageMetadata
//   - domainID string
//   - token string
func (_e *SDK_Expecter) Clients(ctx interface{}, pm interface{}, domainID interface{}, token interface{}) *SDK_Clients_Call {
	return &SDK_Clients_Call{Call: _e.mock.On("Clients", ctx, pm, domainID, token)}
}

func (_c *SDK_Clients_Call) Run(run func(ctx context.Context, pm sdk0.PageMetadata, domainID string, token string)) *SDK_Clients_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.PageMetadata
		if args[1] != nil {
			arg1 = args[1].(sdk0.PageMetadata)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_Clients_Call) Return(clientsPage sdk0.ClientsPage, sDKError errors.SDKError) *SDK_Clients_Call {
	_c.Call.Return(clientsPage, sDKError)
	return _c
}

func (_c *SDK_Clients_Call) RunAndReturn(run func(ctx context.Context, pm sdk0.PageMetadata, domainID string, token string) (sdk0.ClientsPage, errors.SDKError)) *SDK_Clients_Call {
	_c.Call.Return(run)
	return _c
}

// Connect provides a mock function for the type SDK
func (_mock *SDK) Connect(ctx context.Context, conn sdk0.Connection, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, conn, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Connection, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, conn, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - conn sdk0.Connection
//   - domainID string
//   - token string
func (_e *SDK_Expecter) Connect(ctx interface{}, conn interface{}, domainID interface{}, token interface{}) *SDK_Connect_Call {
	return &SDK_Connect_Call{Call: _e.mock.On("Connect", ctx, conn, domainID, token)}
}

func (_c *SDK_Connect_Call) Run(run func(ctx context.Context, conn sdk0.Connection, domainID string, token string)) *SDK_Connect_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.Connection
		if args[1] != nil {
			arg1 = args[1].(sdk0.Connection)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_Connect_Call) Return(sDKError errors.SDKError) *SDK_Connect_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_Connect_Call) RunAndReturn(run func(ctx context.Context, conn sdk0.Connection, domainID string, token string) errors.SDKError) *SDK_Connect_Call {
	_c.Call.Return(run)
	return _c
}

// ConnectClients provides a mock function for the type SDK
func (_mock *SDK) ConnectClients(ctx context.Context, channelID string, clientIDs []string, connTypes []string, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, channelID, clientIDs, connTypes, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string, []string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, channelID, clientIDs, connTypes, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// ConnectClients is a helper method to define mock.On call
//   - ctx context.Context
//   - channelID string
//   - clientIDs []string
//   - connTypes []string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) ConnectClients(ctx interface{}, channelID interface{}, clientIDs interface{}, connTypes interface{}, domainID interface{}, token interface{}) *SDK_ConnectClients_Call {
	return &SDK_ConnectClients_Call{Call: _e.mock.On("ConnectClients", ctx, channelID, clientIDs, connTypes, domainID, token)}
}

func (_c *SDK_ConnectClients_Call) Run(run func(ctx context.Context, channelID string, clientIDs []string, connTypes []string, domainID string, token string)) *SDK_ConnectClients_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []string
		if args[2] != nil {
			arg2 = args[2].([]string)
		}
		var arg3 []string
		if args[3] != nil {
			arg3 = args[3].([]string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *SDK_ConnectClients_Call) Return(sDKError errors.SDKError) *SDK_ConnectClients_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_ConnectClients_Call) RunAndReturn(run func(ctx context.Context, channelID string, clientIDs []string, connTypes []string, domainID string, token string) errors.SDKError) *SDK_ConnectClients_Call {
	_c.Call.Return(run)
	return _c
}

// CreateChannel provides a mock function for the type SDK
func (_mock *SDK) CreateChannel(ctx context.Context, channel sdk0.Channel, domainID string, token string) (sdk0.Channel, errors.SDKError) {
	ret := _mock.Called(ctx, channel, domainID, token)

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

	var r0 sdk0.Channel
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Channel, string, string) (sdk0.Channel, errors.SDKError)); ok {
		return returnFunc(ctx, channel, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Channel, string, string) sdk0.Channel); ok {
		r0 = returnFunc(ctx, channel, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Channel)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.Channel, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, channel, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - channel sdk0.Channel
//   - domainID string
//   - token string
func (_e *SDK_Expecter) CreateChannel(ctx interface{}, channel interface{}, domainID interface{}, token interface{}) *SDK_CreateChannel_Call {
	return &SDK_CreateChannel_Call{Call: _e.mock.On("CreateChannel", ctx, channel, domainID, token)}
}

func (_c *SDK_CreateChannel_Call) Run(run func(ctx context.Context, channel sdk0.Channel, domainID string, token string)) *SDK_CreateChannel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.Channel
		if args[1] != nil {
			arg1 = args[1].(sdk0.Channel)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_CreateChannel_Call) Return(channel1 sdk0.Channel, sDKError errors.SDKError) *SDK_CreateChannel_Call {
	_c.Call.Return(channel1, sDKError)
	return _c
}

func (_c *SDK_CreateChannel_Call) RunAndReturn(run func(ctx context.Context, channel sdk0.Channel, domainID string, token string) (sdk0.Channel, errors.SDKError)) *SDK_CreateChannel_Call {
	_c.Call.Return(run)
	return _c
}

// CreateChannels provides a mock function for the type SDK
func (_mock *SDK) CreateChannels(ctx context.Context, channels []sdk0.Channel, domainID string, token string) ([]sdk0.Channel, errors.SDKError) {
	ret := _mock.Called(ctx, channels, domainID, token)

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

	var r0 []sdk0.Channel
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, []sdk0.Channel, string, string) ([]sdk0.Channel, errors.SDKError)); ok {
		return returnFunc(ctx, channels, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []sdk0.Channel, string, string) []sdk0.Channel); ok {
		r0 = returnFunc(ctx, channels, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]sdk0.Channel)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []sdk0.Channel, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, channels, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// CreateChannels is a helper method to define mock.On call
//   - ctx context.Context
//   - channels []sdk0.Channel
//   - domainID string
//   - token string
func (_e *SDK_Expecter) CreateChannels(ctx interface{}, channels interface{}, domainID interface{}, token interface{}) *SDK_CreateChannels_Call {
	return &SDK_CreateChannels_Call{Call: _e.mock.On("CreateChannels", ctx, channels, domainID, token)}
}

func (_c *SDK_CreateChannels_Call) Run(run func(ctx context.Context, channels []sdk0.Channel, domainID string, token string)) *SDK_CreateChannels_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []sdk0.Channel
		if args[1] != nil {
			arg1 = args[1].([]sdk0.Channel)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_CreateChannels_Call) Return(channels1 []sdk0.Channel, sDKError errors.SDKError) *SDK_CreateChannels_Call {
	_c.Call.Return(channels1, sDKError)
	return _c
}

func (_c *SDK_CreateChannels_Call) RunAndReturn(run func(ctx context.Context, channels []sdk0.Channel, domainID string, token string) ([]sdk0.Channel, errors.SDKError)) *SDK_CreateChannels_Call {
	_c.Call.Return(run)
	return _c
}

// CreateClient provides a mock function for the type SDK
func (_mock *SDK) CreateClient(ctx context.Context, client sdk0.Client, domainID string, token string) (sdk0.Client, errors.SDKError) {
	ret := _mock.Called(ctx, client, domainID, token)

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

	var r0 sdk0.Client
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Client, string, string) (sdk0.Client, errors.SDKError)); ok {
		return returnFunc(ctx, client, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Client, string, string) sdk0.Client); ok {
		r0 = returnFunc(ctx, client, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Client)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.Client, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, client, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - client sdk0.Client
//   - domainID string
//   - token string
func (_e *SDK_Expecter) CreateClient(ctx interface{}, client interface{}, domainID interface{}, token interface{}) *SDK_CreateClient_Call {
	return &SDK_CreateClient_Call{Call: _e.mock.On("CreateClient", ctx, client, domainID, token)}
}

func (_c *SDK_CreateClient_Call) Run(run func(ctx context.Context, client sdk0.Client, domainID string, token string)) *SDK_CreateClient_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.Client
		if args[1] != nil {
			arg1 = args[1].(sdk0.Client)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_CreateClient_Call) Return(client1 sdk0.Client, sDKError errors.SDKError) *SDK_CreateClient_Call {
	_c.Call.Return(client1, sDKError)
	return _c
}

func (_c *SDK_CreateClient_Call) RunAndReturn(run func(ctx context.Context, client sdk0.Client, domainID string, token string) (sdk0.Client, errors.SDKError)) *SDK_CreateClient_Call {
	_c.Call.Return(run)
	return _c
}

// CreateClientRole provides a mock function for the type SDK
func (_mock *SDK) CreateClientRole(ctx context.Context, id string, domainID string, rq sdk0.RoleReq, token string) (sdk0.Role, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, rq, token)

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

	var r0 sdk0.Role
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk0.RoleReq, string) (sdk0.Role, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, rq, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk0.RoleReq, string) sdk0.Role); ok {
		r0 = returnFunc(ctx, id, domainID, rq, token)
	} else {
		r0 = ret.Get(0).(sdk0.Role)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, sdk0.RoleReq, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, domainID, rq, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// CreateClientRole is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - domainID string
//   - rq sdk0.RoleReq
//   - token string
func (_e *SDK_Expecter) CreateClientRole(ctx interface{}, id interface{}, domainID interface{}, rq interface{}, token interface{}) *SDK_CreateClientRole_Call {
	return &SDK_CreateClientRole_Call{Call: _e.mock.On("CreateClientRole", ctx, id, domainID, rq, token)}
}

func (_c *SDK_CreateClientRole_Call) Run(run func(ctx context.Context, id string, domainID string, rq sdk0.RoleReq, token string)) *SDK_CreateClientRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 sdk0.RoleReq
		if args[3] != nil {
			arg3 = args[3].(sdk0.RoleReq)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_CreateClientRole_Call) Return(role sdk0.Role, sDKError errors.SDKError) *SDK_CreateClientRole_Call {
	_c.Call.Return(role, sDKError)
	return _c
}

func (_c *SDK_CreateClientRole_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, rq sdk0.RoleReq, token string) (sdk0.Role, errors.SDKError)) *SDK_CreateClientRole_Call {
	_c.Call.Return(run)
	return _c
}

// CreateClients provides a mock function for the type SDK
func (_mock *SDK) CreateClients(ctx context.Context, client []sdk0.Client, domainID string, token string) ([]sdk0.Client, errors.SDKError) {
	ret := _mock.Called(ctx, client, domainID, token)

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

	var r0 []sdk0.Client
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, []sdk0.Client, string, string) ([]sdk0.Client, errors.SDKError)); ok {
		return returnFunc(ctx, client, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []sdk0.Client, string, string) []sdk0.Client); ok {
		r0 = returnFunc(ctx, client, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]sdk0.Client)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []sdk0.Client, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, client, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - client []sdk0.Client
//   - domainID string
//   - token string
func (_e *SDK_Expecter) CreateClients(ctx interface{}, client interface{}, domainID interface{}, token interface{}) *SDK_CreateClients_Call {
	return &SDK_CreateClients_Call{Call: _e.mock.On("CreateClients", ctx, client, domainID, token)}
}

func (_c *SDK_CreateClients_Call) Run(run func(ctx context.Context, client []sdk0.Client, domainID string, token string)) *SDK_CreateClients_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []sdk0.Client
		if args[1] != nil {
			arg1 = args[1].([]sdk0.Client)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_CreateClients_Call) Return(clients []sdk0.Client, sDKError errors.SDKError) *SDK_CreateClients_Call {
	_c.Call.Return(clients, sDKError)
	return _c
}

func (_c *SDK_CreateClients_Call) RunAndReturn(run func(ctx context.Context, client []sdk0.Client, domainID string, token string) ([]sdk0.Client, errors.SDKError)) *SDK_CreateClients_Call {
	_c.Call.Return(run)
	return _c
}

// CreateDomain provides a mock function for the type SDK
func (_mock *SDK) CreateDomain(ctx context.Context, d sdk0.Domain, token string) (sdk0.Domain, errors.SDKError) {
	ret := _mock.Called(ctx, d, token)

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

	var r0 sdk0.Domain
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Domain, string) (sdk0.Domain, errors.SDKError)); ok {
		return returnFunc(ctx, d, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Domain, string) sdk0.Domain); ok {
		r0 = returnFunc(ctx, d, token)
	} else {
		r0 = ret.Get(0).(sdk0.Domain)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.Domain, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, d, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - d sdk0.Domain
//   - token string
func (_e *SDK_Expecter) CreateDomain(ctx interface{}, d interface{}, token interface{}) *SDK_CreateDomain_Call {
	return &SDK_CreateDomain_Call{Call: _e.mock.On("CreateDomain", ctx, d, token)}
}

func (_c *SDK_CreateDomain_Call) Run(run func(ctx context.Context, d sdk0.Domain, token string)) *SDK_CreateDomain_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.Domain
		if args[1] != nil {
			arg1 = args[1].(sdk0.Domain)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_CreateDomain_Call) Return(domain sdk0.Domain, sDKError errors.SDKError) *SDK_CreateDomain_Call {
	_c.Call.Return(domain, sDKError)
	return _c
}

func (_c *SDK_CreateDomain_Call) RunAndReturn(run func(ctx context.Context, d sdk0.Domain, token string) (sdk0.Domain, errors.SDKError)) *SDK_CreateDomain_Call {
	_c.Call.Return(run)
	return _c
}

// CreateDomainRole provides a mock function for the type SDK
func (_mock *SDK) CreateDomainRole(ctx context.Context, id string, rq sdk0.RoleReq, token string) (sdk0.Role, errors.SDKError) {
	ret := _mock.Called(ctx, id, rq, token)

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

	var r0 sdk0.Role
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, sdk0.RoleReq, string) (sdk0.Role, errors.SDKError)); ok {
		return returnFunc(ctx, id, rq, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, sdk0.RoleReq, string) sdk0.Role); ok {
		r0 = returnFunc(ctx, id, rq, token)
	} else {
		r0 = ret.Get(0).(sdk0.Role)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, sdk0.RoleReq, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, rq, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// CreateDomainRole is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - rq sdk0.RoleReq
//   - token string
func (_e *SDK_Expecter) CreateDomainRole(ctx interface{}, id interface{}, rq interface{}, token interface{}) *SDK_CreateDomainRole_Call {
	return &SDK_CreateDomainRole_Call{Call: _e.mock.On("CreateDomainRole", ctx, id, rq, token)}
}

func (_c *SDK_CreateDomainRole_Call) Run(run func(ctx context.Context, id string, rq sdk0.RoleReq, token string)) *SDK_CreateDomainRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 sdk0.RoleReq
		if args[2] != nil {
			arg2 = args[2].(sdk0.RoleReq)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_CreateDomainRole_Call) Return(role sdk0.Role, sDKError errors.SDKError) *SDK_CreateDomainRole_Call {
	_c.Call.Return(role, sDKError)
	return _c
}

func (_c *SDK_CreateDomainRole_Call) RunAndReturn(run func(ctx context.Context, id string, rq sdk0.RoleReq, token string) (sdk0.Role, errors.SDKError)) *SDK_CreateDomainRole_Call {
	_c.Call.Return(run)
	return _c
}

// CreateGroup provides a mock function for the type SDK
func (_mock *SDK) CreateGroup(ctx context.Context, group sdk0.Group, domainID string, token string) (sdk0.Group, errors.SDKError) {
	ret := _mock.Called(ctx, group, domainID, token)

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

	var r0 sdk0.Group
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Group, string, string) (sdk0.Group, errors.SDKError)); ok {
		return returnFunc(ctx, group, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Group, string, string) sdk0.Group); ok {
		r0 = returnFunc(ctx, group, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Group)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.Group, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, group, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

// 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
}

// CreateGroup is a helper method to define mock.On call
//   - ctx context.Context
//   - group sdk0.Group
//   - domainID string
//   - token string
func (_e *SDK_Expecter) CreateGroup(ctx interface{}, group interface{}, domainID interface{}, token interface{}) *SDK_CreateGroup_Call {
	return &SDK_CreateGroup_Call{Call: _e.mock.On("CreateGroup", ctx, group, domainID, token)}
}

func (_c *SDK_CreateGroup_Call) Run(run func(ctx context.Context, group sdk0.Group, domainID string, token string)) *SDK_CreateGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.Group
		if args[1] != nil {
			arg1 = args[1].(sdk0.Group)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_CreateGroup_Call) Return(group1 sdk0.Group, sDKError errors.SDKError) *SDK_CreateGroup_Call {
	_c.Call.Return(group1, sDKError)
	return _c
}

func (_c *SDK_CreateGroup_Call) RunAndReturn(run func(ctx context.Context, group sdk0.Group, domainID string, token string) (sdk0.Group, errors.SDKError)) *SDK_CreateGroup_Call {
	_c.Call.Return(run)
	return _c
}

// CreateGroupRole provides a mock function for the type SDK
func (_mock *SDK) CreateGroupRole(ctx context.Context, id string, domainID string, rq sdk0.RoleReq, token string) (sdk0.Role, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, rq, token)

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

	var r0 sdk0.Role
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk0.RoleReq, string) (sdk0.Role, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, rq, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk0.RoleReq, string) sdk0.Role); ok {
		r0 = returnFunc(ctx, id, domainID, rq, token)
	} else {
		r0 = ret.Get(0).(sdk0.Role)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, sdk0.RoleReq, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, domainID, rq, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// CreateGroupRole is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - domainID string
//   - rq sdk0.RoleReq
//   - token string
func (_e *SDK_Expecter) CreateGroupRole(ctx interface{}, id interface{}, domainID interface{}, rq interface{}, token interface{}) *SDK_CreateGroupRole_Call {
	return &SDK_CreateGroupRole_Call{Call: _e.mock.On("CreateGroupRole", ctx, id, domainID, rq, token)}
}

func (_c *SDK_CreateGroupRole_Call) Run(run func(ctx context.Context, id string, domainID string, rq sdk0.RoleReq, token string)) *SDK_CreateGroupRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 sdk0.RoleReq
		if args[3] != nil {
			arg3 = args[3].(sdk0.RoleReq)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_CreateGroupRole_Call) Return(role sdk0.Role, sDKError errors.SDKError) *SDK_CreateGroupRole_Call {
	_c.Call.Return(role, sDKError)
	return _c
}

func (_c *SDK_CreateGroupRole_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, rq sdk0.RoleReq, token string) (sdk0.Role, errors.SDKError)) *SDK_CreateGroupRole_Call {
	_c.Call.Return(run)
	return _c
}

// CreateSubscription provides a mock function for the type SDK
func (_mock *SDK) CreateSubscription(ctx context.Context, topic string, contact string, token string) (string, errors.SDKError) {
	ret := _mock.Called(ctx, topic, contact, token)

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

	var r0 string
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (string, errors.SDKError)); ok {
		return returnFunc(ctx, topic, contact, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) string); ok {
		r0 = returnFunc(ctx, topic, contact, token)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, topic, contact, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - topic string
//   - contact string
//   - token string
func (_e *SDK_Expecter) CreateSubscription(ctx interface{}, topic interface{}, contact interface{}, token interface{}) *SDK_CreateSubscription_Call {
	return &SDK_CreateSubscription_Call{Call: _e.mock.On("CreateSubscription", ctx, topic, contact, token)}
}

func (_c *SDK_CreateSubscription_Call) Run(run func(ctx context.Context, topic string, contact string, token string)) *SDK_CreateSubscription_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_CreateSubscription_Call) Return(s string, sDKError errors.SDKError) *SDK_CreateSubscription_Call {
	_c.Call.Return(s, sDKError)
	return _c
}

func (_c *SDK_CreateSubscription_Call) RunAndReturn(run func(ctx context.Context, topic string, contact string, token string) (string, errors.SDKError)) *SDK_CreateSubscription_Call {
	_c.Call.Return(run)
	return _c
}

// CreateToken provides a mock function for the type SDK
func (_mock *SDK) CreateToken(ctx context.Context, lt sdk0.Login) (sdk0.Token, errors.SDKError) {
	ret := _mock.Called(ctx, lt)

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

	var r0 sdk0.Token
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Login) (sdk0.Token, errors.SDKError)); ok {
		return returnFunc(ctx, lt)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Login) sdk0.Token); ok {
		r0 = returnFunc(ctx, lt)
	} else {
		r0 = ret.Get(0).(sdk0.Token)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.Login) errors.SDKError); ok {
		r1 = returnFunc(ctx, lt)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(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
//   - ctx context.Context
//   - lt sdk0.Login
func (_e *SDK_Expecter) CreateToken(ctx interface{}, lt interface{}) *SDK_CreateToken_Call {
	return &SDK_CreateToken_Call{Call: _e.mock.On("CreateToken", ctx, lt)}
}

func (_c *SDK_CreateToken_Call) Run(run func(ctx context.Context, lt sdk0.Login)) *SDK_CreateToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.Login
		if args[1] != nil {
			arg1 = args[1].(sdk0.Login)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *SDK_CreateToken_Call) Return(token sdk0.Token, sDKError errors.SDKError) *SDK_CreateToken_Call {
	_c.Call.Return(token, sDKError)
	return _c
}

func (_c *SDK_CreateToken_Call) RunAndReturn(run func(ctx context.Context, lt sdk0.Login) (sdk0.Token, errors.SDKError)) *SDK_CreateToken_Call {
	_c.Call.Return(run)
	return _c
}

// CreateUser provides a mock function for the type SDK
func (_mock *SDK) CreateUser(ctx context.Context, user sdk0.User, token string) (sdk0.User, errors.SDKError) {
	ret := _mock.Called(ctx, user, token)

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

	var r0 sdk0.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.User, string) (sdk0.User, errors.SDKError)); ok {
		return returnFunc(ctx, user, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.User, string) sdk0.User); ok {
		r0 = returnFunc(ctx, user, token)
	} else {
		r0 = ret.Get(0).(sdk0.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.User, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, user, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - user sdk0.User
//   - token string
func (_e *SDK_Expecter) CreateUser(ctx interface{}, user interface{}, token interface{}) *SDK_CreateUser_Call {
	return &SDK_CreateUser_Call{Call: _e.mock.On("CreateUser", ctx, user, token)}
}

func (_c *SDK_CreateUser_Call) Run(run func(ctx context.Context, user sdk0.User, token string)) *SDK_CreateUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.User
		if args[1] != nil {
			arg1 = args[1].(sdk0.User)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_CreateUser_Call) Return(user1 sdk0.User, sDKError errors.SDKError) *SDK_CreateUser_Call {
	_c.Call.Return(user1, sDKError)
	return _c
}

func (_c *SDK_CreateUser_Call) RunAndReturn(run func(ctx context.Context, user sdk0.User, token string) (sdk0.User, errors.SDKError)) *SDK_CreateUser_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteChannel provides a mock function for the type SDK
func (_mock *SDK) DeleteChannel(ctx context.Context, id string, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - id string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) DeleteChannel(ctx interface{}, id interface{}, domainID interface{}, token interface{}) *SDK_DeleteChannel_Call {
	return &SDK_DeleteChannel_Call{Call: _e.mock.On("DeleteChannel", ctx, id, domainID, token)}
}

func (_c *SDK_DeleteChannel_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_DeleteChannel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_DeleteChannel_Call) Return(sDKError errors.SDKError) *SDK_DeleteChannel_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_DeleteChannel_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) errors.SDKError) *SDK_DeleteChannel_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteClient provides a mock function for the type SDK
func (_mock *SDK) DeleteClient(ctx context.Context, id string, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - id string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) DeleteClient(ctx interface{}, id interface{}, domainID interface{}, token interface{}) *SDK_DeleteClient_Call {
	return &SDK_DeleteClient_Call{Call: _e.mock.On("DeleteClient", ctx, id, domainID, token)}
}

func (_c *SDK_DeleteClient_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_DeleteClient_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_DeleteClient_Call) Return(sDKError errors.SDKError) *SDK_DeleteClient_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_DeleteClient_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) errors.SDKError) *SDK_DeleteClient_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteClientRole provides a mock function for the type SDK
func (_mock *SDK) DeleteClientRole(ctx context.Context, id string, roleID string, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, roleID, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// DeleteClientRole is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) DeleteClientRole(ctx interface{}, id interface{}, roleID interface{}, domainID interface{}, token interface{}) *SDK_DeleteClientRole_Call {
	return &SDK_DeleteClientRole_Call{Call: _e.mock.On("DeleteClientRole", ctx, id, roleID, domainID, token)}
}

func (_c *SDK_DeleteClientRole_Call) Run(run func(ctx context.Context, id string, roleID string, domainID string, token string)) *SDK_DeleteClientRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_DeleteClientRole_Call) Return(sDKError errors.SDKError) *SDK_DeleteClientRole_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_DeleteClientRole_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, domainID string, token string) errors.SDKError) *SDK_DeleteClientRole_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDomainRole provides a mock function for the type SDK
func (_mock *SDK) DeleteDomainRole(ctx context.Context, id string, roleID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, roleID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, roleID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// DeleteDomainRole is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - token string
func (_e *SDK_Expecter) DeleteDomainRole(ctx interface{}, id interface{}, roleID interface{}, token interface{}) *SDK_DeleteDomainRole_Call {
	return &SDK_DeleteDomainRole_Call{Call: _e.mock.On("DeleteDomainRole", ctx, id, roleID, token)}
}

func (_c *SDK_DeleteDomainRole_Call) Run(run func(ctx context.Context, id string, roleID string, token string)) *SDK_DeleteDomainRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_DeleteDomainRole_Call) Return(sDKError errors.SDKError) *SDK_DeleteDomainRole_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_DeleteDomainRole_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, token string) errors.SDKError) *SDK_DeleteDomainRole_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteGroup provides a mock function for the type SDK
func (_mock *SDK) DeleteGroup(ctx context.Context, id string, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - id string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) DeleteGroup(ctx interface{}, id interface{}, domainID interface{}, token interface{}) *SDK_DeleteGroup_Call {
	return &SDK_DeleteGroup_Call{Call: _e.mock.On("DeleteGroup", ctx, id, domainID, token)}
}

func (_c *SDK_DeleteGroup_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_DeleteGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_DeleteGroup_Call) Return(sDKError errors.SDKError) *SDK_DeleteGroup_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_DeleteGroup_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) errors.SDKError) *SDK_DeleteGroup_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteGroupRole provides a mock function for the type SDK
func (_mock *SDK) DeleteGroupRole(ctx context.Context, id string, roleID string, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, roleID, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// DeleteGroupRole is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) DeleteGroupRole(ctx interface{}, id interface{}, roleID interface{}, domainID interface{}, token interface{}) *SDK_DeleteGroupRole_Call {
	return &SDK_DeleteGroupRole_Call{Call: _e.mock.On("DeleteGroupRole", ctx, id, roleID, domainID, token)}
}

func (_c *SDK_DeleteGroupRole_Call) Run(run func(ctx context.Context, id string, roleID string, domainID string, token string)) *SDK_DeleteGroupRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_DeleteGroupRole_Call) Return(sDKError errors.SDKError) *SDK_DeleteGroupRole_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_DeleteGroupRole_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, domainID string, token string) errors.SDKError) *SDK_DeleteGroupRole_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteInvitation provides a mock function for the type SDK
func (_mock *SDK) DeleteInvitation(ctx context.Context, userID string, domainID string, token string) error {
	ret := _mock.Called(ctx, userID, domainID, token)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, userID, domainID, token)
	} else {
		r0 = ret.Error(0)
	}
	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
//   - ctx context.Context
//   - userID string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) DeleteInvitation(ctx interface{}, userID interface{}, domainID interface{}, token interface{}) *SDK_DeleteInvitation_Call {
	return &SDK_DeleteInvitation_Call{Call: _e.mock.On("DeleteInvitation", ctx, userID, domainID, token)}
}

func (_c *SDK_DeleteInvitation_Call) Run(run func(ctx context.Context, userID string, domainID string, token string)) *SDK_DeleteInvitation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	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(ctx context.Context, userID string, domainID string, token string) error) *SDK_DeleteInvitation_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteSubscription provides a mock function for the type SDK
func (_mock *SDK) DeleteSubscription(ctx context.Context, id string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(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
//   - ctx context.Context
//   - id string
//   - token string
func (_e *SDK_Expecter) DeleteSubscription(ctx interface{}, id interface{}, token interface{}) *SDK_DeleteSubscription_Call {
	return &SDK_DeleteSubscription_Call{Call: _e.mock.On("DeleteSubscription", ctx, id, token)}
}

func (_c *SDK_DeleteSubscription_Call) Run(run func(ctx context.Context, id string, token string)) *SDK_DeleteSubscription_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_DeleteSubscription_Call) Return(sDKError errors.SDKError) *SDK_DeleteSubscription_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_DeleteSubscription_Call) RunAndReturn(run func(ctx context.Context, id string, token string) errors.SDKError) *SDK_DeleteSubscription_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteUser provides a mock function for the type SDK
func (_mock *SDK) DeleteUser(ctx context.Context, id string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(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
//   - ctx context.Context
//   - id string
//   - token string
func (_e *SDK_Expecter) DeleteUser(ctx interface{}, id interface{}, token interface{}) *SDK_DeleteUser_Call {
	return &SDK_DeleteUser_Call{Call: _e.mock.On("DeleteUser", ctx, id, token)}
}

func (_c *SDK_DeleteUser_Call) Run(run func(ctx context.Context, id string, token string)) *SDK_DeleteUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_DeleteUser_Call) Return(sDKError errors.SDKError) *SDK_DeleteUser_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_DeleteUser_Call) RunAndReturn(run func(ctx context.Context, id string, token string) errors.SDKError) *SDK_DeleteUser_Call {
	_c.Call.Return(run)
	return _c
}

// DisableChannel provides a mock function for the type SDK
func (_mock *SDK) DisableChannel(ctx context.Context, id string, domainID string, token string) (sdk0.Channel, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 sdk0.Channel
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk0.Channel, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk0.Channel); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Channel)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - id string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) DisableChannel(ctx interface{}, id interface{}, domainID interface{}, token interface{}) *SDK_DisableChannel_Call {
	return &SDK_DisableChannel_Call{Call: _e.mock.On("DisableChannel", ctx, id, domainID, token)}
}

func (_c *SDK_DisableChannel_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_DisableChannel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_DisableChannel_Call) Return(channel sdk0.Channel, sDKError errors.SDKError) *SDK_DisableChannel_Call {
	_c.Call.Return(channel, sDKError)
	return _c
}

func (_c *SDK_DisableChannel_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) (sdk0.Channel, errors.SDKError)) *SDK_DisableChannel_Call {
	_c.Call.Return(run)
	return _c
}

// DisableClient provides a mock function for the type SDK
func (_mock *SDK) DisableClient(ctx context.Context, id string, domainID string, token string) (sdk0.Client, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 sdk0.Client
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk0.Client, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk0.Client); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Client)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - id string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) DisableClient(ctx interface{}, id interface{}, domainID interface{}, token interface{}) *SDK_DisableClient_Call {
	return &SDK_DisableClient_Call{Call: _e.mock.On("DisableClient", ctx, id, domainID, token)}
}

func (_c *SDK_DisableClient_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_DisableClient_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_DisableClient_Call) Return(client sdk0.Client, sDKError errors.SDKError) *SDK_DisableClient_Call {
	_c.Call.Return(client, sDKError)
	return _c
}

func (_c *SDK_DisableClient_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) (sdk0.Client, errors.SDKError)) *SDK_DisableClient_Call {
	_c.Call.Return(run)
	return _c
}

// DisableDomain provides a mock function for the type SDK
func (_mock *SDK) DisableDomain(ctx context.Context, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(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
//   - ctx context.Context
//   - domainID string
//   - token string
func (_e *SDK_Expecter) DisableDomain(ctx interface{}, domainID interface{}, token interface{}) *SDK_DisableDomain_Call {
	return &SDK_DisableDomain_Call{Call: _e.mock.On("DisableDomain", ctx, domainID, token)}
}

func (_c *SDK_DisableDomain_Call) Run(run func(ctx context.Context, domainID string, token string)) *SDK_DisableDomain_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_DisableDomain_Call) Return(sDKError errors.SDKError) *SDK_DisableDomain_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_DisableDomain_Call) RunAndReturn(run func(ctx context.Context, domainID string, token string) errors.SDKError) *SDK_DisableDomain_Call {
	_c.Call.Return(run)
	return _c
}

// DisableGroup provides a mock function for the type SDK
func (_mock *SDK) DisableGroup(ctx context.Context, id string, domainID string, token string) (sdk0.Group, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 sdk0.Group
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk0.Group, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk0.Group); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Group)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - id string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) DisableGroup(ctx interface{}, id interface{}, domainID interface{}, token interface{}) *SDK_DisableGroup_Call {
	return &SDK_DisableGroup_Call{Call: _e.mock.On("DisableGroup", ctx, id, domainID, token)}
}

func (_c *SDK_DisableGroup_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_DisableGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_DisableGroup_Call) Return(group sdk0.Group, sDKError errors.SDKError) *SDK_DisableGroup_Call {
	_c.Call.Return(group, sDKError)
	return _c
}

func (_c *SDK_DisableGroup_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) (sdk0.Group, errors.SDKError)) *SDK_DisableGroup_Call {
	_c.Call.Return(run)
	return _c
}

// DisableUser provides a mock function for the type SDK
func (_mock *SDK) DisableUser(ctx context.Context, id string, token string) (sdk0.User, errors.SDKError) {
	ret := _mock.Called(ctx, id, token)

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

	var r0 sdk0.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (sdk0.User, errors.SDKError)); ok {
		return returnFunc(ctx, id, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) sdk0.User); ok {
		r0 = returnFunc(ctx, id, token)
	} else {
		r0 = ret.Get(0).(sdk0.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(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
//   - ctx context.Context
//   - id string
//   - token string
func (_e *SDK_Expecter) DisableUser(ctx interface{}, id interface{}, token interface{}) *SDK_DisableUser_Call {
	return &SDK_DisableUser_Call{Call: _e.mock.On("DisableUser", ctx, id, token)}
}

func (_c *SDK_DisableUser_Call) Run(run func(ctx context.Context, id string, token string)) *SDK_DisableUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_DisableUser_Call) Return(user sdk0.User, sDKError errors.SDKError) *SDK_DisableUser_Call {
	_c.Call.Return(user, sDKError)
	return _c
}

func (_c *SDK_DisableUser_Call) RunAndReturn(run func(ctx context.Context, id string, token string) (sdk0.User, errors.SDKError)) *SDK_DisableUser_Call {
	_c.Call.Return(run)
	return _c
}

// Disconnect provides a mock function for the type SDK
func (_mock *SDK) Disconnect(ctx context.Context, conn sdk0.Connection, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, conn, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Connection, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, conn, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - conn sdk0.Connection
//   - domainID string
//   - token string
func (_e *SDK_Expecter) Disconnect(ctx interface{}, conn interface{}, domainID interface{}, token interface{}) *SDK_Disconnect_Call {
	return &SDK_Disconnect_Call{Call: _e.mock.On("Disconnect", ctx, conn, domainID, token)}
}

func (_c *SDK_Disconnect_Call) Run(run func(ctx context.Context, conn sdk0.Connection, domainID string, token string)) *SDK_Disconnect_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.Connection
		if args[1] != nil {
			arg1 = args[1].(sdk0.Connection)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_Disconnect_Call) Return(sDKError errors.SDKError) *SDK_Disconnect_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_Disconnect_Call) RunAndReturn(run func(ctx context.Context, conn sdk0.Connection, domainID string, token string) errors.SDKError) *SDK_Disconnect_Call {
	_c.Call.Return(run)
	return _c
}

// DisconnectClients provides a mock function for the type SDK
func (_mock *SDK) DisconnectClients(ctx context.Context, channelID string, clientIDs []string, connTypes []string, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, channelID, clientIDs, connTypes, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string, []string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, channelID, clientIDs, connTypes, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// DisconnectClients is a helper method to define mock.On call
//   - ctx context.Context
//   - channelID string
//   - clientIDs []string
//   - connTypes []string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) DisconnectClients(ctx interface{}, channelID interface{}, clientIDs interface{}, connTypes interface{}, domainID interface{}, token interface{}) *SDK_DisconnectClients_Call {
	return &SDK_DisconnectClients_Call{Call: _e.mock.On("DisconnectClients", ctx, channelID, clientIDs, connTypes, domainID, token)}
}

func (_c *SDK_DisconnectClients_Call) Run(run func(ctx context.Context, channelID string, clientIDs []string, connTypes []string, domainID string, token string)) *SDK_DisconnectClients_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []string
		if args[2] != nil {
			arg2 = args[2].([]string)
		}
		var arg3 []string
		if args[3] != nil {
			arg3 = args[3].([]string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *SDK_DisconnectClients_Call) Return(sDKError errors.SDKError) *SDK_DisconnectClients_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_DisconnectClients_Call) RunAndReturn(run func(ctx context.Context, channelID string, clientIDs []string, connTypes []string, domainID string, token string) errors.SDKError) *SDK_DisconnectClients_Call {
	_c.Call.Return(run)
	return _c
}

// Domain provides a mock function for the type SDK
func (_mock *SDK) Domain(ctx context.Context, domainID string, token string) (sdk0.Domain, errors.SDKError) {
	ret := _mock.Called(ctx, domainID, token)

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

	var r0 sdk0.Domain
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (sdk0.Domain, errors.SDKError)); ok {
		return returnFunc(ctx, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) sdk0.Domain); ok {
		r0 = returnFunc(ctx, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Domain)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - domainID string
//   - token string
func (_e *SDK_Expecter) Domain(ctx interface{}, domainID interface{}, token interface{}) *SDK_Domain_Call {
	return &SDK_Domain_Call{Call: _e.mock.On("Domain", ctx, domainID, token)}
}

func (_c *SDK_Domain_Call) Run(run func(ctx context.Context, domainID string, token string)) *SDK_Domain_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_Domain_Call) Return(domain sdk0.Domain, sDKError errors.SDKError) *SDK_Domain_Call {
	_c.Call.Return(domain, sDKError)
	return _c
}

func (_c *SDK_Domain_Call) RunAndReturn(run func(ctx context.Context, domainID string, token string) (sdk0.Domain, errors.SDKError)) *SDK_Domain_Call {
	_c.Call.Return(run)
	return _c
}

// DomainInvitations provides a mock function for the type SDK
func (_mock *SDK) DomainInvitations(ctx context.Context, pm sdk0.PageMetadata, token string, domainID string) (sdk0.InvitationPage, error) {
	ret := _mock.Called(ctx, pm, token, domainID)

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

	var r0 sdk0.InvitationPage
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.PageMetadata, string, string) (sdk0.InvitationPage, error)); ok {
		return returnFunc(ctx, pm, token, domainID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.PageMetadata, string, string) sdk0.InvitationPage); ok {
		r0 = returnFunc(ctx, pm, token, domainID)
	} else {
		r0 = ret.Get(0).(sdk0.InvitationPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.PageMetadata, string, string) error); ok {
		r1 = returnFunc(ctx, pm, token, domainID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DomainInvitations is a helper method to define mock.On call
//   - ctx context.Context
//   - pm sdk0.PageMetadata
//   - token string
//   - domainID string
func (_e *SDK_Expecter) DomainInvitations(ctx interface{}, pm interface{}, token interface{}, domainID interface{}) *SDK_DomainInvitations_Call {
	return &SDK_DomainInvitations_Call{Call: _e.mock.On("DomainInvitations", ctx, pm, token, domainID)}
}

func (_c *SDK_DomainInvitations_Call) Run(run func(ctx context.Context, pm sdk0.PageMetadata, token string, domainID string)) *SDK_DomainInvitations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.PageMetadata
		if args[1] != nil {
			arg1 = args[1].(sdk0.PageMetadata)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_DomainInvitations_Call) Return(invitations sdk0.InvitationPage, err error) *SDK_DomainInvitations_Call {
	_c.Call.Return(invitations, err)
	return _c
}

func (_c *SDK_DomainInvitations_Call) RunAndReturn(run func(ctx context.Context, pm sdk0.PageMetadata, token string, domainID string) (sdk0.InvitationPage, error)) *SDK_DomainInvitations_Call {
	_c.Call.Return(run)
	return _c
}

// DomainRole provides a mock function for the type SDK
func (_mock *SDK) DomainRole(ctx context.Context, id string, roleID string, token string) (sdk0.Role, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, token)

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

	var r0 sdk0.Role
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk0.Role, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk0.Role); ok {
		r0 = returnFunc(ctx, id, roleID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Role)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, roleID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// DomainRole is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - token string
func (_e *SDK_Expecter) DomainRole(ctx interface{}, id interface{}, roleID interface{}, token interface{}) *SDK_DomainRole_Call {
	return &SDK_DomainRole_Call{Call: _e.mock.On("DomainRole", ctx, id, roleID, token)}
}

func (_c *SDK_DomainRole_Call) Run(run func(ctx context.Context, id string, roleID string, token string)) *SDK_DomainRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_DomainRole_Call) Return(role sdk0.Role, sDKError errors.SDKError) *SDK_DomainRole_Call {
	_c.Call.Return(role, sDKError)
	return _c
}

func (_c *SDK_DomainRole_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, token string) (sdk0.Role, errors.SDKError)) *SDK_DomainRole_Call {
	_c.Call.Return(run)
	return _c
}

// DomainRoleActions provides a mock function for the type SDK
func (_mock *SDK) DomainRoleActions(ctx context.Context, id string, roleID string, token string) ([]string, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, token)

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

	var r0 []string
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) ([]string, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) []string); ok {
		r0 = returnFunc(ctx, id, roleID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, roleID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// DomainRoleActions is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - token string
func (_e *SDK_Expecter) DomainRoleActions(ctx interface{}, id interface{}, roleID interface{}, token interface{}) *SDK_DomainRoleActions_Call {
	return &SDK_DomainRoleActions_Call{Call: _e.mock.On("DomainRoleActions", ctx, id, roleID, token)}
}

func (_c *SDK_DomainRoleActions_Call) Run(run func(ctx context.Context, id string, roleID string, token string)) *SDK_DomainRoleActions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_DomainRoleActions_Call) Return(strings []string, sDKError errors.SDKError) *SDK_DomainRoleActions_Call {
	_c.Call.Return(strings, sDKError)
	return _c
}

func (_c *SDK_DomainRoleActions_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, token string) ([]string, errors.SDKError)) *SDK_DomainRoleActions_Call {
	_c.Call.Return(run)
	return _c
}

// DomainRoleMembers provides a mock function for the type SDK
func (_mock *SDK) DomainRoleMembers(ctx context.Context, id string, roleID string, pm sdk0.PageMetadata, token string) (sdk0.RoleMembersPage, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, pm, token)

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

	var r0 sdk0.RoleMembersPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk0.PageMetadata, string) (sdk0.RoleMembersPage, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk0.PageMetadata, string) sdk0.RoleMembersPage); ok {
		r0 = returnFunc(ctx, id, roleID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk0.RoleMembersPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, sdk0.PageMetadata, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, roleID, pm, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// DomainRoleMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - pm sdk0.PageMetadata
//   - token string
func (_e *SDK_Expecter) DomainRoleMembers(ctx interface{}, id interface{}, roleID interface{}, pm interface{}, token interface{}) *SDK_DomainRoleMembers_Call {
	return &SDK_DomainRoleMembers_Call{Call: _e.mock.On("DomainRoleMembers", ctx, id, roleID, pm, token)}
}

func (_c *SDK_DomainRoleMembers_Call) Run(run func(ctx context.Context, id string, roleID string, pm sdk0.PageMetadata, token string)) *SDK_DomainRoleMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 sdk0.PageMetadata
		if args[3] != nil {
			arg3 = args[3].(sdk0.PageMetadata)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_DomainRoleMembers_Call) Return(roleMembersPage sdk0.RoleMembersPage, sDKError errors.SDKError) *SDK_DomainRoleMembers_Call {
	_c.Call.Return(roleMembersPage, sDKError)
	return _c
}

func (_c *SDK_DomainRoleMembers_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, pm sdk0.PageMetadata, token string) (sdk0.RoleMembersPage, errors.SDKError)) *SDK_DomainRoleMembers_Call {
	_c.Call.Return(run)
	return _c
}

// DomainRoles provides a mock function for the type SDK
func (_mock *SDK) DomainRoles(ctx context.Context, id string, pm sdk0.PageMetadata, token string) (sdk0.RolesPage, errors.SDKError) {
	ret := _mock.Called(ctx, id, pm, token)

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

	var r0 sdk0.RolesPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, sdk0.PageMetadata, string) (sdk0.RolesPage, errors.SDKError)); ok {
		return returnFunc(ctx, id, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, sdk0.PageMetadata, string) sdk0.RolesPage); ok {
		r0 = returnFunc(ctx, id, pm, token)
	} else {
		r0 = ret.Get(0).(sdk0.RolesPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, sdk0.PageMetadata, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, pm, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// DomainRoles is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - pm sdk0.PageMetadata
//   - token string
func (_e *SDK_Expecter) DomainRoles(ctx interface{}, id interface{}, pm interface{}, token interface{}) *SDK_DomainRoles_Call {
	return &SDK_DomainRoles_Call{Call: _e.mock.On("DomainRoles", ctx, id, pm, token)}
}

func (_c *SDK_DomainRoles_Call) Run(run func(ctx context.Context, id string, pm sdk0.PageMetadata, token string)) *SDK_DomainRoles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 sdk0.PageMetadata
		if args[2] != nil {
			arg2 = args[2].(sdk0.PageMetadata)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_DomainRoles_Call) Return(rolesPage sdk0.RolesPage, sDKError errors.SDKError) *SDK_DomainRoles_Call {
	_c.Call.Return(rolesPage, sDKError)
	return _c
}

func (_c *SDK_DomainRoles_Call) RunAndReturn(run func(ctx context.Context, id string, pm sdk0.PageMetadata, token string) (sdk0.RolesPage, errors.SDKError)) *SDK_DomainRoles_Call {
	_c.Call.Return(run)
	return _c
}

// Domains provides a mock function for the type SDK
func (_mock *SDK) Domains(ctx context.Context, pm sdk0.PageMetadata, token string) (sdk0.DomainsPage, errors.SDKError) {
	ret := _mock.Called(ctx, pm, token)

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

	var r0 sdk0.DomainsPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.PageMetadata, string) (sdk0.DomainsPage, errors.SDKError)); ok {
		return returnFunc(ctx, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.PageMetadata, string) sdk0.DomainsPage); ok {
		r0 = returnFunc(ctx, pm, token)
	} else {
		r0 = ret.Get(0).(sdk0.DomainsPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.PageMetadata, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, pm, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - pm sdk0.PageMetadata
//   - token string
func (_e *SDK_Expecter) Domains(ctx interface{}, pm interface{}, token interface{}) *SDK_Domains_Call {
	return &SDK_Domains_Call{Call: _e.mock.On("Domains", ctx, pm, token)}
}

func (_c *SDK_Domains_Call) Run(run func(ctx context.Context, pm sdk0.PageMetadata, token string)) *SDK_Domains_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.PageMetadata
		if args[1] != nil {
			arg1 = args[1].(sdk0.PageMetadata)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_Domains_Call) Return(domainsPage sdk0.DomainsPage, sDKError errors.SDKError) *SDK_Domains_Call {
	_c.Call.Return(domainsPage, sDKError)
	return _c
}

func (_c *SDK_Domains_Call) RunAndReturn(run func(ctx context.Context, pm sdk0.PageMetadata, token string) (sdk0.DomainsPage, errors.SDKError)) *SDK_Domains_Call {
	_c.Call.Return(run)
	return _c
}

// EnableChannel provides a mock function for the type SDK
func (_mock *SDK) EnableChannel(ctx context.Context, id string, domainID string, token string) (sdk0.Channel, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 sdk0.Channel
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk0.Channel, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk0.Channel); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Channel)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - id string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) EnableChannel(ctx interface{}, id interface{}, domainID interface{}, token interface{}) *SDK_EnableChannel_Call {
	return &SDK_EnableChannel_Call{Call: _e.mock.On("EnableChannel", ctx, id, domainID, token)}
}

func (_c *SDK_EnableChannel_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_EnableChannel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_EnableChannel_Call) Return(channel sdk0.Channel, sDKError errors.SDKError) *SDK_EnableChannel_Call {
	_c.Call.Return(channel, sDKError)
	return _c
}

func (_c *SDK_EnableChannel_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) (sdk0.Channel, errors.SDKError)) *SDK_EnableChannel_Call {
	_c.Call.Return(run)
	return _c
}

// EnableClient provides a mock function for the type SDK
func (_mock *SDK) EnableClient(ctx context.Context, id string, domainID string, token string) (sdk0.Client, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 sdk0.Client
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk0.Client, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk0.Client); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Client)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - id string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) EnableClient(ctx interface{}, id interface{}, domainID interface{}, token interface{}) *SDK_EnableClient_Call {
	return &SDK_EnableClient_Call{Call: _e.mock.On("EnableClient", ctx, id, domainID, token)}
}

func (_c *SDK_EnableClient_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_EnableClient_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_EnableClient_Call) Return(client sdk0.Client, sDKError errors.SDKError) *SDK_EnableClient_Call {
	_c.Call.Return(client, sDKError)
	return _c
}

func (_c *SDK_EnableClient_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) (sdk0.Client, errors.SDKError)) *SDK_EnableClient_Call {
	_c.Call.Return(run)
	return _c
}

// EnableDomain provides a mock function for the type SDK
func (_mock *SDK) EnableDomain(ctx context.Context, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(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
//   - ctx context.Context
//   - domainID string
//   - token string
func (_e *SDK_Expecter) EnableDomain(ctx interface{}, domainID interface{}, token interface{}) *SDK_EnableDomain_Call {
	return &SDK_EnableDomain_Call{Call: _e.mock.On("EnableDomain", ctx, domainID, token)}
}

func (_c *SDK_EnableDomain_Call) Run(run func(ctx context.Context, domainID string, token string)) *SDK_EnableDomain_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_EnableDomain_Call) Return(sDKError errors.SDKError) *SDK_EnableDomain_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_EnableDomain_Call) RunAndReturn(run func(ctx context.Context, domainID string, token string) errors.SDKError) *SDK_EnableDomain_Call {
	_c.Call.Return(run)
	return _c
}

// EnableGroup provides a mock function for the type SDK
func (_mock *SDK) EnableGroup(ctx context.Context, id string, domainID string, token string) (sdk0.Group, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 sdk0.Group
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk0.Group, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk0.Group); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Group)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - id string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) EnableGroup(ctx interface{}, id interface{}, domainID interface{}, token interface{}) *SDK_EnableGroup_Call {
	return &SDK_EnableGroup_Call{Call: _e.mock.On("EnableGroup", ctx, id, domainID, token)}
}

func (_c *SDK_EnableGroup_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_EnableGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_EnableGroup_Call) Return(group sdk0.Group, sDKError errors.SDKError) *SDK_EnableGroup_Call {
	_c.Call.Return(group, sDKError)
	return _c
}

func (_c *SDK_EnableGroup_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) (sdk0.Group, errors.SDKError)) *SDK_EnableGroup_Call {
	_c.Call.Return(run)
	return _c
}

// EnableUser provides a mock function for the type SDK
func (_mock *SDK) EnableUser(ctx context.Context, id string, token string) (sdk0.User, errors.SDKError) {
	ret := _mock.Called(ctx, id, token)

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

	var r0 sdk0.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (sdk0.User, errors.SDKError)); ok {
		return returnFunc(ctx, id, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) sdk0.User); ok {
		r0 = returnFunc(ctx, id, token)
	} else {
		r0 = ret.Get(0).(sdk0.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(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
//   - ctx context.Context
//   - id string
//   - token string
func (_e *SDK_Expecter) EnableUser(ctx interface{}, id interface{}, token interface{}) *SDK_EnableUser_Call {
	return &SDK_EnableUser_Call{Call: _e.mock.On("EnableUser", ctx, id, token)}
}

func (_c *SDK_EnableUser_Call) Run(run func(ctx context.Context, id string, token string)) *SDK_EnableUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_EnableUser_Call) Return(user sdk0.User, sDKError errors.SDKError) *SDK_EnableUser_Call {
	_c.Call.Return(user, sDKError)
	return _c
}

func (_c *SDK_EnableUser_Call) RunAndReturn(run func(ctx context.Context, id string, token string) (sdk0.User, errors.SDKError)) *SDK_EnableUser_Call {
	_c.Call.Return(run)
	return _c
}

// FreezeDomain provides a mock function for the type SDK
func (_mock *SDK) FreezeDomain(ctx context.Context, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// FreezeDomain is a helper method to define mock.On call
//   - ctx context.Context
//   - domainID string
//   - token string
func (_e *SDK_Expecter) FreezeDomain(ctx interface{}, domainID interface{}, token interface{}) *SDK_FreezeDomain_Call {
	return &SDK_FreezeDomain_Call{Call: _e.mock.On("FreezeDomain", ctx, domainID, token)}
}

func (_c *SDK_FreezeDomain_Call) Run(run func(ctx context.Context, domainID string, token string)) *SDK_FreezeDomain_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_FreezeDomain_Call) Return(sDKError errors.SDKError) *SDK_FreezeDomain_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_FreezeDomain_Call) RunAndReturn(run func(ctx context.Context, domainID string, token string) errors.SDKError) *SDK_FreezeDomain_Call {
	_c.Call.Return(run)
	return _c
}

// Group provides a mock function for the type SDK
func (_mock *SDK) Group(ctx context.Context, id string, domainID string, token string) (sdk0.Group, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 sdk0.Group
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk0.Group, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk0.Group); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Group)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - id string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) Group(ctx interface{}, id interface{}, domainID interface{}, token interface{}) *SDK_Group_Call {
	return &SDK_Group_Call{Call: _e.mock.On("Group", ctx, id, domainID, token)}
}

func (_c *SDK_Group_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_Group_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_Group_Call) Return(group sdk0.Group, sDKError errors.SDKError) *SDK_Group_Call {
	_c.Call.Return(group, sDKError)
	return _c
}

func (_c *SDK_Group_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) (sdk0.Group, errors.SDKError)) *SDK_Group_Call {
	_c.Call.Return(run)
	return _c
}

// GroupRole provides a mock function for the type SDK
func (_mock *SDK) GroupRole(ctx context.Context, id string, roleID string, domainID string, token string) (sdk0.Role, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, domainID, token)

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

	var r0 sdk0.Role
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (sdk0.Role, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) sdk0.Role); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Role)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, roleID, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// GroupRole is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) GroupRole(ctx interface{}, id interface{}, roleID interface{}, domainID interface{}, token interface{}) *SDK_GroupRole_Call {
	return &SDK_GroupRole_Call{Call: _e.mock.On("GroupRole", ctx, id, roleID, domainID, token)}
}

func (_c *SDK_GroupRole_Call) Run(run func(ctx context.Context, id string, roleID string, domainID string, token string)) *SDK_GroupRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_GroupRole_Call) Return(role sdk0.Role, sDKError errors.SDKError) *SDK_GroupRole_Call {
	_c.Call.Return(role, sDKError)
	return _c
}

func (_c *SDK_GroupRole_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, domainID string, token string) (sdk0.Role, errors.SDKError)) *SDK_GroupRole_Call {
	_c.Call.Return(run)
	return _c
}

// GroupRoleActions provides a mock function for the type SDK
func (_mock *SDK) GroupRoleActions(ctx context.Context, id string, roleID string, domainID string, token string) ([]string, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, domainID, token)

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

	var r0 []string
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) ([]string, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) []string); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, roleID, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// GroupRoleActions is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) GroupRoleActions(ctx interface{}, id interface{}, roleID interface{}, domainID interface{}, token interface{}) *SDK_GroupRoleActions_Call {
	return &SDK_GroupRoleActions_Call{Call: _e.mock.On("GroupRoleActions", ctx, id, roleID, domainID, token)}
}

func (_c *SDK_GroupRoleActions_Call) Run(run func(ctx context.Context, id string, roleID string, domainID string, token string)) *SDK_GroupRoleActions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_GroupRoleActions_Call) Return(strings []string, sDKError errors.SDKError) *SDK_GroupRoleActions_Call {
	_c.Call.Return(strings, sDKError)
	return _c
}

func (_c *SDK_GroupRoleActions_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, domainID string, token string) ([]string, errors.SDKError)) *SDK_GroupRoleActions_Call {
	_c.Call.Return(run)
	return _c
}

// GroupRoleMembers provides a mock function for the type SDK
func (_mock *SDK) GroupRoleMembers(ctx context.Context, id string, roleID string, domainID string, pm sdk0.PageMetadata, token string) (sdk0.RoleMembersPage, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, domainID, pm, token)

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

	var r0 sdk0.RoleMembersPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, sdk0.PageMetadata, string) (sdk0.RoleMembersPage, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, sdk0.PageMetadata, string) sdk0.RoleMembersPage); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk0.RoleMembersPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, sdk0.PageMetadata, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, roleID, domainID, pm, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// GroupRoleMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - domainID string
//   - pm sdk0.PageMetadata
//   - token string
func (_e *SDK_Expecter) GroupRoleMembers(ctx interface{}, id interface{}, roleID interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_GroupRoleMembers_Call {
	return &SDK_GroupRoleMembers_Call{Call: _e.mock.On("GroupRoleMembers", ctx, id, roleID, domainID, pm, token)}
}

func (_c *SDK_GroupRoleMembers_Call) Run(run func(ctx context.Context, id string, roleID string, domainID string, pm sdk0.PageMetadata, token string)) *SDK_GroupRoleMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 sdk0.PageMetadata
		if args[4] != nil {
			arg4 = args[4].(sdk0.PageMetadata)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *SDK_GroupRoleMembers_Call) Return(roleMembersPage sdk0.RoleMembersPage, sDKError errors.SDKError) *SDK_GroupRoleMembers_Call {
	_c.Call.Return(roleMembersPage, sDKError)
	return _c
}

func (_c *SDK_GroupRoleMembers_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, domainID string, pm sdk0.PageMetadata, token string) (sdk0.RoleMembersPage, errors.SDKError)) *SDK_GroupRoleMembers_Call {
	_c.Call.Return(run)
	return _c
}

// GroupRoles provides a mock function for the type SDK
func (_mock *SDK) GroupRoles(ctx context.Context, id string, domainID string, pm sdk0.PageMetadata, token string) (sdk0.RolesPage, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, pm, token)

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

	var r0 sdk0.RolesPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk0.PageMetadata, string) (sdk0.RolesPage, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk0.PageMetadata, string) sdk0.RolesPage); ok {
		r0 = returnFunc(ctx, id, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk0.RolesPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, sdk0.PageMetadata, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, domainID, pm, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// GroupRoles is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - domainID string
//   - pm sdk0.PageMetadata
//   - token string
func (_e *SDK_Expecter) GroupRoles(ctx interface{}, id interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_GroupRoles_Call {
	return &SDK_GroupRoles_Call{Call: _e.mock.On("GroupRoles", ctx, id, domainID, pm, token)}
}

func (_c *SDK_GroupRoles_Call) Run(run func(ctx context.Context, id string, domainID string, pm sdk0.PageMetadata, token string)) *SDK_GroupRoles_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 sdk0.PageMetadata
		if args[3] != nil {
			arg3 = args[3].(sdk0.PageMetadata)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_GroupRoles_Call) Return(rolesPage sdk0.RolesPage, sDKError errors.SDKError) *SDK_GroupRoles_Call {
	_c.Call.Return(rolesPage, sDKError)
	return _c
}

func (_c *SDK_GroupRoles_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, pm sdk0.PageMetadata, token string) (sdk0.RolesPage, errors.SDKError)) *SDK_GroupRoles_Call {
	_c.Call.Return(run)
	return _c
}

// Groups provides a mock function for the type SDK
func (_mock *SDK) Groups(ctx context.Context, pm sdk0.PageMetadata, domainID string, token string) (sdk0.GroupsPage, errors.SDKError) {
	ret := _mock.Called(ctx, pm, domainID, token)

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

	var r0 sdk0.GroupsPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.PageMetadata, string, string) (sdk0.GroupsPage, errors.SDKError)); ok {
		return returnFunc(ctx, pm, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.PageMetadata, string, string) sdk0.GroupsPage); ok {
		r0 = returnFunc(ctx, pm, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.GroupsPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.PageMetadata, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, pm, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - pm sdk0.PageMetadata
//   - domainID string
//   - token string
func (_e *SDK_Expecter) Groups(ctx interface{}, pm interface{}, domainID interface{}, token interface{}) *SDK_Groups_Call {
	return &SDK_Groups_Call{Call: _e.mock.On("Groups", ctx, pm, domainID, token)}
}

func (_c *SDK_Groups_Call) Run(run func(ctx context.Context, pm sdk0.PageMetadata, domainID string, token string)) *SDK_Groups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.PageMetadata
		if args[1] != nil {
			arg1 = args[1].(sdk0.PageMetadata)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_Groups_Call) Return(groupsPage sdk0.GroupsPage, sDKError errors.SDKError) *SDK_Groups_Call {
	_c.Call.Return(groupsPage, sDKError)
	return _c
}

func (_c *SDK_Groups_Call) RunAndReturn(run func(ctx context.Context, pm sdk0.PageMetadata, domainID string, token string) (sdk0.GroupsPage, errors.SDKError)) *SDK_Groups_Call {
	_c.Call.Return(run)
	return _c
}

// Health provides a mock function for the type SDK
func (_mock *SDK) Health(service string) (sdk0.HealthInfo, errors.SDKError) {
	ret := _mock.Called(service)

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

	var r0 sdk0.HealthInfo
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(string) (sdk0.HealthInfo, errors.SDKError)); ok {
		return returnFunc(service)
	}
	if returnFunc, ok := ret.Get(0).(func(string) sdk0.HealthInfo); ok {
		r0 = returnFunc(service)
	} else {
		r0 = ret.Get(0).(sdk0.HealthInfo)
	}
	if returnFunc, ok := ret.Get(1).(func(string) errors.SDKError); ok {
		r1 = returnFunc(service)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(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) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *SDK_Health_Call) Return(healthInfo sdk0.HealthInfo, sDKError errors.SDKError) *SDK_Health_Call {
	_c.Call.Return(healthInfo, sDKError)
	return _c
}

func (_c *SDK_Health_Call) RunAndReturn(run func(service string) (sdk0.HealthInfo, errors.SDKError)) *SDK_Health_Call {
	_c.Call.Return(run)
	return _c
}

// Hierarchy provides a mock function for the type SDK
func (_mock *SDK) Hierarchy(ctx context.Context, id string, domainID string, pm sdk0.PageMetadata, token string) (sdk0.GroupsHierarchyPage, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, pm, token)

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

	var r0 sdk0.GroupsHierarchyPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk0.PageMetadata, string) (sdk0.GroupsHierarchyPage, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk0.PageMetadata, string) sdk0.GroupsHierarchyPage); ok {
		r0 = returnFunc(ctx, id, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk0.GroupsHierarchyPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, sdk0.PageMetadata, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, domainID, pm, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// Hierarchy is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - domainID string
//   - pm sdk0.PageMetadata
//   - token string
func (_e *SDK_Expecter) Hierarchy(ctx interface{}, id interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_Hierarchy_Call {
	return &SDK_Hierarchy_Call{Call: _e.mock.On("Hierarchy", ctx, id, domainID, pm, token)}
}

func (_c *SDK_Hierarchy_Call) Run(run func(ctx context.Context, id string, domainID string, pm sdk0.PageMetadata, token string)) *SDK_Hierarchy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 sdk0.PageMetadata
		if args[3] != nil {
			arg3 = args[3].(sdk0.PageMetadata)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_Hierarchy_Call) Return(groupsHierarchyPage sdk0.GroupsHierarchyPage, sDKError errors.SDKError) *SDK_Hierarchy_Call {
	_c.Call.Return(groupsHierarchyPage, sDKError)
	return _c
}

func (_c *SDK_Hierarchy_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, pm sdk0.PageMetadata, token string) (sdk0.GroupsHierarchyPage, errors.SDKError)) *SDK_Hierarchy_Call {
	_c.Call.Return(run)
	return _c
}

// Invitations provides a mock function for the type SDK
func (_mock *SDK) Invitations(ctx context.Context, pm sdk0.PageMetadata, token string) (sdk0.InvitationPage, error) {
	ret := _mock.Called(ctx, pm, token)

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

	var r0 sdk0.InvitationPage
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.PageMetadata, string) (sdk0.InvitationPage, error)); ok {
		return returnFunc(ctx, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.PageMetadata, string) sdk0.InvitationPage); ok {
		r0 = returnFunc(ctx, pm, token)
	} else {
		r0 = ret.Get(0).(sdk0.InvitationPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.PageMetadata, string) error); ok {
		r1 = returnFunc(ctx, pm, token)
	} else {
		r1 = ret.Error(1)
	}
	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
//   - ctx context.Context
//   - pm sdk0.PageMetadata
//   - token string
func (_e *SDK_Expecter) Invitations(ctx interface{}, pm interface{}, token interface{}) *SDK_Invitations_Call {
	return &SDK_Invitations_Call{Call: _e.mock.On("Invitations", ctx, pm, token)}
}

func (_c *SDK_Invitations_Call) Run(run func(ctx context.Context, pm sdk0.PageMetadata, token string)) *SDK_Invitations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.PageMetadata
		if args[1] != nil {
			arg1 = args[1].(sdk0.PageMetadata)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_Invitations_Call) Return(invitations sdk0.InvitationPage, err error) *SDK_Invitations_Call {
	_c.Call.Return(invitations, err)
	return _c
}

func (_c *SDK_Invitations_Call) RunAndReturn(run func(ctx context.Context, pm sdk0.PageMetadata, token string) (sdk0.InvitationPage, error)) *SDK_Invitations_Call {
	_c.Call.Return(run)
	return _c
}

// IssueCert provides a mock function for the type SDK
func (_mock *SDK) IssueCert(ctx context.Context, clientID string, validity string, domainID string, token string) (sdk0.Cert, errors.SDKError) {
	ret := _mock.Called(ctx, clientID, validity, domainID, token)

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

	var r0 sdk0.Cert
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (sdk0.Cert, errors.SDKError)); ok {
		return returnFunc(ctx, clientID, validity, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) sdk0.Cert); ok {
		r0 = returnFunc(ctx, clientID, validity, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Cert)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, clientID, validity, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - clientID string
//   - validity string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) IssueCert(ctx interface{}, clientID interface{}, validity interface{}, domainID interface{}, token interface{}) *SDK_IssueCert_Call {
	return &SDK_IssueCert_Call{Call: _e.mock.On("IssueCert", ctx, clientID, validity, domainID, token)}
}

func (_c *SDK_IssueCert_Call) Run(run func(ctx context.Context, clientID string, validity string, domainID string, token string)) *SDK_IssueCert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_IssueCert_Call) Return(cert sdk0.Cert, sDKError errors.SDKError) *SDK_IssueCert_Call {
	_c.Call.Return(cert, sDKError)
	return _c
}

func (_c *SDK_IssueCert_Call) RunAndReturn(run func(ctx context.Context, clientID string, validity string, domainID string, token string) (sdk0.Cert, errors.SDKError)) *SDK_IssueCert_Call {
	_c.Call.Return(run)
	return _c
}

// Journal provides a mock function for the type SDK
func (_mock *SDK) Journal(ctx context.Context, entityType string, entityID string, domainID string, pm sdk0.PageMetadata, token string) (sdk0.JournalsPage, error) {
	ret := _mock.Called(ctx, entityType, entityID, domainID, pm, token)

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

	var r0 sdk0.JournalsPage
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, sdk0.PageMetadata, string) (sdk0.JournalsPage, error)); ok {
		return returnFunc(ctx, entityType, entityID, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, sdk0.PageMetadata, string) sdk0.JournalsPage); ok {
		r0 = returnFunc(ctx, entityType, entityID, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk0.JournalsPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, sdk0.PageMetadata, string) error); ok {
		r1 = returnFunc(ctx, entityType, entityID, domainID, pm, token)
	} else {
		r1 = ret.Error(1)
	}
	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
//   - ctx context.Context
//   - entityType string
//   - entityID string
//   - domainID string
//   - pm sdk0.PageMetadata
//   - token string
func (_e *SDK_Expecter) Journal(ctx interface{}, entityType interface{}, entityID interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_Journal_Call {
	return &SDK_Journal_Call{Call: _e.mock.On("Journal", ctx, entityType, entityID, domainID, pm, token)}
}

func (_c *SDK_Journal_Call) Run(run func(ctx context.Context, entityType string, entityID string, domainID string, pm sdk0.PageMetadata, token string)) *SDK_Journal_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 sdk0.PageMetadata
		if args[4] != nil {
			arg4 = args[4].(sdk0.PageMetadata)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *SDK_Journal_Call) Return(journal sdk0.JournalsPage, err error) *SDK_Journal_Call {
	_c.Call.Return(journal, err)
	return _c
}

func (_c *SDK_Journal_Call) RunAndReturn(run func(ctx context.Context, entityType string, entityID string, domainID string, pm sdk0.PageMetadata, token string) (sdk0.JournalsPage, error)) *SDK_Journal_Call {
	_c.Call.Return(run)
	return _c
}

// ListChannelMembers provides a mock function for the type SDK
func (_mock *SDK) ListChannelMembers(ctx context.Context, channelID string, domainID string, pm sdk0.PageMetadata, token string) (sdk0.EntityMembersPage, errors.SDKError) {
	ret := _mock.Called(ctx, channelID, domainID, pm, token)

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

	var r0 sdk0.EntityMembersPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk0.PageMetadata, string) (sdk0.EntityMembersPage, errors.SDKError)); ok {
		return returnFunc(ctx, channelID, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk0.PageMetadata, string) sdk0.EntityMembersPage); ok {
		r0 = returnFunc(ctx, channelID, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk0.EntityMembersPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, sdk0.PageMetadata, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, channelID, domainID, pm, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// ListChannelMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - channelID string
//   - domainID string
//   - pm sdk0.PageMetadata
//   - token string
func (_e *SDK_Expecter) ListChannelMembers(ctx interface{}, channelID interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_ListChannelMembers_Call {
	return &SDK_ListChannelMembers_Call{Call: _e.mock.On("ListChannelMembers", ctx, channelID, domainID, pm, token)}
}

func (_c *SDK_ListChannelMembers_Call) Run(run func(ctx context.Context, channelID string, domainID string, pm sdk0.PageMetadata, token string)) *SDK_ListChannelMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 sdk0.PageMetadata
		if args[3] != nil {
			arg3 = args[3].(sdk0.PageMetadata)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_ListChannelMembers_Call) Return(entityMembersPage sdk0.EntityMembersPage, sDKError errors.SDKError) *SDK_ListChannelMembers_Call {
	_c.Call.Return(entityMembersPage, sDKError)
	return _c
}

func (_c *SDK_ListChannelMembers_Call) RunAndReturn(run func(ctx context.Context, channelID string, domainID string, pm sdk0.PageMetadata, token string) (sdk0.EntityMembersPage, errors.SDKError)) *SDK_ListChannelMembers_Call {
	_c.Call.Return(run)
	return _c
}

// ListClientMembers provides a mock function for the type SDK
func (_mock *SDK) ListClientMembers(ctx context.Context, clientID string, domainID string, pm sdk0.PageMetadata, token string) (sdk0.EntityMembersPage, errors.SDKError) {
	ret := _mock.Called(ctx, clientID, domainID, pm, token)

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

	var r0 sdk0.EntityMembersPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk0.PageMetadata, string) (sdk0.EntityMembersPage, errors.SDKError)); ok {
		return returnFunc(ctx, clientID, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk0.PageMetadata, string) sdk0.EntityMembersPage); ok {
		r0 = returnFunc(ctx, clientID, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk0.EntityMembersPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, sdk0.PageMetadata, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, clientID, domainID, pm, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// ListClientMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - clientID string
//   - domainID string
//   - pm sdk0.PageMetadata
//   - token string
func (_e *SDK_Expecter) ListClientMembers(ctx interface{}, clientID interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_ListClientMembers_Call {
	return &SDK_ListClientMembers_Call{Call: _e.mock.On("ListClientMembers", ctx, clientID, domainID, pm, token)}
}

func (_c *SDK_ListClientMembers_Call) Run(run func(ctx context.Context, clientID string, domainID string, pm sdk0.PageMetadata, token string)) *SDK_ListClientMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 sdk0.PageMetadata
		if args[3] != nil {
			arg3 = args[3].(sdk0.PageMetadata)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_ListClientMembers_Call) Return(entityMembersPage sdk0.EntityMembersPage, sDKError errors.SDKError) *SDK_ListClientMembers_Call {
	_c.Call.Return(entityMembersPage, sDKError)
	return _c
}

func (_c *SDK_ListClientMembers_Call) RunAndReturn(run func(ctx context.Context, clientID string, domainID string, pm sdk0.PageMetadata, token string) (sdk0.EntityMembersPage, errors.SDKError)) *SDK_ListClientMembers_Call {
	_c.Call.Return(run)
	return _c
}

// ListDomainMembers provides a mock function for the type SDK
func (_mock *SDK) ListDomainMembers(ctx context.Context, domainID string, pm sdk0.PageMetadata, token string) (sdk0.EntityMembersPage, errors.SDKError) {
	ret := _mock.Called(ctx, domainID, pm, token)

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

	var r0 sdk0.EntityMembersPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, sdk0.PageMetadata, string) (sdk0.EntityMembersPage, errors.SDKError)); ok {
		return returnFunc(ctx, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, sdk0.PageMetadata, string) sdk0.EntityMembersPage); ok {
		r0 = returnFunc(ctx, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk0.EntityMembersPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, sdk0.PageMetadata, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, domainID, pm, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// ListDomainMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - domainID string
//   - pm sdk0.PageMetadata
//   - token string
func (_e *SDK_Expecter) ListDomainMembers(ctx interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_ListDomainMembers_Call {
	return &SDK_ListDomainMembers_Call{Call: _e.mock.On("ListDomainMembers", ctx, domainID, pm, token)}
}

func (_c *SDK_ListDomainMembers_Call) Run(run func(ctx context.Context, domainID string, pm sdk0.PageMetadata, token string)) *SDK_ListDomainMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 sdk0.PageMetadata
		if args[2] != nil {
			arg2 = args[2].(sdk0.PageMetadata)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_ListDomainMembers_Call) Return(entityMembersPage sdk0.EntityMembersPage, sDKError errors.SDKError) *SDK_ListDomainMembers_Call {
	_c.Call.Return(entityMembersPage, sDKError)
	return _c
}

func (_c *SDK_ListDomainMembers_Call) RunAndReturn(run func(ctx context.Context, domainID string, pm sdk0.PageMetadata, token string) (sdk0.EntityMembersPage, errors.SDKError)) *SDK_ListDomainMembers_Call {
	_c.Call.Return(run)
	return _c
}

// ListGroupMembers provides a mock function for the type SDK
func (_mock *SDK) ListGroupMembers(ctx context.Context, groupID string, domainID string, pm sdk0.PageMetadata, token string) (sdk0.EntityMembersPage, errors.SDKError) {
	ret := _mock.Called(ctx, groupID, domainID, pm, token)

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

	var r0 sdk0.EntityMembersPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk0.PageMetadata, string) (sdk0.EntityMembersPage, errors.SDKError)); ok {
		return returnFunc(ctx, groupID, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk0.PageMetadata, string) sdk0.EntityMembersPage); ok {
		r0 = returnFunc(ctx, groupID, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk0.EntityMembersPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, sdk0.PageMetadata, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, groupID, domainID, pm, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// ListGroupMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - groupID string
//   - domainID string
//   - pm sdk0.PageMetadata
//   - token string
func (_e *SDK_Expecter) ListGroupMembers(ctx interface{}, groupID interface{}, domainID interface{}, pm interface{}, token interface{}) *SDK_ListGroupMembers_Call {
	return &SDK_ListGroupMembers_Call{Call: _e.mock.On("ListGroupMembers", ctx, groupID, domainID, pm, token)}
}

func (_c *SDK_ListGroupMembers_Call) Run(run func(ctx context.Context, groupID string, domainID string, pm sdk0.PageMetadata, token string)) *SDK_ListGroupMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 sdk0.PageMetadata
		if args[3] != nil {
			arg3 = args[3].(sdk0.PageMetadata)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_ListGroupMembers_Call) Return(entityMembersPage sdk0.EntityMembersPage, sDKError errors.SDKError) *SDK_ListGroupMembers_Call {
	_c.Call.Return(entityMembersPage, sDKError)
	return _c
}

func (_c *SDK_ListGroupMembers_Call) RunAndReturn(run func(ctx context.Context, groupID string, domainID string, pm sdk0.PageMetadata, token string) (sdk0.EntityMembersPage, errors.SDKError)) *SDK_ListGroupMembers_Call {
	_c.Call.Return(run)
	return _c
}

// ListSubscriptions provides a mock function for the type SDK
func (_mock *SDK) ListSubscriptions(ctx context.Context, pm sdk.PageMetadata, token string) (sdk.SubscriptionPage, errors.SDKError) {
	ret := _mock.Called(ctx, pm, token)

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

	var r0 sdk.SubscriptionPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string) (sdk.SubscriptionPage, errors.SDKError)); ok {
		return returnFunc(ctx, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string) sdk.SubscriptionPage); ok {
		r0 = returnFunc(ctx, pm, token)
	} else {
		r0 = ret.Get(0).(sdk.SubscriptionPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.PageMetadata, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, pm, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - pm sdk.PageMetadata
//   - token string
func (_e *SDK_Expecter) ListSubscriptions(ctx interface{}, pm interface{}, token interface{}) *SDK_ListSubscriptions_Call {
	return &SDK_ListSubscriptions_Call{Call: _e.mock.On("ListSubscriptions", ctx, pm, token)}
}

func (_c *SDK_ListSubscriptions_Call) Run(run func(ctx context.Context, pm sdk.PageMetadata, token string)) *SDK_ListSubscriptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk.PageMetadata
		if args[1] != nil {
			arg1 = args[1].(sdk.PageMetadata)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_ListSubscriptions_Call) Return(subscriptionPage sdk.SubscriptionPage, sDKError errors.SDKError) *SDK_ListSubscriptions_Call {
	_c.Call.Return(subscriptionPage, sDKError)
	return _c
}

func (_c *SDK_ListSubscriptions_Call) RunAndReturn(run func(ctx context.Context, pm sdk.PageMetadata, token string) (sdk.SubscriptionPage, errors.SDKError)) *SDK_ListSubscriptions_Call {
	_c.Call.Return(run)
	return _c
}

// ReadMessages provides a mock function for the type SDK
func (_mock *SDK) ReadMessages(ctx context.Context, pm sdk.MessagePageMetadata, chanID string, domainID string, token string) (sdk.MessagesPage, errors.SDKError) {
	ret := _mock.Called(ctx, pm, chanID, domainID, token)

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

	var r0 sdk.MessagesPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.MessagePageMetadata, string, string, string) (sdk.MessagesPage, errors.SDKError)); ok {
		return returnFunc(ctx, pm, chanID, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.MessagePageMetadata, string, string, string) sdk.MessagesPage); ok {
		r0 = returnFunc(ctx, pm, chanID, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.MessagesPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.MessagePageMetadata, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, pm, chanID, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - pm sdk.MessagePageMetadata
//   - chanID string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) ReadMessages(ctx interface{}, pm interface{}, chanID interface{}, domainID interface{}, token interface{}) *SDK_ReadMessages_Call {
	return &SDK_ReadMessages_Call{Call: _e.mock.On("ReadMessages", ctx, pm, chanID, domainID, token)}
}

func (_c *SDK_ReadMessages_Call) Run(run func(ctx context.Context, pm sdk.MessagePageMetadata, chanID string, domainID string, token string)) *SDK_ReadMessages_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk.MessagePageMetadata
		if args[1] != nil {
			arg1 = args[1].(sdk.MessagePageMetadata)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_ReadMessages_Call) Return(messagesPage sdk.MessagesPage, sDKError errors.SDKError) *SDK_ReadMessages_Call {
	_c.Call.Return(messagesPage, sDKError)
	return _c
}

func (_c *SDK_ReadMessages_Call) RunAndReturn(run func(ctx context.Context, pm sdk.MessagePageMetadata, chanID string, domainID string, token string) (sdk.MessagesPage, errors.SDKError)) *SDK_ReadMessages_Call {
	_c.Call.Return(run)
	return _c
}

// RefreshToken provides a mock function for the type SDK
func (_mock *SDK) RefreshToken(ctx context.Context, token string) (sdk0.Token, errors.SDKError) {
	ret := _mock.Called(ctx, token)

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

	var r0 sdk0.Token
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (sdk0.Token, errors.SDKError)); ok {
		return returnFunc(ctx, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) sdk0.Token); ok {
		r0 = returnFunc(ctx, token)
	} else {
		r0 = ret.Get(0).(sdk0.Token)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(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
//   - ctx context.Context
//   - token string
func (_e *SDK_Expecter) RefreshToken(ctx interface{}, token interface{}) *SDK_RefreshToken_Call {
	return &SDK_RefreshToken_Call{Call: _e.mock.On("RefreshToken", ctx, token)}
}

func (_c *SDK_RefreshToken_Call) Run(run func(ctx context.Context, token string)) *SDK_RefreshToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *SDK_RefreshToken_Call) Return(token1 sdk0.Token, sDKError errors.SDKError) *SDK_RefreshToken_Call {
	_c.Call.Return(token1, sDKError)
	return _c
}

func (_c *SDK_RefreshToken_Call) RunAndReturn(run func(ctx context.Context, token string) (sdk0.Token, errors.SDKError)) *SDK_RefreshToken_Call {
	_c.Call.Return(run)
	return _c
}

// RejectInvitation provides a mock function for the type SDK
func (_mock *SDK) RejectInvitation(ctx context.Context, domainID string, token string) error {
	ret := _mock.Called(ctx, domainID, token)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, domainID, token)
	} else {
		r0 = ret.Error(0)
	}
	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
//   - ctx context.Context
//   - domainID string
//   - token string
func (_e *SDK_Expecter) RejectInvitation(ctx interface{}, domainID interface{}, token interface{}) *SDK_RejectInvitation_Call {
	return &SDK_RejectInvitation_Call{Call: _e.mock.On("RejectInvitation", ctx, domainID, token)}
}

func (_c *SDK_RejectInvitation_Call) Run(run func(ctx context.Context, domainID string, token string)) *SDK_RejectInvitation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	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(ctx context.Context, domainID string, token string) error) *SDK_RejectInvitation_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveAllChildren provides a mock function for the type SDK
func (_mock *SDK) RemoveAllChildren(ctx context.Context, id string, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// RemoveAllChildren is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) RemoveAllChildren(ctx interface{}, id interface{}, domainID interface{}, token interface{}) *SDK_RemoveAllChildren_Call {
	return &SDK_RemoveAllChildren_Call{Call: _e.mock.On("RemoveAllChildren", ctx, id, domainID, token)}
}

func (_c *SDK_RemoveAllChildren_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_RemoveAllChildren_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_RemoveAllChildren_Call) Return(sDKError errors.SDKError) *SDK_RemoveAllChildren_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RemoveAllChildren_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) errors.SDKError) *SDK_RemoveAllChildren_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveAllClientRoleActions provides a mock function for the type SDK
func (_mock *SDK) RemoveAllClientRoleActions(ctx context.Context, id string, roleID string, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, roleID, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// RemoveAllClientRoleActions is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) RemoveAllClientRoleActions(ctx interface{}, id interface{}, roleID interface{}, domainID interface{}, token interface{}) *SDK_RemoveAllClientRoleActions_Call {
	return &SDK_RemoveAllClientRoleActions_Call{Call: _e.mock.On("RemoveAllClientRoleActions", ctx, id, roleID, domainID, token)}
}

func (_c *SDK_RemoveAllClientRoleActions_Call) Run(run func(ctx context.Context, id string, roleID string, domainID string, token string)) *SDK_RemoveAllClientRoleActions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_RemoveAllClientRoleActions_Call) Return(sDKError errors.SDKError) *SDK_RemoveAllClientRoleActions_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RemoveAllClientRoleActions_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, domainID string, token string) errors.SDKError) *SDK_RemoveAllClientRoleActions_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveAllClientRoleMembers provides a mock function for the type SDK
func (_mock *SDK) RemoveAllClientRoleMembers(ctx context.Context, id string, roleID string, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, roleID, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// RemoveAllClientRoleMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) RemoveAllClientRoleMembers(ctx interface{}, id interface{}, roleID interface{}, domainID interface{}, token interface{}) *SDK_RemoveAllClientRoleMembers_Call {
	return &SDK_RemoveAllClientRoleMembers_Call{Call: _e.mock.On("RemoveAllClientRoleMembers", ctx, id, roleID, domainID, token)}
}

func (_c *SDK_RemoveAllClientRoleMembers_Call) Run(run func(ctx context.Context, id string, roleID string, domainID string, token string)) *SDK_RemoveAllClientRoleMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_RemoveAllClientRoleMembers_Call) Return(sDKError errors.SDKError) *SDK_RemoveAllClientRoleMembers_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RemoveAllClientRoleMembers_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, domainID string, token string) errors.SDKError) *SDK_RemoveAllClientRoleMembers_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveAllDomainRoleActions provides a mock function for the type SDK
func (_mock *SDK) RemoveAllDomainRoleActions(ctx context.Context, id string, roleID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, roleID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, roleID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// RemoveAllDomainRoleActions is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - token string
func (_e *SDK_Expecter) RemoveAllDomainRoleActions(ctx interface{}, id interface{}, roleID interface{}, token interface{}) *SDK_RemoveAllDomainRoleActions_Call {
	return &SDK_RemoveAllDomainRoleActions_Call{Call: _e.mock.On("RemoveAllDomainRoleActions", ctx, id, roleID, token)}
}

func (_c *SDK_RemoveAllDomainRoleActions_Call) Run(run func(ctx context.Context, id string, roleID string, token string)) *SDK_RemoveAllDomainRoleActions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_RemoveAllDomainRoleActions_Call) Return(sDKError errors.SDKError) *SDK_RemoveAllDomainRoleActions_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RemoveAllDomainRoleActions_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, token string) errors.SDKError) *SDK_RemoveAllDomainRoleActions_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveAllDomainRoleMembers provides a mock function for the type SDK
func (_mock *SDK) RemoveAllDomainRoleMembers(ctx context.Context, id string, roleID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, roleID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, roleID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// RemoveAllDomainRoleMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - token string
func (_e *SDK_Expecter) RemoveAllDomainRoleMembers(ctx interface{}, id interface{}, roleID interface{}, token interface{}) *SDK_RemoveAllDomainRoleMembers_Call {
	return &SDK_RemoveAllDomainRoleMembers_Call{Call: _e.mock.On("RemoveAllDomainRoleMembers", ctx, id, roleID, token)}
}

func (_c *SDK_RemoveAllDomainRoleMembers_Call) Run(run func(ctx context.Context, id string, roleID string, token string)) *SDK_RemoveAllDomainRoleMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_RemoveAllDomainRoleMembers_Call) Return(sDKError errors.SDKError) *SDK_RemoveAllDomainRoleMembers_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RemoveAllDomainRoleMembers_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, token string) errors.SDKError) *SDK_RemoveAllDomainRoleMembers_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveAllGroupRoleActions provides a mock function for the type SDK
func (_mock *SDK) RemoveAllGroupRoleActions(ctx context.Context, id string, roleID string, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, roleID, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// RemoveAllGroupRoleActions is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) RemoveAllGroupRoleActions(ctx interface{}, id interface{}, roleID interface{}, domainID interface{}, token interface{}) *SDK_RemoveAllGroupRoleActions_Call {
	return &SDK_RemoveAllGroupRoleActions_Call{Call: _e.mock.On("RemoveAllGroupRoleActions", ctx, id, roleID, domainID, token)}
}

func (_c *SDK_RemoveAllGroupRoleActions_Call) Run(run func(ctx context.Context, id string, roleID string, domainID string, token string)) *SDK_RemoveAllGroupRoleActions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_RemoveAllGroupRoleActions_Call) Return(sDKError errors.SDKError) *SDK_RemoveAllGroupRoleActions_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RemoveAllGroupRoleActions_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, domainID string, token string) errors.SDKError) *SDK_RemoveAllGroupRoleActions_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveAllGroupRoleMembers provides a mock function for the type SDK
func (_mock *SDK) RemoveAllGroupRoleMembers(ctx context.Context, id string, roleID string, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, roleID, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// RemoveAllGroupRoleMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) RemoveAllGroupRoleMembers(ctx interface{}, id interface{}, roleID interface{}, domainID interface{}, token interface{}) *SDK_RemoveAllGroupRoleMembers_Call {
	return &SDK_RemoveAllGroupRoleMembers_Call{Call: _e.mock.On("RemoveAllGroupRoleMembers", ctx, id, roleID, domainID, token)}
}

func (_c *SDK_RemoveAllGroupRoleMembers_Call) Run(run func(ctx context.Context, id string, roleID string, domainID string, token string)) *SDK_RemoveAllGroupRoleMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_RemoveAllGroupRoleMembers_Call) Return(sDKError errors.SDKError) *SDK_RemoveAllGroupRoleMembers_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RemoveAllGroupRoleMembers_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, domainID string, token string) errors.SDKError) *SDK_RemoveAllGroupRoleMembers_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveBootstrap provides a mock function for the type SDK
func (_mock *SDK) RemoveBootstrap(ctx context.Context, id string, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - id string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) RemoveBootstrap(ctx interface{}, id interface{}, domainID interface{}, token interface{}) *SDK_RemoveBootstrap_Call {
	return &SDK_RemoveBootstrap_Call{Call: _e.mock.On("RemoveBootstrap", ctx, id, domainID, token)}
}

func (_c *SDK_RemoveBootstrap_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_RemoveBootstrap_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_RemoveBootstrap_Call) Return(sDKError errors.SDKError) *SDK_RemoveBootstrap_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RemoveBootstrap_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) errors.SDKError) *SDK_RemoveBootstrap_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveChannelParent provides a mock function for the type SDK
func (_mock *SDK) RemoveChannelParent(ctx context.Context, id string, domainID string, groupID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, domainID, groupID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, domainID, groupID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// RemoveChannelParent is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - domainID string
//   - groupID string
//   - token string
func (_e *SDK_Expecter) RemoveChannelParent(ctx interface{}, id interface{}, domainID interface{}, groupID interface{}, token interface{}) *SDK_RemoveChannelParent_Call {
	return &SDK_RemoveChannelParent_Call{Call: _e.mock.On("RemoveChannelParent", ctx, id, domainID, groupID, token)}
}

func (_c *SDK_RemoveChannelParent_Call) Run(run func(ctx context.Context, id string, domainID string, groupID string, token string)) *SDK_RemoveChannelParent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_RemoveChannelParent_Call) Return(sDKError errors.SDKError) *SDK_RemoveChannelParent_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RemoveChannelParent_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, groupID string, token string) errors.SDKError) *SDK_RemoveChannelParent_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveChildren provides a mock function for the type SDK
func (_mock *SDK) RemoveChildren(ctx context.Context, id string, domainID string, groupIDs []string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, domainID, groupIDs, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, domainID, groupIDs, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// RemoveChildren is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - domainID string
//   - groupIDs []string
//   - token string
func (_e *SDK_Expecter) RemoveChildren(ctx interface{}, id interface{}, domainID interface{}, groupIDs interface{}, token interface{}) *SDK_RemoveChildren_Call {
	return &SDK_RemoveChildren_Call{Call: _e.mock.On("RemoveChildren", ctx, id, domainID, groupIDs, token)}
}

func (_c *SDK_RemoveChildren_Call) Run(run func(ctx context.Context, id string, domainID string, groupIDs []string, token string)) *SDK_RemoveChildren_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 []string
		if args[3] != nil {
			arg3 = args[3].([]string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_RemoveChildren_Call) Return(sDKError errors.SDKError) *SDK_RemoveChildren_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RemoveChildren_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, groupIDs []string, token string) errors.SDKError) *SDK_RemoveChildren_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveClientParent provides a mock function for the type SDK
func (_mock *SDK) RemoveClientParent(ctx context.Context, id string, domainID string, groupID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, domainID, groupID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, domainID, groupID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// RemoveClientParent is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - domainID string
//   - groupID string
//   - token string
func (_e *SDK_Expecter) RemoveClientParent(ctx interface{}, id interface{}, domainID interface{}, groupID interface{}, token interface{}) *SDK_RemoveClientParent_Call {
	return &SDK_RemoveClientParent_Call{Call: _e.mock.On("RemoveClientParent", ctx, id, domainID, groupID, token)}
}

func (_c *SDK_RemoveClientParent_Call) Run(run func(ctx context.Context, id string, domainID string, groupID string, token string)) *SDK_RemoveClientParent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_RemoveClientParent_Call) Return(sDKError errors.SDKError) *SDK_RemoveClientParent_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RemoveClientParent_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, groupID string, token string) errors.SDKError) *SDK_RemoveClientParent_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveClientRoleActions provides a mock function for the type SDK
func (_mock *SDK) RemoveClientRoleActions(ctx context.Context, id string, roleID string, domainID string, actions []string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, roleID, domainID, actions, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, []string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, actions, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// RemoveClientRoleActions is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - domainID string
//   - actions []string
//   - token string
func (_e *SDK_Expecter) RemoveClientRoleActions(ctx interface{}, id interface{}, roleID interface{}, domainID interface{}, actions interface{}, token interface{}) *SDK_RemoveClientRoleActions_Call {
	return &SDK_RemoveClientRoleActions_Call{Call: _e.mock.On("RemoveClientRoleActions", ctx, id, roleID, domainID, actions, token)}
}

func (_c *SDK_RemoveClientRoleActions_Call) Run(run func(ctx context.Context, id string, roleID string, domainID string, actions []string, token string)) *SDK_RemoveClientRoleActions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 []string
		if args[4] != nil {
			arg4 = args[4].([]string)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *SDK_RemoveClientRoleActions_Call) Return(sDKError errors.SDKError) *SDK_RemoveClientRoleActions_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RemoveClientRoleActions_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, domainID string, actions []string, token string) errors.SDKError) *SDK_RemoveClientRoleActions_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveClientRoleMembers provides a mock function for the type SDK
func (_mock *SDK) RemoveClientRoleMembers(ctx context.Context, id string, roleID string, domainID string, members []string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, roleID, domainID, members, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, []string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, members, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// RemoveClientRoleMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - domainID string
//   - members []string
//   - token string
func (_e *SDK_Expecter) RemoveClientRoleMembers(ctx interface{}, id interface{}, roleID interface{}, domainID interface{}, members interface{}, token interface{}) *SDK_RemoveClientRoleMembers_Call {
	return &SDK_RemoveClientRoleMembers_Call{Call: _e.mock.On("RemoveClientRoleMembers", ctx, id, roleID, domainID, members, token)}
}

func (_c *SDK_RemoveClientRoleMembers_Call) Run(run func(ctx context.Context, id string, roleID string, domainID string, members []string, token string)) *SDK_RemoveClientRoleMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 []string
		if args[4] != nil {
			arg4 = args[4].([]string)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *SDK_RemoveClientRoleMembers_Call) Return(sDKError errors.SDKError) *SDK_RemoveClientRoleMembers_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RemoveClientRoleMembers_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, domainID string, members []string, token string) errors.SDKError) *SDK_RemoveClientRoleMembers_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveDomainRoleActions provides a mock function for the type SDK
func (_mock *SDK) RemoveDomainRoleActions(ctx context.Context, id string, roleID string, actions []string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, roleID, actions, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, roleID, actions, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// RemoveDomainRoleActions is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - actions []string
//   - token string
func (_e *SDK_Expecter) RemoveDomainRoleActions(ctx interface{}, id interface{}, roleID interface{}, actions interface{}, token interface{}) *SDK_RemoveDomainRoleActions_Call {
	return &SDK_RemoveDomainRoleActions_Call{Call: _e.mock.On("RemoveDomainRoleActions", ctx, id, roleID, actions, token)}
}

func (_c *SDK_RemoveDomainRoleActions_Call) Run(run func(ctx context.Context, id string, roleID string, actions []string, token string)) *SDK_RemoveDomainRoleActions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 []string
		if args[3] != nil {
			arg3 = args[3].([]string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_RemoveDomainRoleActions_Call) Return(sDKError errors.SDKError) *SDK_RemoveDomainRoleActions_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RemoveDomainRoleActions_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, actions []string, token string) errors.SDKError) *SDK_RemoveDomainRoleActions_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveDomainRoleMembers provides a mock function for the type SDK
func (_mock *SDK) RemoveDomainRoleMembers(ctx context.Context, id string, roleID string, members []string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, roleID, members, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, roleID, members, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// RemoveDomainRoleMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - members []string
//   - token string
func (_e *SDK_Expecter) RemoveDomainRoleMembers(ctx interface{}, id interface{}, roleID interface{}, members interface{}, token interface{}) *SDK_RemoveDomainRoleMembers_Call {
	return &SDK_RemoveDomainRoleMembers_Call{Call: _e.mock.On("RemoveDomainRoleMembers", ctx, id, roleID, members, token)}
}

func (_c *SDK_RemoveDomainRoleMembers_Call) Run(run func(ctx context.Context, id string, roleID string, members []string, token string)) *SDK_RemoveDomainRoleMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 []string
		if args[3] != nil {
			arg3 = args[3].([]string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_RemoveDomainRoleMembers_Call) Return(sDKError errors.SDKError) *SDK_RemoveDomainRoleMembers_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RemoveDomainRoleMembers_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, members []string, token string) errors.SDKError) *SDK_RemoveDomainRoleMembers_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveGroupParent provides a mock function for the type SDK
func (_mock *SDK) RemoveGroupParent(ctx context.Context, id string, domainID string, groupID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, domainID, groupID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, domainID, groupID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// RemoveGroupParent is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - domainID string
//   - groupID string
//   - token string
func (_e *SDK_Expecter) RemoveGroupParent(ctx interface{}, id interface{}, domainID interface{}, groupID interface{}, token interface{}) *SDK_RemoveGroupParent_Call {
	return &SDK_RemoveGroupParent_Call{Call: _e.mock.On("RemoveGroupParent", ctx, id, domainID, groupID, token)}
}

func (_c *SDK_RemoveGroupParent_Call) Run(run func(ctx context.Context, id string, domainID string, groupID string, token string)) *SDK_RemoveGroupParent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_RemoveGroupParent_Call) Return(sDKError errors.SDKError) *SDK_RemoveGroupParent_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RemoveGroupParent_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, groupID string, token string) errors.SDKError) *SDK_RemoveGroupParent_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveGroupRoleActions provides a mock function for the type SDK
func (_mock *SDK) RemoveGroupRoleActions(ctx context.Context, id string, roleID string, domainID string, actions []string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, roleID, domainID, actions, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, []string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, actions, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// RemoveGroupRoleActions is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - domainID string
//   - actions []string
//   - token string
func (_e *SDK_Expecter) RemoveGroupRoleActions(ctx interface{}, id interface{}, roleID interface{}, domainID interface{}, actions interface{}, token interface{}) *SDK_RemoveGroupRoleActions_Call {
	return &SDK_RemoveGroupRoleActions_Call{Call: _e.mock.On("RemoveGroupRoleActions", ctx, id, roleID, domainID, actions, token)}
}

func (_c *SDK_RemoveGroupRoleActions_Call) Run(run func(ctx context.Context, id string, roleID string, domainID string, actions []string, token string)) *SDK_RemoveGroupRoleActions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 []string
		if args[4] != nil {
			arg4 = args[4].([]string)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *SDK_RemoveGroupRoleActions_Call) Return(sDKError errors.SDKError) *SDK_RemoveGroupRoleActions_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RemoveGroupRoleActions_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, domainID string, actions []string, token string) errors.SDKError) *SDK_RemoveGroupRoleActions_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveGroupRoleMembers provides a mock function for the type SDK
func (_mock *SDK) RemoveGroupRoleMembers(ctx context.Context, id string, roleID string, domainID string, members []string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, roleID, domainID, members, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, []string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, members, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// RemoveGroupRoleMembers is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - domainID string
//   - members []string
//   - token string
func (_e *SDK_Expecter) RemoveGroupRoleMembers(ctx interface{}, id interface{}, roleID interface{}, domainID interface{}, members interface{}, token interface{}) *SDK_RemoveGroupRoleMembers_Call {
	return &SDK_RemoveGroupRoleMembers_Call{Call: _e.mock.On("RemoveGroupRoleMembers", ctx, id, roleID, domainID, members, token)}
}

func (_c *SDK_RemoveGroupRoleMembers_Call) Run(run func(ctx context.Context, id string, roleID string, domainID string, members []string, token string)) *SDK_RemoveGroupRoleMembers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 []string
		if args[4] != nil {
			arg4 = args[4].([]string)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *SDK_RemoveGroupRoleMembers_Call) Return(sDKError errors.SDKError) *SDK_RemoveGroupRoleMembers_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RemoveGroupRoleMembers_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, domainID string, members []string, token string) errors.SDKError) *SDK_RemoveGroupRoleMembers_Call {
	_c.Call.Return(run)
	return _c
}

// ResetPassword provides a mock function for the type SDK
func (_mock *SDK) ResetPassword(ctx context.Context, password string, confPass string, token string) errors.SDKError {
	ret := _mock.Called(ctx, password, confPass, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, password, confPass, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - password string
//   - confPass string
//   - token string
func (_e *SDK_Expecter) ResetPassword(ctx interface{}, password interface{}, confPass interface{}, token interface{}) *SDK_ResetPassword_Call {
	return &SDK_ResetPassword_Call{Call: _e.mock.On("ResetPassword", ctx, password, confPass, token)}
}

func (_c *SDK_ResetPassword_Call) Run(run func(ctx context.Context, password string, confPass string, token string)) *SDK_ResetPassword_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_ResetPassword_Call) Return(sDKError errors.SDKError) *SDK_ResetPassword_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_ResetPassword_Call) RunAndReturn(run func(ctx context.Context, password string, confPass string, token string) errors.SDKError) *SDK_ResetPassword_Call {
	_c.Call.Return(run)
	return _c
}

// ResetPasswordRequest provides a mock function for the type SDK
func (_mock *SDK) ResetPasswordRequest(ctx context.Context, email string) errors.SDKError {
	ret := _mock.Called(ctx, email)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, email)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(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
//   - ctx context.Context
//   - email string
func (_e *SDK_Expecter) ResetPasswordRequest(ctx interface{}, email interface{}) *SDK_ResetPasswordRequest_Call {
	return &SDK_ResetPasswordRequest_Call{Call: _e.mock.On("ResetPasswordRequest", ctx, email)}
}

func (_c *SDK_ResetPasswordRequest_Call) Run(run func(ctx context.Context, email string)) *SDK_ResetPasswordRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *SDK_ResetPasswordRequest_Call) Return(sDKError errors.SDKError) *SDK_ResetPasswordRequest_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_ResetPasswordRequest_Call) RunAndReturn(run func(ctx context.Context, email string) errors.SDKError) *SDK_ResetPasswordRequest_Call {
	_c.Call.Return(run)
	return _c
}

// RevokeAllCerts provides a mock function for the type SDK
func (_mock *SDK) RevokeAllCerts(ctx context.Context, clientID string, domainID string, token string) (time.Time, errors.SDKError) {
	ret := _mock.Called(ctx, clientID, domainID, token)

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

	var r0 time.Time
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (time.Time, errors.SDKError)); ok {
		return returnFunc(ctx, clientID, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) time.Time); ok {
		r0 = returnFunc(ctx, clientID, domainID, token)
	} else {
		r0 = ret.Get(0).(time.Time)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, clientID, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// RevokeAllCerts is a helper method to define mock.On call
//   - ctx context.Context
//   - clientID string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) RevokeAllCerts(ctx interface{}, clientID interface{}, domainID interface{}, token interface{}) *SDK_RevokeAllCerts_Call {
	return &SDK_RevokeAllCerts_Call{Call: _e.mock.On("RevokeAllCerts", ctx, clientID, domainID, token)}
}

func (_c *SDK_RevokeAllCerts_Call) Run(run func(ctx context.Context, clientID string, domainID string, token string)) *SDK_RevokeAllCerts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_RevokeAllCerts_Call) Return(time1 time.Time, sDKError errors.SDKError) *SDK_RevokeAllCerts_Call {
	_c.Call.Return(time1, sDKError)
	return _c
}

func (_c *SDK_RevokeAllCerts_Call) RunAndReturn(run func(ctx context.Context, clientID string, domainID string, token string) (time.Time, errors.SDKError)) *SDK_RevokeAllCerts_Call {
	_c.Call.Return(run)
	return _c
}

// RevokeCert provides a mock function for the type SDK
func (_mock *SDK) RevokeCert(ctx context.Context, certID string, domainID string, token string) (time.Time, errors.SDKError) {
	ret := _mock.Called(ctx, certID, domainID, token)

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

	var r0 time.Time
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (time.Time, errors.SDKError)); ok {
		return returnFunc(ctx, certID, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) time.Time); ok {
		r0 = returnFunc(ctx, certID, domainID, token)
	} else {
		r0 = ret.Get(0).(time.Time)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, certID, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - certID string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) RevokeCert(ctx interface{}, certID interface{}, domainID interface{}, token interface{}) *SDK_RevokeCert_Call {
	return &SDK_RevokeCert_Call{Call: _e.mock.On("RevokeCert", ctx, certID, domainID, token)}
}

func (_c *SDK_RevokeCert_Call) Run(run func(ctx context.Context, certID string, domainID string, token string)) *SDK_RevokeCert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_RevokeCert_Call) Return(time1 time.Time, sDKError errors.SDKError) *SDK_RevokeCert_Call {
	_c.Call.Return(time1, sDKError)
	return _c
}

func (_c *SDK_RevokeCert_Call) RunAndReturn(run func(ctx context.Context, certID string, domainID string, token string) (time.Time, errors.SDKError)) *SDK_RevokeCert_Call {
	_c.Call.Return(run)
	return _c
}

// SearchUsers provides a mock function for the type SDK
func (_mock *SDK) SearchUsers(ctx context.Context, pm sdk0.PageMetadata, token string) (sdk0.UsersPage, errors.SDKError) {
	ret := _mock.Called(ctx, pm, token)

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

	var r0 sdk0.UsersPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.PageMetadata, string) (sdk0.UsersPage, errors.SDKError)); ok {
		return returnFunc(ctx, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.PageMetadata, string) sdk0.UsersPage); ok {
		r0 = returnFunc(ctx, pm, token)
	} else {
		r0 = ret.Get(0).(sdk0.UsersPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.PageMetadata, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, pm, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - pm sdk0.PageMetadata
//   - token string
func (_e *SDK_Expecter) SearchUsers(ctx interface{}, pm interface{}, token interface{}) *SDK_SearchUsers_Call {
	return &SDK_SearchUsers_Call{Call: _e.mock.On("SearchUsers", ctx, pm, token)}
}

func (_c *SDK_SearchUsers_Call) Run(run func(ctx context.Context, pm sdk0.PageMetadata, token string)) *SDK_SearchUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.PageMetadata
		if args[1] != nil {
			arg1 = args[1].(sdk0.PageMetadata)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_SearchUsers_Call) Return(usersPage sdk0.UsersPage, sDKError errors.SDKError) *SDK_SearchUsers_Call {
	_c.Call.Return(usersPage, sDKError)
	return _c
}

func (_c *SDK_SearchUsers_Call) RunAndReturn(run func(ctx context.Context, pm sdk0.PageMetadata, token string) (sdk0.UsersPage, errors.SDKError)) *SDK_SearchUsers_Call {
	_c.Call.Return(run)
	return _c
}

// SendInvitation provides a mock function for the type SDK
func (_mock *SDK) SendInvitation(ctx context.Context, invitation sdk0.Invitation, token string) error {
	ret := _mock.Called(ctx, invitation, token)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Invitation, string) error); ok {
		r0 = returnFunc(ctx, invitation, token)
	} else {
		r0 = ret.Error(0)
	}
	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
//   - ctx context.Context
//   - invitation sdk0.Invitation
//   - token string
func (_e *SDK_Expecter) SendInvitation(ctx interface{}, invitation interface{}, token interface{}) *SDK_SendInvitation_Call {
	return &SDK_SendInvitation_Call{Call: _e.mock.On("SendInvitation", ctx, invitation, token)}
}

func (_c *SDK_SendInvitation_Call) Run(run func(ctx context.Context, invitation sdk0.Invitation, token string)) *SDK_SendInvitation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.Invitation
		if args[1] != nil {
			arg1 = args[1].(sdk0.Invitation)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	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(ctx context.Context, invitation sdk0.Invitation, token string) error) *SDK_SendInvitation_Call {
	_c.Call.Return(run)
	return _c
}

// SendMessage provides a mock function for the type SDK
func (_mock *SDK) SendMessage(ctx context.Context, domainID string, topic string, msg string, secret string) errors.SDKError {
	ret := _mock.Called(ctx, domainID, topic, msg, secret)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, domainID, topic, msg, secret)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - domainID string
//   - topic string
//   - msg string
//   - secret string
func (_e *SDK_Expecter) SendMessage(ctx interface{}, domainID interface{}, topic interface{}, msg interface{}, secret interface{}) *SDK_SendMessage_Call {
	return &SDK_SendMessage_Call{Call: _e.mock.On("SendMessage", ctx, domainID, topic, msg, secret)}
}

func (_c *SDK_SendMessage_Call) Run(run func(ctx context.Context, domainID string, topic string, msg string, secret string)) *SDK_SendMessage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_SendMessage_Call) Return(sDKError errors.SDKError) *SDK_SendMessage_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_SendMessage_Call) RunAndReturn(run func(ctx context.Context, domainID string, topic string, msg string, secret string) errors.SDKError) *SDK_SendMessage_Call {
	_c.Call.Return(run)
	return _c
}

// SendVerification provides a mock function for the type SDK
func (_mock *SDK) SendVerification(ctx context.Context, token string) errors.SDKError {
	ret := _mock.Called(ctx, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// SendVerification is a helper method to define mock.On call
//   - ctx context.Context
//   - token string
func (_e *SDK_Expecter) SendVerification(ctx interface{}, token interface{}) *SDK_SendVerification_Call {
	return &SDK_SendVerification_Call{Call: _e.mock.On("SendVerification", ctx, token)}
}

func (_c *SDK_SendVerification_Call) Run(run func(ctx context.Context, token string)) *SDK_SendVerification_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *SDK_SendVerification_Call) Return(sDKError errors.SDKError) *SDK_SendVerification_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_SendVerification_Call) RunAndReturn(run func(ctx context.Context, token string) errors.SDKError) *SDK_SendVerification_Call {
	_c.Call.Return(run)
	return _c
}

// SetChannelParent provides a mock function for the type SDK
func (_mock *SDK) SetChannelParent(ctx context.Context, id string, domainID string, groupID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, domainID, groupID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, domainID, groupID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// SetChannelParent is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - domainID string
//   - groupID string
//   - token string
func (_e *SDK_Expecter) SetChannelParent(ctx interface{}, id interface{}, domainID interface{}, groupID interface{}, token interface{}) *SDK_SetChannelParent_Call {
	return &SDK_SetChannelParent_Call{Call: _e.mock.On("SetChannelParent", ctx, id, domainID, groupID, token)}
}

func (_c *SDK_SetChannelParent_Call) Run(run func(ctx context.Context, id string, domainID string, groupID string, token string)) *SDK_SetChannelParent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_SetChannelParent_Call) Return(sDKError errors.SDKError) *SDK_SetChannelParent_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_SetChannelParent_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, groupID string, token string) errors.SDKError) *SDK_SetChannelParent_Call {
	_c.Call.Return(run)
	return _c
}

// SetClientParent provides a mock function for the type SDK
func (_mock *SDK) SetClientParent(ctx context.Context, id string, domainID string, groupID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, domainID, groupID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, domainID, groupID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// SetClientParent is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - domainID string
//   - groupID string
//   - token string
func (_e *SDK_Expecter) SetClientParent(ctx interface{}, id interface{}, domainID interface{}, groupID interface{}, token interface{}) *SDK_SetClientParent_Call {
	return &SDK_SetClientParent_Call{Call: _e.mock.On("SetClientParent", ctx, id, domainID, groupID, token)}
}

func (_c *SDK_SetClientParent_Call) Run(run func(ctx context.Context, id string, domainID string, groupID string, token string)) *SDK_SetClientParent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_SetClientParent_Call) Return(sDKError errors.SDKError) *SDK_SetClientParent_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_SetClientParent_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, groupID string, token string) errors.SDKError) *SDK_SetClientParent_Call {
	_c.Call.Return(run)
	return _c
}

// SetContentType provides a mock function for the type SDK
func (_mock *SDK) SetContentType(ct sdk0.ContentType) errors.SDKError {
	ret := _mock.Called(ct)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(sdk0.ContentType) errors.SDKError); ok {
		r0 = returnFunc(ct)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(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 sdk0.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 sdk0.ContentType)) *SDK_SetContentType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 sdk0.ContentType
		if args[0] != nil {
			arg0 = args[0].(sdk0.ContentType)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *SDK_SetContentType_Call) Return(sDKError errors.SDKError) *SDK_SetContentType_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_SetContentType_Call) RunAndReturn(run func(ct sdk0.ContentType) errors.SDKError) *SDK_SetContentType_Call {
	_c.Call.Return(run)
	return _c
}

// SetGroupParent provides a mock function for the type SDK
func (_mock *SDK) SetGroupParent(ctx context.Context, id string, domainID string, groupID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, domainID, groupID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, domainID, groupID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// SetGroupParent is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - domainID string
//   - groupID string
//   - token string
func (_e *SDK_Expecter) SetGroupParent(ctx interface{}, id interface{}, domainID interface{}, groupID interface{}, token interface{}) *SDK_SetGroupParent_Call {
	return &SDK_SetGroupParent_Call{Call: _e.mock.On("SetGroupParent", ctx, id, domainID, groupID, token)}
}

func (_c *SDK_SetGroupParent_Call) Run(run func(ctx context.Context, id string, domainID string, groupID string, token string)) *SDK_SetGroupParent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_SetGroupParent_Call) Return(sDKError errors.SDKError) *SDK_SetGroupParent_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_SetGroupParent_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, groupID string, token string) errors.SDKError) *SDK_SetGroupParent_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateBootstrap provides a mock function for the type SDK
func (_mock *SDK) UpdateBootstrap(ctx context.Context, cfg sdk.BootstrapConfig, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, cfg, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.BootstrapConfig, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, cfg, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - cfg sdk.BootstrapConfig
//   - domainID string
//   - token string
func (_e *SDK_Expecter) UpdateBootstrap(ctx interface{}, cfg interface{}, domainID interface{}, token interface{}) *SDK_UpdateBootstrap_Call {
	return &SDK_UpdateBootstrap_Call{Call: _e.mock.On("UpdateBootstrap", ctx, cfg, domainID, token)}
}

func (_c *SDK_UpdateBootstrap_Call) Run(run func(ctx context.Context, cfg sdk.BootstrapConfig, domainID string, token string)) *SDK_UpdateBootstrap_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk.BootstrapConfig
		if args[1] != nil {
			arg1 = args[1].(sdk.BootstrapConfig)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_UpdateBootstrap_Call) Return(sDKError errors.SDKError) *SDK_UpdateBootstrap_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_UpdateBootstrap_Call) RunAndReturn(run func(ctx context.Context, cfg sdk.BootstrapConfig, domainID string, token string) errors.SDKError) *SDK_UpdateBootstrap_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateBootstrapCerts provides a mock function for the type SDK
func (_mock *SDK) UpdateBootstrapCerts(ctx context.Context, id string, clientCert string, clientKey string, ca string, domainID string, token string) (sdk.BootstrapConfig, errors.SDKError) {
	ret := _mock.Called(ctx, 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 returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string, string, string) (sdk.BootstrapConfig, errors.SDKError)); ok {
		return returnFunc(ctx, id, clientCert, clientKey, ca, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string, string, string) sdk.BootstrapConfig); ok {
		r0 = returnFunc(ctx, id, clientCert, clientKey, ca, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.BootstrapConfig)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, clientCert, clientKey, ca, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - id string
//   - clientCert string
//   - clientKey string
//   - ca string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) UpdateBootstrapCerts(ctx interface{}, id interface{}, clientCert interface{}, clientKey interface{}, ca interface{}, domainID interface{}, token interface{}) *SDK_UpdateBootstrapCerts_Call {
	return &SDK_UpdateBootstrapCerts_Call{Call: _e.mock.On("UpdateBootstrapCerts", ctx, id, clientCert, clientKey, ca, domainID, token)}
}

func (_c *SDK_UpdateBootstrapCerts_Call) Run(run func(ctx context.Context, id string, clientCert string, clientKey string, ca string, domainID string, token string)) *SDK_UpdateBootstrapCerts_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		var arg6 string
		if args[6] != nil {
			arg6 = args[6].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
			arg6,
		)
	})
	return _c
}

func (_c *SDK_UpdateBootstrapCerts_Call) Return(bootstrapConfig sdk.BootstrapConfig, sDKError errors.SDKError) *SDK_UpdateBootstrapCerts_Call {
	_c.Call.Return(bootstrapConfig, sDKError)
	return _c
}

func (_c *SDK_UpdateBootstrapCerts_Call) RunAndReturn(run func(ctx context.Context, id string, clientCert string, clientKey string, ca string, domainID string, token string) (sdk.BootstrapConfig, errors.SDKError)) *SDK_UpdateBootstrapCerts_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateBootstrapConnection provides a mock function for the type SDK
func (_mock *SDK) UpdateBootstrapConnection(ctx context.Context, id string, channels []string, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, id, channels, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, id, channels, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - id string
//   - channels []string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) UpdateBootstrapConnection(ctx interface{}, id interface{}, channels interface{}, domainID interface{}, token interface{}) *SDK_UpdateBootstrapConnection_Call {
	return &SDK_UpdateBootstrapConnection_Call{Call: _e.mock.On("UpdateBootstrapConnection", ctx, id, channels, domainID, token)}
}

func (_c *SDK_UpdateBootstrapConnection_Call) Run(run func(ctx context.Context, id string, channels []string, domainID string, token string)) *SDK_UpdateBootstrapConnection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []string
		if args[2] != nil {
			arg2 = args[2].([]string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_UpdateBootstrapConnection_Call) Return(sDKError errors.SDKError) *SDK_UpdateBootstrapConnection_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_UpdateBootstrapConnection_Call) RunAndReturn(run func(ctx context.Context, id string, channels []string, domainID string, token string) errors.SDKError) *SDK_UpdateBootstrapConnection_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateChannel provides a mock function for the type SDK
func (_mock *SDK) UpdateChannel(ctx context.Context, channel sdk0.Channel, domainID string, token string) (sdk0.Channel, errors.SDKError) {
	ret := _mock.Called(ctx, channel, domainID, token)

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

	var r0 sdk0.Channel
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Channel, string, string) (sdk0.Channel, errors.SDKError)); ok {
		return returnFunc(ctx, channel, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Channel, string, string) sdk0.Channel); ok {
		r0 = returnFunc(ctx, channel, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Channel)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.Channel, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, channel, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - channel sdk0.Channel
//   - domainID string
//   - token string
func (_e *SDK_Expecter) UpdateChannel(ctx interface{}, channel interface{}, domainID interface{}, token interface{}) *SDK_UpdateChannel_Call {
	return &SDK_UpdateChannel_Call{Call: _e.mock.On("UpdateChannel", ctx, channel, domainID, token)}
}

func (_c *SDK_UpdateChannel_Call) Run(run func(ctx context.Context, channel sdk0.Channel, domainID string, token string)) *SDK_UpdateChannel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.Channel
		if args[1] != nil {
			arg1 = args[1].(sdk0.Channel)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_UpdateChannel_Call) Return(channel1 sdk0.Channel, sDKError errors.SDKError) *SDK_UpdateChannel_Call {
	_c.Call.Return(channel1, sDKError)
	return _c
}

func (_c *SDK_UpdateChannel_Call) RunAndReturn(run func(ctx context.Context, channel sdk0.Channel, domainID string, token string) (sdk0.Channel, errors.SDKError)) *SDK_UpdateChannel_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateChannelTags provides a mock function for the type SDK
func (_mock *SDK) UpdateChannelTags(ctx context.Context, c sdk0.Channel, domainID string, token string) (sdk0.Channel, errors.SDKError) {
	ret := _mock.Called(ctx, c, domainID, token)

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

	var r0 sdk0.Channel
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Channel, string, string) (sdk0.Channel, errors.SDKError)); ok {
		return returnFunc(ctx, c, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Channel, string, string) sdk0.Channel); ok {
		r0 = returnFunc(ctx, c, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Channel)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.Channel, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, c, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// UpdateChannelTags is a helper method to define mock.On call
//   - ctx context.Context
//   - c sdk0.Channel
//   - domainID string
//   - token string
func (_e *SDK_Expecter) UpdateChannelTags(ctx interface{}, c interface{}, domainID interface{}, token interface{}) *SDK_UpdateChannelTags_Call {
	return &SDK_UpdateChannelTags_Call{Call: _e.mock.On("UpdateChannelTags", ctx, c, domainID, token)}
}

func (_c *SDK_UpdateChannelTags_Call) Run(run func(ctx context.Context, c sdk0.Channel, domainID string, token string)) *SDK_UpdateChannelTags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.Channel
		if args[1] != nil {
			arg1 = args[1].(sdk0.Channel)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_UpdateChannelTags_Call) Return(channel sdk0.Channel, sDKError errors.SDKError) *SDK_UpdateChannelTags_Call {
	_c.Call.Return(channel, sDKError)
	return _c
}

func (_c *SDK_UpdateChannelTags_Call) RunAndReturn(run func(ctx context.Context, c sdk0.Channel, domainID string, token string) (sdk0.Channel, errors.SDKError)) *SDK_UpdateChannelTags_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateClient provides a mock function for the type SDK
func (_mock *SDK) UpdateClient(ctx context.Context, client sdk0.Client, domainID string, token string) (sdk0.Client, errors.SDKError) {
	ret := _mock.Called(ctx, client, domainID, token)

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

	var r0 sdk0.Client
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Client, string, string) (sdk0.Client, errors.SDKError)); ok {
		return returnFunc(ctx, client, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Client, string, string) sdk0.Client); ok {
		r0 = returnFunc(ctx, client, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Client)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.Client, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, client, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - client sdk0.Client
//   - domainID string
//   - token string
func (_e *SDK_Expecter) UpdateClient(ctx interface{}, client interface{}, domainID interface{}, token interface{}) *SDK_UpdateClient_Call {
	return &SDK_UpdateClient_Call{Call: _e.mock.On("UpdateClient", ctx, client, domainID, token)}
}

func (_c *SDK_UpdateClient_Call) Run(run func(ctx context.Context, client sdk0.Client, domainID string, token string)) *SDK_UpdateClient_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.Client
		if args[1] != nil {
			arg1 = args[1].(sdk0.Client)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_UpdateClient_Call) Return(client1 sdk0.Client, sDKError errors.SDKError) *SDK_UpdateClient_Call {
	_c.Call.Return(client1, sDKError)
	return _c
}

func (_c *SDK_UpdateClient_Call) RunAndReturn(run func(ctx context.Context, client sdk0.Client, domainID string, token string) (sdk0.Client, errors.SDKError)) *SDK_UpdateClient_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateClientRole provides a mock function for the type SDK
func (_mock *SDK) UpdateClientRole(ctx context.Context, id string, roleID string, newName string, domainID string, token string) (sdk0.Role, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, newName, domainID, token)

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

	var r0 sdk0.Role
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string, string) (sdk0.Role, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, newName, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string, string) sdk0.Role); ok {
		r0 = returnFunc(ctx, id, roleID, newName, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Role)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, roleID, newName, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// UpdateClientRole is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - newName string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) UpdateClientRole(ctx interface{}, id interface{}, roleID interface{}, newName interface{}, domainID interface{}, token interface{}) *SDK_UpdateClientRole_Call {
	return &SDK_UpdateClientRole_Call{Call: _e.mock.On("UpdateClientRole", ctx, id, roleID, newName, domainID, token)}
}

func (_c *SDK_UpdateClientRole_Call) Run(run func(ctx context.Context, id string, roleID string, newName string, domainID string, token string)) *SDK_UpdateClientRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *SDK_UpdateClientRole_Call) Return(role sdk0.Role, sDKError errors.SDKError) *SDK_UpdateClientRole_Call {
	_c.Call.Return(role, sDKError)
	return _c
}

func (_c *SDK_UpdateClientRole_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, newName string, domainID string, token string) (sdk0.Role, errors.SDKError)) *SDK_UpdateClientRole_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateClientSecret provides a mock function for the type SDK
func (_mock *SDK) UpdateClientSecret(ctx context.Context, id string, secret string, domainID string, token string) (sdk0.Client, errors.SDKError) {
	ret := _mock.Called(ctx, id, secret, domainID, token)

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

	var r0 sdk0.Client
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (sdk0.Client, errors.SDKError)); ok {
		return returnFunc(ctx, id, secret, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) sdk0.Client); ok {
		r0 = returnFunc(ctx, id, secret, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Client)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, secret, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - id string
//   - secret string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) UpdateClientSecret(ctx interface{}, id interface{}, secret interface{}, domainID interface{}, token interface{}) *SDK_UpdateClientSecret_Call {
	return &SDK_UpdateClientSecret_Call{Call: _e.mock.On("UpdateClientSecret", ctx, id, secret, domainID, token)}
}

func (_c *SDK_UpdateClientSecret_Call) Run(run func(ctx context.Context, id string, secret string, domainID string, token string)) *SDK_UpdateClientSecret_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_UpdateClientSecret_Call) Return(client sdk0.Client, sDKError errors.SDKError) *SDK_UpdateClientSecret_Call {
	_c.Call.Return(client, sDKError)
	return _c
}

func (_c *SDK_UpdateClientSecret_Call) RunAndReturn(run func(ctx context.Context, id string, secret string, domainID string, token string) (sdk0.Client, errors.SDKError)) *SDK_UpdateClientSecret_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateClientTags provides a mock function for the type SDK
func (_mock *SDK) UpdateClientTags(ctx context.Context, client sdk0.Client, domainID string, token string) (sdk0.Client, errors.SDKError) {
	ret := _mock.Called(ctx, client, domainID, token)

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

	var r0 sdk0.Client
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Client, string, string) (sdk0.Client, errors.SDKError)); ok {
		return returnFunc(ctx, client, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Client, string, string) sdk0.Client); ok {
		r0 = returnFunc(ctx, client, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Client)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.Client, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, client, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - client sdk0.Client
//   - domainID string
//   - token string
func (_e *SDK_Expecter) UpdateClientTags(ctx interface{}, client interface{}, domainID interface{}, token interface{}) *SDK_UpdateClientTags_Call {
	return &SDK_UpdateClientTags_Call{Call: _e.mock.On("UpdateClientTags", ctx, client, domainID, token)}
}

func (_c *SDK_UpdateClientTags_Call) Run(run func(ctx context.Context, client sdk0.Client, domainID string, token string)) *SDK_UpdateClientTags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.Client
		if args[1] != nil {
			arg1 = args[1].(sdk0.Client)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_UpdateClientTags_Call) Return(client1 sdk0.Client, sDKError errors.SDKError) *SDK_UpdateClientTags_Call {
	_c.Call.Return(client1, sDKError)
	return _c
}

func (_c *SDK_UpdateClientTags_Call) RunAndReturn(run func(ctx context.Context, client sdk0.Client, domainID string, token string) (sdk0.Client, errors.SDKError)) *SDK_UpdateClientTags_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDomain provides a mock function for the type SDK
func (_mock *SDK) UpdateDomain(ctx context.Context, d sdk0.Domain, token string) (sdk0.Domain, errors.SDKError) {
	ret := _mock.Called(ctx, d, token)

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

	var r0 sdk0.Domain
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Domain, string) (sdk0.Domain, errors.SDKError)); ok {
		return returnFunc(ctx, d, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Domain, string) sdk0.Domain); ok {
		r0 = returnFunc(ctx, d, token)
	} else {
		r0 = ret.Get(0).(sdk0.Domain)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.Domain, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, d, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - d sdk0.Domain
//   - token string
func (_e *SDK_Expecter) UpdateDomain(ctx interface{}, d interface{}, token interface{}) *SDK_UpdateDomain_Call {
	return &SDK_UpdateDomain_Call{Call: _e.mock.On("UpdateDomain", ctx, d, token)}
}

func (_c *SDK_UpdateDomain_Call) Run(run func(ctx context.Context, d sdk0.Domain, token string)) *SDK_UpdateDomain_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.Domain
		if args[1] != nil {
			arg1 = args[1].(sdk0.Domain)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_UpdateDomain_Call) Return(domain sdk0.Domain, sDKError errors.SDKError) *SDK_UpdateDomain_Call {
	_c.Call.Return(domain, sDKError)
	return _c
}

func (_c *SDK_UpdateDomain_Call) RunAndReturn(run func(ctx context.Context, d sdk0.Domain, token string) (sdk0.Domain, errors.SDKError)) *SDK_UpdateDomain_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDomainRole provides a mock function for the type SDK
func (_mock *SDK) UpdateDomainRole(ctx context.Context, id string, roleID string, newName string, token string) (sdk0.Role, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, newName, token)

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

	var r0 sdk0.Role
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (sdk0.Role, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, newName, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) sdk0.Role); ok {
		r0 = returnFunc(ctx, id, roleID, newName, token)
	} else {
		r0 = ret.Get(0).(sdk0.Role)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, roleID, newName, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// UpdateDomainRole is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - newName string
//   - token string
func (_e *SDK_Expecter) UpdateDomainRole(ctx interface{}, id interface{}, roleID interface{}, newName interface{}, token interface{}) *SDK_UpdateDomainRole_Call {
	return &SDK_UpdateDomainRole_Call{Call: _e.mock.On("UpdateDomainRole", ctx, id, roleID, newName, token)}
}

func (_c *SDK_UpdateDomainRole_Call) Run(run func(ctx context.Context, id string, roleID string, newName string, token string)) *SDK_UpdateDomainRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_UpdateDomainRole_Call) Return(role sdk0.Role, sDKError errors.SDKError) *SDK_UpdateDomainRole_Call {
	_c.Call.Return(role, sDKError)
	return _c
}

func (_c *SDK_UpdateDomainRole_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, newName string, token string) (sdk0.Role, errors.SDKError)) *SDK_UpdateDomainRole_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateGroup provides a mock function for the type SDK
func (_mock *SDK) UpdateGroup(ctx context.Context, group sdk0.Group, domainID string, token string) (sdk0.Group, errors.SDKError) {
	ret := _mock.Called(ctx, group, domainID, token)

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

	var r0 sdk0.Group
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Group, string, string) (sdk0.Group, errors.SDKError)); ok {
		return returnFunc(ctx, group, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Group, string, string) sdk0.Group); ok {
		r0 = returnFunc(ctx, group, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Group)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.Group, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, group, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - group sdk0.Group
//   - domainID string
//   - token string
func (_e *SDK_Expecter) UpdateGroup(ctx interface{}, group interface{}, domainID interface{}, token interface{}) *SDK_UpdateGroup_Call {
	return &SDK_UpdateGroup_Call{Call: _e.mock.On("UpdateGroup", ctx, group, domainID, token)}
}

func (_c *SDK_UpdateGroup_Call) Run(run func(ctx context.Context, group sdk0.Group, domainID string, token string)) *SDK_UpdateGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.Group
		if args[1] != nil {
			arg1 = args[1].(sdk0.Group)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_UpdateGroup_Call) Return(group1 sdk0.Group, sDKError errors.SDKError) *SDK_UpdateGroup_Call {
	_c.Call.Return(group1, sDKError)
	return _c
}

func (_c *SDK_UpdateGroup_Call) RunAndReturn(run func(ctx context.Context, group sdk0.Group, domainID string, token string) (sdk0.Group, errors.SDKError)) *SDK_UpdateGroup_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateGroupRole provides a mock function for the type SDK
func (_mock *SDK) UpdateGroupRole(ctx context.Context, id string, roleID string, newName string, domainID string, token string) (sdk0.Role, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, newName, domainID, token)

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

	var r0 sdk0.Role
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string, string) (sdk0.Role, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, newName, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string, string) sdk0.Role); ok {
		r0 = returnFunc(ctx, id, roleID, newName, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Role)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, roleID, newName, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// UpdateGroupRole is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - roleID string
//   - newName string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) UpdateGroupRole(ctx interface{}, id interface{}, roleID interface{}, newName interface{}, domainID interface{}, token interface{}) *SDK_UpdateGroupRole_Call {
	return &SDK_UpdateGroupRole_Call{Call: _e.mock.On("UpdateGroupRole", ctx, id, roleID, newName, domainID, token)}
}

func (_c *SDK_UpdateGroupRole_Call) Run(run func(ctx context.Context, id string, roleID string, newName string, domainID string, token string)) *SDK_UpdateGroupRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *SDK_UpdateGroupRole_Call) Return(role sdk0.Role, sDKError errors.SDKError) *SDK_UpdateGroupRole_Call {
	_c.Call.Return(role, sDKError)
	return _c
}

func (_c *SDK_UpdateGroupRole_Call) RunAndReturn(run func(ctx context.Context, id string, roleID string, newName string, domainID string, token string) (sdk0.Role, errors.SDKError)) *SDK_UpdateGroupRole_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateGroupTags provides a mock function for the type SDK
func (_mock *SDK) UpdateGroupTags(ctx context.Context, group sdk0.Group, domainID string, token string) (sdk0.Group, errors.SDKError) {
	ret := _mock.Called(ctx, group, domainID, token)

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

	var r0 sdk0.Group
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Group, string, string) (sdk0.Group, errors.SDKError)); ok {
		return returnFunc(ctx, group, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.Group, string, string) sdk0.Group); ok {
		r0 = returnFunc(ctx, group, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Group)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.Group, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, group, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// UpdateGroupTags is a helper method to define mock.On call
//   - ctx context.Context
//   - group sdk0.Group
//   - domainID string
//   - token string
func (_e *SDK_Expecter) UpdateGroupTags(ctx interface{}, group interface{}, domainID interface{}, token interface{}) *SDK_UpdateGroupTags_Call {
	return &SDK_UpdateGroupTags_Call{Call: _e.mock.On("UpdateGroupTags", ctx, group, domainID, token)}
}

func (_c *SDK_UpdateGroupTags_Call) Run(run func(ctx context.Context, group sdk0.Group, domainID string, token string)) *SDK_UpdateGroupTags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.Group
		if args[1] != nil {
			arg1 = args[1].(sdk0.Group)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_UpdateGroupTags_Call) Return(group1 sdk0.Group, sDKError errors.SDKError) *SDK_UpdateGroupTags_Call {
	_c.Call.Return(group1, sDKError)
	return _c
}

func (_c *SDK_UpdateGroupTags_Call) RunAndReturn(run func(ctx context.Context, group sdk0.Group, domainID string, token string) (sdk0.Group, errors.SDKError)) *SDK_UpdateGroupTags_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePassword provides a mock function for the type SDK
func (_mock *SDK) UpdatePassword(ctx context.Context, oldPass string, newPass string, token string) (sdk0.User, errors.SDKError) {
	ret := _mock.Called(ctx, oldPass, newPass, token)

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

	var r0 sdk0.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk0.User, errors.SDKError)); ok {
		return returnFunc(ctx, oldPass, newPass, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk0.User); ok {
		r0 = returnFunc(ctx, oldPass, newPass, token)
	} else {
		r0 = ret.Get(0).(sdk0.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, oldPass, newPass, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - oldPass string
//   - newPass string
//   - token string
func (_e *SDK_Expecter) UpdatePassword(ctx interface{}, oldPass interface{}, newPass interface{}, token interface{}) *SDK_UpdatePassword_Call {
	return &SDK_UpdatePassword_Call{Call: _e.mock.On("UpdatePassword", ctx, oldPass, newPass, token)}
}

func (_c *SDK_UpdatePassword_Call) Run(run func(ctx context.Context, oldPass string, newPass string, token string)) *SDK_UpdatePassword_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_UpdatePassword_Call) Return(user sdk0.User, sDKError errors.SDKError) *SDK_UpdatePassword_Call {
	_c.Call.Return(user, sDKError)
	return _c
}

func (_c *SDK_UpdatePassword_Call) RunAndReturn(run func(ctx context.Context, oldPass string, newPass string, token string) (sdk0.User, errors.SDKError)) *SDK_UpdatePassword_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateProfilePicture provides a mock function for the type SDK
func (_mock *SDK) UpdateProfilePicture(ctx context.Context, user sdk0.User, token string) (sdk0.User, errors.SDKError) {
	ret := _mock.Called(ctx, user, token)

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

	var r0 sdk0.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.User, string) (sdk0.User, errors.SDKError)); ok {
		return returnFunc(ctx, user, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.User, string) sdk0.User); ok {
		r0 = returnFunc(ctx, user, token)
	} else {
		r0 = ret.Get(0).(sdk0.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.User, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, user, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - user sdk0.User
//   - token string
func (_e *SDK_Expecter) UpdateProfilePicture(ctx interface{}, user interface{}, token interface{}) *SDK_UpdateProfilePicture_Call {
	return &SDK_UpdateProfilePicture_Call{Call: _e.mock.On("UpdateProfilePicture", ctx, user, token)}
}

func (_c *SDK_UpdateProfilePicture_Call) Run(run func(ctx context.Context, user sdk0.User, token string)) *SDK_UpdateProfilePicture_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.User
		if args[1] != nil {
			arg1 = args[1].(sdk0.User)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_UpdateProfilePicture_Call) Return(user1 sdk0.User, sDKError errors.SDKError) *SDK_UpdateProfilePicture_Call {
	_c.Call.Return(user1, sDKError)
	return _c
}

func (_c *SDK_UpdateProfilePicture_Call) RunAndReturn(run func(ctx context.Context, user sdk0.User, token string) (sdk0.User, errors.SDKError)) *SDK_UpdateProfilePicture_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateUser provides a mock function for the type SDK
func (_mock *SDK) UpdateUser(ctx context.Context, user sdk0.User, token string) (sdk0.User, errors.SDKError) {
	ret := _mock.Called(ctx, user, token)

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

	var r0 sdk0.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.User, string) (sdk0.User, errors.SDKError)); ok {
		return returnFunc(ctx, user, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.User, string) sdk0.User); ok {
		r0 = returnFunc(ctx, user, token)
	} else {
		r0 = ret.Get(0).(sdk0.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.User, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, user, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - user sdk0.User
//   - token string
func (_e *SDK_Expecter) UpdateUser(ctx interface{}, user interface{}, token interface{}) *SDK_UpdateUser_Call {
	return &SDK_UpdateUser_Call{Call: _e.mock.On("UpdateUser", ctx, user, token)}
}

func (_c *SDK_UpdateUser_Call) Run(run func(ctx context.Context, user sdk0.User, token string)) *SDK_UpdateUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.User
		if args[1] != nil {
			arg1 = args[1].(sdk0.User)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_UpdateUser_Call) Return(user1 sdk0.User, sDKError errors.SDKError) *SDK_UpdateUser_Call {
	_c.Call.Return(user1, sDKError)
	return _c
}

func (_c *SDK_UpdateUser_Call) RunAndReturn(run func(ctx context.Context, user sdk0.User, token string) (sdk0.User, errors.SDKError)) *SDK_UpdateUser_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateUserEmail provides a mock function for the type SDK
func (_mock *SDK) UpdateUserEmail(ctx context.Context, user sdk0.User, token string) (sdk0.User, errors.SDKError) {
	ret := _mock.Called(ctx, user, token)

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

	var r0 sdk0.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.User, string) (sdk0.User, errors.SDKError)); ok {
		return returnFunc(ctx, user, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.User, string) sdk0.User); ok {
		r0 = returnFunc(ctx, user, token)
	} else {
		r0 = ret.Get(0).(sdk0.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.User, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, user, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - user sdk0.User
//   - token string
func (_e *SDK_Expecter) UpdateUserEmail(ctx interface{}, user interface{}, token interface{}) *SDK_UpdateUserEmail_Call {
	return &SDK_UpdateUserEmail_Call{Call: _e.mock.On("UpdateUserEmail", ctx, user, token)}
}

func (_c *SDK_UpdateUserEmail_Call) Run(run func(ctx context.Context, user sdk0.User, token string)) *SDK_UpdateUserEmail_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.User
		if args[1] != nil {
			arg1 = args[1].(sdk0.User)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_UpdateUserEmail_Call) Return(user1 sdk0.User, sDKError errors.SDKError) *SDK_UpdateUserEmail_Call {
	_c.Call.Return(user1, sDKError)
	return _c
}

func (_c *SDK_UpdateUserEmail_Call) RunAndReturn(run func(ctx context.Context, user sdk0.User, token string) (sdk0.User, errors.SDKError)) *SDK_UpdateUserEmail_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateUserRole provides a mock function for the type SDK
func (_mock *SDK) UpdateUserRole(ctx context.Context, user sdk0.User, token string) (sdk0.User, errors.SDKError) {
	ret := _mock.Called(ctx, user, token)

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

	var r0 sdk0.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.User, string) (sdk0.User, errors.SDKError)); ok {
		return returnFunc(ctx, user, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.User, string) sdk0.User); ok {
		r0 = returnFunc(ctx, user, token)
	} else {
		r0 = ret.Get(0).(sdk0.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.User, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, user, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - user sdk0.User
//   - token string
func (_e *SDK_Expecter) UpdateUserRole(ctx interface{}, user interface{}, token interface{}) *SDK_UpdateUserRole_Call {
	return &SDK_UpdateUserRole_Call{Call: _e.mock.On("UpdateUserRole", ctx, user, token)}
}

func (_c *SDK_UpdateUserRole_Call) Run(run func(ctx context.Context, user sdk0.User, token string)) *SDK_UpdateUserRole_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.User
		if args[1] != nil {
			arg1 = args[1].(sdk0.User)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_UpdateUserRole_Call) Return(user1 sdk0.User, sDKError errors.SDKError) *SDK_UpdateUserRole_Call {
	_c.Call.Return(user1, sDKError)
	return _c
}

func (_c *SDK_UpdateUserRole_Call) RunAndReturn(run func(ctx context.Context, user sdk0.User, token string) (sdk0.User, errors.SDKError)) *SDK_UpdateUserRole_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateUserTags provides a mock function for the type SDK
func (_mock *SDK) UpdateUserTags(ctx context.Context, user sdk0.User, token string) (sdk0.User, errors.SDKError) {
	ret := _mock.Called(ctx, user, token)

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

	var r0 sdk0.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.User, string) (sdk0.User, errors.SDKError)); ok {
		return returnFunc(ctx, user, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.User, string) sdk0.User); ok {
		r0 = returnFunc(ctx, user, token)
	} else {
		r0 = ret.Get(0).(sdk0.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.User, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, user, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - user sdk0.User
//   - token string
func (_e *SDK_Expecter) UpdateUserTags(ctx interface{}, user interface{}, token interface{}) *SDK_UpdateUserTags_Call {
	return &SDK_UpdateUserTags_Call{Call: _e.mock.On("UpdateUserTags", ctx, user, token)}
}

func (_c *SDK_UpdateUserTags_Call) Run(run func(ctx context.Context, user sdk0.User, token string)) *SDK_UpdateUserTags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.User
		if args[1] != nil {
			arg1 = args[1].(sdk0.User)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_UpdateUserTags_Call) Return(user1 sdk0.User, sDKError errors.SDKError) *SDK_UpdateUserTags_Call {
	_c.Call.Return(user1, sDKError)
	return _c
}

func (_c *SDK_UpdateUserTags_Call) RunAndReturn(run func(ctx context.Context, user sdk0.User, token string) (sdk0.User, errors.SDKError)) *SDK_UpdateUserTags_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateUsername provides a mock function for the type SDK
func (_mock *SDK) UpdateUsername(ctx context.Context, user sdk0.User, token string) (sdk0.User, errors.SDKError) {
	ret := _mock.Called(ctx, user, token)

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

	var r0 sdk0.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.User, string) (sdk0.User, errors.SDKError)); ok {
		return returnFunc(ctx, user, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.User, string) sdk0.User); ok {
		r0 = returnFunc(ctx, user, token)
	} else {
		r0 = ret.Get(0).(sdk0.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.User, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, user, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - user sdk0.User
//   - token string
func (_e *SDK_Expecter) UpdateUsername(ctx interface{}, user interface{}, token interface{}) *SDK_UpdateUsername_Call {
	return &SDK_UpdateUsername_Call{Call: _e.mock.On("UpdateUsername", ctx, user, token)}
}

func (_c *SDK_UpdateUsername_Call) Run(run func(ctx context.Context, user sdk0.User, token string)) *SDK_UpdateUsername_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.User
		if args[1] != nil {
			arg1 = args[1].(sdk0.User)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_UpdateUsername_Call) Return(user1 sdk0.User, sDKError errors.SDKError) *SDK_UpdateUsername_Call {
	_c.Call.Return(user1, sDKError)
	return _c
}

func (_c *SDK_UpdateUsername_Call) RunAndReturn(run func(ctx context.Context, user sdk0.User, token string) (sdk0.User, errors.SDKError)) *SDK_UpdateUsername_Call {
	_c.Call.Return(run)
	return _c
}

// User provides a mock function for the type SDK
func (_mock *SDK) User(ctx context.Context, id string, token string) (sdk0.User, errors.SDKError) {
	ret := _mock.Called(ctx, id, token)

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

	var r0 sdk0.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (sdk0.User, errors.SDKError)); ok {
		return returnFunc(ctx, id, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) sdk0.User); ok {
		r0 = returnFunc(ctx, id, token)
	} else {
		r0 = ret.Get(0).(sdk0.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(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
//   - ctx context.Context
//   - id string
//   - token string
func (_e *SDK_Expecter) User(ctx interface{}, id interface{}, token interface{}) *SDK_User_Call {
	return &SDK_User_Call{Call: _e.mock.On("User", ctx, id, token)}
}

func (_c *SDK_User_Call) Run(run func(ctx context.Context, id string, token string)) *SDK_User_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_User_Call) Return(user sdk0.User, sDKError errors.SDKError) *SDK_User_Call {
	_c.Call.Return(user, sDKError)
	return _c
}

func (_c *SDK_User_Call) RunAndReturn(run func(ctx context.Context, id string, token string) (sdk0.User, errors.SDKError)) *SDK_User_Call {
	_c.Call.Return(run)
	return _c
}

// UserProfile provides a mock function for the type SDK
func (_mock *SDK) UserProfile(ctx context.Context, token string) (sdk0.User, errors.SDKError) {
	ret := _mock.Called(ctx, token)

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

	var r0 sdk0.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (sdk0.User, errors.SDKError)); ok {
		return returnFunc(ctx, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) sdk0.User); ok {
		r0 = returnFunc(ctx, token)
	} else {
		r0 = ret.Get(0).(sdk0.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(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
//   - ctx context.Context
//   - token string
func (_e *SDK_Expecter) UserProfile(ctx interface{}, token interface{}) *SDK_UserProfile_Call {
	return &SDK_UserProfile_Call{Call: _e.mock.On("UserProfile", ctx, token)}
}

func (_c *SDK_UserProfile_Call) Run(run func(ctx context.Context, token string)) *SDK_UserProfile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *SDK_UserProfile_Call) Return(user sdk0.User, sDKError errors.SDKError) *SDK_UserProfile_Call {
	_c.Call.Return(user, sDKError)
	return _c
}

func (_c *SDK_UserProfile_Call) RunAndReturn(run func(ctx context.Context, token string) (sdk0.User, errors.SDKError)) *SDK_UserProfile_Call {
	_c.Call.Return(run)
	return _c
}

// Users provides a mock function for the type SDK
func (_mock *SDK) Users(ctx context.Context, pm sdk0.PageMetadata, token string) (sdk0.UsersPage, errors.SDKError) {
	ret := _mock.Called(ctx, pm, token)

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

	var r0 sdk0.UsersPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.PageMetadata, string) (sdk0.UsersPage, errors.SDKError)); ok {
		return returnFunc(ctx, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk0.PageMetadata, string) sdk0.UsersPage); ok {
		r0 = returnFunc(ctx, pm, token)
	} else {
		r0 = ret.Get(0).(sdk0.UsersPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk0.PageMetadata, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, pm, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - pm sdk0.PageMetadata
//   - token string
func (_e *SDK_Expecter) Users(ctx interface{}, pm interface{}, token interface{}) *SDK_Users_Call {
	return &SDK_Users_Call{Call: _e.mock.On("Users", ctx, pm, token)}
}

func (_c *SDK_Users_Call) Run(run func(ctx context.Context, pm sdk0.PageMetadata, token string)) *SDK_Users_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk0.PageMetadata
		if args[1] != nil {
			arg1 = args[1].(sdk0.PageMetadata)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_Users_Call) Return(usersPage sdk0.UsersPage, sDKError errors.SDKError) *SDK_Users_Call {
	_c.Call.Return(usersPage, sDKError)
	return _c
}

func (_c *SDK_Users_Call) RunAndReturn(run func(ctx context.Context, pm sdk0.PageMetadata, token string) (sdk0.UsersPage, errors.SDKError)) *SDK_Users_Call {
	_c.Call.Return(run)
	return _c
}

// VerifyEmail provides a mock function for the type SDK
func (_mock *SDK) VerifyEmail(ctx context.Context, verificationToken string) errors.SDKError {
	ret := _mock.Called(ctx, verificationToken)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, verificationToken)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	return r0
}

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

// VerifyEmail is a helper method to define mock.On call
//   - ctx context.Context
//   - verificationToken string
func (_e *SDK_Expecter) VerifyEmail(ctx interface{}, verificationToken interface{}) *SDK_VerifyEmail_Call {
	return &SDK_VerifyEmail_Call{Call: _e.mock.On("VerifyEmail", ctx, verificationToken)}
}

func (_c *SDK_VerifyEmail_Call) Run(run func(ctx context.Context, verificationToken string)) *SDK_VerifyEmail_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *SDK_VerifyEmail_Call) Return(sDKError errors.SDKError) *SDK_VerifyEmail_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_VerifyEmail_Call) RunAndReturn(run func(ctx context.Context, verificationToken string) errors.SDKError) *SDK_VerifyEmail_Call {
	_c.Call.Return(run)
	return _c
}

// ViewBootstrap provides a mock function for the type SDK
func (_mock *SDK) ViewBootstrap(ctx context.Context, id string, domainID string, token string) (sdk.BootstrapConfig, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 sdk.BootstrapConfig
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.BootstrapConfig, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.BootstrapConfig); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.BootstrapConfig)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - id string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) ViewBootstrap(ctx interface{}, id interface{}, domainID interface{}, token interface{}) *SDK_ViewBootstrap_Call {
	return &SDK_ViewBootstrap_Call{Call: _e.mock.On("ViewBootstrap", ctx, id, domainID, token)}
}

func (_c *SDK_ViewBootstrap_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_ViewBootstrap_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_ViewBootstrap_Call) Return(bootstrapConfig sdk.BootstrapConfig, sDKError errors.SDKError) *SDK_ViewBootstrap_Call {
	_c.Call.Return(bootstrapConfig, sDKError)
	return _c
}

func (_c *SDK_ViewBootstrap_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) (sdk.BootstrapConfig, errors.SDKError)) *SDK_ViewBootstrap_Call {
	_c.Call.Return(run)
	return _c
}

// ViewCert provides a mock function for the type SDK
func (_mock *SDK) ViewCert(ctx context.Context, certID string, domainID string, token string) (sdk0.Cert, errors.SDKError) {
	ret := _mock.Called(ctx, certID, domainID, token)

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

	var r0 sdk0.Cert
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk0.Cert, errors.SDKError)); ok {
		return returnFunc(ctx, certID, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk0.Cert); ok {
		r0 = returnFunc(ctx, certID, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.Cert)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, certID, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - certID string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) ViewCert(ctx interface{}, certID interface{}, domainID interface{}, token interface{}) *SDK_ViewCert_Call {
	return &SDK_ViewCert_Call{Call: _e.mock.On("ViewCert", ctx, certID, domainID, token)}
}

func (_c *SDK_ViewCert_Call) Run(run func(ctx context.Context, certID string, domainID string, token string)) *SDK_ViewCert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_ViewCert_Call) Return(cert sdk0.Cert, sDKError errors.SDKError) *SDK_ViewCert_Call {
	_c.Call.Return(cert, sDKError)
	return _c
}

func (_c *SDK_ViewCert_Call) RunAndReturn(run func(ctx context.Context, certID string, domainID string, token string) (sdk0.Cert, errors.SDKError)) *SDK_ViewCert_Call {
	_c.Call.Return(run)
	return _c
}

// ViewCertByClient provides a mock function for the type SDK
func (_mock *SDK) ViewCertByClient(ctx context.Context, clientID string, domainID string, token string) (sdk0.CertSerials, errors.SDKError) {
	ret := _mock.Called(ctx, clientID, domainID, token)

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

	var r0 sdk0.CertSerials
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk0.CertSerials, errors.SDKError)); ok {
		return returnFunc(ctx, clientID, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk0.CertSerials); ok {
		r0 = returnFunc(ctx, clientID, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk0.CertSerials)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, clientID, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - clientID string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) ViewCertByClient(ctx interface{}, clientID interface{}, domainID interface{}, token interface{}) *SDK_ViewCertByClient_Call {
	return &SDK_ViewCertByClient_Call{Call: _e.mock.On("ViewCertByClient", ctx, clientID, domainID, token)}
}

func (_c *SDK_ViewCertByClient_Call) Run(run func(ctx context.Context, clientID string, domainID string, token string)) *SDK_ViewCertByClient_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *SDK_ViewCertByClient_Call) Return(certSerials sdk0.CertSerials, sDKError errors.SDKError) *SDK_ViewCertByClient_Call {
	_c.Call.Return(certSerials, sDKError)
	return _c
}

func (_c *SDK_ViewCertByClient_Call) RunAndReturn(run func(ctx context.Context, clientID string, domainID string, token string) (sdk0.CertSerials, errors.SDKError)) *SDK_ViewCertByClient_Call {
	_c.Call.Return(run)
	return _c
}

// ViewSubscription provides a mock function for the type SDK
func (_mock *SDK) ViewSubscription(ctx context.Context, id string, token string) (sdk.Subscription, errors.SDKError) {
	ret := _mock.Called(ctx, id, token)

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

	var r0 sdk.Subscription
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (sdk.Subscription, errors.SDKError)); ok {
		return returnFunc(ctx, id, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) sdk.Subscription); ok {
		r0 = returnFunc(ctx, id, token)
	} else {
		r0 = ret.Get(0).(sdk.Subscription)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, id, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - id string
//   - token string
func (_e *SDK_Expecter) ViewSubscription(ctx interface{}, id interface{}, token interface{}) *SDK_ViewSubscription_Call {
	return &SDK_ViewSubscription_Call{Call: _e.mock.On("ViewSubscription", ctx, id, token)}
}

func (_c *SDK_ViewSubscription_Call) Run(run func(ctx context.Context, id string, token string)) *SDK_ViewSubscription_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_ViewSubscription_Call) Return(subscription sdk.Subscription, sDKError errors.SDKError) *SDK_ViewSubscription_Call {
	_c.Call.Return(subscription, sDKError)
	return _c
}

func (_c *SDK_ViewSubscription_Call) RunAndReturn(run func(ctx context.Context, id string, token string) (sdk.Subscription, errors.SDKError)) *SDK_ViewSubscription_Call {
	_c.Call.Return(run)
	return _c
}

// Whitelist provides a mock function for the type SDK
func (_mock *SDK) Whitelist(ctx context.Context, clientID string, state int, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, clientID, state, domainID, token)

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, int, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, clientID, state, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(errors.SDKError)
		}
	}
	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
//   - ctx context.Context
//   - clientID string
//   - state int
//   - domainID string
//   - token string
func (_e *SDK_Expecter) Whitelist(ctx interface{}, clientID interface{}, state interface{}, domainID interface{}, token interface{}) *SDK_Whitelist_Call {
	return &SDK_Whitelist_Call{Call: _e.mock.On("Whitelist", ctx, clientID, state, domainID, token)}
}

func (_c *SDK_Whitelist_Call) Run(run func(ctx context.Context, clientID string, state int, domainID string, token string)) *SDK_Whitelist_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 int
		if args[2] != nil {
			arg2 = args[2].(int)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *SDK_Whitelist_Call) Return(sDKError errors.SDKError) *SDK_Whitelist_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_Whitelist_Call) RunAndReturn(run func(ctx context.Context, clientID string, state int, domainID string, token string) errors.SDKError) *SDK_Whitelist_Call {
	_c.Call.Return(run)
	return _c
}