magistrala/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"

	"github.com/absmach/magistrala/pkg/errors"
	"github.com/absmach/magistrala/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
}

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

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

	var r0 sdk.ReportConfig
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.ReportConfig, string, string) (sdk.ReportConfig, errors.SDKError)); ok {
		return returnFunc(ctx, cfg, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.ReportConfig, string, string) sdk.ReportConfig); ok {
		r0 = returnFunc(ctx, cfg, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.ReportConfig)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.ReportConfig, 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_AddReportConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddReportConfig'
type SDK_AddReportConfig_Call struct {
	*mock.Call
}

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

func (_c *SDK_AddReportConfig_Call) Run(run func(ctx context.Context, cfg sdk.ReportConfig, domainID string, token string)) *SDK_AddReportConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk.ReportConfig
		if args[1] != nil {
			arg1 = args[1].(sdk.ReportConfig)
		}
		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_AddReportConfig_Call) Return(reportConfig sdk.ReportConfig, sDKError errors.SDKError) *SDK_AddReportConfig_Call {
	_c.Call.Return(reportConfig, sDKError)
	return _c
}

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

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

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

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

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

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

func (_c *SDK_AddRule_Call) Run(run func(ctx context.Context, r sdk.Rule, domainID string, token string)) *SDK_AddRule_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk.Rule
		if args[1] != nil {
			arg1 = args[1].(sdk.Rule)
		}
		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_AddRule_Call) Return(rule sdk.Rule, sDKError errors.SDKError) *SDK_AddRule_Call {
	_c.Call.Return(rule, sDKError)
	return _c
}

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

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

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

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

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

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

func (_c *SDK_AssignBootstrapProfile_Call) Run(run func(ctx context.Context, configID string, profileID string, domainID string, token string)) *SDK_AssignBootstrapProfile_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_AssignBootstrapProfile_Call) Return(sDKError errors.SDKError) *SDK_AssignBootstrapProfile_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_AssignBootstrapProfile_Call) RunAndReturn(run func(ctx context.Context, configID string, profileID string, domainID string, token string) errors.SDKError) *SDK_AssignBootstrapProfile_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
}

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

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

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

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

// BindBootstrapResources is a helper method to define mock.On call
//   - ctx context.Context
//   - configID string
//   - bindings []sdk.BootstrapBindingRequest
//   - domainID string
//   - token string
func (_e *SDK_Expecter) BindBootstrapResources(ctx interface{}, configID interface{}, bindings interface{}, domainID interface{}, token interface{}) *SDK_BindBootstrapResources_Call {
	return &SDK_BindBootstrapResources_Call{Call: _e.mock.On("BindBootstrapResources", ctx, configID, bindings, domainID, token)}
}

func (_c *SDK_BindBootstrapResources_Call) Run(run func(ctx context.Context, configID string, bindings []sdk.BootstrapBindingRequest, domainID string, token string)) *SDK_BindBootstrapResources_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 []sdk.BootstrapBindingRequest
		if args[2] != nil {
			arg2 = args[2].([]sdk.BootstrapBindingRequest)
		}
		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_BindBootstrapResources_Call) Return(sDKError errors.SDKError) *SDK_BindBootstrapResources_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_BindBootstrapResources_Call) RunAndReturn(run func(ctx context.Context, configID string, bindings []sdk.BootstrapBindingRequest, domainID string, token string) errors.SDKError) *SDK_BindBootstrapResources_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
}

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

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

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

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

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

func (_c *SDK_BootstrapBindings_Call) Run(run func(ctx context.Context, configID string, domainID string, token string)) *SDK_BootstrapBindings_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_BootstrapBindings_Call) Return(bootstrapBindingSnapshots []sdk.BootstrapBindingSnapshot, sDKError errors.SDKError) *SDK_BootstrapBindings_Call {
	_c.Call.Return(bootstrapBindingSnapshots, sDKError)
	return _c
}

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

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

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

	var r0 sdk.BootstrapProfilesPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string, string) (sdk.BootstrapProfilesPage, errors.SDKError)); ok {
		return returnFunc(ctx, pm, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string, string) sdk.BootstrapProfilesPage); ok {
		r0 = returnFunc(ctx, pm, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.BootstrapProfilesPage)
	}
	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_BootstrapProfiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BootstrapProfiles'
type SDK_BootstrapProfiles_Call struct {
	*mock.Call
}

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

func (_c *SDK_BootstrapProfiles_Call) Run(run func(ctx context.Context, pm sdk.PageMetadata, domainID string, token string)) *SDK_BootstrapProfiles_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_BootstrapProfiles_Call) Return(bootstrapProfilesPage sdk.BootstrapProfilesPage, sDKError errors.SDKError) *SDK_BootstrapProfiles_Call {
	_c.Call.Return(bootstrapProfilesPage, sDKError)
	return _c
}

func (_c *SDK_BootstrapProfiles_Call) RunAndReturn(run func(ctx context.Context, pm sdk.PageMetadata, domainID string, token string) (sdk.BootstrapProfilesPage, errors.SDKError)) *SDK_BootstrapProfiles_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) (sdk.Channel, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 sdk.Channel
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.Channel, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.Channel); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.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 sdk.PageMetadata, domainID string, token string) (sdk.ChannelsPage, errors.SDKError) {
	ret := _mock.Called(ctx, pm, domainID, token)

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

	var r0 sdk.ChannelsPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string, string) (sdk.ChannelsPage, errors.SDKError)); ok {
		return returnFunc(ctx, pm, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string, string) sdk.ChannelsPage); ok {
		r0 = returnFunc(ctx, pm, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.ChannelsPage)
	}
	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_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 sdk.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 sdk.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 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_Channels_Call) Return(channelsPage sdk.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 sdk.PageMetadata, domainID string, token string) (sdk.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 sdk.PageMetadata, token string) (sdk.GroupsPage, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, pm, token)

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

	var r0 sdk.GroupsPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk.PageMetadata, string) (sdk.GroupsPage, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk.PageMetadata, string) sdk.GroupsPage); ok {
		r0 = returnFunc(ctx, id, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk.GroupsPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, sdk.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 sdk.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 sdk.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 sdk.PageMetadata
		if args[3] != nil {
			arg3 = args[3].(sdk.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 sdk.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 sdk.PageMetadata, token string) (sdk.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) (sdk.Client, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 sdk.Client
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.Client, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.Client); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.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) (sdk.Role, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, domainID, token)

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

	var r0 sdk.Role
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (sdk.Role, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) sdk.Role); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.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 sdk.PageMetadata, token string) (sdk.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 sdk.RoleMembersPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, sdk.PageMetadata, string) (sdk.RoleMembersPage, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, sdk.PageMetadata, string) sdk.RoleMembersPage); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk.RoleMembersPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, sdk.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 sdk.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 sdk.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 sdk.PageMetadata
		if args[4] != nil {
			arg4 = args[4].(sdk.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 sdk.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 sdk.PageMetadata, token string) (sdk.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 sdk.PageMetadata, token string) (sdk.RolesPage, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, pm, token)

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

	var r0 sdk.RolesPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk.PageMetadata, string) (sdk.RolesPage, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk.PageMetadata, string) sdk.RolesPage); ok {
		r0 = returnFunc(ctx, id, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk.RolesPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, sdk.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 sdk.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 sdk.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 sdk.PageMetadata
		if args[3] != nil {
			arg3 = args[3].(sdk.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 sdk.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 sdk.PageMetadata, token string) (sdk.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 sdk.PageMetadata, domainID string, token string) (sdk.ClientsPage, errors.SDKError) {
	ret := _mock.Called(ctx, pm, domainID, token)

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

	var r0 sdk.ClientsPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string, string) (sdk.ClientsPage, errors.SDKError)); ok {
		return returnFunc(ctx, pm, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string, string) sdk.ClientsPage); ok {
		r0 = returnFunc(ctx, pm, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.ClientsPage)
	}
	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_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 sdk.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 sdk.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 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_Clients_Call) Return(clientsPage sdk.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 sdk.PageMetadata, domainID string, token string) (sdk.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 sdk.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, sdk.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 sdk.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 sdk.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 sdk.Connection
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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
}

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

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

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

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

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

func (_c *SDK_CreateBootstrapProfile_Call) Run(run func(ctx context.Context, profile sdk.BootstrapProfile, domainID string, token string)) *SDK_CreateBootstrapProfile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk.BootstrapProfile
		if args[1] != nil {
			arg1 = args[1].(sdk.BootstrapProfile)
		}
		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_CreateBootstrapProfile_Call) Return(bootstrapProfile sdk.BootstrapProfile, sDKError errors.SDKError) *SDK_CreateBootstrapProfile_Call {
	_c.Call.Return(bootstrapProfile, sDKError)
	return _c
}

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

// CreateCSR provides a mock function for the type SDK
func (_mock *SDK) CreateCSR(ctx context.Context, metadata sdk.CSRMetadata, privKey any) (sdk.CSR, errors.SDKError) {
	ret := _mock.Called(ctx, metadata, privKey)

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

	var r0 sdk.CSR
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.CSRMetadata, any) (sdk.CSR, errors.SDKError)); ok {
		return returnFunc(ctx, metadata, privKey)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.CSRMetadata, any) sdk.CSR); ok {
		r0 = returnFunc(ctx, metadata, privKey)
	} else {
		r0 = ret.Get(0).(sdk.CSR)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.CSRMetadata, any) errors.SDKError); ok {
		r1 = returnFunc(ctx, metadata, privKey)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

// CreateCSR is a helper method to define mock.On call
//   - ctx context.Context
//   - metadata sdk.CSRMetadata
//   - privKey any
func (_e *SDK_Expecter) CreateCSR(ctx interface{}, metadata interface{}, privKey interface{}) *SDK_CreateCSR_Call {
	return &SDK_CreateCSR_Call{Call: _e.mock.On("CreateCSR", ctx, metadata, privKey)}
}

func (_c *SDK_CreateCSR_Call) Run(run func(ctx context.Context, metadata sdk.CSRMetadata, privKey any)) *SDK_CreateCSR_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk.CSRMetadata
		if args[1] != nil {
			arg1 = args[1].(sdk.CSRMetadata)
		}
		var arg2 any
		if args[2] != nil {
			arg2 = args[2].(any)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *SDK_CreateCSR_Call) Return(cSR sdk.CSR, sDKError errors.SDKError) *SDK_CreateCSR_Call {
	_c.Call.Return(cSR, sDKError)
	return _c
}

func (_c *SDK_CreateCSR_Call) RunAndReturn(run func(ctx context.Context, metadata sdk.CSRMetadata, privKey any) (sdk.CSR, errors.SDKError)) *SDK_CreateCSR_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	var r0 sdk.Channel
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Channel, string, string) (sdk.Channel, errors.SDKError)); ok {
		return returnFunc(ctx, channel, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Channel, string, string) sdk.Channel); ok {
		r0 = returnFunc(ctx, channel, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.Channel)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 sdk.Channel
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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 sdk.Channel, domainID string, token string) (sdk.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 []sdk.Channel, domainID string, token string) ([]sdk.Channel, errors.SDKError) {
	ret := _mock.Called(ctx, channels, domainID, token)

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

	var r0 []sdk.Channel
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, []sdk.Channel, string, string) ([]sdk.Channel, errors.SDKError)); ok {
		return returnFunc(ctx, channels, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []sdk.Channel, string, string) []sdk.Channel); ok {
		r0 = returnFunc(ctx, channels, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]sdk.Channel)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []sdk.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 []sdk.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 []sdk.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 []sdk.Channel
		if args[1] != nil {
			arg1 = args[1].([]sdk.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 []sdk.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 []sdk.Channel, domainID string, token string) ([]sdk.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 sdk.Client, domainID string, token string) (sdk.Client, errors.SDKError) {
	ret := _mock.Called(ctx, client, domainID, token)

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

	var r0 sdk.Client
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Client, string, string) (sdk.Client, errors.SDKError)); ok {
		return returnFunc(ctx, client, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Client, string, string) sdk.Client); ok {
		r0 = returnFunc(ctx, client, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.Client)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 sdk.Client
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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 sdk.Client, domainID string, token string) (sdk.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 sdk.RoleReq, token string) (sdk.Role, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, rq, token)

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

	var r0 sdk.Role
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk.RoleReq, string) (sdk.Role, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, rq, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk.RoleReq, string) sdk.Role); ok {
		r0 = returnFunc(ctx, id, domainID, rq, token)
	} else {
		r0 = ret.Get(0).(sdk.Role)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, sdk.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 sdk.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 sdk.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 sdk.RoleReq
		if args[3] != nil {
			arg3 = args[3].(sdk.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 sdk.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 sdk.RoleReq, token string) (sdk.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 []sdk.Client, domainID string, token string) ([]sdk.Client, errors.SDKError) {
	ret := _mock.Called(ctx, client, domainID, token)

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

	var r0 []sdk.Client
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, []sdk.Client, string, string) ([]sdk.Client, errors.SDKError)); ok {
		return returnFunc(ctx, client, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []sdk.Client, string, string) []sdk.Client); ok {
		r0 = returnFunc(ctx, client, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]sdk.Client)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []sdk.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 []sdk.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 []sdk.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 []sdk.Client
		if args[1] != nil {
			arg1 = args[1].([]sdk.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 []sdk.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 []sdk.Client, domainID string, token string) ([]sdk.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 sdk.Domain, token string) (sdk.Domain, errors.SDKError) {
	ret := _mock.Called(ctx, d, token)

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

	var r0 sdk.Domain
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Domain, string) (sdk.Domain, errors.SDKError)); ok {
		return returnFunc(ctx, d, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Domain, string) sdk.Domain); ok {
		r0 = returnFunc(ctx, d, token)
	} else {
		r0 = ret.Get(0).(sdk.Domain)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 sdk.Domain
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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 sdk.Domain, token string) (sdk.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 sdk.RoleReq, token string) (sdk.Role, errors.SDKError) {
	ret := _mock.Called(ctx, id, rq, token)

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

	var r0 sdk.Role
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, sdk.RoleReq, string) (sdk.Role, errors.SDKError)); ok {
		return returnFunc(ctx, id, rq, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, sdk.RoleReq, string) sdk.Role); ok {
		r0 = returnFunc(ctx, id, rq, token)
	} else {
		r0 = ret.Get(0).(sdk.Role)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, sdk.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 sdk.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 sdk.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 sdk.RoleReq
		if args[2] != nil {
			arg2 = args[2].(sdk.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 sdk.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 sdk.RoleReq, token string) (sdk.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 sdk.Group, domainID string, token string) (sdk.Group, errors.SDKError) {
	ret := _mock.Called(ctx, group, domainID, token)

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

	var r0 sdk.Group
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Group, string, string) (sdk.Group, errors.SDKError)); ok {
		return returnFunc(ctx, group, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Group, string, string) sdk.Group); ok {
		r0 = returnFunc(ctx, group, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.Group)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 sdk.Group
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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 sdk.Group, domainID string, token string) (sdk.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 sdk.RoleReq, token string) (sdk.Role, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, rq, token)

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

	var r0 sdk.Role
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk.RoleReq, string) (sdk.Role, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, rq, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk.RoleReq, string) sdk.Role); ok {
		r0 = returnFunc(ctx, id, domainID, rq, token)
	} else {
		r0 = ret.Get(0).(sdk.Role)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, sdk.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 sdk.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 sdk.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 sdk.RoleReq
		if args[3] != nil {
			arg3 = args[3].(sdk.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 sdk.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 sdk.RoleReq, token string) (sdk.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 sdk.Login) (sdk.Token, errors.SDKError) {
	ret := _mock.Called(ctx, lt)

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

	var r0 sdk.Token
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Login) (sdk.Token, errors.SDKError)); ok {
		return returnFunc(ctx, lt)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Login) sdk.Token); ok {
		r0 = returnFunc(ctx, lt)
	} else {
		r0 = ret.Get(0).(sdk.Token)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 sdk.Login
		if args[1] != nil {
			arg1 = args[1].(sdk.Login)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *SDK_CreateToken_Call) Return(token sdk.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 sdk.Login) (sdk.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 sdk.User, token string) (sdk.User, errors.SDKError) {
	ret := _mock.Called(ctx, user, token)

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

	var r0 sdk.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.User, string) (sdk.User, errors.SDKError)); ok {
		return returnFunc(ctx, user, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.User, string) sdk.User); ok {
		r0 = returnFunc(ctx, user, token)
	} else {
		r0 = ret.Get(0).(sdk.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 sdk.User
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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 sdk.User, token string) (sdk.User, errors.SDKError)) *SDK_CreateUser_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteAlarm provides a mock function for the type SDK
func (_mock *SDK) DeleteAlarm(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 DeleteAlarm")
	}

	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_DeleteAlarm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAlarm'
type SDK_DeleteAlarm_Call struct {
	*mock.Call
}

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

func (_c *SDK_DeleteAlarm_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_DeleteAlarm_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_DeleteAlarm_Call) Return(sDKError errors.SDKError) *SDK_DeleteAlarm_Call {
	_c.Call.Return(sDKError)
	return _c
}

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

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

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

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

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

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

func (_c *SDK_DeleteCert_Call) Run(run func(ctx context.Context, entityID string, domainID string, token string)) *SDK_DeleteCert_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_DeleteCert_Call) Return(sDKError errors.SDKError) *SDK_DeleteCert_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_DeleteCert_Call) RunAndReturn(run func(ctx context.Context, entityID string, domainID string, token string) errors.SDKError) *SDK_DeleteCert_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
}

// DeleteReportTemplate provides a mock function for the type SDK
func (_mock *SDK) DeleteReportTemplate(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 DeleteReportTemplate")
	}

	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_DeleteReportTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteReportTemplate'
type SDK_DeleteReportTemplate_Call struct {
	*mock.Call
}

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

func (_c *SDK_DeleteReportTemplate_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_DeleteReportTemplate_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_DeleteReportTemplate_Call) Return(sDKError errors.SDKError) *SDK_DeleteReportTemplate_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_DeleteReportTemplate_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) errors.SDKError) *SDK_DeleteReportTemplate_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) (sdk.Channel, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 sdk.Channel
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.Channel, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.Channel); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.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) (sdk.Client, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 sdk.Client
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.Client, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.Client); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.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) (sdk.Group, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 sdk.Group
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.Group, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.Group); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.Group, errors.SDKError)) *SDK_DisableGroup_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	var r0 sdk.ReportConfig
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.ReportConfig, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.ReportConfig); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.ReportConfig)
	}
	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_DisableReportConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableReportConfig'
type SDK_DisableReportConfig_Call struct {
	*mock.Call
}

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

func (_c *SDK_DisableReportConfig_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_DisableReportConfig_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_DisableReportConfig_Call) Return(reportConfig sdk.ReportConfig, sDKError errors.SDKError) *SDK_DisableReportConfig_Call {
	_c.Call.Return(reportConfig, sDKError)
	return _c
}

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

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

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

	var r0 sdk.Rule
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.Rule, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.Rule); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.Rule)
	}
	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_DisableRule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableRule'
type SDK_DisableRule_Call struct {
	*mock.Call
}

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

func (_c *SDK_DisableRule_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_DisableRule_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_DisableRule_Call) Return(rule sdk.Rule, sDKError errors.SDKError) *SDK_DisableRule_Call {
	_c.Call.Return(rule, sDKError)
	return _c
}

func (_c *SDK_DisableRule_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) (sdk.Rule, errors.SDKError)) *SDK_DisableRule_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) (sdk.User, errors.SDKError) {
	ret := _mock.Called(ctx, id, token)

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

	var r0 sdk.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (sdk.User, errors.SDKError)); ok {
		return returnFunc(ctx, id, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) sdk.User); ok {
		r0 = returnFunc(ctx, id, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.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 sdk.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, sdk.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 sdk.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 sdk.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 sdk.Connection
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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) (sdk.Domain, errors.SDKError) {
	ret := _mock.Called(ctx, domainID, token)

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

	var r0 sdk.Domain
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (sdk.Domain, errors.SDKError)); ok {
		return returnFunc(ctx, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) sdk.Domain); ok {
		r0 = returnFunc(ctx, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.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 sdk.PageMetadata, token string, domainID string) (sdk.InvitationPage, error) {
	ret := _mock.Called(ctx, pm, token, domainID)

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

	var r0 sdk.InvitationPage
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string, string) (sdk.InvitationPage, error)); ok {
		return returnFunc(ctx, pm, token, domainID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string, string) sdk.InvitationPage); ok {
		r0 = returnFunc(ctx, pm, token, domainID)
	} else {
		r0 = ret.Get(0).(sdk.InvitationPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 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_DomainInvitations_Call) Return(invitations sdk.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 sdk.PageMetadata, token string, domainID string) (sdk.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) (sdk.Role, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, token)

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

	var r0 sdk.Role
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.Role, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.Role); ok {
		r0 = returnFunc(ctx, id, roleID, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.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 sdk.PageMetadata, token string) (sdk.RoleMembersPage, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, pm, token)

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

	var r0 sdk.RoleMembersPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk.PageMetadata, string) (sdk.RoleMembersPage, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk.PageMetadata, string) sdk.RoleMembersPage); ok {
		r0 = returnFunc(ctx, id, roleID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk.RoleMembersPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, sdk.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 sdk.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 sdk.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 sdk.PageMetadata
		if args[3] != nil {
			arg3 = args[3].(sdk.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 sdk.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 sdk.PageMetadata, token string) (sdk.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 sdk.PageMetadata, token string) (sdk.RolesPage, errors.SDKError) {
	ret := _mock.Called(ctx, id, pm, token)

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

	var r0 sdk.RolesPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, sdk.PageMetadata, string) (sdk.RolesPage, errors.SDKError)); ok {
		return returnFunc(ctx, id, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, sdk.PageMetadata, string) sdk.RolesPage); ok {
		r0 = returnFunc(ctx, id, pm, token)
	} else {
		r0 = ret.Get(0).(sdk.RolesPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, sdk.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 sdk.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 sdk.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 sdk.PageMetadata
		if args[2] != nil {
			arg2 = args[2].(sdk.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 sdk.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 sdk.PageMetadata, token string) (sdk.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 sdk.PageMetadata, token string) (sdk.DomainsPage, errors.SDKError) {
	ret := _mock.Called(ctx, pm, token)

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

	var r0 sdk.DomainsPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string) (sdk.DomainsPage, errors.SDKError)); ok {
		return returnFunc(ctx, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string) sdk.DomainsPage); ok {
		r0 = returnFunc(ctx, pm, token)
	} else {
		r0 = ret.Get(0).(sdk.DomainsPage)
	}
	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_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 sdk.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 sdk.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 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_Domains_Call) Return(domainsPage sdk.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 sdk.PageMetadata, token string) (sdk.DomainsPage, errors.SDKError)) *SDK_Domains_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

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

func (_c *SDK_DownloadCA_Call) Return(certificateBundle sdk.CertificateBundle, sDKError errors.SDKError) *SDK_DownloadCA_Call {
	_c.Call.Return(certificateBundle, sDKError)
	return _c
}

func (_c *SDK_DownloadCA_Call) RunAndReturn(run func(ctx context.Context) (sdk.CertificateBundle, errors.SDKError)) *SDK_DownloadCA_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) (sdk.Channel, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 sdk.Channel
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.Channel, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.Channel); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.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) (sdk.Client, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 sdk.Client
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.Client, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.Client); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.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) (sdk.Group, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 sdk.Group
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.Group, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.Group); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.Group, errors.SDKError)) *SDK_EnableGroup_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	var r0 sdk.ReportConfig
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.ReportConfig, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.ReportConfig); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.ReportConfig)
	}
	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_EnableReportConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableReportConfig'
type SDK_EnableReportConfig_Call struct {
	*mock.Call
}

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

func (_c *SDK_EnableReportConfig_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_EnableReportConfig_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_EnableReportConfig_Call) Return(reportConfig sdk.ReportConfig, sDKError errors.SDKError) *SDK_EnableReportConfig_Call {
	_c.Call.Return(reportConfig, sDKError)
	return _c
}

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

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

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

	var r0 sdk.Rule
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.Rule, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.Rule); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.Rule)
	}
	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_EnableRule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableRule'
type SDK_EnableRule_Call struct {
	*mock.Call
}

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

func (_c *SDK_EnableRule_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_EnableRule_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_EnableRule_Call) Return(rule sdk.Rule, sDKError errors.SDKError) *SDK_EnableRule_Call {
	_c.Call.Return(rule, sDKError)
	return _c
}

func (_c *SDK_EnableRule_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) (sdk.Rule, errors.SDKError)) *SDK_EnableRule_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) (sdk.User, errors.SDKError) {
	ret := _mock.Called(ctx, id, token)

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

	var r0 sdk.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (sdk.User, errors.SDKError)); ok {
		return returnFunc(ctx, id, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) sdk.User); ok {
		r0 = returnFunc(ctx, id, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.User, errors.SDKError)) *SDK_EnableUser_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	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, serialNumber, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) string); ok {
		r0 = returnFunc(ctx, serialNumber, domainID, 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, serialNumber, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(errors.SDKError)
		}
	}
	return r0, r1
}

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

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

func (_c *SDK_EntityID_Call) Run(run func(ctx context.Context, serialNumber string, domainID string, token string)) *SDK_EntityID_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_EntityID_Call) Return(s string, sDKError errors.SDKError) *SDK_EntityID_Call {
	_c.Call.Return(s, sDKError)
	return _c
}

func (_c *SDK_EntityID_Call) RunAndReturn(run func(ctx context.Context, serialNumber string, domainID string, token string) (string, errors.SDKError)) *SDK_EntityID_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
}

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

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

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

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

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

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

func (_c *SDK_GenerateCRL_Call) Return(bytes []byte, sDKError errors.SDKError) *SDK_GenerateCRL_Call {
	_c.Call.Return(bytes, sDKError)
	return _c
}

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

// GenerateReport provides a mock function for the type SDK
func (_mock *SDK) GenerateReport(ctx context.Context, config sdk.ReportConfig, action sdk.ReportAction, domainID string, token string) (sdk.ReportPage, *sdk.ReportFile, errors.SDKError) {
	ret := _mock.Called(ctx, config, action, domainID, token)

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

	var r0 sdk.ReportPage
	var r1 *sdk.ReportFile
	var r2 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.ReportConfig, sdk.ReportAction, string, string) (sdk.ReportPage, *sdk.ReportFile, errors.SDKError)); ok {
		return returnFunc(ctx, config, action, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.ReportConfig, sdk.ReportAction, string, string) sdk.ReportPage); ok {
		r0 = returnFunc(ctx, config, action, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.ReportPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.ReportConfig, sdk.ReportAction, string, string) *sdk.ReportFile); ok {
		r1 = returnFunc(ctx, config, action, domainID, token)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*sdk.ReportFile)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, sdk.ReportConfig, sdk.ReportAction, string, string) errors.SDKError); ok {
		r2 = returnFunc(ctx, config, action, domainID, token)
	} else {
		if ret.Get(2) != nil {
			r2 = ret.Get(2).(errors.SDKError)
		}
	}
	return r0, r1, r2
}

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

// GenerateReport is a helper method to define mock.On call
//   - ctx context.Context
//   - config sdk.ReportConfig
//   - action sdk.ReportAction
//   - domainID string
//   - token string
func (_e *SDK_Expecter) GenerateReport(ctx interface{}, config interface{}, action interface{}, domainID interface{}, token interface{}) *SDK_GenerateReport_Call {
	return &SDK_GenerateReport_Call{Call: _e.mock.On("GenerateReport", ctx, config, action, domainID, token)}
}

func (_c *SDK_GenerateReport_Call) Run(run func(ctx context.Context, config sdk.ReportConfig, action sdk.ReportAction, domainID string, token string)) *SDK_GenerateReport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk.ReportConfig
		if args[1] != nil {
			arg1 = args[1].(sdk.ReportConfig)
		}
		var arg2 sdk.ReportAction
		if args[2] != nil {
			arg2 = args[2].(sdk.ReportAction)
		}
		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_GenerateReport_Call) Return(reportPage sdk.ReportPage, reportFile *sdk.ReportFile, sDKError errors.SDKError) *SDK_GenerateReport_Call {
	_c.Call.Return(reportPage, reportFile, sDKError)
	return _c
}

func (_c *SDK_GenerateReport_Call) RunAndReturn(run func(ctx context.Context, config sdk.ReportConfig, action sdk.ReportAction, domainID string, token string) (sdk.ReportPage, *sdk.ReportFile, errors.SDKError)) *SDK_GenerateReport_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) (sdk.Group, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, token)

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

	var r0 sdk.Group
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.Group, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.Group); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.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) (sdk.Role, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, domainID, token)

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

	var r0 sdk.Role
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (sdk.Role, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) sdk.Role); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.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 sdk.PageMetadata, token string) (sdk.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 sdk.RoleMembersPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, sdk.PageMetadata, string) (sdk.RoleMembersPage, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, sdk.PageMetadata, string) sdk.RoleMembersPage); ok {
		r0 = returnFunc(ctx, id, roleID, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk.RoleMembersPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, sdk.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 sdk.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 sdk.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 sdk.PageMetadata
		if args[4] != nil {
			arg4 = args[4].(sdk.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 sdk.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 sdk.PageMetadata, token string) (sdk.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 sdk.PageMetadata, token string) (sdk.RolesPage, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, pm, token)

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

	var r0 sdk.RolesPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk.PageMetadata, string) (sdk.RolesPage, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk.PageMetadata, string) sdk.RolesPage); ok {
		r0 = returnFunc(ctx, id, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk.RolesPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, sdk.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 sdk.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 sdk.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 sdk.PageMetadata
		if args[3] != nil {
			arg3 = args[3].(sdk.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 sdk.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 sdk.PageMetadata, token string) (sdk.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 sdk.PageMetadata, domainID string, token string) (sdk.GroupsPage, errors.SDKError) {
	ret := _mock.Called(ctx, pm, domainID, token)

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

	var r0 sdk.GroupsPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string, string) (sdk.GroupsPage, errors.SDKError)); ok {
		return returnFunc(ctx, pm, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string, string) sdk.GroupsPage); ok {
		r0 = returnFunc(ctx, pm, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.GroupsPage)
	}
	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_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 sdk.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 sdk.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 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_Groups_Call) Return(groupsPage sdk.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 sdk.PageMetadata, domainID string, token string) (sdk.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) (sdk.HealthInfo, errors.SDKError) {
	ret := _mock.Called(service)

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

	var r0 sdk.HealthInfo
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(string) (sdk.HealthInfo, errors.SDKError)); ok {
		return returnFunc(service)
	}
	if returnFunc, ok := ret.Get(0).(func(string) sdk.HealthInfo); ok {
		r0 = returnFunc(service)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.HealthInfo, sDKError errors.SDKError) *SDK_Health_Call {
	_c.Call.Return(healthInfo, sDKError)
	return _c
}

func (_c *SDK_Health_Call) RunAndReturn(run func(service string) (sdk.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 sdk.PageMetadata, token string) (sdk.GroupsHierarchyPage, errors.SDKError) {
	ret := _mock.Called(ctx, id, domainID, pm, token)

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

	var r0 sdk.GroupsHierarchyPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk.PageMetadata, string) (sdk.GroupsHierarchyPage, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk.PageMetadata, string) sdk.GroupsHierarchyPage); ok {
		r0 = returnFunc(ctx, id, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk.GroupsHierarchyPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, sdk.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 sdk.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 sdk.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 sdk.PageMetadata
		if args[3] != nil {
			arg3 = args[3].(sdk.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 sdk.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 sdk.PageMetadata, token string) (sdk.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 sdk.PageMetadata, token string) (sdk.InvitationPage, error) {
	ret := _mock.Called(ctx, pm, token)

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

	var r0 sdk.InvitationPage
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string) (sdk.InvitationPage, error)); ok {
		return returnFunc(ctx, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string) sdk.InvitationPage); ok {
		r0 = returnFunc(ctx, pm, token)
	} else {
		r0 = ret.Get(0).(sdk.InvitationPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 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_Invitations_Call) Return(invitations sdk.InvitationPage, err error) *SDK_Invitations_Call {
	_c.Call.Return(invitations, err)
	return _c
}

func (_c *SDK_Invitations_Call) RunAndReturn(run func(ctx context.Context, pm sdk.PageMetadata, token string) (sdk.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, entityID string, ttl string, ipAddrs []string, opts sdk.Options, domainID string, token string) (sdk.Certificate, errors.SDKError) {
	ret := _mock.Called(ctx, entityID, ttl, ipAddrs, opts, domainID, token)

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

	var r0 sdk.Certificate
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string, sdk.Options, string, string) (sdk.Certificate, errors.SDKError)); ok {
		return returnFunc(ctx, entityID, ttl, ipAddrs, opts, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, []string, sdk.Options, string, string) sdk.Certificate); ok {
		r0 = returnFunc(ctx, entityID, ttl, ipAddrs, opts, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.Certificate)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, []string, sdk.Options, string, string) errors.SDKError); ok {
		r1 = returnFunc(ctx, entityID, ttl, ipAddrs, opts, 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
//   - entityID string
//   - ttl string
//   - ipAddrs []string
//   - opts sdk.Options
//   - domainID string
//   - token string
func (_e *SDK_Expecter) IssueCert(ctx interface{}, entityID interface{}, ttl interface{}, ipAddrs interface{}, opts interface{}, domainID interface{}, token interface{}) *SDK_IssueCert_Call {
	return &SDK_IssueCert_Call{Call: _e.mock.On("IssueCert", ctx, entityID, ttl, ipAddrs, opts, domainID, token)}
}

func (_c *SDK_IssueCert_Call) Run(run func(ctx context.Context, entityID string, ttl string, ipAddrs []string, opts sdk.Options, 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 sdk.Options
		if args[4] != nil {
			arg4 = args[4].(sdk.Options)
		}
		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_IssueCert_Call) Return(certificate sdk.Certificate, sDKError errors.SDKError) *SDK_IssueCert_Call {
	_c.Call.Return(certificate, sDKError)
	return _c
}

func (_c *SDK_IssueCert_Call) RunAndReturn(run func(ctx context.Context, entityID string, ttl string, ipAddrs []string, opts sdk.Options, domainID string, token string) (sdk.Certificate, errors.SDKError)) *SDK_IssueCert_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

func (_c *SDK_IssueFromCSR_Call) Run(run func(ctx context.Context, entityID string, ttl string, csr string, domainID string, token string)) *SDK_IssueFromCSR_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_IssueFromCSR_Call) Return(certificate sdk.Certificate, sDKError errors.SDKError) *SDK_IssueFromCSR_Call {
	_c.Call.Return(certificate, sDKError)
	return _c
}

func (_c *SDK_IssueFromCSR_Call) RunAndReturn(run func(ctx context.Context, entityID string, ttl string, csr string, domainID string, token string) (sdk.Certificate, errors.SDKError)) *SDK_IssueFromCSR_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

func (_c *SDK_IssueFromCSRInternal_Call) Run(run func(ctx context.Context, entityID string, ttl string, csr string, token string)) *SDK_IssueFromCSRInternal_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_IssueFromCSRInternal_Call) Return(certificate sdk.Certificate, sDKError errors.SDKError) *SDK_IssueFromCSRInternal_Call {
	_c.Call.Return(certificate, sDKError)
	return _c
}

func (_c *SDK_IssueFromCSRInternal_Call) RunAndReturn(run func(ctx context.Context, entityID string, ttl string, csr string, token string) (sdk.Certificate, errors.SDKError)) *SDK_IssueFromCSRInternal_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 sdk.PageMetadata, token string) (sdk.JournalsPage, error) {
	ret := _mock.Called(ctx, entityType, entityID, domainID, pm, token)

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

	var r0 sdk.JournalsPage
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, sdk.PageMetadata, string) (sdk.JournalsPage, error)); ok {
		return returnFunc(ctx, entityType, entityID, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, sdk.PageMetadata, string) sdk.JournalsPage); ok {
		r0 = returnFunc(ctx, entityType, entityID, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk.JournalsPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, sdk.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 sdk.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 sdk.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 sdk.PageMetadata
		if args[4] != nil {
			arg4 = args[4].(sdk.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 sdk.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 sdk.PageMetadata, token string) (sdk.JournalsPage, error)) *SDK_Journal_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	var r0 sdk.AlarmsPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string, string) (sdk.AlarmsPage, errors.SDKError)); ok {
		return returnFunc(ctx, pm, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string, string) sdk.AlarmsPage); ok {
		r0 = returnFunc(ctx, pm, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.AlarmsPage)
	}
	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_ListAlarms_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAlarms'
type SDK_ListAlarms_Call struct {
	*mock.Call
}

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

func (_c *SDK_ListAlarms_Call) Run(run func(ctx context.Context, pm sdk.PageMetadata, domainID string, token string)) *SDK_ListAlarms_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_ListAlarms_Call) Return(alarmsPage sdk.AlarmsPage, sDKError errors.SDKError) *SDK_ListAlarms_Call {
	_c.Call.Return(alarmsPage, sDKError)
	return _c
}

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

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

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

	var r0 sdk.CertificatePage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string, string) (sdk.CertificatePage, errors.SDKError)); ok {
		return returnFunc(ctx, pm, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string, string) sdk.CertificatePage); ok {
		r0 = returnFunc(ctx, pm, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.CertificatePage)
	}
	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_ListCerts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCerts'
type SDK_ListCerts_Call struct {
	*mock.Call
}

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

func (_c *SDK_ListCerts_Call) Run(run func(ctx context.Context, pm sdk.PageMetadata, domainID string, token string)) *SDK_ListCerts_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_ListCerts_Call) Return(certificatePage sdk.CertificatePage, sDKError errors.SDKError) *SDK_ListCerts_Call {
	_c.Call.Return(certificatePage, sDKError)
	return _c
}

func (_c *SDK_ListCerts_Call) RunAndReturn(run func(ctx context.Context, pm sdk.PageMetadata, domainID string, token string) (sdk.CertificatePage, errors.SDKError)) *SDK_ListCerts_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 sdk.PageMetadata, token string) (sdk.EntityMembersPage, errors.SDKError) {
	ret := _mock.Called(ctx, channelID, domainID, pm, token)

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

	var r0 sdk.EntityMembersPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk.PageMetadata, string) (sdk.EntityMembersPage, errors.SDKError)); ok {
		return returnFunc(ctx, channelID, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk.PageMetadata, string) sdk.EntityMembersPage); ok {
		r0 = returnFunc(ctx, channelID, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk.EntityMembersPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, sdk.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 sdk.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 sdk.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 sdk.PageMetadata
		if args[3] != nil {
			arg3 = args[3].(sdk.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 sdk.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 sdk.PageMetadata, token string) (sdk.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 sdk.PageMetadata, token string) (sdk.EntityMembersPage, errors.SDKError) {
	ret := _mock.Called(ctx, clientID, domainID, pm, token)

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

	var r0 sdk.EntityMembersPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk.PageMetadata, string) (sdk.EntityMembersPage, errors.SDKError)); ok {
		return returnFunc(ctx, clientID, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk.PageMetadata, string) sdk.EntityMembersPage); ok {
		r0 = returnFunc(ctx, clientID, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk.EntityMembersPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, sdk.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 sdk.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 sdk.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 sdk.PageMetadata
		if args[3] != nil {
			arg3 = args[3].(sdk.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 sdk.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 sdk.PageMetadata, token string) (sdk.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 sdk.PageMetadata, token string) (sdk.EntityMembersPage, errors.SDKError) {
	ret := _mock.Called(ctx, domainID, pm, token)

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

	var r0 sdk.EntityMembersPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, sdk.PageMetadata, string) (sdk.EntityMembersPage, errors.SDKError)); ok {
		return returnFunc(ctx, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, sdk.PageMetadata, string) sdk.EntityMembersPage); ok {
		r0 = returnFunc(ctx, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk.EntityMembersPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, sdk.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 sdk.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 sdk.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 sdk.PageMetadata
		if args[2] != nil {
			arg2 = args[2].(sdk.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 sdk.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 sdk.PageMetadata, token string) (sdk.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 sdk.PageMetadata, token string) (sdk.EntityMembersPage, errors.SDKError) {
	ret := _mock.Called(ctx, groupID, domainID, pm, token)

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

	var r0 sdk.EntityMembersPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk.PageMetadata, string) (sdk.EntityMembersPage, errors.SDKError)); ok {
		return returnFunc(ctx, groupID, domainID, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, sdk.PageMetadata, string) sdk.EntityMembersPage); ok {
		r0 = returnFunc(ctx, groupID, domainID, pm, token)
	} else {
		r0 = ret.Get(0).(sdk.EntityMembersPage)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, sdk.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 sdk.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 sdk.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 sdk.PageMetadata
		if args[3] != nil {
			arg3 = args[3].(sdk.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 sdk.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 sdk.PageMetadata, token string) (sdk.EntityMembersPage, errors.SDKError)) *SDK_ListGroupMembers_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	var r0 sdk.ReportConfigPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string, string) (sdk.ReportConfigPage, errors.SDKError)); ok {
		return returnFunc(ctx, pm, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string, string) sdk.ReportConfigPage); ok {
		r0 = returnFunc(ctx, pm, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.ReportConfigPage)
	}
	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_ListReportsConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListReportsConfig'
type SDK_ListReportsConfig_Call struct {
	*mock.Call
}

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

func (_c *SDK_ListReportsConfig_Call) Run(run func(ctx context.Context, pm sdk.PageMetadata, domainID string, token string)) *SDK_ListReportsConfig_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_ListReportsConfig_Call) Return(reportConfigPage sdk.ReportConfigPage, sDKError errors.SDKError) *SDK_ListReportsConfig_Call {
	_c.Call.Return(reportConfigPage, sDKError)
	return _c
}

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

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

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

	var r0 sdk.Page
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string, string) (sdk.Page, errors.SDKError)); ok {
		return returnFunc(ctx, pm, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string, string) sdk.Page); ok {
		r0 = returnFunc(ctx, pm, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.Page)
	}
	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_ListRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRules'
type SDK_ListRules_Call struct {
	*mock.Call
}

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

func (_c *SDK_ListRules_Call) Run(run func(ctx context.Context, pm sdk.PageMetadata, domainID string, token string)) *SDK_ListRules_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_ListRules_Call) Return(page sdk.Page, sDKError errors.SDKError) *SDK_ListRules_Call {
	_c.Call.Return(page, sDKError)
	return _c
}

func (_c *SDK_ListRules_Call) RunAndReturn(run func(ctx context.Context, pm sdk.PageMetadata, domainID string, token string) (sdk.Page, errors.SDKError)) *SDK_ListRules_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
}

// OCSP provides a mock function for the type SDK
func (_mock *SDK) OCSP(ctx context.Context, serialNumber string, cert string) (sdk.OCSPResponse, errors.SDKError) {
	ret := _mock.Called(ctx, serialNumber, cert)

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

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

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

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

func (_c *SDK_OCSP_Call) Run(run func(ctx context.Context, serialNumber string, cert string)) *SDK_OCSP_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_OCSP_Call) Return(oCSPResponse sdk.OCSPResponse, sDKError errors.SDKError) *SDK_OCSP_Call {
	_c.Call.Return(oCSPResponse, sDKError)
	return _c
}

func (_c *SDK_OCSP_Call) RunAndReturn(run func(ctx context.Context, serialNumber string, cert string) (sdk.OCSPResponse, errors.SDKError)) *SDK_OCSP_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
}

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

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

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

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

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

func (_c *SDK_RefreshBootstrapBindings_Call) Run(run func(ctx context.Context, configID string, domainID string, token string)) *SDK_RefreshBootstrapBindings_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_RefreshBootstrapBindings_Call) Return(sDKError errors.SDKError) *SDK_RefreshBootstrapBindings_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RefreshBootstrapBindings_Call) RunAndReturn(run func(ctx context.Context, configID string, domainID string, token string) errors.SDKError) *SDK_RefreshBootstrapBindings_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) (sdk.Token, errors.SDKError) {
	ret := _mock.Called(ctx, token)

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

	var r0 sdk.Token
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (sdk.Token, errors.SDKError)); ok {
		return returnFunc(ctx, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) sdk.Token); ok {
		r0 = returnFunc(ctx, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.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
}

// RemoveBootstrapProfile provides a mock function for the type SDK
func (_mock *SDK) RemoveBootstrapProfile(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 RemoveBootstrapProfile")
	}

	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_RemoveBootstrapProfile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveBootstrapProfile'
type SDK_RemoveBootstrapProfile_Call struct {
	*mock.Call
}

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

func (_c *SDK_RemoveBootstrapProfile_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_RemoveBootstrapProfile_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_RemoveBootstrapProfile_Call) Return(sDKError errors.SDKError) *SDK_RemoveBootstrapProfile_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RemoveBootstrapProfile_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) errors.SDKError) *SDK_RemoveBootstrapProfile_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
}

// RemoveReportConfig provides a mock function for the type SDK
func (_mock *SDK) RemoveReportConfig(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 RemoveReportConfig")
	}

	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_RemoveReportConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveReportConfig'
type SDK_RemoveReportConfig_Call struct {
	*mock.Call
}

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

func (_c *SDK_RemoveReportConfig_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_RemoveReportConfig_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_RemoveReportConfig_Call) Return(sDKError errors.SDKError) *SDK_RemoveReportConfig_Call {
	_c.Call.Return(sDKError)
	return _c
}

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

// RemoveRule provides a mock function for the type SDK
func (_mock *SDK) RemoveRule(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 RemoveRule")
	}

	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_RemoveRule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRule'
type SDK_RemoveRule_Call struct {
	*mock.Call
}

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

func (_c *SDK_RemoveRule_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_RemoveRule_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_RemoveRule_Call) Return(sDKError errors.SDKError) *SDK_RemoveRule_Call {
	_c.Call.Return(sDKError)
	return _c
}

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

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

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

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

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

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

func (_c *SDK_RenewCert_Call) Run(run func(ctx context.Context, serialNumber string, domainID string, token string)) *SDK_RenewCert_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_RenewCert_Call) Return(certificate sdk.Certificate, sDKError errors.SDKError) *SDK_RenewCert_Call {
	_c.Call.Return(certificate, sDKError)
	return _c
}

func (_c *SDK_RenewCert_Call) RunAndReturn(run func(ctx context.Context, serialNumber string, domainID string, token string) (sdk.Certificate, errors.SDKError)) *SDK_RenewCert_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
}

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

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

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

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

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

func (_c *SDK_RevokeAll_Call) Run(run func(ctx context.Context, entityID string, domainID string, token string)) *SDK_RevokeAll_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_RevokeAll_Call) Return(sDKError errors.SDKError) *SDK_RevokeAll_Call {
	_c.Call.Return(sDKError)
	return _c
}

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

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

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

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

// 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
//   - serialNumber string
//   - domainID string
//   - token string
func (_e *SDK_Expecter) RevokeCert(ctx interface{}, serialNumber interface{}, domainID interface{}, token interface{}) *SDK_RevokeCert_Call {
	return &SDK_RevokeCert_Call{Call: _e.mock.On("RevokeCert", ctx, serialNumber, domainID, token)}
}

func (_c *SDK_RevokeCert_Call) Run(run func(ctx context.Context, serialNumber 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(sDKError errors.SDKError) *SDK_RevokeCert_Call {
	_c.Call.Return(sDKError)
	return _c
}

func (_c *SDK_RevokeCert_Call) RunAndReturn(run func(ctx context.Context, serialNumber string, domainID string, token string) 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 sdk.PageMetadata, token string) (sdk.UsersPage, errors.SDKError) {
	ret := _mock.Called(ctx, pm, token)

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

	var r0 sdk.UsersPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string) (sdk.UsersPage, errors.SDKError)); ok {
		return returnFunc(ctx, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string) sdk.UsersPage); ok {
		r0 = returnFunc(ctx, pm, token)
	} else {
		r0 = ret.Get(0).(sdk.UsersPage)
	}
	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_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 sdk.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 sdk.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 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_SearchUsers_Call) Return(usersPage sdk.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 sdk.PageMetadata, token string) (sdk.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 sdk.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, sdk.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 sdk.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 sdk.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 sdk.Invitation
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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 sdk.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(sdk.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 sdk.ContentType
func (_e *SDK_Expecter) SetContentType(ct interface{}) *SDK_SetContentType_Call {
	return &SDK_SetContentType_Call{Call: _e.mock.On("SetContentType", ct)}
}

func (_c *SDK_SetContentType_Call) Run(run func(ct sdk.ContentType)) *SDK_SetContentType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 sdk.ContentType
		if args[0] != nil {
			arg0 = args[0].(sdk.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 sdk.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
}

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

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

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

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

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

func (_c *SDK_UpdateAlarm_Call) Run(run func(ctx context.Context, alarm sdk.Alarm, domainID string, token string)) *SDK_UpdateAlarm_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk.Alarm
		if args[1] != nil {
			arg1 = args[1].(sdk.Alarm)
		}
		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_UpdateAlarm_Call) Return(alarm1 sdk.Alarm, sDKError errors.SDKError) *SDK_UpdateAlarm_Call {
	_c.Call.Return(alarm1, sDKError)
	return _c
}

func (_c *SDK_UpdateAlarm_Call) RunAndReturn(run func(ctx context.Context, alarm sdk.Alarm, domainID string, token string) (sdk.Alarm, errors.SDKError)) *SDK_UpdateAlarm_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
}

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

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

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

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

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

func (_c *SDK_UpdateBootstrapProfile_Call) Run(run func(ctx context.Context, profile sdk.BootstrapProfile, domainID string, token string)) *SDK_UpdateBootstrapProfile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk.BootstrapProfile
		if args[1] != nil {
			arg1 = args[1].(sdk.BootstrapProfile)
		}
		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_UpdateBootstrapProfile_Call) Return(bootstrapProfile sdk.BootstrapProfile, sDKError errors.SDKError) *SDK_UpdateBootstrapProfile_Call {
	_c.Call.Return(bootstrapProfile, sDKError)
	return _c
}

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

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

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

	var r0 sdk.Channel
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Channel, string, string) (sdk.Channel, errors.SDKError)); ok {
		return returnFunc(ctx, channel, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Channel, string, string) sdk.Channel); ok {
		r0 = returnFunc(ctx, channel, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.Channel)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 sdk.Channel
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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 sdk.Channel, domainID string, token string) (sdk.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 sdk.Channel, domainID string, token string) (sdk.Channel, errors.SDKError) {
	ret := _mock.Called(ctx, c, domainID, token)

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

	var r0 sdk.Channel
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Channel, string, string) (sdk.Channel, errors.SDKError)); ok {
		return returnFunc(ctx, c, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Channel, string, string) sdk.Channel); ok {
		r0 = returnFunc(ctx, c, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.Channel)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 sdk.Channel
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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 sdk.Channel, domainID string, token string) (sdk.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 sdk.Client, domainID string, token string) (sdk.Client, errors.SDKError) {
	ret := _mock.Called(ctx, client, domainID, token)

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

	var r0 sdk.Client
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Client, string, string) (sdk.Client, errors.SDKError)); ok {
		return returnFunc(ctx, client, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Client, string, string) sdk.Client); ok {
		r0 = returnFunc(ctx, client, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.Client)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 sdk.Client
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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 sdk.Client, domainID string, token string) (sdk.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) (sdk.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 sdk.Role
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string, string) (sdk.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) sdk.Role); ok {
		r0 = returnFunc(ctx, id, roleID, newName, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.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) (sdk.Client, errors.SDKError) {
	ret := _mock.Called(ctx, id, secret, domainID, token)

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

	var r0 sdk.Client
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (sdk.Client, errors.SDKError)); ok {
		return returnFunc(ctx, id, secret, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) sdk.Client); ok {
		r0 = returnFunc(ctx, id, secret, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.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 sdk.Client, domainID string, token string) (sdk.Client, errors.SDKError) {
	ret := _mock.Called(ctx, client, domainID, token)

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

	var r0 sdk.Client
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Client, string, string) (sdk.Client, errors.SDKError)); ok {
		return returnFunc(ctx, client, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Client, string, string) sdk.Client); ok {
		r0 = returnFunc(ctx, client, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.Client)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 sdk.Client
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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 sdk.Client, domainID string, token string) (sdk.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 sdk.Domain, token string) (sdk.Domain, errors.SDKError) {
	ret := _mock.Called(ctx, d, token)

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

	var r0 sdk.Domain
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Domain, string) (sdk.Domain, errors.SDKError)); ok {
		return returnFunc(ctx, d, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Domain, string) sdk.Domain); ok {
		r0 = returnFunc(ctx, d, token)
	} else {
		r0 = ret.Get(0).(sdk.Domain)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 sdk.Domain
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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 sdk.Domain, token string) (sdk.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) (sdk.Role, errors.SDKError) {
	ret := _mock.Called(ctx, id, roleID, newName, token)

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

	var r0 sdk.Role
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (sdk.Role, errors.SDKError)); ok {
		return returnFunc(ctx, id, roleID, newName, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) sdk.Role); ok {
		r0 = returnFunc(ctx, id, roleID, newName, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.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 sdk.Group, domainID string, token string) (sdk.Group, errors.SDKError) {
	ret := _mock.Called(ctx, group, domainID, token)

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

	var r0 sdk.Group
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Group, string, string) (sdk.Group, errors.SDKError)); ok {
		return returnFunc(ctx, group, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Group, string, string) sdk.Group); ok {
		r0 = returnFunc(ctx, group, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.Group)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 sdk.Group
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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 sdk.Group, domainID string, token string) (sdk.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) (sdk.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 sdk.Role
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string, string) (sdk.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) sdk.Role); ok {
		r0 = returnFunc(ctx, id, roleID, newName, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.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 sdk.Group, domainID string, token string) (sdk.Group, errors.SDKError) {
	ret := _mock.Called(ctx, group, domainID, token)

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

	var r0 sdk.Group
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Group, string, string) (sdk.Group, errors.SDKError)); ok {
		return returnFunc(ctx, group, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.Group, string, string) sdk.Group); ok {
		r0 = returnFunc(ctx, group, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.Group)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 sdk.Group
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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 sdk.Group, domainID string, token string) (sdk.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) (sdk.User, errors.SDKError) {
	ret := _mock.Called(ctx, oldPass, newPass, token)

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

	var r0 sdk.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.User, errors.SDKError)); ok {
		return returnFunc(ctx, oldPass, newPass, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.User); ok {
		r0 = returnFunc(ctx, oldPass, newPass, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.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 sdk.User, token string) (sdk.User, errors.SDKError) {
	ret := _mock.Called(ctx, user, token)

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

	var r0 sdk.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.User, string) (sdk.User, errors.SDKError)); ok {
		return returnFunc(ctx, user, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.User, string) sdk.User); ok {
		r0 = returnFunc(ctx, user, token)
	} else {
		r0 = ret.Get(0).(sdk.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 sdk.User
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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 sdk.User, token string) (sdk.User, errors.SDKError)) *SDK_UpdateProfilePicture_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	var r0 sdk.ReportConfig
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.ReportConfig, string, string) (sdk.ReportConfig, errors.SDKError)); ok {
		return returnFunc(ctx, cfg, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.ReportConfig, string, string) sdk.ReportConfig); ok {
		r0 = returnFunc(ctx, cfg, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.ReportConfig)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.ReportConfig, 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_UpdateReportConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateReportConfig'
type SDK_UpdateReportConfig_Call struct {
	*mock.Call
}

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

func (_c *SDK_UpdateReportConfig_Call) Run(run func(ctx context.Context, cfg sdk.ReportConfig, domainID string, token string)) *SDK_UpdateReportConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk.ReportConfig
		if args[1] != nil {
			arg1 = args[1].(sdk.ReportConfig)
		}
		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_UpdateReportConfig_Call) Return(reportConfig sdk.ReportConfig, sDKError errors.SDKError) *SDK_UpdateReportConfig_Call {
	_c.Call.Return(reportConfig, sDKError)
	return _c
}

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

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

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

	var r0 sdk.ReportConfig
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.ReportConfig, string, string) (sdk.ReportConfig, errors.SDKError)); ok {
		return returnFunc(ctx, cfg, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.ReportConfig, string, string) sdk.ReportConfig); ok {
		r0 = returnFunc(ctx, cfg, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.ReportConfig)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.ReportConfig, 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_UpdateReportSchedule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateReportSchedule'
type SDK_UpdateReportSchedule_Call struct {
	*mock.Call
}

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

func (_c *SDK_UpdateReportSchedule_Call) Run(run func(ctx context.Context, cfg sdk.ReportConfig, domainID string, token string)) *SDK_UpdateReportSchedule_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk.ReportConfig
		if args[1] != nil {
			arg1 = args[1].(sdk.ReportConfig)
		}
		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_UpdateReportSchedule_Call) Return(reportConfig sdk.ReportConfig, sDKError errors.SDKError) *SDK_UpdateReportSchedule_Call {
	_c.Call.Return(reportConfig, sDKError)
	return _c
}

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

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

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

	var r0 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.ReportConfig, 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_UpdateReportTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateReportTemplate'
type SDK_UpdateReportTemplate_Call struct {
	*mock.Call
}

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

func (_c *SDK_UpdateReportTemplate_Call) Run(run func(ctx context.Context, cfg sdk.ReportConfig, domainID string, token string)) *SDK_UpdateReportTemplate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk.ReportConfig
		if args[1] != nil {
			arg1 = args[1].(sdk.ReportConfig)
		}
		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_UpdateReportTemplate_Call) Return(sDKError errors.SDKError) *SDK_UpdateReportTemplate_Call {
	_c.Call.Return(sDKError)
	return _c
}

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

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

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

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

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

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

func (_c *SDK_UpdateRule_Call) Run(run func(ctx context.Context, r sdk.Rule, domainID string, token string)) *SDK_UpdateRule_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk.Rule
		if args[1] != nil {
			arg1 = args[1].(sdk.Rule)
		}
		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_UpdateRule_Call) Return(rule sdk.Rule, sDKError errors.SDKError) *SDK_UpdateRule_Call {
	_c.Call.Return(rule, sDKError)
	return _c
}

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

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

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

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

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

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

func (_c *SDK_UpdateRuleSchedule_Call) Run(run func(ctx context.Context, r sdk.Rule, domainID string, token string)) *SDK_UpdateRuleSchedule_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk.Rule
		if args[1] != nil {
			arg1 = args[1].(sdk.Rule)
		}
		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_UpdateRuleSchedule_Call) Return(rule sdk.Rule, sDKError errors.SDKError) *SDK_UpdateRuleSchedule_Call {
	_c.Call.Return(rule, sDKError)
	return _c
}

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

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

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

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

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

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

func (_c *SDK_UpdateRuleTags_Call) Run(run func(ctx context.Context, r sdk.Rule, domainID string, token string)) *SDK_UpdateRuleTags_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 sdk.Rule
		if args[1] != nil {
			arg1 = args[1].(sdk.Rule)
		}
		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_UpdateRuleTags_Call) Return(rule sdk.Rule, sDKError errors.SDKError) *SDK_UpdateRuleTags_Call {
	_c.Call.Return(rule, sDKError)
	return _c
}

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

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

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

	var r0 sdk.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.User, string) (sdk.User, errors.SDKError)); ok {
		return returnFunc(ctx, user, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.User, string) sdk.User); ok {
		r0 = returnFunc(ctx, user, token)
	} else {
		r0 = ret.Get(0).(sdk.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 sdk.User
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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 sdk.User, token string) (sdk.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 sdk.User, token string) (sdk.User, errors.SDKError) {
	ret := _mock.Called(ctx, user, token)

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

	var r0 sdk.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.User, string) (sdk.User, errors.SDKError)); ok {
		return returnFunc(ctx, user, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.User, string) sdk.User); ok {
		r0 = returnFunc(ctx, user, token)
	} else {
		r0 = ret.Get(0).(sdk.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 sdk.User
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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 sdk.User, token string) (sdk.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 sdk.User, token string) (sdk.User, errors.SDKError) {
	ret := _mock.Called(ctx, user, token)

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

	var r0 sdk.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.User, string) (sdk.User, errors.SDKError)); ok {
		return returnFunc(ctx, user, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.User, string) sdk.User); ok {
		r0 = returnFunc(ctx, user, token)
	} else {
		r0 = ret.Get(0).(sdk.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 sdk.User
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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 sdk.User, token string) (sdk.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 sdk.User, token string) (sdk.User, errors.SDKError) {
	ret := _mock.Called(ctx, user, token)

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

	var r0 sdk.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.User, string) (sdk.User, errors.SDKError)); ok {
		return returnFunc(ctx, user, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.User, string) sdk.User); ok {
		r0 = returnFunc(ctx, user, token)
	} else {
		r0 = ret.Get(0).(sdk.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 sdk.User
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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 sdk.User, token string) (sdk.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 sdk.User, token string) (sdk.User, errors.SDKError) {
	ret := _mock.Called(ctx, user, token)

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

	var r0 sdk.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.User, string) (sdk.User, errors.SDKError)); ok {
		return returnFunc(ctx, user, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.User, string) sdk.User); ok {
		r0 = returnFunc(ctx, user, token)
	} else {
		r0 = ret.Get(0).(sdk.User)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, sdk.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 sdk.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 sdk.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 sdk.User
		if args[1] != nil {
			arg1 = args[1].(sdk.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 sdk.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 sdk.User, token string) (sdk.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) (sdk.User, errors.SDKError) {
	ret := _mock.Called(ctx, id, token)

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

	var r0 sdk.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (sdk.User, errors.SDKError)); ok {
		return returnFunc(ctx, id, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) sdk.User); ok {
		r0 = returnFunc(ctx, id, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.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) (sdk.User, errors.SDKError) {
	ret := _mock.Called(ctx, token)

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

	var r0 sdk.User
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (sdk.User, errors.SDKError)); ok {
		return returnFunc(ctx, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) sdk.User); ok {
		r0 = returnFunc(ctx, token)
	} else {
		r0 = ret.Get(0).(sdk.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 sdk.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) (sdk.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 sdk.PageMetadata, token string) (sdk.UsersPage, errors.SDKError) {
	ret := _mock.Called(ctx, pm, token)

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

	var r0 sdk.UsersPage
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string) (sdk.UsersPage, errors.SDKError)); ok {
		return returnFunc(ctx, pm, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, sdk.PageMetadata, string) sdk.UsersPage); ok {
		r0 = returnFunc(ctx, pm, token)
	} else {
		r0 = ret.Get(0).(sdk.UsersPage)
	}
	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_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 sdk.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 sdk.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 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_Users_Call) Return(usersPage sdk.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 sdk.PageMetadata, token string) (sdk.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
}

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

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

	var r0 sdk.Alarm
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.Alarm, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.Alarm); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.Alarm)
	}
	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_ViewAlarm_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ViewAlarm'
type SDK_ViewAlarm_Call struct {
	*mock.Call
}

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

func (_c *SDK_ViewAlarm_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_ViewAlarm_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_ViewAlarm_Call) Return(alarm sdk.Alarm, sDKError errors.SDKError) *SDK_ViewAlarm_Call {
	_c.Call.Return(alarm, sDKError)
	return _c
}

func (_c *SDK_ViewAlarm_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) (sdk.Alarm, errors.SDKError)) *SDK_ViewAlarm_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
}

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

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

	var r0 sdk.BootstrapProfile
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.BootstrapProfile, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.BootstrapProfile); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.BootstrapProfile)
	}
	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_ViewBootstrapProfile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ViewBootstrapProfile'
type SDK_ViewBootstrapProfile_Call struct {
	*mock.Call
}

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

func (_c *SDK_ViewBootstrapProfile_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_ViewBootstrapProfile_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_ViewBootstrapProfile_Call) Return(bootstrapProfile sdk.BootstrapProfile, sDKError errors.SDKError) *SDK_ViewBootstrapProfile_Call {
	_c.Call.Return(bootstrapProfile, sDKError)
	return _c
}

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

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

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

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

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

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

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

func (_c *SDK_ViewCA_Call) Return(certificate sdk.Certificate, sDKError errors.SDKError) *SDK_ViewCA_Call {
	_c.Call.Return(certificate, sDKError)
	return _c
}

func (_c *SDK_ViewCA_Call) RunAndReturn(run func(ctx context.Context) (sdk.Certificate, errors.SDKError)) *SDK_ViewCA_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

func (_c *SDK_ViewCert_Call) Run(run func(ctx context.Context, serialNumber 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(certificate sdk.Certificate, sDKError errors.SDKError) *SDK_ViewCert_Call {
	_c.Call.Return(certificate, sDKError)
	return _c
}

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

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

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

	var r0 sdk.ReportConfig
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.ReportConfig, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.ReportConfig); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.ReportConfig)
	}
	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_ViewReportConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ViewReportConfig'
type SDK_ViewReportConfig_Call struct {
	*mock.Call
}

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

func (_c *SDK_ViewReportConfig_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_ViewReportConfig_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_ViewReportConfig_Call) Return(reportConfig sdk.ReportConfig, sDKError errors.SDKError) *SDK_ViewReportConfig_Call {
	_c.Call.Return(reportConfig, sDKError)
	return _c
}

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

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

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

	var r0 sdk.ReportTemplate
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.ReportTemplate, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.ReportTemplate); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(sdk.ReportTemplate)
		}
	}
	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_ViewReportTemplate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ViewReportTemplate'
type SDK_ViewReportTemplate_Call struct {
	*mock.Call
}

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

func (_c *SDK_ViewReportTemplate_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_ViewReportTemplate_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_ViewReportTemplate_Call) Return(reportTemplate sdk.ReportTemplate, sDKError errors.SDKError) *SDK_ViewReportTemplate_Call {
	_c.Call.Return(reportTemplate, sDKError)
	return _c
}

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

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

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

	var r0 sdk.Rule
	var r1 errors.SDKError
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (sdk.Rule, errors.SDKError)); ok {
		return returnFunc(ctx, id, domainID, token)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) sdk.Rule); ok {
		r0 = returnFunc(ctx, id, domainID, token)
	} else {
		r0 = ret.Get(0).(sdk.Rule)
	}
	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_ViewRule_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ViewRule'
type SDK_ViewRule_Call struct {
	*mock.Call
}

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

func (_c *SDK_ViewRule_Call) Run(run func(ctx context.Context, id string, domainID string, token string)) *SDK_ViewRule_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_ViewRule_Call) Return(rule sdk.Rule, sDKError errors.SDKError) *SDK_ViewRule_Call {
	_c.Call.Return(rule, sDKError)
	return _c
}

func (_c *SDK_ViewRule_Call) RunAndReturn(run func(ctx context.Context, id string, domainID string, token string) (sdk.Rule, errors.SDKError)) *SDK_ViewRule_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, status sdk.BootstrapStatus, domainID string, token string) errors.SDKError {
	ret := _mock.Called(ctx, clientID, status, 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, sdk.BootstrapStatus, string, string) errors.SDKError); ok {
		r0 = returnFunc(ctx, clientID, status, 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
//   - status sdk.BootstrapStatus
//   - domainID string
//   - token string
func (_e *SDK_Expecter) Whitelist(ctx interface{}, clientID interface{}, status interface{}, domainID interface{}, token interface{}) *SDK_Whitelist_Call {
	return &SDK_Whitelist_Call{Call: _e.mock.On("Whitelist", ctx, clientID, status, domainID, token)}
}

func (_c *SDK_Whitelist_Call) Run(run func(ctx context.Context, clientID string, status sdk.BootstrapStatus, 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 sdk.BootstrapStatus
		if args[2] != nil {
			arg2 = args[2].(sdk.BootstrapStatus)
		}
		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, status sdk.BootstrapStatus, domainID string, token string) errors.SDKError) *SDK_Whitelist_Call {
	_c.Call.Return(run)
	return _c
}