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

package mocks

import (
	"context"

	"github.com/aiven/go-client-codegen/handler/account"
	"github.com/aiven/go-client-codegen/handler/accountauthentication"
	"github.com/aiven/go-client-codegen/handler/accountteam"
	"github.com/aiven/go-client-codegen/handler/accountteammember"
	"github.com/aiven/go-client-codegen/handler/alloydbomni"
	"github.com/aiven/go-client-codegen/handler/applicationuser"
	"github.com/aiven/go-client-codegen/handler/billinggroup"
	"github.com/aiven/go-client-codegen/handler/byoc"
	"github.com/aiven/go-client-codegen/handler/clickhouse"
	"github.com/aiven/go-client-codegen/handler/cloud"
	"github.com/aiven/go-client-codegen/handler/domain"
	"github.com/aiven/go-client-codegen/handler/flink"
	"github.com/aiven/go-client-codegen/handler/flinkapplication"
	"github.com/aiven/go-client-codegen/handler/flinkapplicationdeployment"
	"github.com/aiven/go-client-codegen/handler/flinkapplicationversion"
	"github.com/aiven/go-client-codegen/handler/flinkjarapplication"
	"github.com/aiven/go-client-codegen/handler/flinkjarapplicationdeployment"
	"github.com/aiven/go-client-codegen/handler/flinkjarapplicationversion"
	"github.com/aiven/go-client-codegen/handler/flinkjob"
	"github.com/aiven/go-client-codegen/handler/kafka"
	"github.com/aiven/go-client-codegen/handler/kafkaconnect"
	"github.com/aiven/go-client-codegen/handler/kafkamirrormaker"
	"github.com/aiven/go-client-codegen/handler/kafkaschemaregistry"
	"github.com/aiven/go-client-codegen/handler/kafkatopic"
	"github.com/aiven/go-client-codegen/handler/mysql"
	"github.com/aiven/go-client-codegen/handler/opensearch"
	"github.com/aiven/go-client-codegen/handler/organization"
	"github.com/aiven/go-client-codegen/handler/organizationbilling"
	"github.com/aiven/go-client-codegen/handler/organizationgovernance"
	"github.com/aiven/go-client-codegen/handler/organizationprojects"
	"github.com/aiven/go-client-codegen/handler/organizationuser"
	"github.com/aiven/go-client-codegen/handler/organizationvpc"
	"github.com/aiven/go-client-codegen/handler/postgresql"
	"github.com/aiven/go-client-codegen/handler/privatelink"
	"github.com/aiven/go-client-codegen/handler/project"
	"github.com/aiven/go-client-codegen/handler/projectbilling"
	"github.com/aiven/go-client-codegen/handler/service"
	"github.com/aiven/go-client-codegen/handler/staticip"
	"github.com/aiven/go-client-codegen/handler/thanos"
	"github.com/aiven/go-client-codegen/handler/user"
	"github.com/aiven/go-client-codegen/handler/usergroup"
	"github.com/aiven/go-client-codegen/handler/vpc"
	mock "github.com/stretchr/testify/mock"
)

// NewMockClient creates a new instance of MockClient. 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 NewMockClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockClient {
	mock := &MockClient{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

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

type MockClient_Expecter struct {
	mock *mock.Mock
}

func (_m *MockClient) EXPECT() *MockClient_Expecter {
	return &MockClient_Expecter{mock: &_m.Mock}
}

// AccessTokenCreate provides a mock function for the type MockClient
func (_mock *MockClient) AccessTokenCreate(ctx context.Context, in *user.AccessTokenCreateIn) (*user.AccessTokenCreateOut, error) {
	ret := _mock.Called(ctx, in)

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

	var r0 *user.AccessTokenCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.AccessTokenCreateIn) (*user.AccessTokenCreateOut, error)); ok {
		return returnFunc(ctx, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.AccessTokenCreateIn) *user.AccessTokenCreateOut); ok {
		r0 = returnFunc(ctx, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*user.AccessTokenCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *user.AccessTokenCreateIn) error); ok {
		r1 = returnFunc(ctx, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccessTokenCreate is a helper method to define mock.On call
//   - ctx
//   - in
func (_e *MockClient_Expecter) AccessTokenCreate(ctx interface{}, in interface{}) *MockClient_AccessTokenCreate_Call {
	return &MockClient_AccessTokenCreate_Call{Call: _e.mock.On("AccessTokenCreate", ctx, in)}
}

func (_c *MockClient_AccessTokenCreate_Call) Run(run func(ctx context.Context, in *user.AccessTokenCreateIn)) *MockClient_AccessTokenCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*user.AccessTokenCreateIn))
	})
	return _c
}

func (_c *MockClient_AccessTokenCreate_Call) Return(accessTokenCreateOut *user.AccessTokenCreateOut, err error) *MockClient_AccessTokenCreate_Call {
	_c.Call.Return(accessTokenCreateOut, err)
	return _c
}

func (_c *MockClient_AccessTokenCreate_Call) RunAndReturn(run func(ctx context.Context, in *user.AccessTokenCreateIn) (*user.AccessTokenCreateOut, error)) *MockClient_AccessTokenCreate_Call {
	_c.Call.Return(run)
	return _c
}

// AccessTokenList provides a mock function for the type MockClient
func (_mock *MockClient) AccessTokenList(ctx context.Context) ([]user.TokenOut, error) {
	ret := _mock.Called(ctx)

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

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

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

// AccessTokenList is a helper method to define mock.On call
//   - ctx
func (_e *MockClient_Expecter) AccessTokenList(ctx interface{}) *MockClient_AccessTokenList_Call {
	return &MockClient_AccessTokenList_Call{Call: _e.mock.On("AccessTokenList", ctx)}
}

func (_c *MockClient_AccessTokenList_Call) Run(run func(ctx context.Context)) *MockClient_AccessTokenList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockClient_AccessTokenList_Call) Return(tokenOuts []user.TokenOut, err error) *MockClient_AccessTokenList_Call {
	_c.Call.Return(tokenOuts, err)
	return _c
}

func (_c *MockClient_AccessTokenList_Call) RunAndReturn(run func(ctx context.Context) ([]user.TokenOut, error)) *MockClient_AccessTokenList_Call {
	_c.Call.Return(run)
	return _c
}

// AccessTokenRevoke provides a mock function for the type MockClient
func (_mock *MockClient) AccessTokenRevoke(ctx context.Context, tokenPrefix string) error {
	ret := _mock.Called(ctx, tokenPrefix)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(ctx, tokenPrefix)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// AccessTokenRevoke is a helper method to define mock.On call
//   - ctx
//   - tokenPrefix
func (_e *MockClient_Expecter) AccessTokenRevoke(ctx interface{}, tokenPrefix interface{}) *MockClient_AccessTokenRevoke_Call {
	return &MockClient_AccessTokenRevoke_Call{Call: _e.mock.On("AccessTokenRevoke", ctx, tokenPrefix)}
}

func (_c *MockClient_AccessTokenRevoke_Call) Run(run func(ctx context.Context, tokenPrefix string)) *MockClient_AccessTokenRevoke_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_AccessTokenRevoke_Call) Return(err error) *MockClient_AccessTokenRevoke_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_AccessTokenRevoke_Call) RunAndReturn(run func(ctx context.Context, tokenPrefix string) error) *MockClient_AccessTokenRevoke_Call {
	_c.Call.Return(run)
	return _c
}

// AccessTokenUpdate provides a mock function for the type MockClient
func (_mock *MockClient) AccessTokenUpdate(ctx context.Context, tokenPrefix string, in *user.AccessTokenUpdateIn) (*user.AccessTokenUpdateOut, error) {
	ret := _mock.Called(ctx, tokenPrefix, in)

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

	var r0 *user.AccessTokenUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *user.AccessTokenUpdateIn) (*user.AccessTokenUpdateOut, error)); ok {
		return returnFunc(ctx, tokenPrefix, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *user.AccessTokenUpdateIn) *user.AccessTokenUpdateOut); ok {
		r0 = returnFunc(ctx, tokenPrefix, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*user.AccessTokenUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *user.AccessTokenUpdateIn) error); ok {
		r1 = returnFunc(ctx, tokenPrefix, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccessTokenUpdate is a helper method to define mock.On call
//   - ctx
//   - tokenPrefix
//   - in
func (_e *MockClient_Expecter) AccessTokenUpdate(ctx interface{}, tokenPrefix interface{}, in interface{}) *MockClient_AccessTokenUpdate_Call {
	return &MockClient_AccessTokenUpdate_Call{Call: _e.mock.On("AccessTokenUpdate", ctx, tokenPrefix, in)}
}

func (_c *MockClient_AccessTokenUpdate_Call) Run(run func(ctx context.Context, tokenPrefix string, in *user.AccessTokenUpdateIn)) *MockClient_AccessTokenUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*user.AccessTokenUpdateIn))
	})
	return _c
}

func (_c *MockClient_AccessTokenUpdate_Call) Return(accessTokenUpdateOut *user.AccessTokenUpdateOut, err error) *MockClient_AccessTokenUpdate_Call {
	_c.Call.Return(accessTokenUpdateOut, err)
	return _c
}

func (_c *MockClient_AccessTokenUpdate_Call) RunAndReturn(run func(ctx context.Context, tokenPrefix string, in *user.AccessTokenUpdateIn) (*user.AccessTokenUpdateOut, error)) *MockClient_AccessTokenUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// AccountAttachPaymentMethod provides a mock function for the type MockClient
func (_mock *MockClient) AccountAttachPaymentMethod(ctx context.Context, accountId string, in *account.AccountAttachPaymentMethodIn) (*account.AccountAttachPaymentMethodOut, error) {
	ret := _mock.Called(ctx, accountId, in)

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

	var r0 *account.AccountAttachPaymentMethodOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *account.AccountAttachPaymentMethodIn) (*account.AccountAttachPaymentMethodOut, error)); ok {
		return returnFunc(ctx, accountId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *account.AccountAttachPaymentMethodIn) *account.AccountAttachPaymentMethodOut); ok {
		r0 = returnFunc(ctx, accountId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*account.AccountAttachPaymentMethodOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *account.AccountAttachPaymentMethodIn) error); ok {
		r1 = returnFunc(ctx, accountId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountAttachPaymentMethod is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - in
func (_e *MockClient_Expecter) AccountAttachPaymentMethod(ctx interface{}, accountId interface{}, in interface{}) *MockClient_AccountAttachPaymentMethod_Call {
	return &MockClient_AccountAttachPaymentMethod_Call{Call: _e.mock.On("AccountAttachPaymentMethod", ctx, accountId, in)}
}

func (_c *MockClient_AccountAttachPaymentMethod_Call) Run(run func(ctx context.Context, accountId string, in *account.AccountAttachPaymentMethodIn)) *MockClient_AccountAttachPaymentMethod_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*account.AccountAttachPaymentMethodIn))
	})
	return _c
}

func (_c *MockClient_AccountAttachPaymentMethod_Call) Return(accountAttachPaymentMethodOut *account.AccountAttachPaymentMethodOut, err error) *MockClient_AccountAttachPaymentMethod_Call {
	_c.Call.Return(accountAttachPaymentMethodOut, err)
	return _c
}

func (_c *MockClient_AccountAttachPaymentMethod_Call) RunAndReturn(run func(ctx context.Context, accountId string, in *account.AccountAttachPaymentMethodIn) (*account.AccountAttachPaymentMethodOut, error)) *MockClient_AccountAttachPaymentMethod_Call {
	_c.Call.Return(run)
	return _c
}

// AccountAuthenticationMethodCreate provides a mock function for the type MockClient
func (_mock *MockClient) AccountAuthenticationMethodCreate(ctx context.Context, accountId string, in *accountauthentication.AccountAuthenticationMethodCreateIn) (*accountauthentication.AccountAuthenticationMethodCreateOut, error) {
	ret := _mock.Called(ctx, accountId, in)

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

	var r0 *accountauthentication.AccountAuthenticationMethodCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *accountauthentication.AccountAuthenticationMethodCreateIn) (*accountauthentication.AccountAuthenticationMethodCreateOut, error)); ok {
		return returnFunc(ctx, accountId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *accountauthentication.AccountAuthenticationMethodCreateIn) *accountauthentication.AccountAuthenticationMethodCreateOut); ok {
		r0 = returnFunc(ctx, accountId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*accountauthentication.AccountAuthenticationMethodCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *accountauthentication.AccountAuthenticationMethodCreateIn) error); ok {
		r1 = returnFunc(ctx, accountId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountAuthenticationMethodCreate is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - in
func (_e *MockClient_Expecter) AccountAuthenticationMethodCreate(ctx interface{}, accountId interface{}, in interface{}) *MockClient_AccountAuthenticationMethodCreate_Call {
	return &MockClient_AccountAuthenticationMethodCreate_Call{Call: _e.mock.On("AccountAuthenticationMethodCreate", ctx, accountId, in)}
}

func (_c *MockClient_AccountAuthenticationMethodCreate_Call) Run(run func(ctx context.Context, accountId string, in *accountauthentication.AccountAuthenticationMethodCreateIn)) *MockClient_AccountAuthenticationMethodCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*accountauthentication.AccountAuthenticationMethodCreateIn))
	})
	return _c
}

func (_c *MockClient_AccountAuthenticationMethodCreate_Call) Return(accountAuthenticationMethodCreateOut *accountauthentication.AccountAuthenticationMethodCreateOut, err error) *MockClient_AccountAuthenticationMethodCreate_Call {
	_c.Call.Return(accountAuthenticationMethodCreateOut, err)
	return _c
}

func (_c *MockClient_AccountAuthenticationMethodCreate_Call) RunAndReturn(run func(ctx context.Context, accountId string, in *accountauthentication.AccountAuthenticationMethodCreateIn) (*accountauthentication.AccountAuthenticationMethodCreateOut, error)) *MockClient_AccountAuthenticationMethodCreate_Call {
	_c.Call.Return(run)
	return _c
}

// AccountAuthenticationMethodDelete provides a mock function for the type MockClient
func (_mock *MockClient) AccountAuthenticationMethodDelete(ctx context.Context, accountId string, accountAuthenticationMethodId string) error {
	ret := _mock.Called(ctx, accountId, accountAuthenticationMethodId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, accountId, accountAuthenticationMethodId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// AccountAuthenticationMethodDelete is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - accountAuthenticationMethodId
func (_e *MockClient_Expecter) AccountAuthenticationMethodDelete(ctx interface{}, accountId interface{}, accountAuthenticationMethodId interface{}) *MockClient_AccountAuthenticationMethodDelete_Call {
	return &MockClient_AccountAuthenticationMethodDelete_Call{Call: _e.mock.On("AccountAuthenticationMethodDelete", ctx, accountId, accountAuthenticationMethodId)}
}

func (_c *MockClient_AccountAuthenticationMethodDelete_Call) Run(run func(ctx context.Context, accountId string, accountAuthenticationMethodId string)) *MockClient_AccountAuthenticationMethodDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_AccountAuthenticationMethodDelete_Call) Return(err error) *MockClient_AccountAuthenticationMethodDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_AccountAuthenticationMethodDelete_Call) RunAndReturn(run func(ctx context.Context, accountId string, accountAuthenticationMethodId string) error) *MockClient_AccountAuthenticationMethodDelete_Call {
	_c.Call.Return(run)
	return _c
}

// AccountAuthenticationMethodGet provides a mock function for the type MockClient
func (_mock *MockClient) AccountAuthenticationMethodGet(ctx context.Context, accountId string, accountAuthenticationMethodId string) (*accountauthentication.AccountAuthenticationMethodGetOut, error) {
	ret := _mock.Called(ctx, accountId, accountAuthenticationMethodId)

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

	var r0 *accountauthentication.AccountAuthenticationMethodGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*accountauthentication.AccountAuthenticationMethodGetOut, error)); ok {
		return returnFunc(ctx, accountId, accountAuthenticationMethodId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *accountauthentication.AccountAuthenticationMethodGetOut); ok {
		r0 = returnFunc(ctx, accountId, accountAuthenticationMethodId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*accountauthentication.AccountAuthenticationMethodGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, accountId, accountAuthenticationMethodId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountAuthenticationMethodGet is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - accountAuthenticationMethodId
func (_e *MockClient_Expecter) AccountAuthenticationMethodGet(ctx interface{}, accountId interface{}, accountAuthenticationMethodId interface{}) *MockClient_AccountAuthenticationMethodGet_Call {
	return &MockClient_AccountAuthenticationMethodGet_Call{Call: _e.mock.On("AccountAuthenticationMethodGet", ctx, accountId, accountAuthenticationMethodId)}
}

func (_c *MockClient_AccountAuthenticationMethodGet_Call) Run(run func(ctx context.Context, accountId string, accountAuthenticationMethodId string)) *MockClient_AccountAuthenticationMethodGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_AccountAuthenticationMethodGet_Call) Return(accountAuthenticationMethodGetOut *accountauthentication.AccountAuthenticationMethodGetOut, err error) *MockClient_AccountAuthenticationMethodGet_Call {
	_c.Call.Return(accountAuthenticationMethodGetOut, err)
	return _c
}

func (_c *MockClient_AccountAuthenticationMethodGet_Call) RunAndReturn(run func(ctx context.Context, accountId string, accountAuthenticationMethodId string) (*accountauthentication.AccountAuthenticationMethodGetOut, error)) *MockClient_AccountAuthenticationMethodGet_Call {
	_c.Call.Return(run)
	return _c
}

// AccountAuthenticationMethodUpdate provides a mock function for the type MockClient
func (_mock *MockClient) AccountAuthenticationMethodUpdate(ctx context.Context, accountId string, accountAuthenticationMethodId string, in *accountauthentication.AccountAuthenticationMethodUpdateIn) (*accountauthentication.AccountAuthenticationMethodUpdateOut, error) {
	ret := _mock.Called(ctx, accountId, accountAuthenticationMethodId, in)

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

	var r0 *accountauthentication.AccountAuthenticationMethodUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *accountauthentication.AccountAuthenticationMethodUpdateIn) (*accountauthentication.AccountAuthenticationMethodUpdateOut, error)); ok {
		return returnFunc(ctx, accountId, accountAuthenticationMethodId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *accountauthentication.AccountAuthenticationMethodUpdateIn) *accountauthentication.AccountAuthenticationMethodUpdateOut); ok {
		r0 = returnFunc(ctx, accountId, accountAuthenticationMethodId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*accountauthentication.AccountAuthenticationMethodUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *accountauthentication.AccountAuthenticationMethodUpdateIn) error); ok {
		r1 = returnFunc(ctx, accountId, accountAuthenticationMethodId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountAuthenticationMethodUpdate is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - accountAuthenticationMethodId
//   - in
func (_e *MockClient_Expecter) AccountAuthenticationMethodUpdate(ctx interface{}, accountId interface{}, accountAuthenticationMethodId interface{}, in interface{}) *MockClient_AccountAuthenticationMethodUpdate_Call {
	return &MockClient_AccountAuthenticationMethodUpdate_Call{Call: _e.mock.On("AccountAuthenticationMethodUpdate", ctx, accountId, accountAuthenticationMethodId, in)}
}

func (_c *MockClient_AccountAuthenticationMethodUpdate_Call) Run(run func(ctx context.Context, accountId string, accountAuthenticationMethodId string, in *accountauthentication.AccountAuthenticationMethodUpdateIn)) *MockClient_AccountAuthenticationMethodUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*accountauthentication.AccountAuthenticationMethodUpdateIn))
	})
	return _c
}

func (_c *MockClient_AccountAuthenticationMethodUpdate_Call) Return(accountAuthenticationMethodUpdateOut *accountauthentication.AccountAuthenticationMethodUpdateOut, err error) *MockClient_AccountAuthenticationMethodUpdate_Call {
	_c.Call.Return(accountAuthenticationMethodUpdateOut, err)
	return _c
}

func (_c *MockClient_AccountAuthenticationMethodUpdate_Call) RunAndReturn(run func(ctx context.Context, accountId string, accountAuthenticationMethodId string, in *accountauthentication.AccountAuthenticationMethodUpdateIn) (*accountauthentication.AccountAuthenticationMethodUpdateOut, error)) *MockClient_AccountAuthenticationMethodUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// AccountAuthenticationMethodsList provides a mock function for the type MockClient
func (_mock *MockClient) AccountAuthenticationMethodsList(ctx context.Context, accountId string) ([]accountauthentication.AuthenticationMethodOut, error) {
	ret := _mock.Called(ctx, accountId)

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

	var r0 []accountauthentication.AuthenticationMethodOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]accountauthentication.AuthenticationMethodOut, error)); ok {
		return returnFunc(ctx, accountId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []accountauthentication.AuthenticationMethodOut); ok {
		r0 = returnFunc(ctx, accountId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]accountauthentication.AuthenticationMethodOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, accountId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountAuthenticationMethodsList is a helper method to define mock.On call
//   - ctx
//   - accountId
func (_e *MockClient_Expecter) AccountAuthenticationMethodsList(ctx interface{}, accountId interface{}) *MockClient_AccountAuthenticationMethodsList_Call {
	return &MockClient_AccountAuthenticationMethodsList_Call{Call: _e.mock.On("AccountAuthenticationMethodsList", ctx, accountId)}
}

func (_c *MockClient_AccountAuthenticationMethodsList_Call) Run(run func(ctx context.Context, accountId string)) *MockClient_AccountAuthenticationMethodsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_AccountAuthenticationMethodsList_Call) Return(authenticationMethodOuts []accountauthentication.AuthenticationMethodOut, err error) *MockClient_AccountAuthenticationMethodsList_Call {
	_c.Call.Return(authenticationMethodOuts, err)
	return _c
}

func (_c *MockClient_AccountAuthenticationMethodsList_Call) RunAndReturn(run func(ctx context.Context, accountId string) ([]accountauthentication.AuthenticationMethodOut, error)) *MockClient_AccountAuthenticationMethodsList_Call {
	_c.Call.Return(run)
	return _c
}

// AccountBillingGroupList provides a mock function for the type MockClient
func (_mock *MockClient) AccountBillingGroupList(ctx context.Context, accountId string) ([]account.AccountBillingGroupOut, error) {
	ret := _mock.Called(ctx, accountId)

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

	var r0 []account.AccountBillingGroupOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]account.AccountBillingGroupOut, error)); ok {
		return returnFunc(ctx, accountId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []account.AccountBillingGroupOut); ok {
		r0 = returnFunc(ctx, accountId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]account.AccountBillingGroupOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, accountId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountBillingGroupList is a helper method to define mock.On call
//   - ctx
//   - accountId
func (_e *MockClient_Expecter) AccountBillingGroupList(ctx interface{}, accountId interface{}) *MockClient_AccountBillingGroupList_Call {
	return &MockClient_AccountBillingGroupList_Call{Call: _e.mock.On("AccountBillingGroupList", ctx, accountId)}
}

func (_c *MockClient_AccountBillingGroupList_Call) Run(run func(ctx context.Context, accountId string)) *MockClient_AccountBillingGroupList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_AccountBillingGroupList_Call) Return(accountBillingGroupOuts []account.AccountBillingGroupOut, err error) *MockClient_AccountBillingGroupList_Call {
	_c.Call.Return(accountBillingGroupOuts, err)
	return _c
}

func (_c *MockClient_AccountBillingGroupList_Call) RunAndReturn(run func(ctx context.Context, accountId string) ([]account.AccountBillingGroupOut, error)) *MockClient_AccountBillingGroupList_Call {
	_c.Call.Return(run)
	return _c
}

// AccountCreate provides a mock function for the type MockClient
func (_mock *MockClient) AccountCreate(ctx context.Context, in *account.AccountCreateIn) (*account.AccountCreateOut, error) {
	ret := _mock.Called(ctx, in)

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

	var r0 *account.AccountCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *account.AccountCreateIn) (*account.AccountCreateOut, error)); ok {
		return returnFunc(ctx, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *account.AccountCreateIn) *account.AccountCreateOut); ok {
		r0 = returnFunc(ctx, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*account.AccountCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *account.AccountCreateIn) error); ok {
		r1 = returnFunc(ctx, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountCreate is a helper method to define mock.On call
//   - ctx
//   - in
func (_e *MockClient_Expecter) AccountCreate(ctx interface{}, in interface{}) *MockClient_AccountCreate_Call {
	return &MockClient_AccountCreate_Call{Call: _e.mock.On("AccountCreate", ctx, in)}
}

func (_c *MockClient_AccountCreate_Call) Run(run func(ctx context.Context, in *account.AccountCreateIn)) *MockClient_AccountCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*account.AccountCreateIn))
	})
	return _c
}

func (_c *MockClient_AccountCreate_Call) Return(accountCreateOut *account.AccountCreateOut, err error) *MockClient_AccountCreate_Call {
	_c.Call.Return(accountCreateOut, err)
	return _c
}

func (_c *MockClient_AccountCreate_Call) RunAndReturn(run func(ctx context.Context, in *account.AccountCreateIn) (*account.AccountCreateOut, error)) *MockClient_AccountCreate_Call {
	_c.Call.Return(run)
	return _c
}

// AccountDelete provides a mock function for the type MockClient
func (_mock *MockClient) AccountDelete(ctx context.Context, accountId string) error {
	ret := _mock.Called(ctx, accountId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(ctx, accountId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// AccountDelete is a helper method to define mock.On call
//   - ctx
//   - accountId
func (_e *MockClient_Expecter) AccountDelete(ctx interface{}, accountId interface{}) *MockClient_AccountDelete_Call {
	return &MockClient_AccountDelete_Call{Call: _e.mock.On("AccountDelete", ctx, accountId)}
}

func (_c *MockClient_AccountDelete_Call) Run(run func(ctx context.Context, accountId string)) *MockClient_AccountDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_AccountDelete_Call) Return(err error) *MockClient_AccountDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_AccountDelete_Call) RunAndReturn(run func(ctx context.Context, accountId string) error) *MockClient_AccountDelete_Call {
	_c.Call.Return(run)
	return _c
}

// AccountEventList provides a mock function for the type MockClient
func (_mock *MockClient) AccountEventList(ctx context.Context, accountId string) ([]account.EventOut, error) {
	ret := _mock.Called(ctx, accountId)

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

	var r0 []account.EventOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]account.EventOut, error)); ok {
		return returnFunc(ctx, accountId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []account.EventOut); ok {
		r0 = returnFunc(ctx, accountId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]account.EventOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, accountId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountEventList is a helper method to define mock.On call
//   - ctx
//   - accountId
func (_e *MockClient_Expecter) AccountEventList(ctx interface{}, accountId interface{}) *MockClient_AccountEventList_Call {
	return &MockClient_AccountEventList_Call{Call: _e.mock.On("AccountEventList", ctx, accountId)}
}

func (_c *MockClient_AccountEventList_Call) Run(run func(ctx context.Context, accountId string)) *MockClient_AccountEventList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_AccountEventList_Call) Return(eventOuts []account.EventOut, err error) *MockClient_AccountEventList_Call {
	_c.Call.Return(eventOuts, err)
	return _c
}

func (_c *MockClient_AccountEventList_Call) RunAndReturn(run func(ctx context.Context, accountId string) ([]account.EventOut, error)) *MockClient_AccountEventList_Call {
	_c.Call.Return(run)
	return _c
}

// AccountGet provides a mock function for the type MockClient
func (_mock *MockClient) AccountGet(ctx context.Context, accountId string) (*account.AccountGetOut, error) {
	ret := _mock.Called(ctx, accountId)

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

	var r0 *account.AccountGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*account.AccountGetOut, error)); ok {
		return returnFunc(ctx, accountId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *account.AccountGetOut); ok {
		r0 = returnFunc(ctx, accountId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*account.AccountGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, accountId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountGet is a helper method to define mock.On call
//   - ctx
//   - accountId
func (_e *MockClient_Expecter) AccountGet(ctx interface{}, accountId interface{}) *MockClient_AccountGet_Call {
	return &MockClient_AccountGet_Call{Call: _e.mock.On("AccountGet", ctx, accountId)}
}

func (_c *MockClient_AccountGet_Call) Run(run func(ctx context.Context, accountId string)) *MockClient_AccountGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_AccountGet_Call) Return(accountGetOut *account.AccountGetOut, err error) *MockClient_AccountGet_Call {
	_c.Call.Return(accountGetOut, err)
	return _c
}

func (_c *MockClient_AccountGet_Call) RunAndReturn(run func(ctx context.Context, accountId string) (*account.AccountGetOut, error)) *MockClient_AccountGet_Call {
	_c.Call.Return(run)
	return _c
}

// AccountList provides a mock function for the type MockClient
func (_mock *MockClient) AccountList(ctx context.Context) ([]account.AccountOut, error) {
	ret := _mock.Called(ctx)

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

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

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

// AccountList is a helper method to define mock.On call
//   - ctx
func (_e *MockClient_Expecter) AccountList(ctx interface{}) *MockClient_AccountList_Call {
	return &MockClient_AccountList_Call{Call: _e.mock.On("AccountList", ctx)}
}

func (_c *MockClient_AccountList_Call) Run(run func(ctx context.Context)) *MockClient_AccountList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockClient_AccountList_Call) Return(accountOuts []account.AccountOut, err error) *MockClient_AccountList_Call {
	_c.Call.Return(accountOuts, err)
	return _c
}

func (_c *MockClient_AccountList_Call) RunAndReturn(run func(ctx context.Context) ([]account.AccountOut, error)) *MockClient_AccountList_Call {
	_c.Call.Return(run)
	return _c
}

// AccountMove provides a mock function for the type MockClient
func (_mock *MockClient) AccountMove(ctx context.Context, accountId string, in *account.AccountMoveIn) (*account.AccountMoveOut, error) {
	ret := _mock.Called(ctx, accountId, in)

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

	var r0 *account.AccountMoveOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *account.AccountMoveIn) (*account.AccountMoveOut, error)); ok {
		return returnFunc(ctx, accountId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *account.AccountMoveIn) *account.AccountMoveOut); ok {
		r0 = returnFunc(ctx, accountId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*account.AccountMoveOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *account.AccountMoveIn) error); ok {
		r1 = returnFunc(ctx, accountId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountMove is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - in
func (_e *MockClient_Expecter) AccountMove(ctx interface{}, accountId interface{}, in interface{}) *MockClient_AccountMove_Call {
	return &MockClient_AccountMove_Call{Call: _e.mock.On("AccountMove", ctx, accountId, in)}
}

func (_c *MockClient_AccountMove_Call) Run(run func(ctx context.Context, accountId string, in *account.AccountMoveIn)) *MockClient_AccountMove_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*account.AccountMoveIn))
	})
	return _c
}

func (_c *MockClient_AccountMove_Call) Return(accountMoveOut *account.AccountMoveOut, err error) *MockClient_AccountMove_Call {
	_c.Call.Return(accountMoveOut, err)
	return _c
}

func (_c *MockClient_AccountMove_Call) RunAndReturn(run func(ctx context.Context, accountId string, in *account.AccountMoveIn) (*account.AccountMoveOut, error)) *MockClient_AccountMove_Call {
	_c.Call.Return(run)
	return _c
}

// AccountPaymentMethodDelete provides a mock function for the type MockClient
func (_mock *MockClient) AccountPaymentMethodDelete(ctx context.Context, accountId string, cardId string) error {
	ret := _mock.Called(ctx, accountId, cardId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, accountId, cardId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// AccountPaymentMethodDelete is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - cardId
func (_e *MockClient_Expecter) AccountPaymentMethodDelete(ctx interface{}, accountId interface{}, cardId interface{}) *MockClient_AccountPaymentMethodDelete_Call {
	return &MockClient_AccountPaymentMethodDelete_Call{Call: _e.mock.On("AccountPaymentMethodDelete", ctx, accountId, cardId)}
}

func (_c *MockClient_AccountPaymentMethodDelete_Call) Run(run func(ctx context.Context, accountId string, cardId string)) *MockClient_AccountPaymentMethodDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_AccountPaymentMethodDelete_Call) Return(err error) *MockClient_AccountPaymentMethodDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_AccountPaymentMethodDelete_Call) RunAndReturn(run func(ctx context.Context, accountId string, cardId string) error) *MockClient_AccountPaymentMethodDelete_Call {
	_c.Call.Return(run)
	return _c
}

// AccountPaymentMethodsList provides a mock function for the type MockClient
func (_mock *MockClient) AccountPaymentMethodsList(ctx context.Context, accountId string) ([]account.CardOut, error) {
	ret := _mock.Called(ctx, accountId)

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

	var r0 []account.CardOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]account.CardOut, error)); ok {
		return returnFunc(ctx, accountId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []account.CardOut); ok {
		r0 = returnFunc(ctx, accountId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]account.CardOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, accountId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountPaymentMethodsList is a helper method to define mock.On call
//   - ctx
//   - accountId
func (_e *MockClient_Expecter) AccountPaymentMethodsList(ctx interface{}, accountId interface{}) *MockClient_AccountPaymentMethodsList_Call {
	return &MockClient_AccountPaymentMethodsList_Call{Call: _e.mock.On("AccountPaymentMethodsList", ctx, accountId)}
}

func (_c *MockClient_AccountPaymentMethodsList_Call) Run(run func(ctx context.Context, accountId string)) *MockClient_AccountPaymentMethodsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_AccountPaymentMethodsList_Call) Return(cardOuts []account.CardOut, err error) *MockClient_AccountPaymentMethodsList_Call {
	_c.Call.Return(cardOuts, err)
	return _c
}

func (_c *MockClient_AccountPaymentMethodsList_Call) RunAndReturn(run func(ctx context.Context, accountId string) ([]account.CardOut, error)) *MockClient_AccountPaymentMethodsList_Call {
	_c.Call.Return(run)
	return _c
}

// AccountProjectsList provides a mock function for the type MockClient
func (_mock *MockClient) AccountProjectsList(ctx context.Context, accountId string) (*account.AccountProjectsListOut, error) {
	ret := _mock.Called(ctx, accountId)

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

	var r0 *account.AccountProjectsListOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*account.AccountProjectsListOut, error)); ok {
		return returnFunc(ctx, accountId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *account.AccountProjectsListOut); ok {
		r0 = returnFunc(ctx, accountId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*account.AccountProjectsListOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, accountId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountProjectsList is a helper method to define mock.On call
//   - ctx
//   - accountId
func (_e *MockClient_Expecter) AccountProjectsList(ctx interface{}, accountId interface{}) *MockClient_AccountProjectsList_Call {
	return &MockClient_AccountProjectsList_Call{Call: _e.mock.On("AccountProjectsList", ctx, accountId)}
}

func (_c *MockClient_AccountProjectsList_Call) Run(run func(ctx context.Context, accountId string)) *MockClient_AccountProjectsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_AccountProjectsList_Call) Return(accountProjectsListOut *account.AccountProjectsListOut, err error) *MockClient_AccountProjectsList_Call {
	_c.Call.Return(accountProjectsListOut, err)
	return _c
}

func (_c *MockClient_AccountProjectsList_Call) RunAndReturn(run func(ctx context.Context, accountId string) (*account.AccountProjectsListOut, error)) *MockClient_AccountProjectsList_Call {
	_c.Call.Return(run)
	return _c
}

// AccountProjectsTeamsList provides a mock function for the type MockClient
func (_mock *MockClient) AccountProjectsTeamsList(ctx context.Context, accountId string, projectName string) ([]account.TeamOut, error) {
	ret := _mock.Called(ctx, accountId, projectName)

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

	var r0 []account.TeamOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]account.TeamOut, error)); ok {
		return returnFunc(ctx, accountId, projectName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []account.TeamOut); ok {
		r0 = returnFunc(ctx, accountId, projectName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]account.TeamOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, accountId, projectName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountProjectsTeamsList is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - projectName
func (_e *MockClient_Expecter) AccountProjectsTeamsList(ctx interface{}, accountId interface{}, projectName interface{}) *MockClient_AccountProjectsTeamsList_Call {
	return &MockClient_AccountProjectsTeamsList_Call{Call: _e.mock.On("AccountProjectsTeamsList", ctx, accountId, projectName)}
}

func (_c *MockClient_AccountProjectsTeamsList_Call) Run(run func(ctx context.Context, accountId string, projectName string)) *MockClient_AccountProjectsTeamsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_AccountProjectsTeamsList_Call) Return(teamOuts []account.TeamOut, err error) *MockClient_AccountProjectsTeamsList_Call {
	_c.Call.Return(teamOuts, err)
	return _c
}

func (_c *MockClient_AccountProjectsTeamsList_Call) RunAndReturn(run func(ctx context.Context, accountId string, projectName string) ([]account.TeamOut, error)) *MockClient_AccountProjectsTeamsList_Call {
	_c.Call.Return(run)
	return _c
}

// AccountTeamCreate provides a mock function for the type MockClient
func (_mock *MockClient) AccountTeamCreate(ctx context.Context, accountId string, in *accountteam.AccountTeamCreateIn) (*accountteam.AccountTeamCreateOut, error) {
	ret := _mock.Called(ctx, accountId, in)

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

	var r0 *accountteam.AccountTeamCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *accountteam.AccountTeamCreateIn) (*accountteam.AccountTeamCreateOut, error)); ok {
		return returnFunc(ctx, accountId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *accountteam.AccountTeamCreateIn) *accountteam.AccountTeamCreateOut); ok {
		r0 = returnFunc(ctx, accountId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*accountteam.AccountTeamCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *accountteam.AccountTeamCreateIn) error); ok {
		r1 = returnFunc(ctx, accountId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountTeamCreate is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - in
func (_e *MockClient_Expecter) AccountTeamCreate(ctx interface{}, accountId interface{}, in interface{}) *MockClient_AccountTeamCreate_Call {
	return &MockClient_AccountTeamCreate_Call{Call: _e.mock.On("AccountTeamCreate", ctx, accountId, in)}
}

func (_c *MockClient_AccountTeamCreate_Call) Run(run func(ctx context.Context, accountId string, in *accountteam.AccountTeamCreateIn)) *MockClient_AccountTeamCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*accountteam.AccountTeamCreateIn))
	})
	return _c
}

func (_c *MockClient_AccountTeamCreate_Call) Return(accountTeamCreateOut *accountteam.AccountTeamCreateOut, err error) *MockClient_AccountTeamCreate_Call {
	_c.Call.Return(accountTeamCreateOut, err)
	return _c
}

func (_c *MockClient_AccountTeamCreate_Call) RunAndReturn(run func(ctx context.Context, accountId string, in *accountteam.AccountTeamCreateIn) (*accountteam.AccountTeamCreateOut, error)) *MockClient_AccountTeamCreate_Call {
	_c.Call.Return(run)
	return _c
}

// AccountTeamDelete provides a mock function for the type MockClient
func (_mock *MockClient) AccountTeamDelete(ctx context.Context, accountId string, teamId string) error {
	ret := _mock.Called(ctx, accountId, teamId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, accountId, teamId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// AccountTeamDelete is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - teamId
func (_e *MockClient_Expecter) AccountTeamDelete(ctx interface{}, accountId interface{}, teamId interface{}) *MockClient_AccountTeamDelete_Call {
	return &MockClient_AccountTeamDelete_Call{Call: _e.mock.On("AccountTeamDelete", ctx, accountId, teamId)}
}

func (_c *MockClient_AccountTeamDelete_Call) Run(run func(ctx context.Context, accountId string, teamId string)) *MockClient_AccountTeamDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_AccountTeamDelete_Call) Return(err error) *MockClient_AccountTeamDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_AccountTeamDelete_Call) RunAndReturn(run func(ctx context.Context, accountId string, teamId string) error) *MockClient_AccountTeamDelete_Call {
	_c.Call.Return(run)
	return _c
}

// AccountTeamGet provides a mock function for the type MockClient
func (_mock *MockClient) AccountTeamGet(ctx context.Context, accountId string, teamId string) (*accountteam.AccountTeamGetOut, error) {
	ret := _mock.Called(ctx, accountId, teamId)

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

	var r0 *accountteam.AccountTeamGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*accountteam.AccountTeamGetOut, error)); ok {
		return returnFunc(ctx, accountId, teamId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *accountteam.AccountTeamGetOut); ok {
		r0 = returnFunc(ctx, accountId, teamId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*accountteam.AccountTeamGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, accountId, teamId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountTeamGet is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - teamId
func (_e *MockClient_Expecter) AccountTeamGet(ctx interface{}, accountId interface{}, teamId interface{}) *MockClient_AccountTeamGet_Call {
	return &MockClient_AccountTeamGet_Call{Call: _e.mock.On("AccountTeamGet", ctx, accountId, teamId)}
}

func (_c *MockClient_AccountTeamGet_Call) Run(run func(ctx context.Context, accountId string, teamId string)) *MockClient_AccountTeamGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_AccountTeamGet_Call) Return(accountTeamGetOut *accountteam.AccountTeamGetOut, err error) *MockClient_AccountTeamGet_Call {
	_c.Call.Return(accountTeamGetOut, err)
	return _c
}

func (_c *MockClient_AccountTeamGet_Call) RunAndReturn(run func(ctx context.Context, accountId string, teamId string) (*accountteam.AccountTeamGetOut, error)) *MockClient_AccountTeamGet_Call {
	_c.Call.Return(run)
	return _c
}

// AccountTeamInvitesList provides a mock function for the type MockClient
func (_mock *MockClient) AccountTeamInvitesList(ctx context.Context, accountId string, teamId string) ([]accountteam.AccountInviteOut, error) {
	ret := _mock.Called(ctx, accountId, teamId)

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

	var r0 []accountteam.AccountInviteOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]accountteam.AccountInviteOut, error)); ok {
		return returnFunc(ctx, accountId, teamId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []accountteam.AccountInviteOut); ok {
		r0 = returnFunc(ctx, accountId, teamId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]accountteam.AccountInviteOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, accountId, teamId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountTeamInvitesList is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - teamId
func (_e *MockClient_Expecter) AccountTeamInvitesList(ctx interface{}, accountId interface{}, teamId interface{}) *MockClient_AccountTeamInvitesList_Call {
	return &MockClient_AccountTeamInvitesList_Call{Call: _e.mock.On("AccountTeamInvitesList", ctx, accountId, teamId)}
}

func (_c *MockClient_AccountTeamInvitesList_Call) Run(run func(ctx context.Context, accountId string, teamId string)) *MockClient_AccountTeamInvitesList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_AccountTeamInvitesList_Call) Return(accountInviteOuts []accountteam.AccountInviteOut, err error) *MockClient_AccountTeamInvitesList_Call {
	_c.Call.Return(accountInviteOuts, err)
	return _c
}

func (_c *MockClient_AccountTeamInvitesList_Call) RunAndReturn(run func(ctx context.Context, accountId string, teamId string) ([]accountteam.AccountInviteOut, error)) *MockClient_AccountTeamInvitesList_Call {
	_c.Call.Return(run)
	return _c
}

// AccountTeamList provides a mock function for the type MockClient
func (_mock *MockClient) AccountTeamList(ctx context.Context, accountId string) ([]accountteam.TeamOut, error) {
	ret := _mock.Called(ctx, accountId)

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

	var r0 []accountteam.TeamOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]accountteam.TeamOut, error)); ok {
		return returnFunc(ctx, accountId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []accountteam.TeamOut); ok {
		r0 = returnFunc(ctx, accountId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]accountteam.TeamOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, accountId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountTeamList is a helper method to define mock.On call
//   - ctx
//   - accountId
func (_e *MockClient_Expecter) AccountTeamList(ctx interface{}, accountId interface{}) *MockClient_AccountTeamList_Call {
	return &MockClient_AccountTeamList_Call{Call: _e.mock.On("AccountTeamList", ctx, accountId)}
}

func (_c *MockClient_AccountTeamList_Call) Run(run func(ctx context.Context, accountId string)) *MockClient_AccountTeamList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_AccountTeamList_Call) Return(teamOuts []accountteam.TeamOut, err error) *MockClient_AccountTeamList_Call {
	_c.Call.Return(teamOuts, err)
	return _c
}

func (_c *MockClient_AccountTeamList_Call) RunAndReturn(run func(ctx context.Context, accountId string) ([]accountteam.TeamOut, error)) *MockClient_AccountTeamList_Call {
	_c.Call.Return(run)
	return _c
}

// AccountTeamMemberCancelInvite provides a mock function for the type MockClient
func (_mock *MockClient) AccountTeamMemberCancelInvite(ctx context.Context, accountId string, teamId string, userEmail string) error {
	ret := _mock.Called(ctx, accountId, teamId, userEmail)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, accountId, teamId, userEmail)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// AccountTeamMemberCancelInvite is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - teamId
//   - userEmail
func (_e *MockClient_Expecter) AccountTeamMemberCancelInvite(ctx interface{}, accountId interface{}, teamId interface{}, userEmail interface{}) *MockClient_AccountTeamMemberCancelInvite_Call {
	return &MockClient_AccountTeamMemberCancelInvite_Call{Call: _e.mock.On("AccountTeamMemberCancelInvite", ctx, accountId, teamId, userEmail)}
}

func (_c *MockClient_AccountTeamMemberCancelInvite_Call) Run(run func(ctx context.Context, accountId string, teamId string, userEmail string)) *MockClient_AccountTeamMemberCancelInvite_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_AccountTeamMemberCancelInvite_Call) Return(err error) *MockClient_AccountTeamMemberCancelInvite_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_AccountTeamMemberCancelInvite_Call) RunAndReturn(run func(ctx context.Context, accountId string, teamId string, userEmail string) error) *MockClient_AccountTeamMemberCancelInvite_Call {
	_c.Call.Return(run)
	return _c
}

// AccountTeamMemberVerifyInvite provides a mock function for the type MockClient
func (_mock *MockClient) AccountTeamMemberVerifyInvite(ctx context.Context, accountId string, inviteVerificationCode string) (*accountteammember.AccountTeamMemberVerifyInviteOut, error) {
	ret := _mock.Called(ctx, accountId, inviteVerificationCode)

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

	var r0 *accountteammember.AccountTeamMemberVerifyInviteOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*accountteammember.AccountTeamMemberVerifyInviteOut, error)); ok {
		return returnFunc(ctx, accountId, inviteVerificationCode)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *accountteammember.AccountTeamMemberVerifyInviteOut); ok {
		r0 = returnFunc(ctx, accountId, inviteVerificationCode)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*accountteammember.AccountTeamMemberVerifyInviteOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, accountId, inviteVerificationCode)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountTeamMemberVerifyInvite is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - inviteVerificationCode
func (_e *MockClient_Expecter) AccountTeamMemberVerifyInvite(ctx interface{}, accountId interface{}, inviteVerificationCode interface{}) *MockClient_AccountTeamMemberVerifyInvite_Call {
	return &MockClient_AccountTeamMemberVerifyInvite_Call{Call: _e.mock.On("AccountTeamMemberVerifyInvite", ctx, accountId, inviteVerificationCode)}
}

func (_c *MockClient_AccountTeamMemberVerifyInvite_Call) Run(run func(ctx context.Context, accountId string, inviteVerificationCode string)) *MockClient_AccountTeamMemberVerifyInvite_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_AccountTeamMemberVerifyInvite_Call) Return(accountTeamMemberVerifyInviteOut *accountteammember.AccountTeamMemberVerifyInviteOut, err error) *MockClient_AccountTeamMemberVerifyInvite_Call {
	_c.Call.Return(accountTeamMemberVerifyInviteOut, err)
	return _c
}

func (_c *MockClient_AccountTeamMemberVerifyInvite_Call) RunAndReturn(run func(ctx context.Context, accountId string, inviteVerificationCode string) (*accountteammember.AccountTeamMemberVerifyInviteOut, error)) *MockClient_AccountTeamMemberVerifyInvite_Call {
	_c.Call.Return(run)
	return _c
}

// AccountTeamMembersDelete provides a mock function for the type MockClient
func (_mock *MockClient) AccountTeamMembersDelete(ctx context.Context, accountId string, teamId string, userId string) error {
	ret := _mock.Called(ctx, accountId, teamId, userId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, accountId, teamId, userId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// AccountTeamMembersDelete is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - teamId
//   - userId
func (_e *MockClient_Expecter) AccountTeamMembersDelete(ctx interface{}, accountId interface{}, teamId interface{}, userId interface{}) *MockClient_AccountTeamMembersDelete_Call {
	return &MockClient_AccountTeamMembersDelete_Call{Call: _e.mock.On("AccountTeamMembersDelete", ctx, accountId, teamId, userId)}
}

func (_c *MockClient_AccountTeamMembersDelete_Call) Run(run func(ctx context.Context, accountId string, teamId string, userId string)) *MockClient_AccountTeamMembersDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_AccountTeamMembersDelete_Call) Return(err error) *MockClient_AccountTeamMembersDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_AccountTeamMembersDelete_Call) RunAndReturn(run func(ctx context.Context, accountId string, teamId string, userId string) error) *MockClient_AccountTeamMembersDelete_Call {
	_c.Call.Return(run)
	return _c
}

// AccountTeamMembersInvite provides a mock function for the type MockClient
func (_mock *MockClient) AccountTeamMembersInvite(ctx context.Context, accountId string, teamId string, in *accountteammember.AccountTeamMembersInviteIn) error {
	ret := _mock.Called(ctx, accountId, teamId, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *accountteammember.AccountTeamMembersInviteIn) error); ok {
		r0 = returnFunc(ctx, accountId, teamId, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// AccountTeamMembersInvite is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - teamId
//   - in
func (_e *MockClient_Expecter) AccountTeamMembersInvite(ctx interface{}, accountId interface{}, teamId interface{}, in interface{}) *MockClient_AccountTeamMembersInvite_Call {
	return &MockClient_AccountTeamMembersInvite_Call{Call: _e.mock.On("AccountTeamMembersInvite", ctx, accountId, teamId, in)}
}

func (_c *MockClient_AccountTeamMembersInvite_Call) Run(run func(ctx context.Context, accountId string, teamId string, in *accountteammember.AccountTeamMembersInviteIn)) *MockClient_AccountTeamMembersInvite_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*accountteammember.AccountTeamMembersInviteIn))
	})
	return _c
}

func (_c *MockClient_AccountTeamMembersInvite_Call) Return(err error) *MockClient_AccountTeamMembersInvite_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_AccountTeamMembersInvite_Call) RunAndReturn(run func(ctx context.Context, accountId string, teamId string, in *accountteammember.AccountTeamMembersInviteIn) error) *MockClient_AccountTeamMembersInvite_Call {
	_c.Call.Return(run)
	return _c
}

// AccountTeamMembersList provides a mock function for the type MockClient
func (_mock *MockClient) AccountTeamMembersList(ctx context.Context, accountId string, teamId string) ([]accountteammember.MemberOut, error) {
	ret := _mock.Called(ctx, accountId, teamId)

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

	var r0 []accountteammember.MemberOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]accountteammember.MemberOut, error)); ok {
		return returnFunc(ctx, accountId, teamId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []accountteammember.MemberOut); ok {
		r0 = returnFunc(ctx, accountId, teamId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]accountteammember.MemberOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, accountId, teamId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountTeamMembersList is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - teamId
func (_e *MockClient_Expecter) AccountTeamMembersList(ctx interface{}, accountId interface{}, teamId interface{}) *MockClient_AccountTeamMembersList_Call {
	return &MockClient_AccountTeamMembersList_Call{Call: _e.mock.On("AccountTeamMembersList", ctx, accountId, teamId)}
}

func (_c *MockClient_AccountTeamMembersList_Call) Run(run func(ctx context.Context, accountId string, teamId string)) *MockClient_AccountTeamMembersList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_AccountTeamMembersList_Call) Return(memberOuts []accountteammember.MemberOut, err error) *MockClient_AccountTeamMembersList_Call {
	_c.Call.Return(memberOuts, err)
	return _c
}

func (_c *MockClient_AccountTeamMembersList_Call) RunAndReturn(run func(ctx context.Context, accountId string, teamId string) ([]accountteammember.MemberOut, error)) *MockClient_AccountTeamMembersList_Call {
	_c.Call.Return(run)
	return _c
}

// AccountTeamProjectAssociate provides a mock function for the type MockClient
func (_mock *MockClient) AccountTeamProjectAssociate(ctx context.Context, accountId string, teamId string, project string, in *accountteam.AccountTeamProjectAssociateIn) error {
	ret := _mock.Called(ctx, accountId, teamId, project, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *accountteam.AccountTeamProjectAssociateIn) error); ok {
		r0 = returnFunc(ctx, accountId, teamId, project, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// AccountTeamProjectAssociate is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - teamId
//   - project
//   - in
func (_e *MockClient_Expecter) AccountTeamProjectAssociate(ctx interface{}, accountId interface{}, teamId interface{}, project interface{}, in interface{}) *MockClient_AccountTeamProjectAssociate_Call {
	return &MockClient_AccountTeamProjectAssociate_Call{Call: _e.mock.On("AccountTeamProjectAssociate", ctx, accountId, teamId, project, in)}
}

func (_c *MockClient_AccountTeamProjectAssociate_Call) Run(run func(ctx context.Context, accountId string, teamId string, project string, in *accountteam.AccountTeamProjectAssociateIn)) *MockClient_AccountTeamProjectAssociate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*accountteam.AccountTeamProjectAssociateIn))
	})
	return _c
}

func (_c *MockClient_AccountTeamProjectAssociate_Call) Return(err error) *MockClient_AccountTeamProjectAssociate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_AccountTeamProjectAssociate_Call) RunAndReturn(run func(ctx context.Context, accountId string, teamId string, project string, in *accountteam.AccountTeamProjectAssociateIn) error) *MockClient_AccountTeamProjectAssociate_Call {
	_c.Call.Return(run)
	return _c
}

// AccountTeamProjectAssociationUpdate provides a mock function for the type MockClient
func (_mock *MockClient) AccountTeamProjectAssociationUpdate(ctx context.Context, accountId string, teamId string, project string, in *accountteam.AccountTeamProjectAssociationUpdateIn) error {
	ret := _mock.Called(ctx, accountId, teamId, project, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *accountteam.AccountTeamProjectAssociationUpdateIn) error); ok {
		r0 = returnFunc(ctx, accountId, teamId, project, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// AccountTeamProjectAssociationUpdate is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - teamId
//   - project
//   - in
func (_e *MockClient_Expecter) AccountTeamProjectAssociationUpdate(ctx interface{}, accountId interface{}, teamId interface{}, project interface{}, in interface{}) *MockClient_AccountTeamProjectAssociationUpdate_Call {
	return &MockClient_AccountTeamProjectAssociationUpdate_Call{Call: _e.mock.On("AccountTeamProjectAssociationUpdate", ctx, accountId, teamId, project, in)}
}

func (_c *MockClient_AccountTeamProjectAssociationUpdate_Call) Run(run func(ctx context.Context, accountId string, teamId string, project string, in *accountteam.AccountTeamProjectAssociationUpdateIn)) *MockClient_AccountTeamProjectAssociationUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*accountteam.AccountTeamProjectAssociationUpdateIn))
	})
	return _c
}

func (_c *MockClient_AccountTeamProjectAssociationUpdate_Call) Return(err error) *MockClient_AccountTeamProjectAssociationUpdate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_AccountTeamProjectAssociationUpdate_Call) RunAndReturn(run func(ctx context.Context, accountId string, teamId string, project string, in *accountteam.AccountTeamProjectAssociationUpdateIn) error) *MockClient_AccountTeamProjectAssociationUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// AccountTeamProjectDisassociate provides a mock function for the type MockClient
func (_mock *MockClient) AccountTeamProjectDisassociate(ctx context.Context, accountId string, teamId string, project string) error {
	ret := _mock.Called(ctx, accountId, teamId, project)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, accountId, teamId, project)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// AccountTeamProjectDisassociate is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - teamId
//   - project
func (_e *MockClient_Expecter) AccountTeamProjectDisassociate(ctx interface{}, accountId interface{}, teamId interface{}, project interface{}) *MockClient_AccountTeamProjectDisassociate_Call {
	return &MockClient_AccountTeamProjectDisassociate_Call{Call: _e.mock.On("AccountTeamProjectDisassociate", ctx, accountId, teamId, project)}
}

func (_c *MockClient_AccountTeamProjectDisassociate_Call) Run(run func(ctx context.Context, accountId string, teamId string, project string)) *MockClient_AccountTeamProjectDisassociate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_AccountTeamProjectDisassociate_Call) Return(err error) *MockClient_AccountTeamProjectDisassociate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_AccountTeamProjectDisassociate_Call) RunAndReturn(run func(ctx context.Context, accountId string, teamId string, project string) error) *MockClient_AccountTeamProjectDisassociate_Call {
	_c.Call.Return(run)
	return _c
}

// AccountTeamProjectList provides a mock function for the type MockClient
func (_mock *MockClient) AccountTeamProjectList(ctx context.Context, accountId string, teamId string) ([]accountteam.ProjectOut, error) {
	ret := _mock.Called(ctx, accountId, teamId)

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

	var r0 []accountteam.ProjectOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]accountteam.ProjectOut, error)); ok {
		return returnFunc(ctx, accountId, teamId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []accountteam.ProjectOut); ok {
		r0 = returnFunc(ctx, accountId, teamId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]accountteam.ProjectOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, accountId, teamId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountTeamProjectList is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - teamId
func (_e *MockClient_Expecter) AccountTeamProjectList(ctx interface{}, accountId interface{}, teamId interface{}) *MockClient_AccountTeamProjectList_Call {
	return &MockClient_AccountTeamProjectList_Call{Call: _e.mock.On("AccountTeamProjectList", ctx, accountId, teamId)}
}

func (_c *MockClient_AccountTeamProjectList_Call) Run(run func(ctx context.Context, accountId string, teamId string)) *MockClient_AccountTeamProjectList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_AccountTeamProjectList_Call) Return(projectOuts []accountteam.ProjectOut, err error) *MockClient_AccountTeamProjectList_Call {
	_c.Call.Return(projectOuts, err)
	return _c
}

func (_c *MockClient_AccountTeamProjectList_Call) RunAndReturn(run func(ctx context.Context, accountId string, teamId string) ([]accountteam.ProjectOut, error)) *MockClient_AccountTeamProjectList_Call {
	_c.Call.Return(run)
	return _c
}

// AccountTeamUpdate provides a mock function for the type MockClient
func (_mock *MockClient) AccountTeamUpdate(ctx context.Context, accountId string, teamId string, in *accountteam.AccountTeamUpdateIn) (*accountteam.AccountTeamUpdateOut, error) {
	ret := _mock.Called(ctx, accountId, teamId, in)

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

	var r0 *accountteam.AccountTeamUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *accountteam.AccountTeamUpdateIn) (*accountteam.AccountTeamUpdateOut, error)); ok {
		return returnFunc(ctx, accountId, teamId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *accountteam.AccountTeamUpdateIn) *accountteam.AccountTeamUpdateOut); ok {
		r0 = returnFunc(ctx, accountId, teamId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*accountteam.AccountTeamUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *accountteam.AccountTeamUpdateIn) error); ok {
		r1 = returnFunc(ctx, accountId, teamId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountTeamUpdate is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - teamId
//   - in
func (_e *MockClient_Expecter) AccountTeamUpdate(ctx interface{}, accountId interface{}, teamId interface{}, in interface{}) *MockClient_AccountTeamUpdate_Call {
	return &MockClient_AccountTeamUpdate_Call{Call: _e.mock.On("AccountTeamUpdate", ctx, accountId, teamId, in)}
}

func (_c *MockClient_AccountTeamUpdate_Call) Run(run func(ctx context.Context, accountId string, teamId string, in *accountteam.AccountTeamUpdateIn)) *MockClient_AccountTeamUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*accountteam.AccountTeamUpdateIn))
	})
	return _c
}

func (_c *MockClient_AccountTeamUpdate_Call) Return(accountTeamUpdateOut *accountteam.AccountTeamUpdateOut, err error) *MockClient_AccountTeamUpdate_Call {
	_c.Call.Return(accountTeamUpdateOut, err)
	return _c
}

func (_c *MockClient_AccountTeamUpdate_Call) RunAndReturn(run func(ctx context.Context, accountId string, teamId string, in *accountteam.AccountTeamUpdateIn) (*accountteam.AccountTeamUpdateOut, error)) *MockClient_AccountTeamUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// AccountUpdate provides a mock function for the type MockClient
func (_mock *MockClient) AccountUpdate(ctx context.Context, accountId string, in *account.AccountUpdateIn) (*account.AccountUpdateOut, error) {
	ret := _mock.Called(ctx, accountId, in)

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

	var r0 *account.AccountUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *account.AccountUpdateIn) (*account.AccountUpdateOut, error)); ok {
		return returnFunc(ctx, accountId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *account.AccountUpdateIn) *account.AccountUpdateOut); ok {
		r0 = returnFunc(ctx, accountId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*account.AccountUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *account.AccountUpdateIn) error); ok {
		r1 = returnFunc(ctx, accountId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountUpdate is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - in
func (_e *MockClient_Expecter) AccountUpdate(ctx interface{}, accountId interface{}, in interface{}) *MockClient_AccountUpdate_Call {
	return &MockClient_AccountUpdate_Call{Call: _e.mock.On("AccountUpdate", ctx, accountId, in)}
}

func (_c *MockClient_AccountUpdate_Call) Run(run func(ctx context.Context, accountId string, in *account.AccountUpdateIn)) *MockClient_AccountUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*account.AccountUpdateIn))
	})
	return _c
}

func (_c *MockClient_AccountUpdate_Call) Return(accountUpdateOut *account.AccountUpdateOut, err error) *MockClient_AccountUpdate_Call {
	_c.Call.Return(accountUpdateOut, err)
	return _c
}

func (_c *MockClient_AccountUpdate_Call) RunAndReturn(run func(ctx context.Context, accountId string, in *account.AccountUpdateIn) (*account.AccountUpdateOut, error)) *MockClient_AccountUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// AccountUserProjectsList provides a mock function for the type MockClient
func (_mock *MockClient) AccountUserProjectsList(ctx context.Context, accountId string, userId string) ([]account.UserProjectOut, error) {
	ret := _mock.Called(ctx, accountId, userId)

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

	var r0 []account.UserProjectOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]account.UserProjectOut, error)); ok {
		return returnFunc(ctx, accountId, userId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []account.UserProjectOut); ok {
		r0 = returnFunc(ctx, accountId, userId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]account.UserProjectOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, accountId, userId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountUserProjectsList is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - userId
func (_e *MockClient_Expecter) AccountUserProjectsList(ctx interface{}, accountId interface{}, userId interface{}) *MockClient_AccountUserProjectsList_Call {
	return &MockClient_AccountUserProjectsList_Call{Call: _e.mock.On("AccountUserProjectsList", ctx, accountId, userId)}
}

func (_c *MockClient_AccountUserProjectsList_Call) Run(run func(ctx context.Context, accountId string, userId string)) *MockClient_AccountUserProjectsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_AccountUserProjectsList_Call) Return(userProjectOuts []account.UserProjectOut, err error) *MockClient_AccountUserProjectsList_Call {
	_c.Call.Return(userProjectOuts, err)
	return _c
}

func (_c *MockClient_AccountUserProjectsList_Call) RunAndReturn(run func(ctx context.Context, accountId string, userId string) ([]account.UserProjectOut, error)) *MockClient_AccountUserProjectsList_Call {
	_c.Call.Return(run)
	return _c
}

// AccountUserTeamsList provides a mock function for the type MockClient
func (_mock *MockClient) AccountUserTeamsList(ctx context.Context, accountId string, userId string) ([]account.AccountUserTeamsListOut, error) {
	ret := _mock.Called(ctx, accountId, userId)

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

	var r0 []account.AccountUserTeamsListOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]account.AccountUserTeamsListOut, error)); ok {
		return returnFunc(ctx, accountId, userId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []account.AccountUserTeamsListOut); ok {
		r0 = returnFunc(ctx, accountId, userId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]account.AccountUserTeamsListOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, accountId, userId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountUserTeamsList is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - userId
func (_e *MockClient_Expecter) AccountUserTeamsList(ctx interface{}, accountId interface{}, userId interface{}) *MockClient_AccountUserTeamsList_Call {
	return &MockClient_AccountUserTeamsList_Call{Call: _e.mock.On("AccountUserTeamsList", ctx, accountId, userId)}
}

func (_c *MockClient_AccountUserTeamsList_Call) Run(run func(ctx context.Context, accountId string, userId string)) *MockClient_AccountUserTeamsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_AccountUserTeamsList_Call) Return(accountUserTeamsListOuts []account.AccountUserTeamsListOut, err error) *MockClient_AccountUserTeamsList_Call {
	_c.Call.Return(accountUserTeamsListOuts, err)
	return _c
}

func (_c *MockClient_AccountUserTeamsList_Call) RunAndReturn(run func(ctx context.Context, accountId string, userId string) ([]account.AccountUserTeamsListOut, error)) *MockClient_AccountUserTeamsList_Call {
	_c.Call.Return(run)
	return _c
}

// AccountUsersSearch provides a mock function for the type MockClient
func (_mock *MockClient) AccountUsersSearch(ctx context.Context, accountId string, in *account.AccountUsersSearchIn) ([]account.UserOut, error) {
	ret := _mock.Called(ctx, accountId, in)

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

	var r0 []account.UserOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *account.AccountUsersSearchIn) ([]account.UserOut, error)); ok {
		return returnFunc(ctx, accountId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *account.AccountUsersSearchIn) []account.UserOut); ok {
		r0 = returnFunc(ctx, accountId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]account.UserOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *account.AccountUsersSearchIn) error); ok {
		r1 = returnFunc(ctx, accountId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AccountUsersSearch is a helper method to define mock.On call
//   - ctx
//   - accountId
//   - in
func (_e *MockClient_Expecter) AccountUsersSearch(ctx interface{}, accountId interface{}, in interface{}) *MockClient_AccountUsersSearch_Call {
	return &MockClient_AccountUsersSearch_Call{Call: _e.mock.On("AccountUsersSearch", ctx, accountId, in)}
}

func (_c *MockClient_AccountUsersSearch_Call) Run(run func(ctx context.Context, accountId string, in *account.AccountUsersSearchIn)) *MockClient_AccountUsersSearch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*account.AccountUsersSearchIn))
	})
	return _c
}

func (_c *MockClient_AccountUsersSearch_Call) Return(userOuts []account.UserOut, err error) *MockClient_AccountUsersSearch_Call {
	_c.Call.Return(userOuts, err)
	return _c
}

func (_c *MockClient_AccountUsersSearch_Call) RunAndReturn(run func(ctx context.Context, accountId string, in *account.AccountUsersSearchIn) ([]account.UserOut, error)) *MockClient_AccountUsersSearch_Call {
	_c.Call.Return(run)
	return _c
}

// AlloyDbOmniGoogleCloudPrivateKeyIdentify provides a mock function for the type MockClient
func (_mock *MockClient) AlloyDbOmniGoogleCloudPrivateKeyIdentify(ctx context.Context, project string, serviceName string) (*alloydbomni.AlloyDbOmniGoogleCloudPrivateKeyIdentifyOut, error) {
	ret := _mock.Called(ctx, project, serviceName)

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

	var r0 *alloydbomni.AlloyDbOmniGoogleCloudPrivateKeyIdentifyOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*alloydbomni.AlloyDbOmniGoogleCloudPrivateKeyIdentifyOut, error)); ok {
		return returnFunc(ctx, project, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *alloydbomni.AlloyDbOmniGoogleCloudPrivateKeyIdentifyOut); ok {
		r0 = returnFunc(ctx, project, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*alloydbomni.AlloyDbOmniGoogleCloudPrivateKeyIdentifyOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AlloyDbOmniGoogleCloudPrivateKeyIdentify is a helper method to define mock.On call
//   - ctx
//   - project
//   - serviceName
func (_e *MockClient_Expecter) AlloyDbOmniGoogleCloudPrivateKeyIdentify(ctx interface{}, project interface{}, serviceName interface{}) *MockClient_AlloyDbOmniGoogleCloudPrivateKeyIdentify_Call {
	return &MockClient_AlloyDbOmniGoogleCloudPrivateKeyIdentify_Call{Call: _e.mock.On("AlloyDbOmniGoogleCloudPrivateKeyIdentify", ctx, project, serviceName)}
}

func (_c *MockClient_AlloyDbOmniGoogleCloudPrivateKeyIdentify_Call) Run(run func(ctx context.Context, project string, serviceName string)) *MockClient_AlloyDbOmniGoogleCloudPrivateKeyIdentify_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_AlloyDbOmniGoogleCloudPrivateKeyIdentify_Call) Return(alloyDbOmniGoogleCloudPrivateKeyIdentifyOut *alloydbomni.AlloyDbOmniGoogleCloudPrivateKeyIdentifyOut, err error) *MockClient_AlloyDbOmniGoogleCloudPrivateKeyIdentify_Call {
	_c.Call.Return(alloyDbOmniGoogleCloudPrivateKeyIdentifyOut, err)
	return _c
}

func (_c *MockClient_AlloyDbOmniGoogleCloudPrivateKeyIdentify_Call) RunAndReturn(run func(ctx context.Context, project string, serviceName string) (*alloydbomni.AlloyDbOmniGoogleCloudPrivateKeyIdentifyOut, error)) *MockClient_AlloyDbOmniGoogleCloudPrivateKeyIdentify_Call {
	_c.Call.Return(run)
	return _c
}

// AlloyDbOmniGoogleCloudPrivateKeyRemove provides a mock function for the type MockClient
func (_mock *MockClient) AlloyDbOmniGoogleCloudPrivateKeyRemove(ctx context.Context, project string, serviceName string) (*alloydbomni.AlloyDbOmniGoogleCloudPrivateKeyRemoveOut, error) {
	ret := _mock.Called(ctx, project, serviceName)

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

	var r0 *alloydbomni.AlloyDbOmniGoogleCloudPrivateKeyRemoveOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*alloydbomni.AlloyDbOmniGoogleCloudPrivateKeyRemoveOut, error)); ok {
		return returnFunc(ctx, project, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *alloydbomni.AlloyDbOmniGoogleCloudPrivateKeyRemoveOut); ok {
		r0 = returnFunc(ctx, project, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*alloydbomni.AlloyDbOmniGoogleCloudPrivateKeyRemoveOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AlloyDbOmniGoogleCloudPrivateKeyRemove is a helper method to define mock.On call
//   - ctx
//   - project
//   - serviceName
func (_e *MockClient_Expecter) AlloyDbOmniGoogleCloudPrivateKeyRemove(ctx interface{}, project interface{}, serviceName interface{}) *MockClient_AlloyDbOmniGoogleCloudPrivateKeyRemove_Call {
	return &MockClient_AlloyDbOmniGoogleCloudPrivateKeyRemove_Call{Call: _e.mock.On("AlloyDbOmniGoogleCloudPrivateKeyRemove", ctx, project, serviceName)}
}

func (_c *MockClient_AlloyDbOmniGoogleCloudPrivateKeyRemove_Call) Run(run func(ctx context.Context, project string, serviceName string)) *MockClient_AlloyDbOmniGoogleCloudPrivateKeyRemove_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_AlloyDbOmniGoogleCloudPrivateKeyRemove_Call) Return(alloyDbOmniGoogleCloudPrivateKeyRemoveOut *alloydbomni.AlloyDbOmniGoogleCloudPrivateKeyRemoveOut, err error) *MockClient_AlloyDbOmniGoogleCloudPrivateKeyRemove_Call {
	_c.Call.Return(alloyDbOmniGoogleCloudPrivateKeyRemoveOut, err)
	return _c
}

func (_c *MockClient_AlloyDbOmniGoogleCloudPrivateKeyRemove_Call) RunAndReturn(run func(ctx context.Context, project string, serviceName string) (*alloydbomni.AlloyDbOmniGoogleCloudPrivateKeyRemoveOut, error)) *MockClient_AlloyDbOmniGoogleCloudPrivateKeyRemove_Call {
	_c.Call.Return(run)
	return _c
}

// AlloyDbOmniGoogleCloudPrivateKeySet provides a mock function for the type MockClient
func (_mock *MockClient) AlloyDbOmniGoogleCloudPrivateKeySet(ctx context.Context, project string, serviceName string, in *alloydbomni.AlloyDbOmniGoogleCloudPrivateKeySetIn) (*alloydbomni.AlloyDbOmniGoogleCloudPrivateKeySetOut, error) {
	ret := _mock.Called(ctx, project, serviceName, in)

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

	var r0 *alloydbomni.AlloyDbOmniGoogleCloudPrivateKeySetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *alloydbomni.AlloyDbOmniGoogleCloudPrivateKeySetIn) (*alloydbomni.AlloyDbOmniGoogleCloudPrivateKeySetOut, error)); ok {
		return returnFunc(ctx, project, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *alloydbomni.AlloyDbOmniGoogleCloudPrivateKeySetIn) *alloydbomni.AlloyDbOmniGoogleCloudPrivateKeySetOut); ok {
		r0 = returnFunc(ctx, project, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*alloydbomni.AlloyDbOmniGoogleCloudPrivateKeySetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *alloydbomni.AlloyDbOmniGoogleCloudPrivateKeySetIn) error); ok {
		r1 = returnFunc(ctx, project, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AlloyDbOmniGoogleCloudPrivateKeySet is a helper method to define mock.On call
//   - ctx
//   - project
//   - serviceName
//   - in
func (_e *MockClient_Expecter) AlloyDbOmniGoogleCloudPrivateKeySet(ctx interface{}, project interface{}, serviceName interface{}, in interface{}) *MockClient_AlloyDbOmniGoogleCloudPrivateKeySet_Call {
	return &MockClient_AlloyDbOmniGoogleCloudPrivateKeySet_Call{Call: _e.mock.On("AlloyDbOmniGoogleCloudPrivateKeySet", ctx, project, serviceName, in)}
}

func (_c *MockClient_AlloyDbOmniGoogleCloudPrivateKeySet_Call) Run(run func(ctx context.Context, project string, serviceName string, in *alloydbomni.AlloyDbOmniGoogleCloudPrivateKeySetIn)) *MockClient_AlloyDbOmniGoogleCloudPrivateKeySet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*alloydbomni.AlloyDbOmniGoogleCloudPrivateKeySetIn))
	})
	return _c
}

func (_c *MockClient_AlloyDbOmniGoogleCloudPrivateKeySet_Call) Return(alloyDbOmniGoogleCloudPrivateKeySetOut *alloydbomni.AlloyDbOmniGoogleCloudPrivateKeySetOut, err error) *MockClient_AlloyDbOmniGoogleCloudPrivateKeySet_Call {
	_c.Call.Return(alloyDbOmniGoogleCloudPrivateKeySetOut, err)
	return _c
}

func (_c *MockClient_AlloyDbOmniGoogleCloudPrivateKeySet_Call) RunAndReturn(run func(ctx context.Context, project string, serviceName string, in *alloydbomni.AlloyDbOmniGoogleCloudPrivateKeySetIn) (*alloydbomni.AlloyDbOmniGoogleCloudPrivateKeySetOut, error)) *MockClient_AlloyDbOmniGoogleCloudPrivateKeySet_Call {
	_c.Call.Return(run)
	return _c
}

// ApplicationUserAccessTokenCreate provides a mock function for the type MockClient
func (_mock *MockClient) ApplicationUserAccessTokenCreate(ctx context.Context, organizationId string, userId string, in *applicationuser.ApplicationUserAccessTokenCreateIn) (*applicationuser.ApplicationUserAccessTokenCreateOut, error) {
	ret := _mock.Called(ctx, organizationId, userId, in)

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

	var r0 *applicationuser.ApplicationUserAccessTokenCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *applicationuser.ApplicationUserAccessTokenCreateIn) (*applicationuser.ApplicationUserAccessTokenCreateOut, error)); ok {
		return returnFunc(ctx, organizationId, userId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *applicationuser.ApplicationUserAccessTokenCreateIn) *applicationuser.ApplicationUserAccessTokenCreateOut); ok {
		r0 = returnFunc(ctx, organizationId, userId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*applicationuser.ApplicationUserAccessTokenCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *applicationuser.ApplicationUserAccessTokenCreateIn) error); ok {
		r1 = returnFunc(ctx, organizationId, userId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ApplicationUserAccessTokenCreate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - userId
//   - in
func (_e *MockClient_Expecter) ApplicationUserAccessTokenCreate(ctx interface{}, organizationId interface{}, userId interface{}, in interface{}) *MockClient_ApplicationUserAccessTokenCreate_Call {
	return &MockClient_ApplicationUserAccessTokenCreate_Call{Call: _e.mock.On("ApplicationUserAccessTokenCreate", ctx, organizationId, userId, in)}
}

func (_c *MockClient_ApplicationUserAccessTokenCreate_Call) Run(run func(ctx context.Context, organizationId string, userId string, in *applicationuser.ApplicationUserAccessTokenCreateIn)) *MockClient_ApplicationUserAccessTokenCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*applicationuser.ApplicationUserAccessTokenCreateIn))
	})
	return _c
}

func (_c *MockClient_ApplicationUserAccessTokenCreate_Call) Return(applicationUserAccessTokenCreateOut *applicationuser.ApplicationUserAccessTokenCreateOut, err error) *MockClient_ApplicationUserAccessTokenCreate_Call {
	_c.Call.Return(applicationUserAccessTokenCreateOut, err)
	return _c
}

func (_c *MockClient_ApplicationUserAccessTokenCreate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, userId string, in *applicationuser.ApplicationUserAccessTokenCreateIn) (*applicationuser.ApplicationUserAccessTokenCreateOut, error)) *MockClient_ApplicationUserAccessTokenCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ApplicationUserAccessTokenDelete provides a mock function for the type MockClient
func (_mock *MockClient) ApplicationUserAccessTokenDelete(ctx context.Context, organizationId string, userId string, tokenPrefix string) error {
	ret := _mock.Called(ctx, organizationId, userId, tokenPrefix)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, organizationId, userId, tokenPrefix)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ApplicationUserAccessTokenDelete is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - userId
//   - tokenPrefix
func (_e *MockClient_Expecter) ApplicationUserAccessTokenDelete(ctx interface{}, organizationId interface{}, userId interface{}, tokenPrefix interface{}) *MockClient_ApplicationUserAccessTokenDelete_Call {
	return &MockClient_ApplicationUserAccessTokenDelete_Call{Call: _e.mock.On("ApplicationUserAccessTokenDelete", ctx, organizationId, userId, tokenPrefix)}
}

func (_c *MockClient_ApplicationUserAccessTokenDelete_Call) Run(run func(ctx context.Context, organizationId string, userId string, tokenPrefix string)) *MockClient_ApplicationUserAccessTokenDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ApplicationUserAccessTokenDelete_Call) Return(err error) *MockClient_ApplicationUserAccessTokenDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ApplicationUserAccessTokenDelete_Call) RunAndReturn(run func(ctx context.Context, organizationId string, userId string, tokenPrefix string) error) *MockClient_ApplicationUserAccessTokenDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ApplicationUserAccessTokensList provides a mock function for the type MockClient
func (_mock *MockClient) ApplicationUserAccessTokensList(ctx context.Context, organizationId string, userId string) ([]applicationuser.TokenOut, error) {
	ret := _mock.Called(ctx, organizationId, userId)

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

	var r0 []applicationuser.TokenOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]applicationuser.TokenOut, error)); ok {
		return returnFunc(ctx, organizationId, userId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []applicationuser.TokenOut); ok {
		r0 = returnFunc(ctx, organizationId, userId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]applicationuser.TokenOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, organizationId, userId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ApplicationUserAccessTokensList is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - userId
func (_e *MockClient_Expecter) ApplicationUserAccessTokensList(ctx interface{}, organizationId interface{}, userId interface{}) *MockClient_ApplicationUserAccessTokensList_Call {
	return &MockClient_ApplicationUserAccessTokensList_Call{Call: _e.mock.On("ApplicationUserAccessTokensList", ctx, organizationId, userId)}
}

func (_c *MockClient_ApplicationUserAccessTokensList_Call) Run(run func(ctx context.Context, organizationId string, userId string)) *MockClient_ApplicationUserAccessTokensList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ApplicationUserAccessTokensList_Call) Return(tokenOuts []applicationuser.TokenOut, err error) *MockClient_ApplicationUserAccessTokensList_Call {
	_c.Call.Return(tokenOuts, err)
	return _c
}

func (_c *MockClient_ApplicationUserAccessTokensList_Call) RunAndReturn(run func(ctx context.Context, organizationId string, userId string) ([]applicationuser.TokenOut, error)) *MockClient_ApplicationUserAccessTokensList_Call {
	_c.Call.Return(run)
	return _c
}

// ApplicationUserCreate provides a mock function for the type MockClient
func (_mock *MockClient) ApplicationUserCreate(ctx context.Context, organizationId string, in *applicationuser.ApplicationUserCreateIn) (*applicationuser.ApplicationUserCreateOut, error) {
	ret := _mock.Called(ctx, organizationId, in)

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

	var r0 *applicationuser.ApplicationUserCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *applicationuser.ApplicationUserCreateIn) (*applicationuser.ApplicationUserCreateOut, error)); ok {
		return returnFunc(ctx, organizationId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *applicationuser.ApplicationUserCreateIn) *applicationuser.ApplicationUserCreateOut); ok {
		r0 = returnFunc(ctx, organizationId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*applicationuser.ApplicationUserCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *applicationuser.ApplicationUserCreateIn) error); ok {
		r1 = returnFunc(ctx, organizationId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ApplicationUserCreate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - in
func (_e *MockClient_Expecter) ApplicationUserCreate(ctx interface{}, organizationId interface{}, in interface{}) *MockClient_ApplicationUserCreate_Call {
	return &MockClient_ApplicationUserCreate_Call{Call: _e.mock.On("ApplicationUserCreate", ctx, organizationId, in)}
}

func (_c *MockClient_ApplicationUserCreate_Call) Run(run func(ctx context.Context, organizationId string, in *applicationuser.ApplicationUserCreateIn)) *MockClient_ApplicationUserCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*applicationuser.ApplicationUserCreateIn))
	})
	return _c
}

func (_c *MockClient_ApplicationUserCreate_Call) Return(applicationUserCreateOut *applicationuser.ApplicationUserCreateOut, err error) *MockClient_ApplicationUserCreate_Call {
	_c.Call.Return(applicationUserCreateOut, err)
	return _c
}

func (_c *MockClient_ApplicationUserCreate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, in *applicationuser.ApplicationUserCreateIn) (*applicationuser.ApplicationUserCreateOut, error)) *MockClient_ApplicationUserCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ApplicationUserDelete provides a mock function for the type MockClient
func (_mock *MockClient) ApplicationUserDelete(ctx context.Context, organizationId string, userId string) error {
	ret := _mock.Called(ctx, organizationId, userId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, organizationId, userId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ApplicationUserDelete is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - userId
func (_e *MockClient_Expecter) ApplicationUserDelete(ctx interface{}, organizationId interface{}, userId interface{}) *MockClient_ApplicationUserDelete_Call {
	return &MockClient_ApplicationUserDelete_Call{Call: _e.mock.On("ApplicationUserDelete", ctx, organizationId, userId)}
}

func (_c *MockClient_ApplicationUserDelete_Call) Run(run func(ctx context.Context, organizationId string, userId string)) *MockClient_ApplicationUserDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ApplicationUserDelete_Call) Return(err error) *MockClient_ApplicationUserDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ApplicationUserDelete_Call) RunAndReturn(run func(ctx context.Context, organizationId string, userId string) error) *MockClient_ApplicationUserDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ApplicationUserGet provides a mock function for the type MockClient
func (_mock *MockClient) ApplicationUserGet(ctx context.Context, organizationId string, userId string) (*applicationuser.ApplicationUserGetOut, error) {
	ret := _mock.Called(ctx, organizationId, userId)

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

	var r0 *applicationuser.ApplicationUserGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*applicationuser.ApplicationUserGetOut, error)); ok {
		return returnFunc(ctx, organizationId, userId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *applicationuser.ApplicationUserGetOut); ok {
		r0 = returnFunc(ctx, organizationId, userId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*applicationuser.ApplicationUserGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, organizationId, userId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ApplicationUserGet is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - userId
func (_e *MockClient_Expecter) ApplicationUserGet(ctx interface{}, organizationId interface{}, userId interface{}) *MockClient_ApplicationUserGet_Call {
	return &MockClient_ApplicationUserGet_Call{Call: _e.mock.On("ApplicationUserGet", ctx, organizationId, userId)}
}

func (_c *MockClient_ApplicationUserGet_Call) Run(run func(ctx context.Context, organizationId string, userId string)) *MockClient_ApplicationUserGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ApplicationUserGet_Call) Return(applicationUserGetOut *applicationuser.ApplicationUserGetOut, err error) *MockClient_ApplicationUserGet_Call {
	_c.Call.Return(applicationUserGetOut, err)
	return _c
}

func (_c *MockClient_ApplicationUserGet_Call) RunAndReturn(run func(ctx context.Context, organizationId string, userId string) (*applicationuser.ApplicationUserGetOut, error)) *MockClient_ApplicationUserGet_Call {
	_c.Call.Return(run)
	return _c
}

// ApplicationUserUpdate provides a mock function for the type MockClient
func (_mock *MockClient) ApplicationUserUpdate(ctx context.Context, organizationId string, userId string, in *applicationuser.ApplicationUserUpdateIn) (*applicationuser.ApplicationUserUpdateOut, error) {
	ret := _mock.Called(ctx, organizationId, userId, in)

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

	var r0 *applicationuser.ApplicationUserUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *applicationuser.ApplicationUserUpdateIn) (*applicationuser.ApplicationUserUpdateOut, error)); ok {
		return returnFunc(ctx, organizationId, userId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *applicationuser.ApplicationUserUpdateIn) *applicationuser.ApplicationUserUpdateOut); ok {
		r0 = returnFunc(ctx, organizationId, userId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*applicationuser.ApplicationUserUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *applicationuser.ApplicationUserUpdateIn) error); ok {
		r1 = returnFunc(ctx, organizationId, userId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ApplicationUserUpdate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - userId
//   - in
func (_e *MockClient_Expecter) ApplicationUserUpdate(ctx interface{}, organizationId interface{}, userId interface{}, in interface{}) *MockClient_ApplicationUserUpdate_Call {
	return &MockClient_ApplicationUserUpdate_Call{Call: _e.mock.On("ApplicationUserUpdate", ctx, organizationId, userId, in)}
}

func (_c *MockClient_ApplicationUserUpdate_Call) Run(run func(ctx context.Context, organizationId string, userId string, in *applicationuser.ApplicationUserUpdateIn)) *MockClient_ApplicationUserUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*applicationuser.ApplicationUserUpdateIn))
	})
	return _c
}

func (_c *MockClient_ApplicationUserUpdate_Call) Return(applicationUserUpdateOut *applicationuser.ApplicationUserUpdateOut, err error) *MockClient_ApplicationUserUpdate_Call {
	_c.Call.Return(applicationUserUpdateOut, err)
	return _c
}

func (_c *MockClient_ApplicationUserUpdate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, userId string, in *applicationuser.ApplicationUserUpdateIn) (*applicationuser.ApplicationUserUpdateOut, error)) *MockClient_ApplicationUserUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// ApplicationUsersList provides a mock function for the type MockClient
func (_mock *MockClient) ApplicationUsersList(ctx context.Context, organizationId string) ([]applicationuser.ApplicationUserOut, error) {
	ret := _mock.Called(ctx, organizationId)

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

	var r0 []applicationuser.ApplicationUserOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]applicationuser.ApplicationUserOut, error)); ok {
		return returnFunc(ctx, organizationId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []applicationuser.ApplicationUserOut); ok {
		r0 = returnFunc(ctx, organizationId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]applicationuser.ApplicationUserOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, organizationId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ApplicationUsersList is a helper method to define mock.On call
//   - ctx
//   - organizationId
func (_e *MockClient_Expecter) ApplicationUsersList(ctx interface{}, organizationId interface{}) *MockClient_ApplicationUsersList_Call {
	return &MockClient_ApplicationUsersList_Call{Call: _e.mock.On("ApplicationUsersList", ctx, organizationId)}
}

func (_c *MockClient_ApplicationUsersList_Call) Run(run func(ctx context.Context, organizationId string)) *MockClient_ApplicationUsersList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ApplicationUsersList_Call) Return(applicationUserOuts []applicationuser.ApplicationUserOut, err error) *MockClient_ApplicationUsersList_Call {
	_c.Call.Return(applicationUserOuts, err)
	return _c
}

func (_c *MockClient_ApplicationUsersList_Call) RunAndReturn(run func(ctx context.Context, organizationId string) ([]applicationuser.ApplicationUserOut, error)) *MockClient_ApplicationUsersList_Call {
	_c.Call.Return(run)
	return _c
}

// BillingGroupCreate provides a mock function for the type MockClient
func (_mock *MockClient) BillingGroupCreate(ctx context.Context, in *billinggroup.BillingGroupCreateIn) (*billinggroup.BillingGroupCreateOut, error) {
	ret := _mock.Called(ctx, in)

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

	var r0 *billinggroup.BillingGroupCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *billinggroup.BillingGroupCreateIn) (*billinggroup.BillingGroupCreateOut, error)); ok {
		return returnFunc(ctx, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *billinggroup.BillingGroupCreateIn) *billinggroup.BillingGroupCreateOut); ok {
		r0 = returnFunc(ctx, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*billinggroup.BillingGroupCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *billinggroup.BillingGroupCreateIn) error); ok {
		r1 = returnFunc(ctx, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// BillingGroupCreate is a helper method to define mock.On call
//   - ctx
//   - in
func (_e *MockClient_Expecter) BillingGroupCreate(ctx interface{}, in interface{}) *MockClient_BillingGroupCreate_Call {
	return &MockClient_BillingGroupCreate_Call{Call: _e.mock.On("BillingGroupCreate", ctx, in)}
}

func (_c *MockClient_BillingGroupCreate_Call) Run(run func(ctx context.Context, in *billinggroup.BillingGroupCreateIn)) *MockClient_BillingGroupCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*billinggroup.BillingGroupCreateIn))
	})
	return _c
}

func (_c *MockClient_BillingGroupCreate_Call) Return(billingGroupCreateOut *billinggroup.BillingGroupCreateOut, err error) *MockClient_BillingGroupCreate_Call {
	_c.Call.Return(billingGroupCreateOut, err)
	return _c
}

func (_c *MockClient_BillingGroupCreate_Call) RunAndReturn(run func(ctx context.Context, in *billinggroup.BillingGroupCreateIn) (*billinggroup.BillingGroupCreateOut, error)) *MockClient_BillingGroupCreate_Call {
	_c.Call.Return(run)
	return _c
}

// BillingGroupCreditsClaim provides a mock function for the type MockClient
func (_mock *MockClient) BillingGroupCreditsClaim(ctx context.Context, billingGroupId string, in *billinggroup.BillingGroupCreditsClaimIn) (*billinggroup.BillingGroupCreditsClaimOut, error) {
	ret := _mock.Called(ctx, billingGroupId, in)

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

	var r0 *billinggroup.BillingGroupCreditsClaimOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *billinggroup.BillingGroupCreditsClaimIn) (*billinggroup.BillingGroupCreditsClaimOut, error)); ok {
		return returnFunc(ctx, billingGroupId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *billinggroup.BillingGroupCreditsClaimIn) *billinggroup.BillingGroupCreditsClaimOut); ok {
		r0 = returnFunc(ctx, billingGroupId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*billinggroup.BillingGroupCreditsClaimOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *billinggroup.BillingGroupCreditsClaimIn) error); ok {
		r1 = returnFunc(ctx, billingGroupId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// BillingGroupCreditsClaim is a helper method to define mock.On call
//   - ctx
//   - billingGroupId
//   - in
func (_e *MockClient_Expecter) BillingGroupCreditsClaim(ctx interface{}, billingGroupId interface{}, in interface{}) *MockClient_BillingGroupCreditsClaim_Call {
	return &MockClient_BillingGroupCreditsClaim_Call{Call: _e.mock.On("BillingGroupCreditsClaim", ctx, billingGroupId, in)}
}

func (_c *MockClient_BillingGroupCreditsClaim_Call) Run(run func(ctx context.Context, billingGroupId string, in *billinggroup.BillingGroupCreditsClaimIn)) *MockClient_BillingGroupCreditsClaim_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*billinggroup.BillingGroupCreditsClaimIn))
	})
	return _c
}

func (_c *MockClient_BillingGroupCreditsClaim_Call) Return(billingGroupCreditsClaimOut *billinggroup.BillingGroupCreditsClaimOut, err error) *MockClient_BillingGroupCreditsClaim_Call {
	_c.Call.Return(billingGroupCreditsClaimOut, err)
	return _c
}

func (_c *MockClient_BillingGroupCreditsClaim_Call) RunAndReturn(run func(ctx context.Context, billingGroupId string, in *billinggroup.BillingGroupCreditsClaimIn) (*billinggroup.BillingGroupCreditsClaimOut, error)) *MockClient_BillingGroupCreditsClaim_Call {
	_c.Call.Return(run)
	return _c
}

// BillingGroupCreditsList provides a mock function for the type MockClient
func (_mock *MockClient) BillingGroupCreditsList(ctx context.Context, billingGroupId string) ([]billinggroup.CreditOut, error) {
	ret := _mock.Called(ctx, billingGroupId)

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

	var r0 []billinggroup.CreditOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]billinggroup.CreditOut, error)); ok {
		return returnFunc(ctx, billingGroupId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []billinggroup.CreditOut); ok {
		r0 = returnFunc(ctx, billingGroupId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]billinggroup.CreditOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, billingGroupId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// BillingGroupCreditsList is a helper method to define mock.On call
//   - ctx
//   - billingGroupId
func (_e *MockClient_Expecter) BillingGroupCreditsList(ctx interface{}, billingGroupId interface{}) *MockClient_BillingGroupCreditsList_Call {
	return &MockClient_BillingGroupCreditsList_Call{Call: _e.mock.On("BillingGroupCreditsList", ctx, billingGroupId)}
}

func (_c *MockClient_BillingGroupCreditsList_Call) Run(run func(ctx context.Context, billingGroupId string)) *MockClient_BillingGroupCreditsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_BillingGroupCreditsList_Call) Return(creditOuts []billinggroup.CreditOut, err error) *MockClient_BillingGroupCreditsList_Call {
	_c.Call.Return(creditOuts, err)
	return _c
}

func (_c *MockClient_BillingGroupCreditsList_Call) RunAndReturn(run func(ctx context.Context, billingGroupId string) ([]billinggroup.CreditOut, error)) *MockClient_BillingGroupCreditsList_Call {
	_c.Call.Return(run)
	return _c
}

// BillingGroupDelete provides a mock function for the type MockClient
func (_mock *MockClient) BillingGroupDelete(ctx context.Context, billingGroupId string) error {
	ret := _mock.Called(ctx, billingGroupId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(ctx, billingGroupId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// BillingGroupDelete is a helper method to define mock.On call
//   - ctx
//   - billingGroupId
func (_e *MockClient_Expecter) BillingGroupDelete(ctx interface{}, billingGroupId interface{}) *MockClient_BillingGroupDelete_Call {
	return &MockClient_BillingGroupDelete_Call{Call: _e.mock.On("BillingGroupDelete", ctx, billingGroupId)}
}

func (_c *MockClient_BillingGroupDelete_Call) Run(run func(ctx context.Context, billingGroupId string)) *MockClient_BillingGroupDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_BillingGroupDelete_Call) Return(err error) *MockClient_BillingGroupDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_BillingGroupDelete_Call) RunAndReturn(run func(ctx context.Context, billingGroupId string) error) *MockClient_BillingGroupDelete_Call {
	_c.Call.Return(run)
	return _c
}

// BillingGroupEventList provides a mock function for the type MockClient
func (_mock *MockClient) BillingGroupEventList(ctx context.Context, billingGroupId string) ([]billinggroup.EventOut, error) {
	ret := _mock.Called(ctx, billingGroupId)

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

	var r0 []billinggroup.EventOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]billinggroup.EventOut, error)); ok {
		return returnFunc(ctx, billingGroupId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []billinggroup.EventOut); ok {
		r0 = returnFunc(ctx, billingGroupId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]billinggroup.EventOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, billingGroupId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// BillingGroupEventList is a helper method to define mock.On call
//   - ctx
//   - billingGroupId
func (_e *MockClient_Expecter) BillingGroupEventList(ctx interface{}, billingGroupId interface{}) *MockClient_BillingGroupEventList_Call {
	return &MockClient_BillingGroupEventList_Call{Call: _e.mock.On("BillingGroupEventList", ctx, billingGroupId)}
}

func (_c *MockClient_BillingGroupEventList_Call) Run(run func(ctx context.Context, billingGroupId string)) *MockClient_BillingGroupEventList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_BillingGroupEventList_Call) Return(eventOuts []billinggroup.EventOut, err error) *MockClient_BillingGroupEventList_Call {
	_c.Call.Return(eventOuts, err)
	return _c
}

func (_c *MockClient_BillingGroupEventList_Call) RunAndReturn(run func(ctx context.Context, billingGroupId string) ([]billinggroup.EventOut, error)) *MockClient_BillingGroupEventList_Call {
	_c.Call.Return(run)
	return _c
}

// BillingGroupGet provides a mock function for the type MockClient
func (_mock *MockClient) BillingGroupGet(ctx context.Context, billingGroupId string) (*billinggroup.BillingGroupGetOut, error) {
	ret := _mock.Called(ctx, billingGroupId)

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

	var r0 *billinggroup.BillingGroupGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*billinggroup.BillingGroupGetOut, error)); ok {
		return returnFunc(ctx, billingGroupId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *billinggroup.BillingGroupGetOut); ok {
		r0 = returnFunc(ctx, billingGroupId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*billinggroup.BillingGroupGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, billingGroupId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// BillingGroupGet is a helper method to define mock.On call
//   - ctx
//   - billingGroupId
func (_e *MockClient_Expecter) BillingGroupGet(ctx interface{}, billingGroupId interface{}) *MockClient_BillingGroupGet_Call {
	return &MockClient_BillingGroupGet_Call{Call: _e.mock.On("BillingGroupGet", ctx, billingGroupId)}
}

func (_c *MockClient_BillingGroupGet_Call) Run(run func(ctx context.Context, billingGroupId string)) *MockClient_BillingGroupGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_BillingGroupGet_Call) Return(billingGroupGetOut *billinggroup.BillingGroupGetOut, err error) *MockClient_BillingGroupGet_Call {
	_c.Call.Return(billingGroupGetOut, err)
	return _c
}

func (_c *MockClient_BillingGroupGet_Call) RunAndReturn(run func(ctx context.Context, billingGroupId string) (*billinggroup.BillingGroupGetOut, error)) *MockClient_BillingGroupGet_Call {
	_c.Call.Return(run)
	return _c
}

// BillingGroupInvoiceLinesList provides a mock function for the type MockClient
func (_mock *MockClient) BillingGroupInvoiceLinesList(ctx context.Context, billingGroupId string, invoiceNumber string) ([]billinggroup.LineOut, error) {
	ret := _mock.Called(ctx, billingGroupId, invoiceNumber)

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

	var r0 []billinggroup.LineOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]billinggroup.LineOut, error)); ok {
		return returnFunc(ctx, billingGroupId, invoiceNumber)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []billinggroup.LineOut); ok {
		r0 = returnFunc(ctx, billingGroupId, invoiceNumber)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]billinggroup.LineOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, billingGroupId, invoiceNumber)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// BillingGroupInvoiceLinesList is a helper method to define mock.On call
//   - ctx
//   - billingGroupId
//   - invoiceNumber
func (_e *MockClient_Expecter) BillingGroupInvoiceLinesList(ctx interface{}, billingGroupId interface{}, invoiceNumber interface{}) *MockClient_BillingGroupInvoiceLinesList_Call {
	return &MockClient_BillingGroupInvoiceLinesList_Call{Call: _e.mock.On("BillingGroupInvoiceLinesList", ctx, billingGroupId, invoiceNumber)}
}

func (_c *MockClient_BillingGroupInvoiceLinesList_Call) Run(run func(ctx context.Context, billingGroupId string, invoiceNumber string)) *MockClient_BillingGroupInvoiceLinesList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_BillingGroupInvoiceLinesList_Call) Return(lineOuts []billinggroup.LineOut, err error) *MockClient_BillingGroupInvoiceLinesList_Call {
	_c.Call.Return(lineOuts, err)
	return _c
}

func (_c *MockClient_BillingGroupInvoiceLinesList_Call) RunAndReturn(run func(ctx context.Context, billingGroupId string, invoiceNumber string) ([]billinggroup.LineOut, error)) *MockClient_BillingGroupInvoiceLinesList_Call {
	_c.Call.Return(run)
	return _c
}

// BillingGroupInvoiceList provides a mock function for the type MockClient
func (_mock *MockClient) BillingGroupInvoiceList(ctx context.Context, billingGroupId string) ([]billinggroup.InvoiceOut, error) {
	ret := _mock.Called(ctx, billingGroupId)

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

	var r0 []billinggroup.InvoiceOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]billinggroup.InvoiceOut, error)); ok {
		return returnFunc(ctx, billingGroupId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []billinggroup.InvoiceOut); ok {
		r0 = returnFunc(ctx, billingGroupId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]billinggroup.InvoiceOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, billingGroupId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// BillingGroupInvoiceList is a helper method to define mock.On call
//   - ctx
//   - billingGroupId
func (_e *MockClient_Expecter) BillingGroupInvoiceList(ctx interface{}, billingGroupId interface{}) *MockClient_BillingGroupInvoiceList_Call {
	return &MockClient_BillingGroupInvoiceList_Call{Call: _e.mock.On("BillingGroupInvoiceList", ctx, billingGroupId)}
}

func (_c *MockClient_BillingGroupInvoiceList_Call) Run(run func(ctx context.Context, billingGroupId string)) *MockClient_BillingGroupInvoiceList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_BillingGroupInvoiceList_Call) Return(invoiceOuts []billinggroup.InvoiceOut, err error) *MockClient_BillingGroupInvoiceList_Call {
	_c.Call.Return(invoiceOuts, err)
	return _c
}

func (_c *MockClient_BillingGroupInvoiceList_Call) RunAndReturn(run func(ctx context.Context, billingGroupId string) ([]billinggroup.InvoiceOut, error)) *MockClient_BillingGroupInvoiceList_Call {
	_c.Call.Return(run)
	return _c
}

// BillingGroupList provides a mock function for the type MockClient
func (_mock *MockClient) BillingGroupList(ctx context.Context) ([]billinggroup.BillingGroupOut, error) {
	ret := _mock.Called(ctx)

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

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

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

// BillingGroupList is a helper method to define mock.On call
//   - ctx
func (_e *MockClient_Expecter) BillingGroupList(ctx interface{}) *MockClient_BillingGroupList_Call {
	return &MockClient_BillingGroupList_Call{Call: _e.mock.On("BillingGroupList", ctx)}
}

func (_c *MockClient_BillingGroupList_Call) Run(run func(ctx context.Context)) *MockClient_BillingGroupList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockClient_BillingGroupList_Call) Return(billingGroupOuts []billinggroup.BillingGroupOut, err error) *MockClient_BillingGroupList_Call {
	_c.Call.Return(billingGroupOuts, err)
	return _c
}

func (_c *MockClient_BillingGroupList_Call) RunAndReturn(run func(ctx context.Context) ([]billinggroup.BillingGroupOut, error)) *MockClient_BillingGroupList_Call {
	_c.Call.Return(run)
	return _c
}

// BillingGroupProjectAssign provides a mock function for the type MockClient
func (_mock *MockClient) BillingGroupProjectAssign(ctx context.Context, billingGroupId string, project string) error {
	ret := _mock.Called(ctx, billingGroupId, project)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, billingGroupId, project)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// BillingGroupProjectAssign is a helper method to define mock.On call
//   - ctx
//   - billingGroupId
//   - project
func (_e *MockClient_Expecter) BillingGroupProjectAssign(ctx interface{}, billingGroupId interface{}, project interface{}) *MockClient_BillingGroupProjectAssign_Call {
	return &MockClient_BillingGroupProjectAssign_Call{Call: _e.mock.On("BillingGroupProjectAssign", ctx, billingGroupId, project)}
}

func (_c *MockClient_BillingGroupProjectAssign_Call) Run(run func(ctx context.Context, billingGroupId string, project string)) *MockClient_BillingGroupProjectAssign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_BillingGroupProjectAssign_Call) Return(err error) *MockClient_BillingGroupProjectAssign_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_BillingGroupProjectAssign_Call) RunAndReturn(run func(ctx context.Context, billingGroupId string, project string) error) *MockClient_BillingGroupProjectAssign_Call {
	_c.Call.Return(run)
	return _c
}

// BillingGroupProjectList provides a mock function for the type MockClient
func (_mock *MockClient) BillingGroupProjectList(ctx context.Context, billingGroupId string) ([]billinggroup.ProjectOut, error) {
	ret := _mock.Called(ctx, billingGroupId)

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

	var r0 []billinggroup.ProjectOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]billinggroup.ProjectOut, error)); ok {
		return returnFunc(ctx, billingGroupId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []billinggroup.ProjectOut); ok {
		r0 = returnFunc(ctx, billingGroupId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]billinggroup.ProjectOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, billingGroupId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// BillingGroupProjectList is a helper method to define mock.On call
//   - ctx
//   - billingGroupId
func (_e *MockClient_Expecter) BillingGroupProjectList(ctx interface{}, billingGroupId interface{}) *MockClient_BillingGroupProjectList_Call {
	return &MockClient_BillingGroupProjectList_Call{Call: _e.mock.On("BillingGroupProjectList", ctx, billingGroupId)}
}

func (_c *MockClient_BillingGroupProjectList_Call) Run(run func(ctx context.Context, billingGroupId string)) *MockClient_BillingGroupProjectList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_BillingGroupProjectList_Call) Return(projectOuts []billinggroup.ProjectOut, err error) *MockClient_BillingGroupProjectList_Call {
	_c.Call.Return(projectOuts, err)
	return _c
}

func (_c *MockClient_BillingGroupProjectList_Call) RunAndReturn(run func(ctx context.Context, billingGroupId string) ([]billinggroup.ProjectOut, error)) *MockClient_BillingGroupProjectList_Call {
	_c.Call.Return(run)
	return _c
}

// BillingGroupProjectsAssign provides a mock function for the type MockClient
func (_mock *MockClient) BillingGroupProjectsAssign(ctx context.Context, billingGroupId string, in *billinggroup.BillingGroupProjectsAssignIn) error {
	ret := _mock.Called(ctx, billingGroupId, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *billinggroup.BillingGroupProjectsAssignIn) error); ok {
		r0 = returnFunc(ctx, billingGroupId, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// BillingGroupProjectsAssign is a helper method to define mock.On call
//   - ctx
//   - billingGroupId
//   - in
func (_e *MockClient_Expecter) BillingGroupProjectsAssign(ctx interface{}, billingGroupId interface{}, in interface{}) *MockClient_BillingGroupProjectsAssign_Call {
	return &MockClient_BillingGroupProjectsAssign_Call{Call: _e.mock.On("BillingGroupProjectsAssign", ctx, billingGroupId, in)}
}

func (_c *MockClient_BillingGroupProjectsAssign_Call) Run(run func(ctx context.Context, billingGroupId string, in *billinggroup.BillingGroupProjectsAssignIn)) *MockClient_BillingGroupProjectsAssign_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*billinggroup.BillingGroupProjectsAssignIn))
	})
	return _c
}

func (_c *MockClient_BillingGroupProjectsAssign_Call) Return(err error) *MockClient_BillingGroupProjectsAssign_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_BillingGroupProjectsAssign_Call) RunAndReturn(run func(ctx context.Context, billingGroupId string, in *billinggroup.BillingGroupProjectsAssignIn) error) *MockClient_BillingGroupProjectsAssign_Call {
	_c.Call.Return(run)
	return _c
}

// BillingGroupUpdate provides a mock function for the type MockClient
func (_mock *MockClient) BillingGroupUpdate(ctx context.Context, billingGroupId string, in *billinggroup.BillingGroupUpdateIn) (*billinggroup.BillingGroupUpdateOut, error) {
	ret := _mock.Called(ctx, billingGroupId, in)

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

	var r0 *billinggroup.BillingGroupUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *billinggroup.BillingGroupUpdateIn) (*billinggroup.BillingGroupUpdateOut, error)); ok {
		return returnFunc(ctx, billingGroupId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *billinggroup.BillingGroupUpdateIn) *billinggroup.BillingGroupUpdateOut); ok {
		r0 = returnFunc(ctx, billingGroupId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*billinggroup.BillingGroupUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *billinggroup.BillingGroupUpdateIn) error); ok {
		r1 = returnFunc(ctx, billingGroupId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// BillingGroupUpdate is a helper method to define mock.On call
//   - ctx
//   - billingGroupId
//   - in
func (_e *MockClient_Expecter) BillingGroupUpdate(ctx interface{}, billingGroupId interface{}, in interface{}) *MockClient_BillingGroupUpdate_Call {
	return &MockClient_BillingGroupUpdate_Call{Call: _e.mock.On("BillingGroupUpdate", ctx, billingGroupId, in)}
}

func (_c *MockClient_BillingGroupUpdate_Call) Run(run func(ctx context.Context, billingGroupId string, in *billinggroup.BillingGroupUpdateIn)) *MockClient_BillingGroupUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*billinggroup.BillingGroupUpdateIn))
	})
	return _c
}

func (_c *MockClient_BillingGroupUpdate_Call) Return(billingGroupUpdateOut *billinggroup.BillingGroupUpdateOut, err error) *MockClient_BillingGroupUpdate_Call {
	_c.Call.Return(billingGroupUpdateOut, err)
	return _c
}

func (_c *MockClient_BillingGroupUpdate_Call) RunAndReturn(run func(ctx context.Context, billingGroupId string, in *billinggroup.BillingGroupUpdateIn) (*billinggroup.BillingGroupUpdateOut, error)) *MockClient_BillingGroupUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// CheckPasswordStrengthExistingUser provides a mock function for the type MockClient
func (_mock *MockClient) CheckPasswordStrengthExistingUser(ctx context.Context, in *user.CheckPasswordStrengthExistingUserIn) (*user.CheckPasswordStrengthExistingUserOut, error) {
	ret := _mock.Called(ctx, in)

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

	var r0 *user.CheckPasswordStrengthExistingUserOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.CheckPasswordStrengthExistingUserIn) (*user.CheckPasswordStrengthExistingUserOut, error)); ok {
		return returnFunc(ctx, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.CheckPasswordStrengthExistingUserIn) *user.CheckPasswordStrengthExistingUserOut); ok {
		r0 = returnFunc(ctx, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*user.CheckPasswordStrengthExistingUserOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *user.CheckPasswordStrengthExistingUserIn) error); ok {
		r1 = returnFunc(ctx, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CheckPasswordStrengthExistingUser is a helper method to define mock.On call
//   - ctx
//   - in
func (_e *MockClient_Expecter) CheckPasswordStrengthExistingUser(ctx interface{}, in interface{}) *MockClient_CheckPasswordStrengthExistingUser_Call {
	return &MockClient_CheckPasswordStrengthExistingUser_Call{Call: _e.mock.On("CheckPasswordStrengthExistingUser", ctx, in)}
}

func (_c *MockClient_CheckPasswordStrengthExistingUser_Call) Run(run func(ctx context.Context, in *user.CheckPasswordStrengthExistingUserIn)) *MockClient_CheckPasswordStrengthExistingUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*user.CheckPasswordStrengthExistingUserIn))
	})
	return _c
}

func (_c *MockClient_CheckPasswordStrengthExistingUser_Call) Return(checkPasswordStrengthExistingUserOut *user.CheckPasswordStrengthExistingUserOut, err error) *MockClient_CheckPasswordStrengthExistingUser_Call {
	_c.Call.Return(checkPasswordStrengthExistingUserOut, err)
	return _c
}

func (_c *MockClient_CheckPasswordStrengthExistingUser_Call) RunAndReturn(run func(ctx context.Context, in *user.CheckPasswordStrengthExistingUserIn) (*user.CheckPasswordStrengthExistingUserOut, error)) *MockClient_CheckPasswordStrengthExistingUser_Call {
	_c.Call.Return(run)
	return _c
}

// CheckPasswordStrengthNewUser provides a mock function for the type MockClient
func (_mock *MockClient) CheckPasswordStrengthNewUser(ctx context.Context, in *user.CheckPasswordStrengthNewUserIn) (*user.CheckPasswordStrengthNewUserOut, error) {
	ret := _mock.Called(ctx, in)

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

	var r0 *user.CheckPasswordStrengthNewUserOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.CheckPasswordStrengthNewUserIn) (*user.CheckPasswordStrengthNewUserOut, error)); ok {
		return returnFunc(ctx, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.CheckPasswordStrengthNewUserIn) *user.CheckPasswordStrengthNewUserOut); ok {
		r0 = returnFunc(ctx, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*user.CheckPasswordStrengthNewUserOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *user.CheckPasswordStrengthNewUserIn) error); ok {
		r1 = returnFunc(ctx, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CheckPasswordStrengthNewUser is a helper method to define mock.On call
//   - ctx
//   - in
func (_e *MockClient_Expecter) CheckPasswordStrengthNewUser(ctx interface{}, in interface{}) *MockClient_CheckPasswordStrengthNewUser_Call {
	return &MockClient_CheckPasswordStrengthNewUser_Call{Call: _e.mock.On("CheckPasswordStrengthNewUser", ctx, in)}
}

func (_c *MockClient_CheckPasswordStrengthNewUser_Call) Run(run func(ctx context.Context, in *user.CheckPasswordStrengthNewUserIn)) *MockClient_CheckPasswordStrengthNewUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*user.CheckPasswordStrengthNewUserIn))
	})
	return _c
}

func (_c *MockClient_CheckPasswordStrengthNewUser_Call) Return(checkPasswordStrengthNewUserOut *user.CheckPasswordStrengthNewUserOut, err error) *MockClient_CheckPasswordStrengthNewUser_Call {
	_c.Call.Return(checkPasswordStrengthNewUserOut, err)
	return _c
}

func (_c *MockClient_CheckPasswordStrengthNewUser_Call) RunAndReturn(run func(ctx context.Context, in *user.CheckPasswordStrengthNewUserIn) (*user.CheckPasswordStrengthNewUserOut, error)) *MockClient_CheckPasswordStrengthNewUser_Call {
	_c.Call.Return(run)
	return _c
}

// CustomCloudEnvironmentCreate provides a mock function for the type MockClient
func (_mock *MockClient) CustomCloudEnvironmentCreate(ctx context.Context, organizationId string, in *byoc.CustomCloudEnvironmentCreateIn) (*byoc.CustomCloudEnvironmentCreateOut, error) {
	ret := _mock.Called(ctx, organizationId, in)

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

	var r0 *byoc.CustomCloudEnvironmentCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *byoc.CustomCloudEnvironmentCreateIn) (*byoc.CustomCloudEnvironmentCreateOut, error)); ok {
		return returnFunc(ctx, organizationId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *byoc.CustomCloudEnvironmentCreateIn) *byoc.CustomCloudEnvironmentCreateOut); ok {
		r0 = returnFunc(ctx, organizationId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*byoc.CustomCloudEnvironmentCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *byoc.CustomCloudEnvironmentCreateIn) error); ok {
		r1 = returnFunc(ctx, organizationId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CustomCloudEnvironmentCreate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - in
func (_e *MockClient_Expecter) CustomCloudEnvironmentCreate(ctx interface{}, organizationId interface{}, in interface{}) *MockClient_CustomCloudEnvironmentCreate_Call {
	return &MockClient_CustomCloudEnvironmentCreate_Call{Call: _e.mock.On("CustomCloudEnvironmentCreate", ctx, organizationId, in)}
}

func (_c *MockClient_CustomCloudEnvironmentCreate_Call) Run(run func(ctx context.Context, organizationId string, in *byoc.CustomCloudEnvironmentCreateIn)) *MockClient_CustomCloudEnvironmentCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*byoc.CustomCloudEnvironmentCreateIn))
	})
	return _c
}

func (_c *MockClient_CustomCloudEnvironmentCreate_Call) Return(customCloudEnvironmentCreateOut *byoc.CustomCloudEnvironmentCreateOut, err error) *MockClient_CustomCloudEnvironmentCreate_Call {
	_c.Call.Return(customCloudEnvironmentCreateOut, err)
	return _c
}

func (_c *MockClient_CustomCloudEnvironmentCreate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, in *byoc.CustomCloudEnvironmentCreateIn) (*byoc.CustomCloudEnvironmentCreateOut, error)) *MockClient_CustomCloudEnvironmentCreate_Call {
	_c.Call.Return(run)
	return _c
}

// CustomCloudEnvironmentDelete provides a mock function for the type MockClient
func (_mock *MockClient) CustomCloudEnvironmentDelete(ctx context.Context, organizationId string, customCloudEnvironmentId string) error {
	ret := _mock.Called(ctx, organizationId, customCloudEnvironmentId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, organizationId, customCloudEnvironmentId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// CustomCloudEnvironmentDelete is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - customCloudEnvironmentId
func (_e *MockClient_Expecter) CustomCloudEnvironmentDelete(ctx interface{}, organizationId interface{}, customCloudEnvironmentId interface{}) *MockClient_CustomCloudEnvironmentDelete_Call {
	return &MockClient_CustomCloudEnvironmentDelete_Call{Call: _e.mock.On("CustomCloudEnvironmentDelete", ctx, organizationId, customCloudEnvironmentId)}
}

func (_c *MockClient_CustomCloudEnvironmentDelete_Call) Run(run func(ctx context.Context, organizationId string, customCloudEnvironmentId string)) *MockClient_CustomCloudEnvironmentDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_CustomCloudEnvironmentDelete_Call) Return(err error) *MockClient_CustomCloudEnvironmentDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_CustomCloudEnvironmentDelete_Call) RunAndReturn(run func(ctx context.Context, organizationId string, customCloudEnvironmentId string) error) *MockClient_CustomCloudEnvironmentDelete_Call {
	_c.Call.Return(run)
	return _c
}

// CustomCloudEnvironmentGet provides a mock function for the type MockClient
func (_mock *MockClient) CustomCloudEnvironmentGet(ctx context.Context, organizationId string, customCloudEnvironmentId string) (*byoc.CustomCloudEnvironmentGetOut, error) {
	ret := _mock.Called(ctx, organizationId, customCloudEnvironmentId)

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

	var r0 *byoc.CustomCloudEnvironmentGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*byoc.CustomCloudEnvironmentGetOut, error)); ok {
		return returnFunc(ctx, organizationId, customCloudEnvironmentId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *byoc.CustomCloudEnvironmentGetOut); ok {
		r0 = returnFunc(ctx, organizationId, customCloudEnvironmentId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*byoc.CustomCloudEnvironmentGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, organizationId, customCloudEnvironmentId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CustomCloudEnvironmentGet is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - customCloudEnvironmentId
func (_e *MockClient_Expecter) CustomCloudEnvironmentGet(ctx interface{}, organizationId interface{}, customCloudEnvironmentId interface{}) *MockClient_CustomCloudEnvironmentGet_Call {
	return &MockClient_CustomCloudEnvironmentGet_Call{Call: _e.mock.On("CustomCloudEnvironmentGet", ctx, organizationId, customCloudEnvironmentId)}
}

func (_c *MockClient_CustomCloudEnvironmentGet_Call) Run(run func(ctx context.Context, organizationId string, customCloudEnvironmentId string)) *MockClient_CustomCloudEnvironmentGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_CustomCloudEnvironmentGet_Call) Return(customCloudEnvironmentGetOut *byoc.CustomCloudEnvironmentGetOut, err error) *MockClient_CustomCloudEnvironmentGet_Call {
	_c.Call.Return(customCloudEnvironmentGetOut, err)
	return _c
}

func (_c *MockClient_CustomCloudEnvironmentGet_Call) RunAndReturn(run func(ctx context.Context, organizationId string, customCloudEnvironmentId string) (*byoc.CustomCloudEnvironmentGetOut, error)) *MockClient_CustomCloudEnvironmentGet_Call {
	_c.Call.Return(run)
	return _c
}

// CustomCloudEnvironmentPermissionsGet provides a mock function for the type MockClient
func (_mock *MockClient) CustomCloudEnvironmentPermissionsGet(ctx context.Context, organizationId string, customCloudEnvironmentId string) (*byoc.CustomCloudEnvironmentPermissionsGetOut, error) {
	ret := _mock.Called(ctx, organizationId, customCloudEnvironmentId)

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

	var r0 *byoc.CustomCloudEnvironmentPermissionsGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*byoc.CustomCloudEnvironmentPermissionsGetOut, error)); ok {
		return returnFunc(ctx, organizationId, customCloudEnvironmentId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *byoc.CustomCloudEnvironmentPermissionsGetOut); ok {
		r0 = returnFunc(ctx, organizationId, customCloudEnvironmentId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*byoc.CustomCloudEnvironmentPermissionsGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, organizationId, customCloudEnvironmentId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CustomCloudEnvironmentPermissionsGet is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - customCloudEnvironmentId
func (_e *MockClient_Expecter) CustomCloudEnvironmentPermissionsGet(ctx interface{}, organizationId interface{}, customCloudEnvironmentId interface{}) *MockClient_CustomCloudEnvironmentPermissionsGet_Call {
	return &MockClient_CustomCloudEnvironmentPermissionsGet_Call{Call: _e.mock.On("CustomCloudEnvironmentPermissionsGet", ctx, organizationId, customCloudEnvironmentId)}
}

func (_c *MockClient_CustomCloudEnvironmentPermissionsGet_Call) Run(run func(ctx context.Context, organizationId string, customCloudEnvironmentId string)) *MockClient_CustomCloudEnvironmentPermissionsGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_CustomCloudEnvironmentPermissionsGet_Call) Return(customCloudEnvironmentPermissionsGetOut *byoc.CustomCloudEnvironmentPermissionsGetOut, err error) *MockClient_CustomCloudEnvironmentPermissionsGet_Call {
	_c.Call.Return(customCloudEnvironmentPermissionsGetOut, err)
	return _c
}

func (_c *MockClient_CustomCloudEnvironmentPermissionsGet_Call) RunAndReturn(run func(ctx context.Context, organizationId string, customCloudEnvironmentId string) (*byoc.CustomCloudEnvironmentPermissionsGetOut, error)) *MockClient_CustomCloudEnvironmentPermissionsGet_Call {
	_c.Call.Return(run)
	return _c
}

// CustomCloudEnvironmentPermissionsSet provides a mock function for the type MockClient
func (_mock *MockClient) CustomCloudEnvironmentPermissionsSet(ctx context.Context, organizationId string, customCloudEnvironmentId string, in *byoc.CustomCloudEnvironmentPermissionsSetIn) error {
	ret := _mock.Called(ctx, organizationId, customCloudEnvironmentId, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *byoc.CustomCloudEnvironmentPermissionsSetIn) error); ok {
		r0 = returnFunc(ctx, organizationId, customCloudEnvironmentId, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// CustomCloudEnvironmentPermissionsSet is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - customCloudEnvironmentId
//   - in
func (_e *MockClient_Expecter) CustomCloudEnvironmentPermissionsSet(ctx interface{}, organizationId interface{}, customCloudEnvironmentId interface{}, in interface{}) *MockClient_CustomCloudEnvironmentPermissionsSet_Call {
	return &MockClient_CustomCloudEnvironmentPermissionsSet_Call{Call: _e.mock.On("CustomCloudEnvironmentPermissionsSet", ctx, organizationId, customCloudEnvironmentId, in)}
}

func (_c *MockClient_CustomCloudEnvironmentPermissionsSet_Call) Run(run func(ctx context.Context, organizationId string, customCloudEnvironmentId string, in *byoc.CustomCloudEnvironmentPermissionsSetIn)) *MockClient_CustomCloudEnvironmentPermissionsSet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*byoc.CustomCloudEnvironmentPermissionsSetIn))
	})
	return _c
}

func (_c *MockClient_CustomCloudEnvironmentPermissionsSet_Call) Return(err error) *MockClient_CustomCloudEnvironmentPermissionsSet_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_CustomCloudEnvironmentPermissionsSet_Call) RunAndReturn(run func(ctx context.Context, organizationId string, customCloudEnvironmentId string, in *byoc.CustomCloudEnvironmentPermissionsSetIn) error) *MockClient_CustomCloudEnvironmentPermissionsSet_Call {
	_c.Call.Return(run)
	return _c
}

// CustomCloudEnvironmentProvision provides a mock function for the type MockClient
func (_mock *MockClient) CustomCloudEnvironmentProvision(ctx context.Context, organizationId string, customCloudEnvironmentId string, in *byoc.CustomCloudEnvironmentProvisionIn) (*byoc.CustomCloudEnvironmentProvisionOut, error) {
	ret := _mock.Called(ctx, organizationId, customCloudEnvironmentId, in)

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

	var r0 *byoc.CustomCloudEnvironmentProvisionOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *byoc.CustomCloudEnvironmentProvisionIn) (*byoc.CustomCloudEnvironmentProvisionOut, error)); ok {
		return returnFunc(ctx, organizationId, customCloudEnvironmentId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *byoc.CustomCloudEnvironmentProvisionIn) *byoc.CustomCloudEnvironmentProvisionOut); ok {
		r0 = returnFunc(ctx, organizationId, customCloudEnvironmentId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*byoc.CustomCloudEnvironmentProvisionOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *byoc.CustomCloudEnvironmentProvisionIn) error); ok {
		r1 = returnFunc(ctx, organizationId, customCloudEnvironmentId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CustomCloudEnvironmentProvision is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - customCloudEnvironmentId
//   - in
func (_e *MockClient_Expecter) CustomCloudEnvironmentProvision(ctx interface{}, organizationId interface{}, customCloudEnvironmentId interface{}, in interface{}) *MockClient_CustomCloudEnvironmentProvision_Call {
	return &MockClient_CustomCloudEnvironmentProvision_Call{Call: _e.mock.On("CustomCloudEnvironmentProvision", ctx, organizationId, customCloudEnvironmentId, in)}
}

func (_c *MockClient_CustomCloudEnvironmentProvision_Call) Run(run func(ctx context.Context, organizationId string, customCloudEnvironmentId string, in *byoc.CustomCloudEnvironmentProvisionIn)) *MockClient_CustomCloudEnvironmentProvision_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*byoc.CustomCloudEnvironmentProvisionIn))
	})
	return _c
}

func (_c *MockClient_CustomCloudEnvironmentProvision_Call) Return(customCloudEnvironmentProvisionOut *byoc.CustomCloudEnvironmentProvisionOut, err error) *MockClient_CustomCloudEnvironmentProvision_Call {
	_c.Call.Return(customCloudEnvironmentProvisionOut, err)
	return _c
}

func (_c *MockClient_CustomCloudEnvironmentProvision_Call) RunAndReturn(run func(ctx context.Context, organizationId string, customCloudEnvironmentId string, in *byoc.CustomCloudEnvironmentProvisionIn) (*byoc.CustomCloudEnvironmentProvisionOut, error)) *MockClient_CustomCloudEnvironmentProvision_Call {
	_c.Call.Return(run)
	return _c
}

// CustomCloudEnvironmentUpdate provides a mock function for the type MockClient
func (_mock *MockClient) CustomCloudEnvironmentUpdate(ctx context.Context, organizationId string, customCloudEnvironmentId string, in *byoc.CustomCloudEnvironmentUpdateIn) (*byoc.CustomCloudEnvironmentUpdateOut, error) {
	ret := _mock.Called(ctx, organizationId, customCloudEnvironmentId, in)

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

	var r0 *byoc.CustomCloudEnvironmentUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *byoc.CustomCloudEnvironmentUpdateIn) (*byoc.CustomCloudEnvironmentUpdateOut, error)); ok {
		return returnFunc(ctx, organizationId, customCloudEnvironmentId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *byoc.CustomCloudEnvironmentUpdateIn) *byoc.CustomCloudEnvironmentUpdateOut); ok {
		r0 = returnFunc(ctx, organizationId, customCloudEnvironmentId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*byoc.CustomCloudEnvironmentUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *byoc.CustomCloudEnvironmentUpdateIn) error); ok {
		r1 = returnFunc(ctx, organizationId, customCloudEnvironmentId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CustomCloudEnvironmentUpdate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - customCloudEnvironmentId
//   - in
func (_e *MockClient_Expecter) CustomCloudEnvironmentUpdate(ctx interface{}, organizationId interface{}, customCloudEnvironmentId interface{}, in interface{}) *MockClient_CustomCloudEnvironmentUpdate_Call {
	return &MockClient_CustomCloudEnvironmentUpdate_Call{Call: _e.mock.On("CustomCloudEnvironmentUpdate", ctx, organizationId, customCloudEnvironmentId, in)}
}

func (_c *MockClient_CustomCloudEnvironmentUpdate_Call) Run(run func(ctx context.Context, organizationId string, customCloudEnvironmentId string, in *byoc.CustomCloudEnvironmentUpdateIn)) *MockClient_CustomCloudEnvironmentUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*byoc.CustomCloudEnvironmentUpdateIn))
	})
	return _c
}

func (_c *MockClient_CustomCloudEnvironmentUpdate_Call) Return(customCloudEnvironmentUpdateOut *byoc.CustomCloudEnvironmentUpdateOut, err error) *MockClient_CustomCloudEnvironmentUpdate_Call {
	_c.Call.Return(customCloudEnvironmentUpdateOut, err)
	return _c
}

func (_c *MockClient_CustomCloudEnvironmentUpdate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, customCloudEnvironmentId string, in *byoc.CustomCloudEnvironmentUpdateIn) (*byoc.CustomCloudEnvironmentUpdateOut, error)) *MockClient_CustomCloudEnvironmentUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// InvoiceGet provides a mock function for the type MockClient
func (_mock *MockClient) InvoiceGet(ctx context.Context, invoiceNumber string) (*projectbilling.InvoiceGetOut, error) {
	ret := _mock.Called(ctx, invoiceNumber)

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

	var r0 *projectbilling.InvoiceGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*projectbilling.InvoiceGetOut, error)); ok {
		return returnFunc(ctx, invoiceNumber)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *projectbilling.InvoiceGetOut); ok {
		r0 = returnFunc(ctx, invoiceNumber)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*projectbilling.InvoiceGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, invoiceNumber)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// InvoiceGet is a helper method to define mock.On call
//   - ctx
//   - invoiceNumber
func (_e *MockClient_Expecter) InvoiceGet(ctx interface{}, invoiceNumber interface{}) *MockClient_InvoiceGet_Call {
	return &MockClient_InvoiceGet_Call{Call: _e.mock.On("InvoiceGet", ctx, invoiceNumber)}
}

func (_c *MockClient_InvoiceGet_Call) Run(run func(ctx context.Context, invoiceNumber string)) *MockClient_InvoiceGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_InvoiceGet_Call) Return(invoiceGetOut *projectbilling.InvoiceGetOut, err error) *MockClient_InvoiceGet_Call {
	_c.Call.Return(invoiceGetOut, err)
	return _c
}

func (_c *MockClient_InvoiceGet_Call) RunAndReturn(run func(ctx context.Context, invoiceNumber string) (*projectbilling.InvoiceGetOut, error)) *MockClient_InvoiceGet_Call {
	_c.Call.Return(run)
	return _c
}

// ListClouds provides a mock function for the type MockClient
func (_mock *MockClient) ListClouds(ctx context.Context) ([]cloud.CloudOut, error) {
	ret := _mock.Called(ctx)

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

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

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

// ListClouds is a helper method to define mock.On call
//   - ctx
func (_e *MockClient_Expecter) ListClouds(ctx interface{}) *MockClient_ListClouds_Call {
	return &MockClient_ListClouds_Call{Call: _e.mock.On("ListClouds", ctx)}
}

func (_c *MockClient_ListClouds_Call) Run(run func(ctx context.Context)) *MockClient_ListClouds_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockClient_ListClouds_Call) Return(cloudOuts []cloud.CloudOut, err error) *MockClient_ListClouds_Call {
	_c.Call.Return(cloudOuts, err)
	return _c
}

func (_c *MockClient_ListClouds_Call) RunAndReturn(run func(ctx context.Context) ([]cloud.CloudOut, error)) *MockClient_ListClouds_Call {
	_c.Call.Return(run)
	return _c
}

// ListProjectClouds provides a mock function for the type MockClient
func (_mock *MockClient) ListProjectClouds(ctx context.Context, project string) ([]cloud.CloudOut, error) {
	ret := _mock.Called(ctx, project)

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

	var r0 []cloud.CloudOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]cloud.CloudOut, error)); ok {
		return returnFunc(ctx, project)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []cloud.CloudOut); ok {
		r0 = returnFunc(ctx, project)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]cloud.CloudOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, project)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListProjectClouds is a helper method to define mock.On call
//   - ctx
//   - project
func (_e *MockClient_Expecter) ListProjectClouds(ctx interface{}, project interface{}) *MockClient_ListProjectClouds_Call {
	return &MockClient_ListProjectClouds_Call{Call: _e.mock.On("ListProjectClouds", ctx, project)}
}

func (_c *MockClient_ListProjectClouds_Call) Run(run func(ctx context.Context, project string)) *MockClient_ListProjectClouds_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ListProjectClouds_Call) Return(cloudOuts []cloud.CloudOut, err error) *MockClient_ListProjectClouds_Call {
	_c.Call.Return(cloudOuts, err)
	return _c
}

func (_c *MockClient_ListProjectClouds_Call) RunAndReturn(run func(ctx context.Context, project string) ([]cloud.CloudOut, error)) *MockClient_ListProjectClouds_Call {
	_c.Call.Return(run)
	return _c
}

// ListProjectServiceTypes provides a mock function for the type MockClient
func (_mock *MockClient) ListProjectServiceTypes(ctx context.Context, project string) (*service.ListProjectServiceTypesOut, error) {
	ret := _mock.Called(ctx, project)

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

	var r0 *service.ListProjectServiceTypesOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*service.ListProjectServiceTypesOut, error)); ok {
		return returnFunc(ctx, project)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *service.ListProjectServiceTypesOut); ok {
		r0 = returnFunc(ctx, project)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ListProjectServiceTypesOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, project)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListProjectServiceTypes is a helper method to define mock.On call
//   - ctx
//   - project
func (_e *MockClient_Expecter) ListProjectServiceTypes(ctx interface{}, project interface{}) *MockClient_ListProjectServiceTypes_Call {
	return &MockClient_ListProjectServiceTypes_Call{Call: _e.mock.On("ListProjectServiceTypes", ctx, project)}
}

func (_c *MockClient_ListProjectServiceTypes_Call) Run(run func(ctx context.Context, project string)) *MockClient_ListProjectServiceTypes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ListProjectServiceTypes_Call) Return(listProjectServiceTypesOut *service.ListProjectServiceTypesOut, err error) *MockClient_ListProjectServiceTypes_Call {
	_c.Call.Return(listProjectServiceTypesOut, err)
	return _c
}

func (_c *MockClient_ListProjectServiceTypes_Call) RunAndReturn(run func(ctx context.Context, project string) (*service.ListProjectServiceTypesOut, error)) *MockClient_ListProjectServiceTypes_Call {
	_c.Call.Return(run)
	return _c
}

// ListProjectVpcPeeringConnectionTypes provides a mock function for the type MockClient
func (_mock *MockClient) ListProjectVpcPeeringConnectionTypes(ctx context.Context, project1 string) ([]project.VpcPeeringConnectionTypeOut, error) {
	ret := _mock.Called(ctx, project1)

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

	var r0 []project.VpcPeeringConnectionTypeOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]project.VpcPeeringConnectionTypeOut, error)); ok {
		return returnFunc(ctx, project1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []project.VpcPeeringConnectionTypeOut); ok {
		r0 = returnFunc(ctx, project1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]project.VpcPeeringConnectionTypeOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, project1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListProjectVpcPeeringConnectionTypes is a helper method to define mock.On call
//   - ctx
//   - project1
func (_e *MockClient_Expecter) ListProjectVpcPeeringConnectionTypes(ctx interface{}, project1 interface{}) *MockClient_ListProjectVpcPeeringConnectionTypes_Call {
	return &MockClient_ListProjectVpcPeeringConnectionTypes_Call{Call: _e.mock.On("ListProjectVpcPeeringConnectionTypes", ctx, project1)}
}

func (_c *MockClient_ListProjectVpcPeeringConnectionTypes_Call) Run(run func(ctx context.Context, project1 string)) *MockClient_ListProjectVpcPeeringConnectionTypes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ListProjectVpcPeeringConnectionTypes_Call) Return(vpcPeeringConnectionTypeOuts []project.VpcPeeringConnectionTypeOut, err error) *MockClient_ListProjectVpcPeeringConnectionTypes_Call {
	_c.Call.Return(vpcPeeringConnectionTypeOuts, err)
	return _c
}

func (_c *MockClient_ListProjectVpcPeeringConnectionTypes_Call) RunAndReturn(run func(ctx context.Context, project1 string) ([]project.VpcPeeringConnectionTypeOut, error)) *MockClient_ListProjectVpcPeeringConnectionTypes_Call {
	_c.Call.Return(run)
	return _c
}

// ListPublicServiceTypes provides a mock function for the type MockClient
func (_mock *MockClient) ListPublicServiceTypes(ctx context.Context) (*service.ListPublicServiceTypesOut, error) {
	ret := _mock.Called(ctx)

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

	var r0 *service.ListPublicServiceTypesOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (*service.ListPublicServiceTypesOut, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) *service.ListPublicServiceTypesOut); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ListPublicServiceTypesOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListPublicServiceTypes is a helper method to define mock.On call
//   - ctx
func (_e *MockClient_Expecter) ListPublicServiceTypes(ctx interface{}) *MockClient_ListPublicServiceTypes_Call {
	return &MockClient_ListPublicServiceTypes_Call{Call: _e.mock.On("ListPublicServiceTypes", ctx)}
}

func (_c *MockClient_ListPublicServiceTypes_Call) Run(run func(ctx context.Context)) *MockClient_ListPublicServiceTypes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockClient_ListPublicServiceTypes_Call) Return(listPublicServiceTypesOut *service.ListPublicServiceTypesOut, err error) *MockClient_ListPublicServiceTypes_Call {
	_c.Call.Return(listPublicServiceTypesOut, err)
	return _c
}

func (_c *MockClient_ListPublicServiceTypes_Call) RunAndReturn(run func(ctx context.Context) (*service.ListPublicServiceTypesOut, error)) *MockClient_ListPublicServiceTypes_Call {
	_c.Call.Return(run)
	return _c
}

// ListServiceVersions provides a mock function for the type MockClient
func (_mock *MockClient) ListServiceVersions(ctx context.Context) ([]service.ServiceVersionOut, error) {
	ret := _mock.Called(ctx)

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

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

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

// ListServiceVersions is a helper method to define mock.On call
//   - ctx
func (_e *MockClient_Expecter) ListServiceVersions(ctx interface{}) *MockClient_ListServiceVersions_Call {
	return &MockClient_ListServiceVersions_Call{Call: _e.mock.On("ListServiceVersions", ctx)}
}

func (_c *MockClient_ListServiceVersions_Call) Run(run func(ctx context.Context)) *MockClient_ListServiceVersions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockClient_ListServiceVersions_Call) Return(serviceVersionOuts []service.ServiceVersionOut, err error) *MockClient_ListServiceVersions_Call {
	_c.Call.Return(serviceVersionOuts, err)
	return _c
}

func (_c *MockClient_ListServiceVersions_Call) RunAndReturn(run func(ctx context.Context) ([]service.ServiceVersionOut, error)) *MockClient_ListServiceVersions_Call {
	_c.Call.Return(run)
	return _c
}

// MySQLServiceQueryStatistics provides a mock function for the type MockClient
func (_mock *MockClient) MySQLServiceQueryStatistics(ctx context.Context, project1 string, serviceName string, in *mysql.MySqlserviceQueryStatisticsIn) ([]mysql.QueryOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 []mysql.QueryOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *mysql.MySqlserviceQueryStatisticsIn) ([]mysql.QueryOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *mysql.MySqlserviceQueryStatisticsIn) []mysql.QueryOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]mysql.QueryOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *mysql.MySqlserviceQueryStatisticsIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// MySQLServiceQueryStatistics is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) MySQLServiceQueryStatistics(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_MySQLServiceQueryStatistics_Call {
	return &MockClient_MySQLServiceQueryStatistics_Call{Call: _e.mock.On("MySQLServiceQueryStatistics", ctx, project1, serviceName, in)}
}

func (_c *MockClient_MySQLServiceQueryStatistics_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *mysql.MySqlserviceQueryStatisticsIn)) *MockClient_MySQLServiceQueryStatistics_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*mysql.MySqlserviceQueryStatisticsIn))
	})
	return _c
}

func (_c *MockClient_MySQLServiceQueryStatistics_Call) Return(queryOuts []mysql.QueryOut, err error) *MockClient_MySQLServiceQueryStatistics_Call {
	_c.Call.Return(queryOuts, err)
	return _c
}

func (_c *MockClient_MySQLServiceQueryStatistics_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *mysql.MySqlserviceQueryStatisticsIn) ([]mysql.QueryOut, error)) *MockClient_MySQLServiceQueryStatistics_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationAddressCreate provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationAddressCreate(ctx context.Context, organizationId string, in *organization.OrganizationAddressCreateIn) (*organization.OrganizationAddressCreateOut, error) {
	ret := _mock.Called(ctx, organizationId, in)

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

	var r0 *organization.OrganizationAddressCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *organization.OrganizationAddressCreateIn) (*organization.OrganizationAddressCreateOut, error)); ok {
		return returnFunc(ctx, organizationId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *organization.OrganizationAddressCreateIn) *organization.OrganizationAddressCreateOut); ok {
		r0 = returnFunc(ctx, organizationId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organization.OrganizationAddressCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *organization.OrganizationAddressCreateIn) error); ok {
		r1 = returnFunc(ctx, organizationId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationAddressCreate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - in
func (_e *MockClient_Expecter) OrganizationAddressCreate(ctx interface{}, organizationId interface{}, in interface{}) *MockClient_OrganizationAddressCreate_Call {
	return &MockClient_OrganizationAddressCreate_Call{Call: _e.mock.On("OrganizationAddressCreate", ctx, organizationId, in)}
}

func (_c *MockClient_OrganizationAddressCreate_Call) Run(run func(ctx context.Context, organizationId string, in *organization.OrganizationAddressCreateIn)) *MockClient_OrganizationAddressCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*organization.OrganizationAddressCreateIn))
	})
	return _c
}

func (_c *MockClient_OrganizationAddressCreate_Call) Return(organizationAddressCreateOut *organization.OrganizationAddressCreateOut, err error) *MockClient_OrganizationAddressCreate_Call {
	_c.Call.Return(organizationAddressCreateOut, err)
	return _c
}

func (_c *MockClient_OrganizationAddressCreate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, in *organization.OrganizationAddressCreateIn) (*organization.OrganizationAddressCreateOut, error)) *MockClient_OrganizationAddressCreate_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationAddressDelete provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationAddressDelete(ctx context.Context, organizationId string, addressId string) error {
	ret := _mock.Called(ctx, organizationId, addressId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, organizationId, addressId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// OrganizationAddressDelete is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - addressId
func (_e *MockClient_Expecter) OrganizationAddressDelete(ctx interface{}, organizationId interface{}, addressId interface{}) *MockClient_OrganizationAddressDelete_Call {
	return &MockClient_OrganizationAddressDelete_Call{Call: _e.mock.On("OrganizationAddressDelete", ctx, organizationId, addressId)}
}

func (_c *MockClient_OrganizationAddressDelete_Call) Run(run func(ctx context.Context, organizationId string, addressId string)) *MockClient_OrganizationAddressDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationAddressDelete_Call) Return(err error) *MockClient_OrganizationAddressDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_OrganizationAddressDelete_Call) RunAndReturn(run func(ctx context.Context, organizationId string, addressId string) error) *MockClient_OrganizationAddressDelete_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationAddressGet provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationAddressGet(ctx context.Context, organizationId string, addressId string) (*organization.OrganizationAddressGetOut, error) {
	ret := _mock.Called(ctx, organizationId, addressId)

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

	var r0 *organization.OrganizationAddressGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*organization.OrganizationAddressGetOut, error)); ok {
		return returnFunc(ctx, organizationId, addressId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *organization.OrganizationAddressGetOut); ok {
		r0 = returnFunc(ctx, organizationId, addressId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organization.OrganizationAddressGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, organizationId, addressId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationAddressGet is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - addressId
func (_e *MockClient_Expecter) OrganizationAddressGet(ctx interface{}, organizationId interface{}, addressId interface{}) *MockClient_OrganizationAddressGet_Call {
	return &MockClient_OrganizationAddressGet_Call{Call: _e.mock.On("OrganizationAddressGet", ctx, organizationId, addressId)}
}

func (_c *MockClient_OrganizationAddressGet_Call) Run(run func(ctx context.Context, organizationId string, addressId string)) *MockClient_OrganizationAddressGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationAddressGet_Call) Return(organizationAddressGetOut *organization.OrganizationAddressGetOut, err error) *MockClient_OrganizationAddressGet_Call {
	_c.Call.Return(organizationAddressGetOut, err)
	return _c
}

func (_c *MockClient_OrganizationAddressGet_Call) RunAndReturn(run func(ctx context.Context, organizationId string, addressId string) (*organization.OrganizationAddressGetOut, error)) *MockClient_OrganizationAddressGet_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationAddressList provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationAddressList(ctx context.Context, organizationId string) ([]organization.AddresseOut, error) {
	ret := _mock.Called(ctx, organizationId)

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

	var r0 []organization.AddresseOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]organization.AddresseOut, error)); ok {
		return returnFunc(ctx, organizationId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []organization.AddresseOut); ok {
		r0 = returnFunc(ctx, organizationId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]organization.AddresseOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, organizationId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationAddressList is a helper method to define mock.On call
//   - ctx
//   - organizationId
func (_e *MockClient_Expecter) OrganizationAddressList(ctx interface{}, organizationId interface{}) *MockClient_OrganizationAddressList_Call {
	return &MockClient_OrganizationAddressList_Call{Call: _e.mock.On("OrganizationAddressList", ctx, organizationId)}
}

func (_c *MockClient_OrganizationAddressList_Call) Run(run func(ctx context.Context, organizationId string)) *MockClient_OrganizationAddressList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationAddressList_Call) Return(addresseOuts []organization.AddresseOut, err error) *MockClient_OrganizationAddressList_Call {
	_c.Call.Return(addresseOuts, err)
	return _c
}

func (_c *MockClient_OrganizationAddressList_Call) RunAndReturn(run func(ctx context.Context, organizationId string) ([]organization.AddresseOut, error)) *MockClient_OrganizationAddressList_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationAddressUpdate provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationAddressUpdate(ctx context.Context, organizationId string, addressId string, in *organization.OrganizationAddressUpdateIn) (*organization.OrganizationAddressUpdateOut, error) {
	ret := _mock.Called(ctx, organizationId, addressId, in)

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

	var r0 *organization.OrganizationAddressUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *organization.OrganizationAddressUpdateIn) (*organization.OrganizationAddressUpdateOut, error)); ok {
		return returnFunc(ctx, organizationId, addressId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *organization.OrganizationAddressUpdateIn) *organization.OrganizationAddressUpdateOut); ok {
		r0 = returnFunc(ctx, organizationId, addressId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organization.OrganizationAddressUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *organization.OrganizationAddressUpdateIn) error); ok {
		r1 = returnFunc(ctx, organizationId, addressId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationAddressUpdate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - addressId
//   - in
func (_e *MockClient_Expecter) OrganizationAddressUpdate(ctx interface{}, organizationId interface{}, addressId interface{}, in interface{}) *MockClient_OrganizationAddressUpdate_Call {
	return &MockClient_OrganizationAddressUpdate_Call{Call: _e.mock.On("OrganizationAddressUpdate", ctx, organizationId, addressId, in)}
}

func (_c *MockClient_OrganizationAddressUpdate_Call) Run(run func(ctx context.Context, organizationId string, addressId string, in *organization.OrganizationAddressUpdateIn)) *MockClient_OrganizationAddressUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*organization.OrganizationAddressUpdateIn))
	})
	return _c
}

func (_c *MockClient_OrganizationAddressUpdate_Call) Return(organizationAddressUpdateOut *organization.OrganizationAddressUpdateOut, err error) *MockClient_OrganizationAddressUpdate_Call {
	_c.Call.Return(organizationAddressUpdateOut, err)
	return _c
}

func (_c *MockClient_OrganizationAddressUpdate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, addressId string, in *organization.OrganizationAddressUpdateIn) (*organization.OrganizationAddressUpdateOut, error)) *MockClient_OrganizationAddressUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationAuthDomainLink provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationAuthDomainLink(ctx context.Context, organizationId string, authenticationMethodId string, in *organization.OrganizationAuthDomainLinkIn) error {
	ret := _mock.Called(ctx, organizationId, authenticationMethodId, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *organization.OrganizationAuthDomainLinkIn) error); ok {
		r0 = returnFunc(ctx, organizationId, authenticationMethodId, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// OrganizationAuthDomainLink is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - authenticationMethodId
//   - in
func (_e *MockClient_Expecter) OrganizationAuthDomainLink(ctx interface{}, organizationId interface{}, authenticationMethodId interface{}, in interface{}) *MockClient_OrganizationAuthDomainLink_Call {
	return &MockClient_OrganizationAuthDomainLink_Call{Call: _e.mock.On("OrganizationAuthDomainLink", ctx, organizationId, authenticationMethodId, in)}
}

func (_c *MockClient_OrganizationAuthDomainLink_Call) Run(run func(ctx context.Context, organizationId string, authenticationMethodId string, in *organization.OrganizationAuthDomainLinkIn)) *MockClient_OrganizationAuthDomainLink_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*organization.OrganizationAuthDomainLinkIn))
	})
	return _c
}

func (_c *MockClient_OrganizationAuthDomainLink_Call) Return(err error) *MockClient_OrganizationAuthDomainLink_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_OrganizationAuthDomainLink_Call) RunAndReturn(run func(ctx context.Context, organizationId string, authenticationMethodId string, in *organization.OrganizationAuthDomainLinkIn) error) *MockClient_OrganizationAuthDomainLink_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationAuthDomainList provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationAuthDomainList(ctx context.Context, organizationId string, authenticationMethodId string) ([]organization.DomainOut, error) {
	ret := _mock.Called(ctx, organizationId, authenticationMethodId)

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

	var r0 []organization.DomainOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]organization.DomainOut, error)); ok {
		return returnFunc(ctx, organizationId, authenticationMethodId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []organization.DomainOut); ok {
		r0 = returnFunc(ctx, organizationId, authenticationMethodId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]organization.DomainOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, organizationId, authenticationMethodId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationAuthDomainList is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - authenticationMethodId
func (_e *MockClient_Expecter) OrganizationAuthDomainList(ctx interface{}, organizationId interface{}, authenticationMethodId interface{}) *MockClient_OrganizationAuthDomainList_Call {
	return &MockClient_OrganizationAuthDomainList_Call{Call: _e.mock.On("OrganizationAuthDomainList", ctx, organizationId, authenticationMethodId)}
}

func (_c *MockClient_OrganizationAuthDomainList_Call) Run(run func(ctx context.Context, organizationId string, authenticationMethodId string)) *MockClient_OrganizationAuthDomainList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationAuthDomainList_Call) Return(domainOuts []organization.DomainOut, err error) *MockClient_OrganizationAuthDomainList_Call {
	_c.Call.Return(domainOuts, err)
	return _c
}

func (_c *MockClient_OrganizationAuthDomainList_Call) RunAndReturn(run func(ctx context.Context, organizationId string, authenticationMethodId string) ([]organization.DomainOut, error)) *MockClient_OrganizationAuthDomainList_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationAuthDomainUnlink provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationAuthDomainUnlink(ctx context.Context, organizationId string, authenticationMethodId string, domainId string) error {
	ret := _mock.Called(ctx, organizationId, authenticationMethodId, domainId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, organizationId, authenticationMethodId, domainId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// OrganizationAuthDomainUnlink is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - authenticationMethodId
//   - domainId
func (_e *MockClient_Expecter) OrganizationAuthDomainUnlink(ctx interface{}, organizationId interface{}, authenticationMethodId interface{}, domainId interface{}) *MockClient_OrganizationAuthDomainUnlink_Call {
	return &MockClient_OrganizationAuthDomainUnlink_Call{Call: _e.mock.On("OrganizationAuthDomainUnlink", ctx, organizationId, authenticationMethodId, domainId)}
}

func (_c *MockClient_OrganizationAuthDomainUnlink_Call) Run(run func(ctx context.Context, organizationId string, authenticationMethodId string, domainId string)) *MockClient_OrganizationAuthDomainUnlink_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationAuthDomainUnlink_Call) Return(err error) *MockClient_OrganizationAuthDomainUnlink_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_OrganizationAuthDomainUnlink_Call) RunAndReturn(run func(ctx context.Context, organizationId string, authenticationMethodId string, domainId string) error) *MockClient_OrganizationAuthDomainUnlink_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationAuthenticationConfigGet provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationAuthenticationConfigGet(ctx context.Context, organizationId string) (*organization.OrganizationAuthenticationConfigGetOut, error) {
	ret := _mock.Called(ctx, organizationId)

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

	var r0 *organization.OrganizationAuthenticationConfigGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*organization.OrganizationAuthenticationConfigGetOut, error)); ok {
		return returnFunc(ctx, organizationId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *organization.OrganizationAuthenticationConfigGetOut); ok {
		r0 = returnFunc(ctx, organizationId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organization.OrganizationAuthenticationConfigGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, organizationId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationAuthenticationConfigGet is a helper method to define mock.On call
//   - ctx
//   - organizationId
func (_e *MockClient_Expecter) OrganizationAuthenticationConfigGet(ctx interface{}, organizationId interface{}) *MockClient_OrganizationAuthenticationConfigGet_Call {
	return &MockClient_OrganizationAuthenticationConfigGet_Call{Call: _e.mock.On("OrganizationAuthenticationConfigGet", ctx, organizationId)}
}

func (_c *MockClient_OrganizationAuthenticationConfigGet_Call) Run(run func(ctx context.Context, organizationId string)) *MockClient_OrganizationAuthenticationConfigGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationAuthenticationConfigGet_Call) Return(organizationAuthenticationConfigGetOut *organization.OrganizationAuthenticationConfigGetOut, err error) *MockClient_OrganizationAuthenticationConfigGet_Call {
	_c.Call.Return(organizationAuthenticationConfigGetOut, err)
	return _c
}

func (_c *MockClient_OrganizationAuthenticationConfigGet_Call) RunAndReturn(run func(ctx context.Context, organizationId string) (*organization.OrganizationAuthenticationConfigGetOut, error)) *MockClient_OrganizationAuthenticationConfigGet_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationAuthenticationConfigUpdate provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationAuthenticationConfigUpdate(ctx context.Context, organizationId string, in *organization.OrganizationAuthenticationConfigUpdateIn) (*organization.OrganizationAuthenticationConfigUpdateOut, error) {
	ret := _mock.Called(ctx, organizationId, in)

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

	var r0 *organization.OrganizationAuthenticationConfigUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *organization.OrganizationAuthenticationConfigUpdateIn) (*organization.OrganizationAuthenticationConfigUpdateOut, error)); ok {
		return returnFunc(ctx, organizationId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *organization.OrganizationAuthenticationConfigUpdateIn) *organization.OrganizationAuthenticationConfigUpdateOut); ok {
		r0 = returnFunc(ctx, organizationId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organization.OrganizationAuthenticationConfigUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *organization.OrganizationAuthenticationConfigUpdateIn) error); ok {
		r1 = returnFunc(ctx, organizationId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationAuthenticationConfigUpdate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - in
func (_e *MockClient_Expecter) OrganizationAuthenticationConfigUpdate(ctx interface{}, organizationId interface{}, in interface{}) *MockClient_OrganizationAuthenticationConfigUpdate_Call {
	return &MockClient_OrganizationAuthenticationConfigUpdate_Call{Call: _e.mock.On("OrganizationAuthenticationConfigUpdate", ctx, organizationId, in)}
}

func (_c *MockClient_OrganizationAuthenticationConfigUpdate_Call) Run(run func(ctx context.Context, organizationId string, in *organization.OrganizationAuthenticationConfigUpdateIn)) *MockClient_OrganizationAuthenticationConfigUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*organization.OrganizationAuthenticationConfigUpdateIn))
	})
	return _c
}

func (_c *MockClient_OrganizationAuthenticationConfigUpdate_Call) Return(organizationAuthenticationConfigUpdateOut *organization.OrganizationAuthenticationConfigUpdateOut, err error) *MockClient_OrganizationAuthenticationConfigUpdate_Call {
	_c.Call.Return(organizationAuthenticationConfigUpdateOut, err)
	return _c
}

func (_c *MockClient_OrganizationAuthenticationConfigUpdate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, in *organization.OrganizationAuthenticationConfigUpdateIn) (*organization.OrganizationAuthenticationConfigUpdateOut, error)) *MockClient_OrganizationAuthenticationConfigUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationBillingGroupCreate provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationBillingGroupCreate(ctx context.Context, organizationId string, in *organizationbilling.OrganizationBillingGroupCreateIn) (*organizationbilling.OrganizationBillingGroupCreateOut, error) {
	ret := _mock.Called(ctx, organizationId, in)

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

	var r0 *organizationbilling.OrganizationBillingGroupCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *organizationbilling.OrganizationBillingGroupCreateIn) (*organizationbilling.OrganizationBillingGroupCreateOut, error)); ok {
		return returnFunc(ctx, organizationId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *organizationbilling.OrganizationBillingGroupCreateIn) *organizationbilling.OrganizationBillingGroupCreateOut); ok {
		r0 = returnFunc(ctx, organizationId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organizationbilling.OrganizationBillingGroupCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *organizationbilling.OrganizationBillingGroupCreateIn) error); ok {
		r1 = returnFunc(ctx, organizationId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationBillingGroupCreate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - in
func (_e *MockClient_Expecter) OrganizationBillingGroupCreate(ctx interface{}, organizationId interface{}, in interface{}) *MockClient_OrganizationBillingGroupCreate_Call {
	return &MockClient_OrganizationBillingGroupCreate_Call{Call: _e.mock.On("OrganizationBillingGroupCreate", ctx, organizationId, in)}
}

func (_c *MockClient_OrganizationBillingGroupCreate_Call) Run(run func(ctx context.Context, organizationId string, in *organizationbilling.OrganizationBillingGroupCreateIn)) *MockClient_OrganizationBillingGroupCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*organizationbilling.OrganizationBillingGroupCreateIn))
	})
	return _c
}

func (_c *MockClient_OrganizationBillingGroupCreate_Call) Return(organizationBillingGroupCreateOut *organizationbilling.OrganizationBillingGroupCreateOut, err error) *MockClient_OrganizationBillingGroupCreate_Call {
	_c.Call.Return(organizationBillingGroupCreateOut, err)
	return _c
}

func (_c *MockClient_OrganizationBillingGroupCreate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, in *organizationbilling.OrganizationBillingGroupCreateIn) (*organizationbilling.OrganizationBillingGroupCreateOut, error)) *MockClient_OrganizationBillingGroupCreate_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationBillingGroupDelete provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationBillingGroupDelete(ctx context.Context, organizationId string, billingGroupId string) error {
	ret := _mock.Called(ctx, organizationId, billingGroupId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, organizationId, billingGroupId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// OrganizationBillingGroupDelete is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - billingGroupId
func (_e *MockClient_Expecter) OrganizationBillingGroupDelete(ctx interface{}, organizationId interface{}, billingGroupId interface{}) *MockClient_OrganizationBillingGroupDelete_Call {
	return &MockClient_OrganizationBillingGroupDelete_Call{Call: _e.mock.On("OrganizationBillingGroupDelete", ctx, organizationId, billingGroupId)}
}

func (_c *MockClient_OrganizationBillingGroupDelete_Call) Run(run func(ctx context.Context, organizationId string, billingGroupId string)) *MockClient_OrganizationBillingGroupDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationBillingGroupDelete_Call) Return(err error) *MockClient_OrganizationBillingGroupDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_OrganizationBillingGroupDelete_Call) RunAndReturn(run func(ctx context.Context, organizationId string, billingGroupId string) error) *MockClient_OrganizationBillingGroupDelete_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationBillingGroupGet provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationBillingGroupGet(ctx context.Context, organizationId string, billingGroupId string) (*organizationbilling.OrganizationBillingGroupGetOut, error) {
	ret := _mock.Called(ctx, organizationId, billingGroupId)

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

	var r0 *organizationbilling.OrganizationBillingGroupGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*organizationbilling.OrganizationBillingGroupGetOut, error)); ok {
		return returnFunc(ctx, organizationId, billingGroupId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *organizationbilling.OrganizationBillingGroupGetOut); ok {
		r0 = returnFunc(ctx, organizationId, billingGroupId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organizationbilling.OrganizationBillingGroupGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, organizationId, billingGroupId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationBillingGroupGet is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - billingGroupId
func (_e *MockClient_Expecter) OrganizationBillingGroupGet(ctx interface{}, organizationId interface{}, billingGroupId interface{}) *MockClient_OrganizationBillingGroupGet_Call {
	return &MockClient_OrganizationBillingGroupGet_Call{Call: _e.mock.On("OrganizationBillingGroupGet", ctx, organizationId, billingGroupId)}
}

func (_c *MockClient_OrganizationBillingGroupGet_Call) Run(run func(ctx context.Context, organizationId string, billingGroupId string)) *MockClient_OrganizationBillingGroupGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationBillingGroupGet_Call) Return(organizationBillingGroupGetOut *organizationbilling.OrganizationBillingGroupGetOut, err error) *MockClient_OrganizationBillingGroupGet_Call {
	_c.Call.Return(organizationBillingGroupGetOut, err)
	return _c
}

func (_c *MockClient_OrganizationBillingGroupGet_Call) RunAndReturn(run func(ctx context.Context, organizationId string, billingGroupId string) (*organizationbilling.OrganizationBillingGroupGetOut, error)) *MockClient_OrganizationBillingGroupGet_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationBillingGroupList provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationBillingGroupList(ctx context.Context, organizationId string) ([]organizationbilling.BillingGroupOut, error) {
	ret := _mock.Called(ctx, organizationId)

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

	var r0 []organizationbilling.BillingGroupOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]organizationbilling.BillingGroupOut, error)); ok {
		return returnFunc(ctx, organizationId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []organizationbilling.BillingGroupOut); ok {
		r0 = returnFunc(ctx, organizationId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]organizationbilling.BillingGroupOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, organizationId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationBillingGroupList is a helper method to define mock.On call
//   - ctx
//   - organizationId
func (_e *MockClient_Expecter) OrganizationBillingGroupList(ctx interface{}, organizationId interface{}) *MockClient_OrganizationBillingGroupList_Call {
	return &MockClient_OrganizationBillingGroupList_Call{Call: _e.mock.On("OrganizationBillingGroupList", ctx, organizationId)}
}

func (_c *MockClient_OrganizationBillingGroupList_Call) Run(run func(ctx context.Context, organizationId string)) *MockClient_OrganizationBillingGroupList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationBillingGroupList_Call) Return(billingGroupOuts []organizationbilling.BillingGroupOut, err error) *MockClient_OrganizationBillingGroupList_Call {
	_c.Call.Return(billingGroupOuts, err)
	return _c
}

func (_c *MockClient_OrganizationBillingGroupList_Call) RunAndReturn(run func(ctx context.Context, organizationId string) ([]organizationbilling.BillingGroupOut, error)) *MockClient_OrganizationBillingGroupList_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationBillingGroupUpdate provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationBillingGroupUpdate(ctx context.Context, organizationId string, billingGroupId string, in *organizationbilling.OrganizationBillingGroupUpdateIn) (*organizationbilling.OrganizationBillingGroupUpdateOut, error) {
	ret := _mock.Called(ctx, organizationId, billingGroupId, in)

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

	var r0 *organizationbilling.OrganizationBillingGroupUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *organizationbilling.OrganizationBillingGroupUpdateIn) (*organizationbilling.OrganizationBillingGroupUpdateOut, error)); ok {
		return returnFunc(ctx, organizationId, billingGroupId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *organizationbilling.OrganizationBillingGroupUpdateIn) *organizationbilling.OrganizationBillingGroupUpdateOut); ok {
		r0 = returnFunc(ctx, organizationId, billingGroupId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organizationbilling.OrganizationBillingGroupUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *organizationbilling.OrganizationBillingGroupUpdateIn) error); ok {
		r1 = returnFunc(ctx, organizationId, billingGroupId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationBillingGroupUpdate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - billingGroupId
//   - in
func (_e *MockClient_Expecter) OrganizationBillingGroupUpdate(ctx interface{}, organizationId interface{}, billingGroupId interface{}, in interface{}) *MockClient_OrganizationBillingGroupUpdate_Call {
	return &MockClient_OrganizationBillingGroupUpdate_Call{Call: _e.mock.On("OrganizationBillingGroupUpdate", ctx, organizationId, billingGroupId, in)}
}

func (_c *MockClient_OrganizationBillingGroupUpdate_Call) Run(run func(ctx context.Context, organizationId string, billingGroupId string, in *organizationbilling.OrganizationBillingGroupUpdateIn)) *MockClient_OrganizationBillingGroupUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*organizationbilling.OrganizationBillingGroupUpdateIn))
	})
	return _c
}

func (_c *MockClient_OrganizationBillingGroupUpdate_Call) Return(organizationBillingGroupUpdateOut *organizationbilling.OrganizationBillingGroupUpdateOut, err error) *MockClient_OrganizationBillingGroupUpdate_Call {
	_c.Call.Return(organizationBillingGroupUpdateOut, err)
	return _c
}

func (_c *MockClient_OrganizationBillingGroupUpdate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, billingGroupId string, in *organizationbilling.OrganizationBillingGroupUpdateIn) (*organizationbilling.OrganizationBillingGroupUpdateOut, error)) *MockClient_OrganizationBillingGroupUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationDelete provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationDelete(ctx context.Context, organizationId string, query ...[2]string) error {
	var tmpRet mock.Arguments
	if len(query) > 0 {
		tmpRet = _mock.Called(ctx, organizationId, query)
	} else {
		tmpRet = _mock.Called(ctx, organizationId)
	}
	ret := tmpRet

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, ...[2]string) error); ok {
		r0 = returnFunc(ctx, organizationId, query...)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// OrganizationDelete is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - query
func (_e *MockClient_Expecter) OrganizationDelete(ctx interface{}, organizationId interface{}, query ...interface{}) *MockClient_OrganizationDelete_Call {
	return &MockClient_OrganizationDelete_Call{Call: _e.mock.On("OrganizationDelete",
		append([]interface{}{ctx, organizationId}, query...)...)}
}

func (_c *MockClient_OrganizationDelete_Call) Run(run func(ctx context.Context, organizationId string, query ...[2]string)) *MockClient_OrganizationDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := args[2].([][2]string)
		run(args[0].(context.Context), args[1].(string), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_OrganizationDelete_Call) Return(err error) *MockClient_OrganizationDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_OrganizationDelete_Call) RunAndReturn(run func(ctx context.Context, organizationId string, query ...[2]string) error) *MockClient_OrganizationDelete_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationDomainAdd provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationDomainAdd(ctx context.Context, organizationId string, in *domain.OrganizationDomainAddIn) (*domain.OrganizationDomainAddOut, error) {
	ret := _mock.Called(ctx, organizationId, in)

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

	var r0 *domain.OrganizationDomainAddOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *domain.OrganizationDomainAddIn) (*domain.OrganizationDomainAddOut, error)); ok {
		return returnFunc(ctx, organizationId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *domain.OrganizationDomainAddIn) *domain.OrganizationDomainAddOut); ok {
		r0 = returnFunc(ctx, organizationId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*domain.OrganizationDomainAddOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *domain.OrganizationDomainAddIn) error); ok {
		r1 = returnFunc(ctx, organizationId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationDomainAdd is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - in
func (_e *MockClient_Expecter) OrganizationDomainAdd(ctx interface{}, organizationId interface{}, in interface{}) *MockClient_OrganizationDomainAdd_Call {
	return &MockClient_OrganizationDomainAdd_Call{Call: _e.mock.On("OrganizationDomainAdd", ctx, organizationId, in)}
}

func (_c *MockClient_OrganizationDomainAdd_Call) Run(run func(ctx context.Context, organizationId string, in *domain.OrganizationDomainAddIn)) *MockClient_OrganizationDomainAdd_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*domain.OrganizationDomainAddIn))
	})
	return _c
}

func (_c *MockClient_OrganizationDomainAdd_Call) Return(organizationDomainAddOut *domain.OrganizationDomainAddOut, err error) *MockClient_OrganizationDomainAdd_Call {
	_c.Call.Return(organizationDomainAddOut, err)
	return _c
}

func (_c *MockClient_OrganizationDomainAdd_Call) RunAndReturn(run func(ctx context.Context, organizationId string, in *domain.OrganizationDomainAddIn) (*domain.OrganizationDomainAddOut, error)) *MockClient_OrganizationDomainAdd_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationDomainUpdate provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationDomainUpdate(ctx context.Context, organizationId string, domainId string, in *domain.OrganizationDomainUpdateIn) (*domain.OrganizationDomainUpdateOut, error) {
	ret := _mock.Called(ctx, organizationId, domainId, in)

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

	var r0 *domain.OrganizationDomainUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *domain.OrganizationDomainUpdateIn) (*domain.OrganizationDomainUpdateOut, error)); ok {
		return returnFunc(ctx, organizationId, domainId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *domain.OrganizationDomainUpdateIn) *domain.OrganizationDomainUpdateOut); ok {
		r0 = returnFunc(ctx, organizationId, domainId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*domain.OrganizationDomainUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *domain.OrganizationDomainUpdateIn) error); ok {
		r1 = returnFunc(ctx, organizationId, domainId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationDomainUpdate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - domainId
//   - in
func (_e *MockClient_Expecter) OrganizationDomainUpdate(ctx interface{}, organizationId interface{}, domainId interface{}, in interface{}) *MockClient_OrganizationDomainUpdate_Call {
	return &MockClient_OrganizationDomainUpdate_Call{Call: _e.mock.On("OrganizationDomainUpdate", ctx, organizationId, domainId, in)}
}

func (_c *MockClient_OrganizationDomainUpdate_Call) Run(run func(ctx context.Context, organizationId string, domainId string, in *domain.OrganizationDomainUpdateIn)) *MockClient_OrganizationDomainUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*domain.OrganizationDomainUpdateIn))
	})
	return _c
}

func (_c *MockClient_OrganizationDomainUpdate_Call) Return(organizationDomainUpdateOut *domain.OrganizationDomainUpdateOut, err error) *MockClient_OrganizationDomainUpdate_Call {
	_c.Call.Return(organizationDomainUpdateOut, err)
	return _c
}

func (_c *MockClient_OrganizationDomainUpdate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, domainId string, in *domain.OrganizationDomainUpdateIn) (*domain.OrganizationDomainUpdateOut, error)) *MockClient_OrganizationDomainUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationDomainVerify provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationDomainVerify(ctx context.Context, organizationId string, domainId string) (*domain.OrganizationDomainVerifyOut, error) {
	ret := _mock.Called(ctx, organizationId, domainId)

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

	var r0 *domain.OrganizationDomainVerifyOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*domain.OrganizationDomainVerifyOut, error)); ok {
		return returnFunc(ctx, organizationId, domainId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *domain.OrganizationDomainVerifyOut); ok {
		r0 = returnFunc(ctx, organizationId, domainId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*domain.OrganizationDomainVerifyOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, organizationId, domainId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationDomainVerify is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - domainId
func (_e *MockClient_Expecter) OrganizationDomainVerify(ctx interface{}, organizationId interface{}, domainId interface{}) *MockClient_OrganizationDomainVerify_Call {
	return &MockClient_OrganizationDomainVerify_Call{Call: _e.mock.On("OrganizationDomainVerify", ctx, organizationId, domainId)}
}

func (_c *MockClient_OrganizationDomainVerify_Call) Run(run func(ctx context.Context, organizationId string, domainId string)) *MockClient_OrganizationDomainVerify_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationDomainVerify_Call) Return(organizationDomainVerifyOut *domain.OrganizationDomainVerifyOut, err error) *MockClient_OrganizationDomainVerify_Call {
	_c.Call.Return(organizationDomainVerifyOut, err)
	return _c
}

func (_c *MockClient_OrganizationDomainVerify_Call) RunAndReturn(run func(ctx context.Context, organizationId string, domainId string) (*domain.OrganizationDomainVerifyOut, error)) *MockClient_OrganizationDomainVerify_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationDomainsList provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationDomainsList(ctx context.Context, organizationId string) ([]domain.DomainOut, error) {
	ret := _mock.Called(ctx, organizationId)

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

	var r0 []domain.DomainOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]domain.DomainOut, error)); ok {
		return returnFunc(ctx, organizationId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []domain.DomainOut); ok {
		r0 = returnFunc(ctx, organizationId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]domain.DomainOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, organizationId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationDomainsList is a helper method to define mock.On call
//   - ctx
//   - organizationId
func (_e *MockClient_Expecter) OrganizationDomainsList(ctx interface{}, organizationId interface{}) *MockClient_OrganizationDomainsList_Call {
	return &MockClient_OrganizationDomainsList_Call{Call: _e.mock.On("OrganizationDomainsList", ctx, organizationId)}
}

func (_c *MockClient_OrganizationDomainsList_Call) Run(run func(ctx context.Context, organizationId string)) *MockClient_OrganizationDomainsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationDomainsList_Call) Return(domainOuts []domain.DomainOut, err error) *MockClient_OrganizationDomainsList_Call {
	_c.Call.Return(domainOuts, err)
	return _c
}

func (_c *MockClient_OrganizationDomainsList_Call) RunAndReturn(run func(ctx context.Context, organizationId string) ([]domain.DomainOut, error)) *MockClient_OrganizationDomainsList_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationDomainsRemove provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationDomainsRemove(ctx context.Context, organizationId string, domainId string) error {
	ret := _mock.Called(ctx, organizationId, domainId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, organizationId, domainId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// OrganizationDomainsRemove is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - domainId
func (_e *MockClient_Expecter) OrganizationDomainsRemove(ctx interface{}, organizationId interface{}, domainId interface{}) *MockClient_OrganizationDomainsRemove_Call {
	return &MockClient_OrganizationDomainsRemove_Call{Call: _e.mock.On("OrganizationDomainsRemove", ctx, organizationId, domainId)}
}

func (_c *MockClient_OrganizationDomainsRemove_Call) Run(run func(ctx context.Context, organizationId string, domainId string)) *MockClient_OrganizationDomainsRemove_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationDomainsRemove_Call) Return(err error) *MockClient_OrganizationDomainsRemove_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_OrganizationDomainsRemove_Call) RunAndReturn(run func(ctx context.Context, organizationId string, domainId string) error) *MockClient_OrganizationDomainsRemove_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationGet provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationGet(ctx context.Context, organizationId string) (*organization.OrganizationGetOut, error) {
	ret := _mock.Called(ctx, organizationId)

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

	var r0 *organization.OrganizationGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*organization.OrganizationGetOut, error)); ok {
		return returnFunc(ctx, organizationId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *organization.OrganizationGetOut); ok {
		r0 = returnFunc(ctx, organizationId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organization.OrganizationGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, organizationId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationGet is a helper method to define mock.On call
//   - ctx
//   - organizationId
func (_e *MockClient_Expecter) OrganizationGet(ctx interface{}, organizationId interface{}) *MockClient_OrganizationGet_Call {
	return &MockClient_OrganizationGet_Call{Call: _e.mock.On("OrganizationGet", ctx, organizationId)}
}

func (_c *MockClient_OrganizationGet_Call) Run(run func(ctx context.Context, organizationId string)) *MockClient_OrganizationGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationGet_Call) Return(organizationGetOut *organization.OrganizationGetOut, err error) *MockClient_OrganizationGet_Call {
	_c.Call.Return(organizationGetOut, err)
	return _c
}

func (_c *MockClient_OrganizationGet_Call) RunAndReturn(run func(ctx context.Context, organizationId string) (*organization.OrganizationGetOut, error)) *MockClient_OrganizationGet_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationGovernanceAccessCreate provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationGovernanceAccessCreate(ctx context.Context, organizationId string, in *organizationgovernance.OrganizationGovernanceAccessCreateIn) (*organizationgovernance.OrganizationGovernanceAccessCreateOut, error) {
	ret := _mock.Called(ctx, organizationId, in)

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

	var r0 *organizationgovernance.OrganizationGovernanceAccessCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *organizationgovernance.OrganizationGovernanceAccessCreateIn) (*organizationgovernance.OrganizationGovernanceAccessCreateOut, error)); ok {
		return returnFunc(ctx, organizationId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *organizationgovernance.OrganizationGovernanceAccessCreateIn) *organizationgovernance.OrganizationGovernanceAccessCreateOut); ok {
		r0 = returnFunc(ctx, organizationId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organizationgovernance.OrganizationGovernanceAccessCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *organizationgovernance.OrganizationGovernanceAccessCreateIn) error); ok {
		r1 = returnFunc(ctx, organizationId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationGovernanceAccessCreate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - in
func (_e *MockClient_Expecter) OrganizationGovernanceAccessCreate(ctx interface{}, organizationId interface{}, in interface{}) *MockClient_OrganizationGovernanceAccessCreate_Call {
	return &MockClient_OrganizationGovernanceAccessCreate_Call{Call: _e.mock.On("OrganizationGovernanceAccessCreate", ctx, organizationId, in)}
}

func (_c *MockClient_OrganizationGovernanceAccessCreate_Call) Run(run func(ctx context.Context, organizationId string, in *organizationgovernance.OrganizationGovernanceAccessCreateIn)) *MockClient_OrganizationGovernanceAccessCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*organizationgovernance.OrganizationGovernanceAccessCreateIn))
	})
	return _c
}

func (_c *MockClient_OrganizationGovernanceAccessCreate_Call) Return(organizationGovernanceAccessCreateOut *organizationgovernance.OrganizationGovernanceAccessCreateOut, err error) *MockClient_OrganizationGovernanceAccessCreate_Call {
	_c.Call.Return(organizationGovernanceAccessCreateOut, err)
	return _c
}

func (_c *MockClient_OrganizationGovernanceAccessCreate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, in *organizationgovernance.OrganizationGovernanceAccessCreateIn) (*organizationgovernance.OrganizationGovernanceAccessCreateOut, error)) *MockClient_OrganizationGovernanceAccessCreate_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationGovernanceAccessDelete provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationGovernanceAccessDelete(ctx context.Context, organizationId string, accessId string) (string, error) {
	ret := _mock.Called(ctx, organizationId, accessId)

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

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
		return returnFunc(ctx, organizationId, accessId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
		r0 = returnFunc(ctx, organizationId, accessId)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, organizationId, accessId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationGovernanceAccessDelete is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - accessId
func (_e *MockClient_Expecter) OrganizationGovernanceAccessDelete(ctx interface{}, organizationId interface{}, accessId interface{}) *MockClient_OrganizationGovernanceAccessDelete_Call {
	return &MockClient_OrganizationGovernanceAccessDelete_Call{Call: _e.mock.On("OrganizationGovernanceAccessDelete", ctx, organizationId, accessId)}
}

func (_c *MockClient_OrganizationGovernanceAccessDelete_Call) Run(run func(ctx context.Context, organizationId string, accessId string)) *MockClient_OrganizationGovernanceAccessDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationGovernanceAccessDelete_Call) Return(s string, err error) *MockClient_OrganizationGovernanceAccessDelete_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockClient_OrganizationGovernanceAccessDelete_Call) RunAndReturn(run func(ctx context.Context, organizationId string, accessId string) (string, error)) *MockClient_OrganizationGovernanceAccessDelete_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationGovernanceAccessGet provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationGovernanceAccessGet(ctx context.Context, organizationId string, accessId string) (*organizationgovernance.OrganizationGovernanceAccessGetOut, error) {
	ret := _mock.Called(ctx, organizationId, accessId)

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

	var r0 *organizationgovernance.OrganizationGovernanceAccessGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*organizationgovernance.OrganizationGovernanceAccessGetOut, error)); ok {
		return returnFunc(ctx, organizationId, accessId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *organizationgovernance.OrganizationGovernanceAccessGetOut); ok {
		r0 = returnFunc(ctx, organizationId, accessId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organizationgovernance.OrganizationGovernanceAccessGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, organizationId, accessId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationGovernanceAccessGet is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - accessId
func (_e *MockClient_Expecter) OrganizationGovernanceAccessGet(ctx interface{}, organizationId interface{}, accessId interface{}) *MockClient_OrganizationGovernanceAccessGet_Call {
	return &MockClient_OrganizationGovernanceAccessGet_Call{Call: _e.mock.On("OrganizationGovernanceAccessGet", ctx, organizationId, accessId)}
}

func (_c *MockClient_OrganizationGovernanceAccessGet_Call) Run(run func(ctx context.Context, organizationId string, accessId string)) *MockClient_OrganizationGovernanceAccessGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationGovernanceAccessGet_Call) Return(organizationGovernanceAccessGetOut *organizationgovernance.OrganizationGovernanceAccessGetOut, err error) *MockClient_OrganizationGovernanceAccessGet_Call {
	_c.Call.Return(organizationGovernanceAccessGetOut, err)
	return _c
}

func (_c *MockClient_OrganizationGovernanceAccessGet_Call) RunAndReturn(run func(ctx context.Context, organizationId string, accessId string) (*organizationgovernance.OrganizationGovernanceAccessGetOut, error)) *MockClient_OrganizationGovernanceAccessGet_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationGovernanceAccessList provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationGovernanceAccessList(ctx context.Context, organizationId string, query ...[2]string) (*organizationgovernance.OrganizationGovernanceAccessListOut, error) {
	var tmpRet mock.Arguments
	if len(query) > 0 {
		tmpRet = _mock.Called(ctx, organizationId, query)
	} else {
		tmpRet = _mock.Called(ctx, organizationId)
	}
	ret := tmpRet

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

	var r0 *organizationgovernance.OrganizationGovernanceAccessListOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, ...[2]string) (*organizationgovernance.OrganizationGovernanceAccessListOut, error)); ok {
		return returnFunc(ctx, organizationId, query...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, ...[2]string) *organizationgovernance.OrganizationGovernanceAccessListOut); ok {
		r0 = returnFunc(ctx, organizationId, query...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organizationgovernance.OrganizationGovernanceAccessListOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, ...[2]string) error); ok {
		r1 = returnFunc(ctx, organizationId, query...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationGovernanceAccessList is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - query
func (_e *MockClient_Expecter) OrganizationGovernanceAccessList(ctx interface{}, organizationId interface{}, query ...interface{}) *MockClient_OrganizationGovernanceAccessList_Call {
	return &MockClient_OrganizationGovernanceAccessList_Call{Call: _e.mock.On("OrganizationGovernanceAccessList",
		append([]interface{}{ctx, organizationId}, query...)...)}
}

func (_c *MockClient_OrganizationGovernanceAccessList_Call) Run(run func(ctx context.Context, organizationId string, query ...[2]string)) *MockClient_OrganizationGovernanceAccessList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := args[2].([][2]string)
		run(args[0].(context.Context), args[1].(string), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_OrganizationGovernanceAccessList_Call) Return(organizationGovernanceAccessListOut *organizationgovernance.OrganizationGovernanceAccessListOut, err error) *MockClient_OrganizationGovernanceAccessList_Call {
	_c.Call.Return(organizationGovernanceAccessListOut, err)
	return _c
}

func (_c *MockClient_OrganizationGovernanceAccessList_Call) RunAndReturn(run func(ctx context.Context, organizationId string, query ...[2]string) (*organizationgovernance.OrganizationGovernanceAccessListOut, error)) *MockClient_OrganizationGovernanceAccessList_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationMemberGroupsList provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationMemberGroupsList(ctx context.Context, organizationId string, memberUserId string) ([]user.UserGroupOut, error) {
	ret := _mock.Called(ctx, organizationId, memberUserId)

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

	var r0 []user.UserGroupOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]user.UserGroupOut, error)); ok {
		return returnFunc(ctx, organizationId, memberUserId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []user.UserGroupOut); ok {
		r0 = returnFunc(ctx, organizationId, memberUserId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]user.UserGroupOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, organizationId, memberUserId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationMemberGroupsList is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - memberUserId
func (_e *MockClient_Expecter) OrganizationMemberGroupsList(ctx interface{}, organizationId interface{}, memberUserId interface{}) *MockClient_OrganizationMemberGroupsList_Call {
	return &MockClient_OrganizationMemberGroupsList_Call{Call: _e.mock.On("OrganizationMemberGroupsList", ctx, organizationId, memberUserId)}
}

func (_c *MockClient_OrganizationMemberGroupsList_Call) Run(run func(ctx context.Context, organizationId string, memberUserId string)) *MockClient_OrganizationMemberGroupsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationMemberGroupsList_Call) Return(userGroupOuts []user.UserGroupOut, err error) *MockClient_OrganizationMemberGroupsList_Call {
	_c.Call.Return(userGroupOuts, err)
	return _c
}

func (_c *MockClient_OrganizationMemberGroupsList_Call) RunAndReturn(run func(ctx context.Context, organizationId string, memberUserId string) ([]user.UserGroupOut, error)) *MockClient_OrganizationMemberGroupsList_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationProjectsCreate provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationProjectsCreate(ctx context.Context, organizationId string, in *organizationprojects.OrganizationProjectsCreateIn) (*organizationprojects.OrganizationProjectsCreateOut, error) {
	ret := _mock.Called(ctx, organizationId, in)

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

	var r0 *organizationprojects.OrganizationProjectsCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *organizationprojects.OrganizationProjectsCreateIn) (*organizationprojects.OrganizationProjectsCreateOut, error)); ok {
		return returnFunc(ctx, organizationId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *organizationprojects.OrganizationProjectsCreateIn) *organizationprojects.OrganizationProjectsCreateOut); ok {
		r0 = returnFunc(ctx, organizationId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organizationprojects.OrganizationProjectsCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *organizationprojects.OrganizationProjectsCreateIn) error); ok {
		r1 = returnFunc(ctx, organizationId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationProjectsCreate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - in
func (_e *MockClient_Expecter) OrganizationProjectsCreate(ctx interface{}, organizationId interface{}, in interface{}) *MockClient_OrganizationProjectsCreate_Call {
	return &MockClient_OrganizationProjectsCreate_Call{Call: _e.mock.On("OrganizationProjectsCreate", ctx, organizationId, in)}
}

func (_c *MockClient_OrganizationProjectsCreate_Call) Run(run func(ctx context.Context, organizationId string, in *organizationprojects.OrganizationProjectsCreateIn)) *MockClient_OrganizationProjectsCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*organizationprojects.OrganizationProjectsCreateIn))
	})
	return _c
}

func (_c *MockClient_OrganizationProjectsCreate_Call) Return(organizationProjectsCreateOut *organizationprojects.OrganizationProjectsCreateOut, err error) *MockClient_OrganizationProjectsCreate_Call {
	_c.Call.Return(organizationProjectsCreateOut, err)
	return _c
}

func (_c *MockClient_OrganizationProjectsCreate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, in *organizationprojects.OrganizationProjectsCreateIn) (*organizationprojects.OrganizationProjectsCreateOut, error)) *MockClient_OrganizationProjectsCreate_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationProjectsDelete provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationProjectsDelete(ctx context.Context, organizationId string, projectId string) error {
	ret := _mock.Called(ctx, organizationId, projectId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, organizationId, projectId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// OrganizationProjectsDelete is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - projectId
func (_e *MockClient_Expecter) OrganizationProjectsDelete(ctx interface{}, organizationId interface{}, projectId interface{}) *MockClient_OrganizationProjectsDelete_Call {
	return &MockClient_OrganizationProjectsDelete_Call{Call: _e.mock.On("OrganizationProjectsDelete", ctx, organizationId, projectId)}
}

func (_c *MockClient_OrganizationProjectsDelete_Call) Run(run func(ctx context.Context, organizationId string, projectId string)) *MockClient_OrganizationProjectsDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationProjectsDelete_Call) Return(err error) *MockClient_OrganizationProjectsDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_OrganizationProjectsDelete_Call) RunAndReturn(run func(ctx context.Context, organizationId string, projectId string) error) *MockClient_OrganizationProjectsDelete_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationProjectsGet provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationProjectsGet(ctx context.Context, organizationId string, projectId string) (*organizationprojects.OrganizationProjectsGetOut, error) {
	ret := _mock.Called(ctx, organizationId, projectId)

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

	var r0 *organizationprojects.OrganizationProjectsGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*organizationprojects.OrganizationProjectsGetOut, error)); ok {
		return returnFunc(ctx, organizationId, projectId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *organizationprojects.OrganizationProjectsGetOut); ok {
		r0 = returnFunc(ctx, organizationId, projectId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organizationprojects.OrganizationProjectsGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, organizationId, projectId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationProjectsGet is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - projectId
func (_e *MockClient_Expecter) OrganizationProjectsGet(ctx interface{}, organizationId interface{}, projectId interface{}) *MockClient_OrganizationProjectsGet_Call {
	return &MockClient_OrganizationProjectsGet_Call{Call: _e.mock.On("OrganizationProjectsGet", ctx, organizationId, projectId)}
}

func (_c *MockClient_OrganizationProjectsGet_Call) Run(run func(ctx context.Context, organizationId string, projectId string)) *MockClient_OrganizationProjectsGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationProjectsGet_Call) Return(organizationProjectsGetOut *organizationprojects.OrganizationProjectsGetOut, err error) *MockClient_OrganizationProjectsGet_Call {
	_c.Call.Return(organizationProjectsGetOut, err)
	return _c
}

func (_c *MockClient_OrganizationProjectsGet_Call) RunAndReturn(run func(ctx context.Context, organizationId string, projectId string) (*organizationprojects.OrganizationProjectsGetOut, error)) *MockClient_OrganizationProjectsGet_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationProjectsList provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationProjectsList(ctx context.Context, organizationId string) (*organizationprojects.OrganizationProjectsListOut, error) {
	ret := _mock.Called(ctx, organizationId)

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

	var r0 *organizationprojects.OrganizationProjectsListOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*organizationprojects.OrganizationProjectsListOut, error)); ok {
		return returnFunc(ctx, organizationId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *organizationprojects.OrganizationProjectsListOut); ok {
		r0 = returnFunc(ctx, organizationId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organizationprojects.OrganizationProjectsListOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, organizationId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationProjectsList is a helper method to define mock.On call
//   - ctx
//   - organizationId
func (_e *MockClient_Expecter) OrganizationProjectsList(ctx interface{}, organizationId interface{}) *MockClient_OrganizationProjectsList_Call {
	return &MockClient_OrganizationProjectsList_Call{Call: _e.mock.On("OrganizationProjectsList", ctx, organizationId)}
}

func (_c *MockClient_OrganizationProjectsList_Call) Run(run func(ctx context.Context, organizationId string)) *MockClient_OrganizationProjectsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationProjectsList_Call) Return(organizationProjectsListOut *organizationprojects.OrganizationProjectsListOut, err error) *MockClient_OrganizationProjectsList_Call {
	_c.Call.Return(organizationProjectsListOut, err)
	return _c
}

func (_c *MockClient_OrganizationProjectsList_Call) RunAndReturn(run func(ctx context.Context, organizationId string) (*organizationprojects.OrganizationProjectsListOut, error)) *MockClient_OrganizationProjectsList_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationProjectsUpdate provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationProjectsUpdate(ctx context.Context, organizationId string, projectId string, in *organizationprojects.OrganizationProjectsUpdateIn) (*organizationprojects.OrganizationProjectsUpdateOut, error) {
	ret := _mock.Called(ctx, organizationId, projectId, in)

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

	var r0 *organizationprojects.OrganizationProjectsUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *organizationprojects.OrganizationProjectsUpdateIn) (*organizationprojects.OrganizationProjectsUpdateOut, error)); ok {
		return returnFunc(ctx, organizationId, projectId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *organizationprojects.OrganizationProjectsUpdateIn) *organizationprojects.OrganizationProjectsUpdateOut); ok {
		r0 = returnFunc(ctx, organizationId, projectId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organizationprojects.OrganizationProjectsUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *organizationprojects.OrganizationProjectsUpdateIn) error); ok {
		r1 = returnFunc(ctx, organizationId, projectId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationProjectsUpdate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - projectId
//   - in
func (_e *MockClient_Expecter) OrganizationProjectsUpdate(ctx interface{}, organizationId interface{}, projectId interface{}, in interface{}) *MockClient_OrganizationProjectsUpdate_Call {
	return &MockClient_OrganizationProjectsUpdate_Call{Call: _e.mock.On("OrganizationProjectsUpdate", ctx, organizationId, projectId, in)}
}

func (_c *MockClient_OrganizationProjectsUpdate_Call) Run(run func(ctx context.Context, organizationId string, projectId string, in *organizationprojects.OrganizationProjectsUpdateIn)) *MockClient_OrganizationProjectsUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*organizationprojects.OrganizationProjectsUpdateIn))
	})
	return _c
}

func (_c *MockClient_OrganizationProjectsUpdate_Call) Return(organizationProjectsUpdateOut *organizationprojects.OrganizationProjectsUpdateOut, err error) *MockClient_OrganizationProjectsUpdate_Call {
	_c.Call.Return(organizationProjectsUpdateOut, err)
	return _c
}

func (_c *MockClient_OrganizationProjectsUpdate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, projectId string, in *organizationprojects.OrganizationProjectsUpdateIn) (*organizationprojects.OrganizationProjectsUpdateOut, error)) *MockClient_OrganizationProjectsUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationUpdate provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationUpdate(ctx context.Context, organizationId string, in *organization.OrganizationUpdateIn) (*organization.OrganizationUpdateOut, error) {
	ret := _mock.Called(ctx, organizationId, in)

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

	var r0 *organization.OrganizationUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *organization.OrganizationUpdateIn) (*organization.OrganizationUpdateOut, error)); ok {
		return returnFunc(ctx, organizationId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *organization.OrganizationUpdateIn) *organization.OrganizationUpdateOut); ok {
		r0 = returnFunc(ctx, organizationId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organization.OrganizationUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *organization.OrganizationUpdateIn) error); ok {
		r1 = returnFunc(ctx, organizationId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationUpdate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - in
func (_e *MockClient_Expecter) OrganizationUpdate(ctx interface{}, organizationId interface{}, in interface{}) *MockClient_OrganizationUpdate_Call {
	return &MockClient_OrganizationUpdate_Call{Call: _e.mock.On("OrganizationUpdate", ctx, organizationId, in)}
}

func (_c *MockClient_OrganizationUpdate_Call) Run(run func(ctx context.Context, organizationId string, in *organization.OrganizationUpdateIn)) *MockClient_OrganizationUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*organization.OrganizationUpdateIn))
	})
	return _c
}

func (_c *MockClient_OrganizationUpdate_Call) Return(organizationUpdateOut *organization.OrganizationUpdateOut, err error) *MockClient_OrganizationUpdate_Call {
	_c.Call.Return(organizationUpdateOut, err)
	return _c
}

func (_c *MockClient_OrganizationUpdate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, in *organization.OrganizationUpdateIn) (*organization.OrganizationUpdateOut, error)) *MockClient_OrganizationUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationUserAuthenticationMethodsList provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationUserAuthenticationMethodsList(ctx context.Context, organizationId string, memberUserId string) ([]organizationuser.AuthenticationMethodOut, error) {
	ret := _mock.Called(ctx, organizationId, memberUserId)

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

	var r0 []organizationuser.AuthenticationMethodOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]organizationuser.AuthenticationMethodOut, error)); ok {
		return returnFunc(ctx, organizationId, memberUserId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []organizationuser.AuthenticationMethodOut); ok {
		r0 = returnFunc(ctx, organizationId, memberUserId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]organizationuser.AuthenticationMethodOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, organizationId, memberUserId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationUserAuthenticationMethodsList is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - memberUserId
func (_e *MockClient_Expecter) OrganizationUserAuthenticationMethodsList(ctx interface{}, organizationId interface{}, memberUserId interface{}) *MockClient_OrganizationUserAuthenticationMethodsList_Call {
	return &MockClient_OrganizationUserAuthenticationMethodsList_Call{Call: _e.mock.On("OrganizationUserAuthenticationMethodsList", ctx, organizationId, memberUserId)}
}

func (_c *MockClient_OrganizationUserAuthenticationMethodsList_Call) Run(run func(ctx context.Context, organizationId string, memberUserId string)) *MockClient_OrganizationUserAuthenticationMethodsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationUserAuthenticationMethodsList_Call) Return(authenticationMethodOuts []organizationuser.AuthenticationMethodOut, err error) *MockClient_OrganizationUserAuthenticationMethodsList_Call {
	_c.Call.Return(authenticationMethodOuts, err)
	return _c
}

func (_c *MockClient_OrganizationUserAuthenticationMethodsList_Call) RunAndReturn(run func(ctx context.Context, organizationId string, memberUserId string) ([]organizationuser.AuthenticationMethodOut, error)) *MockClient_OrganizationUserAuthenticationMethodsList_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationUserDelete provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationUserDelete(ctx context.Context, organizationId string, memberUserId string) error {
	ret := _mock.Called(ctx, organizationId, memberUserId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, organizationId, memberUserId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// OrganizationUserDelete is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - memberUserId
func (_e *MockClient_Expecter) OrganizationUserDelete(ctx interface{}, organizationId interface{}, memberUserId interface{}) *MockClient_OrganizationUserDelete_Call {
	return &MockClient_OrganizationUserDelete_Call{Call: _e.mock.On("OrganizationUserDelete", ctx, organizationId, memberUserId)}
}

func (_c *MockClient_OrganizationUserDelete_Call) Run(run func(ctx context.Context, organizationId string, memberUserId string)) *MockClient_OrganizationUserDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationUserDelete_Call) Return(err error) *MockClient_OrganizationUserDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_OrganizationUserDelete_Call) RunAndReturn(run func(ctx context.Context, organizationId string, memberUserId string) error) *MockClient_OrganizationUserDelete_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationUserGet provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationUserGet(ctx context.Context, organizationId string, memberUserId string) (*organizationuser.OrganizationUserGetOut, error) {
	ret := _mock.Called(ctx, organizationId, memberUserId)

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

	var r0 *organizationuser.OrganizationUserGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*organizationuser.OrganizationUserGetOut, error)); ok {
		return returnFunc(ctx, organizationId, memberUserId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *organizationuser.OrganizationUserGetOut); ok {
		r0 = returnFunc(ctx, organizationId, memberUserId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organizationuser.OrganizationUserGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, organizationId, memberUserId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationUserGet is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - memberUserId
func (_e *MockClient_Expecter) OrganizationUserGet(ctx interface{}, organizationId interface{}, memberUserId interface{}) *MockClient_OrganizationUserGet_Call {
	return &MockClient_OrganizationUserGet_Call{Call: _e.mock.On("OrganizationUserGet", ctx, organizationId, memberUserId)}
}

func (_c *MockClient_OrganizationUserGet_Call) Run(run func(ctx context.Context, organizationId string, memberUserId string)) *MockClient_OrganizationUserGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationUserGet_Call) Return(organizationUserGetOut *organizationuser.OrganizationUserGetOut, err error) *MockClient_OrganizationUserGet_Call {
	_c.Call.Return(organizationUserGetOut, err)
	return _c
}

func (_c *MockClient_OrganizationUserGet_Call) RunAndReturn(run func(ctx context.Context, organizationId string, memberUserId string) (*organizationuser.OrganizationUserGetOut, error)) *MockClient_OrganizationUserGet_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationUserInvitationAccept provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationUserInvitationAccept(ctx context.Context, organizationId string, userEmail string, in *organizationuser.OrganizationUserInvitationAcceptIn) error {
	ret := _mock.Called(ctx, organizationId, userEmail, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *organizationuser.OrganizationUserInvitationAcceptIn) error); ok {
		r0 = returnFunc(ctx, organizationId, userEmail, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// OrganizationUserInvitationAccept is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - userEmail
//   - in
func (_e *MockClient_Expecter) OrganizationUserInvitationAccept(ctx interface{}, organizationId interface{}, userEmail interface{}, in interface{}) *MockClient_OrganizationUserInvitationAccept_Call {
	return &MockClient_OrganizationUserInvitationAccept_Call{Call: _e.mock.On("OrganizationUserInvitationAccept", ctx, organizationId, userEmail, in)}
}

func (_c *MockClient_OrganizationUserInvitationAccept_Call) Run(run func(ctx context.Context, organizationId string, userEmail string, in *organizationuser.OrganizationUserInvitationAcceptIn)) *MockClient_OrganizationUserInvitationAccept_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*organizationuser.OrganizationUserInvitationAcceptIn))
	})
	return _c
}

func (_c *MockClient_OrganizationUserInvitationAccept_Call) Return(err error) *MockClient_OrganizationUserInvitationAccept_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_OrganizationUserInvitationAccept_Call) RunAndReturn(run func(ctx context.Context, organizationId string, userEmail string, in *organizationuser.OrganizationUserInvitationAcceptIn) error) *MockClient_OrganizationUserInvitationAccept_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationUserInvitationDelete provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationUserInvitationDelete(ctx context.Context, organizationId string, userEmail string) error {
	ret := _mock.Called(ctx, organizationId, userEmail)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, organizationId, userEmail)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// OrganizationUserInvitationDelete is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - userEmail
func (_e *MockClient_Expecter) OrganizationUserInvitationDelete(ctx interface{}, organizationId interface{}, userEmail interface{}) *MockClient_OrganizationUserInvitationDelete_Call {
	return &MockClient_OrganizationUserInvitationDelete_Call{Call: _e.mock.On("OrganizationUserInvitationDelete", ctx, organizationId, userEmail)}
}

func (_c *MockClient_OrganizationUserInvitationDelete_Call) Run(run func(ctx context.Context, organizationId string, userEmail string)) *MockClient_OrganizationUserInvitationDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationUserInvitationDelete_Call) Return(err error) *MockClient_OrganizationUserInvitationDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_OrganizationUserInvitationDelete_Call) RunAndReturn(run func(ctx context.Context, organizationId string, userEmail string) error) *MockClient_OrganizationUserInvitationDelete_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationUserInvitationsList provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationUserInvitationsList(ctx context.Context, organizationId string) ([]organizationuser.InvitationOut, error) {
	ret := _mock.Called(ctx, organizationId)

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

	var r0 []organizationuser.InvitationOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]organizationuser.InvitationOut, error)); ok {
		return returnFunc(ctx, organizationId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []organizationuser.InvitationOut); ok {
		r0 = returnFunc(ctx, organizationId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]organizationuser.InvitationOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, organizationId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationUserInvitationsList is a helper method to define mock.On call
//   - ctx
//   - organizationId
func (_e *MockClient_Expecter) OrganizationUserInvitationsList(ctx interface{}, organizationId interface{}) *MockClient_OrganizationUserInvitationsList_Call {
	return &MockClient_OrganizationUserInvitationsList_Call{Call: _e.mock.On("OrganizationUserInvitationsList", ctx, organizationId)}
}

func (_c *MockClient_OrganizationUserInvitationsList_Call) Run(run func(ctx context.Context, organizationId string)) *MockClient_OrganizationUserInvitationsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationUserInvitationsList_Call) Return(invitationOuts []organizationuser.InvitationOut, err error) *MockClient_OrganizationUserInvitationsList_Call {
	_c.Call.Return(invitationOuts, err)
	return _c
}

func (_c *MockClient_OrganizationUserInvitationsList_Call) RunAndReturn(run func(ctx context.Context, organizationId string) ([]organizationuser.InvitationOut, error)) *MockClient_OrganizationUserInvitationsList_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationUserInvite provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationUserInvite(ctx context.Context, organizationId string, in *organizationuser.OrganizationUserInviteIn) error {
	ret := _mock.Called(ctx, organizationId, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *organizationuser.OrganizationUserInviteIn) error); ok {
		r0 = returnFunc(ctx, organizationId, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// OrganizationUserInvite is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - in
func (_e *MockClient_Expecter) OrganizationUserInvite(ctx interface{}, organizationId interface{}, in interface{}) *MockClient_OrganizationUserInvite_Call {
	return &MockClient_OrganizationUserInvite_Call{Call: _e.mock.On("OrganizationUserInvite", ctx, organizationId, in)}
}

func (_c *MockClient_OrganizationUserInvite_Call) Run(run func(ctx context.Context, organizationId string, in *organizationuser.OrganizationUserInviteIn)) *MockClient_OrganizationUserInvite_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*organizationuser.OrganizationUserInviteIn))
	})
	return _c
}

func (_c *MockClient_OrganizationUserInvite_Call) Return(err error) *MockClient_OrganizationUserInvite_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_OrganizationUserInvite_Call) RunAndReturn(run func(ctx context.Context, organizationId string, in *organizationuser.OrganizationUserInviteIn) error) *MockClient_OrganizationUserInvite_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationUserList provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationUserList(ctx context.Context, organizationId string) ([]organizationuser.UserOut, error) {
	ret := _mock.Called(ctx, organizationId)

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

	var r0 []organizationuser.UserOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]organizationuser.UserOut, error)); ok {
		return returnFunc(ctx, organizationId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []organizationuser.UserOut); ok {
		r0 = returnFunc(ctx, organizationId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]organizationuser.UserOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, organizationId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationUserList is a helper method to define mock.On call
//   - ctx
//   - organizationId
func (_e *MockClient_Expecter) OrganizationUserList(ctx interface{}, organizationId interface{}) *MockClient_OrganizationUserList_Call {
	return &MockClient_OrganizationUserList_Call{Call: _e.mock.On("OrganizationUserList", ctx, organizationId)}
}

func (_c *MockClient_OrganizationUserList_Call) Run(run func(ctx context.Context, organizationId string)) *MockClient_OrganizationUserList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationUserList_Call) Return(userOuts []organizationuser.UserOut, err error) *MockClient_OrganizationUserList_Call {
	_c.Call.Return(userOuts, err)
	return _c
}

func (_c *MockClient_OrganizationUserList_Call) RunAndReturn(run func(ctx context.Context, organizationId string) ([]organizationuser.UserOut, error)) *MockClient_OrganizationUserList_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationUserPasswordReset provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationUserPasswordReset(ctx context.Context, organizationId string, memberUserId string) error {
	ret := _mock.Called(ctx, organizationId, memberUserId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, organizationId, memberUserId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// OrganizationUserPasswordReset is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - memberUserId
func (_e *MockClient_Expecter) OrganizationUserPasswordReset(ctx interface{}, organizationId interface{}, memberUserId interface{}) *MockClient_OrganizationUserPasswordReset_Call {
	return &MockClient_OrganizationUserPasswordReset_Call{Call: _e.mock.On("OrganizationUserPasswordReset", ctx, organizationId, memberUserId)}
}

func (_c *MockClient_OrganizationUserPasswordReset_Call) Run(run func(ctx context.Context, organizationId string, memberUserId string)) *MockClient_OrganizationUserPasswordReset_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationUserPasswordReset_Call) Return(err error) *MockClient_OrganizationUserPasswordReset_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_OrganizationUserPasswordReset_Call) RunAndReturn(run func(ctx context.Context, organizationId string, memberUserId string) error) *MockClient_OrganizationUserPasswordReset_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationUserRevokeToken provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationUserRevokeToken(ctx context.Context, organizationId string, memberUserId string, tokenPrefix string) error {
	ret := _mock.Called(ctx, organizationId, memberUserId, tokenPrefix)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, organizationId, memberUserId, tokenPrefix)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// OrganizationUserRevokeToken is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - memberUserId
//   - tokenPrefix
func (_e *MockClient_Expecter) OrganizationUserRevokeToken(ctx interface{}, organizationId interface{}, memberUserId interface{}, tokenPrefix interface{}) *MockClient_OrganizationUserRevokeToken_Call {
	return &MockClient_OrganizationUserRevokeToken_Call{Call: _e.mock.On("OrganizationUserRevokeToken", ctx, organizationId, memberUserId, tokenPrefix)}
}

func (_c *MockClient_OrganizationUserRevokeToken_Call) Run(run func(ctx context.Context, organizationId string, memberUserId string, tokenPrefix string)) *MockClient_OrganizationUserRevokeToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationUserRevokeToken_Call) Return(err error) *MockClient_OrganizationUserRevokeToken_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_OrganizationUserRevokeToken_Call) RunAndReturn(run func(ctx context.Context, organizationId string, memberUserId string, tokenPrefix string) error) *MockClient_OrganizationUserRevokeToken_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationUserTokensList provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationUserTokensList(ctx context.Context, organizationId string, memberUserId string) ([]organizationuser.TokenOut, error) {
	ret := _mock.Called(ctx, organizationId, memberUserId)

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

	var r0 []organizationuser.TokenOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]organizationuser.TokenOut, error)); ok {
		return returnFunc(ctx, organizationId, memberUserId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []organizationuser.TokenOut); ok {
		r0 = returnFunc(ctx, organizationId, memberUserId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]organizationuser.TokenOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, organizationId, memberUserId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationUserTokensList is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - memberUserId
func (_e *MockClient_Expecter) OrganizationUserTokensList(ctx interface{}, organizationId interface{}, memberUserId interface{}) *MockClient_OrganizationUserTokensList_Call {
	return &MockClient_OrganizationUserTokensList_Call{Call: _e.mock.On("OrganizationUserTokensList", ctx, organizationId, memberUserId)}
}

func (_c *MockClient_OrganizationUserTokensList_Call) Run(run func(ctx context.Context, organizationId string, memberUserId string)) *MockClient_OrganizationUserTokensList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationUserTokensList_Call) Return(tokenOuts []organizationuser.TokenOut, err error) *MockClient_OrganizationUserTokensList_Call {
	_c.Call.Return(tokenOuts, err)
	return _c
}

func (_c *MockClient_OrganizationUserTokensList_Call) RunAndReturn(run func(ctx context.Context, organizationId string, memberUserId string) ([]organizationuser.TokenOut, error)) *MockClient_OrganizationUserTokensList_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationUserUpdate provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationUserUpdate(ctx context.Context, organizationId string, memberUserId string, in *organizationuser.OrganizationUserUpdateIn) (*organizationuser.OrganizationUserUpdateOut, error) {
	ret := _mock.Called(ctx, organizationId, memberUserId, in)

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

	var r0 *organizationuser.OrganizationUserUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *organizationuser.OrganizationUserUpdateIn) (*organizationuser.OrganizationUserUpdateOut, error)); ok {
		return returnFunc(ctx, organizationId, memberUserId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *organizationuser.OrganizationUserUpdateIn) *organizationuser.OrganizationUserUpdateOut); ok {
		r0 = returnFunc(ctx, organizationId, memberUserId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organizationuser.OrganizationUserUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *organizationuser.OrganizationUserUpdateIn) error); ok {
		r1 = returnFunc(ctx, organizationId, memberUserId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationUserUpdate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - memberUserId
//   - in
func (_e *MockClient_Expecter) OrganizationUserUpdate(ctx interface{}, organizationId interface{}, memberUserId interface{}, in interface{}) *MockClient_OrganizationUserUpdate_Call {
	return &MockClient_OrganizationUserUpdate_Call{Call: _e.mock.On("OrganizationUserUpdate", ctx, organizationId, memberUserId, in)}
}

func (_c *MockClient_OrganizationUserUpdate_Call) Run(run func(ctx context.Context, organizationId string, memberUserId string, in *organizationuser.OrganizationUserUpdateIn)) *MockClient_OrganizationUserUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*organizationuser.OrganizationUserUpdateIn))
	})
	return _c
}

func (_c *MockClient_OrganizationUserUpdate_Call) Return(organizationUserUpdateOut *organizationuser.OrganizationUserUpdateOut, err error) *MockClient_OrganizationUserUpdate_Call {
	_c.Call.Return(organizationUserUpdateOut, err)
	return _c
}

func (_c *MockClient_OrganizationUserUpdate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, memberUserId string, in *organizationuser.OrganizationUserUpdateIn) (*organizationuser.OrganizationUserUpdateOut, error)) *MockClient_OrganizationUserUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationVpcCreate provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationVpcCreate(ctx context.Context, organizationId string, in *organizationvpc.OrganizationVpcCreateIn) (*organizationvpc.OrganizationVpcCreateOut, error) {
	ret := _mock.Called(ctx, organizationId, in)

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

	var r0 *organizationvpc.OrganizationVpcCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *organizationvpc.OrganizationVpcCreateIn) (*organizationvpc.OrganizationVpcCreateOut, error)); ok {
		return returnFunc(ctx, organizationId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *organizationvpc.OrganizationVpcCreateIn) *organizationvpc.OrganizationVpcCreateOut); ok {
		r0 = returnFunc(ctx, organizationId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organizationvpc.OrganizationVpcCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *organizationvpc.OrganizationVpcCreateIn) error); ok {
		r1 = returnFunc(ctx, organizationId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationVpcCreate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - in
func (_e *MockClient_Expecter) OrganizationVpcCreate(ctx interface{}, organizationId interface{}, in interface{}) *MockClient_OrganizationVpcCreate_Call {
	return &MockClient_OrganizationVpcCreate_Call{Call: _e.mock.On("OrganizationVpcCreate", ctx, organizationId, in)}
}

func (_c *MockClient_OrganizationVpcCreate_Call) Run(run func(ctx context.Context, organizationId string, in *organizationvpc.OrganizationVpcCreateIn)) *MockClient_OrganizationVpcCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*organizationvpc.OrganizationVpcCreateIn))
	})
	return _c
}

func (_c *MockClient_OrganizationVpcCreate_Call) Return(organizationVpcCreateOut *organizationvpc.OrganizationVpcCreateOut, err error) *MockClient_OrganizationVpcCreate_Call {
	_c.Call.Return(organizationVpcCreateOut, err)
	return _c
}

func (_c *MockClient_OrganizationVpcCreate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, in *organizationvpc.OrganizationVpcCreateIn) (*organizationvpc.OrganizationVpcCreateOut, error)) *MockClient_OrganizationVpcCreate_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationVpcDelete provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationVpcDelete(ctx context.Context, organizationId string, organizationVpcId string) (*organizationvpc.OrganizationVpcDeleteOut, error) {
	ret := _mock.Called(ctx, organizationId, organizationVpcId)

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

	var r0 *organizationvpc.OrganizationVpcDeleteOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*organizationvpc.OrganizationVpcDeleteOut, error)); ok {
		return returnFunc(ctx, organizationId, organizationVpcId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *organizationvpc.OrganizationVpcDeleteOut); ok {
		r0 = returnFunc(ctx, organizationId, organizationVpcId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organizationvpc.OrganizationVpcDeleteOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, organizationId, organizationVpcId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationVpcDelete is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - organizationVpcId
func (_e *MockClient_Expecter) OrganizationVpcDelete(ctx interface{}, organizationId interface{}, organizationVpcId interface{}) *MockClient_OrganizationVpcDelete_Call {
	return &MockClient_OrganizationVpcDelete_Call{Call: _e.mock.On("OrganizationVpcDelete", ctx, organizationId, organizationVpcId)}
}

func (_c *MockClient_OrganizationVpcDelete_Call) Run(run func(ctx context.Context, organizationId string, organizationVpcId string)) *MockClient_OrganizationVpcDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationVpcDelete_Call) Return(organizationVpcDeleteOut *organizationvpc.OrganizationVpcDeleteOut, err error) *MockClient_OrganizationVpcDelete_Call {
	_c.Call.Return(organizationVpcDeleteOut, err)
	return _c
}

func (_c *MockClient_OrganizationVpcDelete_Call) RunAndReturn(run func(ctx context.Context, organizationId string, organizationVpcId string) (*organizationvpc.OrganizationVpcDeleteOut, error)) *MockClient_OrganizationVpcDelete_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationVpcGet provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationVpcGet(ctx context.Context, organizationId string, organizationVpcId string) (*organizationvpc.OrganizationVpcGetOut, error) {
	ret := _mock.Called(ctx, organizationId, organizationVpcId)

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

	var r0 *organizationvpc.OrganizationVpcGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*organizationvpc.OrganizationVpcGetOut, error)); ok {
		return returnFunc(ctx, organizationId, organizationVpcId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *organizationvpc.OrganizationVpcGetOut); ok {
		r0 = returnFunc(ctx, organizationId, organizationVpcId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organizationvpc.OrganizationVpcGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, organizationId, organizationVpcId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationVpcGet is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - organizationVpcId
func (_e *MockClient_Expecter) OrganizationVpcGet(ctx interface{}, organizationId interface{}, organizationVpcId interface{}) *MockClient_OrganizationVpcGet_Call {
	return &MockClient_OrganizationVpcGet_Call{Call: _e.mock.On("OrganizationVpcGet", ctx, organizationId, organizationVpcId)}
}

func (_c *MockClient_OrganizationVpcGet_Call) Run(run func(ctx context.Context, organizationId string, organizationVpcId string)) *MockClient_OrganizationVpcGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationVpcGet_Call) Return(organizationVpcGetOut *organizationvpc.OrganizationVpcGetOut, err error) *MockClient_OrganizationVpcGet_Call {
	_c.Call.Return(organizationVpcGetOut, err)
	return _c
}

func (_c *MockClient_OrganizationVpcGet_Call) RunAndReturn(run func(ctx context.Context, organizationId string, organizationVpcId string) (*organizationvpc.OrganizationVpcGetOut, error)) *MockClient_OrganizationVpcGet_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationVpcList provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationVpcList(ctx context.Context, organizationId string) ([]organizationvpc.VpcOut, error) {
	ret := _mock.Called(ctx, organizationId)

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

	var r0 []organizationvpc.VpcOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]organizationvpc.VpcOut, error)); ok {
		return returnFunc(ctx, organizationId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []organizationvpc.VpcOut); ok {
		r0 = returnFunc(ctx, organizationId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]organizationvpc.VpcOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, organizationId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationVpcList is a helper method to define mock.On call
//   - ctx
//   - organizationId
func (_e *MockClient_Expecter) OrganizationVpcList(ctx interface{}, organizationId interface{}) *MockClient_OrganizationVpcList_Call {
	return &MockClient_OrganizationVpcList_Call{Call: _e.mock.On("OrganizationVpcList", ctx, organizationId)}
}

func (_c *MockClient_OrganizationVpcList_Call) Run(run func(ctx context.Context, organizationId string)) *MockClient_OrganizationVpcList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationVpcList_Call) Return(vpcOuts []organizationvpc.VpcOut, err error) *MockClient_OrganizationVpcList_Call {
	_c.Call.Return(vpcOuts, err)
	return _c
}

func (_c *MockClient_OrganizationVpcList_Call) RunAndReturn(run func(ctx context.Context, organizationId string) ([]organizationvpc.VpcOut, error)) *MockClient_OrganizationVpcList_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationVpcPeeringConnectionCreate provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationVpcPeeringConnectionCreate(ctx context.Context, organizationId string, organizationVpcId string, in *organizationvpc.OrganizationVpcPeeringConnectionCreateIn) (*organizationvpc.OrganizationVpcPeeringConnectionCreateOut, error) {
	ret := _mock.Called(ctx, organizationId, organizationVpcId, in)

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

	var r0 *organizationvpc.OrganizationVpcPeeringConnectionCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *organizationvpc.OrganizationVpcPeeringConnectionCreateIn) (*organizationvpc.OrganizationVpcPeeringConnectionCreateOut, error)); ok {
		return returnFunc(ctx, organizationId, organizationVpcId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *organizationvpc.OrganizationVpcPeeringConnectionCreateIn) *organizationvpc.OrganizationVpcPeeringConnectionCreateOut); ok {
		r0 = returnFunc(ctx, organizationId, organizationVpcId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organizationvpc.OrganizationVpcPeeringConnectionCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *organizationvpc.OrganizationVpcPeeringConnectionCreateIn) error); ok {
		r1 = returnFunc(ctx, organizationId, organizationVpcId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationVpcPeeringConnectionCreate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - organizationVpcId
//   - in
func (_e *MockClient_Expecter) OrganizationVpcPeeringConnectionCreate(ctx interface{}, organizationId interface{}, organizationVpcId interface{}, in interface{}) *MockClient_OrganizationVpcPeeringConnectionCreate_Call {
	return &MockClient_OrganizationVpcPeeringConnectionCreate_Call{Call: _e.mock.On("OrganizationVpcPeeringConnectionCreate", ctx, organizationId, organizationVpcId, in)}
}

func (_c *MockClient_OrganizationVpcPeeringConnectionCreate_Call) Run(run func(ctx context.Context, organizationId string, organizationVpcId string, in *organizationvpc.OrganizationVpcPeeringConnectionCreateIn)) *MockClient_OrganizationVpcPeeringConnectionCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*organizationvpc.OrganizationVpcPeeringConnectionCreateIn))
	})
	return _c
}

func (_c *MockClient_OrganizationVpcPeeringConnectionCreate_Call) Return(organizationVpcPeeringConnectionCreateOut *organizationvpc.OrganizationVpcPeeringConnectionCreateOut, err error) *MockClient_OrganizationVpcPeeringConnectionCreate_Call {
	_c.Call.Return(organizationVpcPeeringConnectionCreateOut, err)
	return _c
}

func (_c *MockClient_OrganizationVpcPeeringConnectionCreate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, organizationVpcId string, in *organizationvpc.OrganizationVpcPeeringConnectionCreateIn) (*organizationvpc.OrganizationVpcPeeringConnectionCreateOut, error)) *MockClient_OrganizationVpcPeeringConnectionCreate_Call {
	_c.Call.Return(run)
	return _c
}

// OrganizationVpcPeeringConnectionDeleteById provides a mock function for the type MockClient
func (_mock *MockClient) OrganizationVpcPeeringConnectionDeleteById(ctx context.Context, organizationId string, organizationVpcId string, peeringConnectionId string) (*organizationvpc.OrganizationVpcPeeringConnectionDeleteByIdOut, error) {
	ret := _mock.Called(ctx, organizationId, organizationVpcId, peeringConnectionId)

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

	var r0 *organizationvpc.OrganizationVpcPeeringConnectionDeleteByIdOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*organizationvpc.OrganizationVpcPeeringConnectionDeleteByIdOut, error)); ok {
		return returnFunc(ctx, organizationId, organizationVpcId, peeringConnectionId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *organizationvpc.OrganizationVpcPeeringConnectionDeleteByIdOut); ok {
		r0 = returnFunc(ctx, organizationId, organizationVpcId, peeringConnectionId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organizationvpc.OrganizationVpcPeeringConnectionDeleteByIdOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, organizationId, organizationVpcId, peeringConnectionId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// OrganizationVpcPeeringConnectionDeleteById is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - organizationVpcId
//   - peeringConnectionId
func (_e *MockClient_Expecter) OrganizationVpcPeeringConnectionDeleteById(ctx interface{}, organizationId interface{}, organizationVpcId interface{}, peeringConnectionId interface{}) *MockClient_OrganizationVpcPeeringConnectionDeleteById_Call {
	return &MockClient_OrganizationVpcPeeringConnectionDeleteById_Call{Call: _e.mock.On("OrganizationVpcPeeringConnectionDeleteById", ctx, organizationId, organizationVpcId, peeringConnectionId)}
}

func (_c *MockClient_OrganizationVpcPeeringConnectionDeleteById_Call) Run(run func(ctx context.Context, organizationId string, organizationVpcId string, peeringConnectionId string)) *MockClient_OrganizationVpcPeeringConnectionDeleteById_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_OrganizationVpcPeeringConnectionDeleteById_Call) Return(organizationVpcPeeringConnectionDeleteByIdOut *organizationvpc.OrganizationVpcPeeringConnectionDeleteByIdOut, err error) *MockClient_OrganizationVpcPeeringConnectionDeleteById_Call {
	_c.Call.Return(organizationVpcPeeringConnectionDeleteByIdOut, err)
	return _c
}

func (_c *MockClient_OrganizationVpcPeeringConnectionDeleteById_Call) RunAndReturn(run func(ctx context.Context, organizationId string, organizationVpcId string, peeringConnectionId string) (*organizationvpc.OrganizationVpcPeeringConnectionDeleteByIdOut, error)) *MockClient_OrganizationVpcPeeringConnectionDeleteById_Call {
	_c.Call.Return(run)
	return _c
}

// PGServiceAvailableExtensions provides a mock function for the type MockClient
func (_mock *MockClient) PGServiceAvailableExtensions(ctx context.Context, project1 string, serviceName string) ([]postgresql.ExtensionOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []postgresql.ExtensionOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]postgresql.ExtensionOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []postgresql.ExtensionOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]postgresql.ExtensionOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// PGServiceAvailableExtensions is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) PGServiceAvailableExtensions(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_PGServiceAvailableExtensions_Call {
	return &MockClient_PGServiceAvailableExtensions_Call{Call: _e.mock.On("PGServiceAvailableExtensions", ctx, project1, serviceName)}
}

func (_c *MockClient_PGServiceAvailableExtensions_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_PGServiceAvailableExtensions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_PGServiceAvailableExtensions_Call) Return(extensionOuts []postgresql.ExtensionOut, err error) *MockClient_PGServiceAvailableExtensions_Call {
	_c.Call.Return(extensionOuts, err)
	return _c
}

func (_c *MockClient_PGServiceAvailableExtensions_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]postgresql.ExtensionOut, error)) *MockClient_PGServiceAvailableExtensions_Call {
	_c.Call.Return(run)
	return _c
}

// PGServiceQueryStatistics provides a mock function for the type MockClient
func (_mock *MockClient) PGServiceQueryStatistics(ctx context.Context, project1 string, serviceName string, in *postgresql.PgserviceQueryStatisticsIn) ([]postgresql.QueryOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 []postgresql.QueryOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *postgresql.PgserviceQueryStatisticsIn) ([]postgresql.QueryOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *postgresql.PgserviceQueryStatisticsIn) []postgresql.QueryOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]postgresql.QueryOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *postgresql.PgserviceQueryStatisticsIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// PGServiceQueryStatistics is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) PGServiceQueryStatistics(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_PGServiceQueryStatistics_Call {
	return &MockClient_PGServiceQueryStatistics_Call{Call: _e.mock.On("PGServiceQueryStatistics", ctx, project1, serviceName, in)}
}

func (_c *MockClient_PGServiceQueryStatistics_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *postgresql.PgserviceQueryStatisticsIn)) *MockClient_PGServiceQueryStatistics_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*postgresql.PgserviceQueryStatisticsIn))
	})
	return _c
}

func (_c *MockClient_PGServiceQueryStatistics_Call) Return(queryOuts []postgresql.QueryOut, err error) *MockClient_PGServiceQueryStatistics_Call {
	_c.Call.Return(queryOuts, err)
	return _c
}

func (_c *MockClient_PGServiceQueryStatistics_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *postgresql.PgserviceQueryStatisticsIn) ([]postgresql.QueryOut, error)) *MockClient_PGServiceQueryStatistics_Call {
	_c.Call.Return(run)
	return _c
}

// PermissionsGet provides a mock function for the type MockClient
func (_mock *MockClient) PermissionsGet(ctx context.Context, organizationId string, resourceType organization.ResourceType, resourceId string) ([]organization.PermissionOut, error) {
	ret := _mock.Called(ctx, organizationId, resourceType, resourceId)

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

	var r0 []organization.PermissionOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, organization.ResourceType, string) ([]organization.PermissionOut, error)); ok {
		return returnFunc(ctx, organizationId, resourceType, resourceId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, organization.ResourceType, string) []organization.PermissionOut); ok {
		r0 = returnFunc(ctx, organizationId, resourceType, resourceId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]organization.PermissionOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, organization.ResourceType, string) error); ok {
		r1 = returnFunc(ctx, organizationId, resourceType, resourceId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// PermissionsGet is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - resourceType
//   - resourceId
func (_e *MockClient_Expecter) PermissionsGet(ctx interface{}, organizationId interface{}, resourceType interface{}, resourceId interface{}) *MockClient_PermissionsGet_Call {
	return &MockClient_PermissionsGet_Call{Call: _e.mock.On("PermissionsGet", ctx, organizationId, resourceType, resourceId)}
}

func (_c *MockClient_PermissionsGet_Call) Run(run func(ctx context.Context, organizationId string, resourceType organization.ResourceType, resourceId string)) *MockClient_PermissionsGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(organization.ResourceType), args[3].(string))
	})
	return _c
}

func (_c *MockClient_PermissionsGet_Call) Return(permissionOuts []organization.PermissionOut, err error) *MockClient_PermissionsGet_Call {
	_c.Call.Return(permissionOuts, err)
	return _c
}

func (_c *MockClient_PermissionsGet_Call) RunAndReturn(run func(ctx context.Context, organizationId string, resourceType organization.ResourceType, resourceId string) ([]organization.PermissionOut, error)) *MockClient_PermissionsGet_Call {
	_c.Call.Return(run)
	return _c
}

// PermissionsSet provides a mock function for the type MockClient
func (_mock *MockClient) PermissionsSet(ctx context.Context, organizationId string, resourceType organization.ResourceType, resourceId string, in *organization.PermissionsSetIn) error {
	ret := _mock.Called(ctx, organizationId, resourceType, resourceId, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, organization.ResourceType, string, *organization.PermissionsSetIn) error); ok {
		r0 = returnFunc(ctx, organizationId, resourceType, resourceId, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// PermissionsSet is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - resourceType
//   - resourceId
//   - in
func (_e *MockClient_Expecter) PermissionsSet(ctx interface{}, organizationId interface{}, resourceType interface{}, resourceId interface{}, in interface{}) *MockClient_PermissionsSet_Call {
	return &MockClient_PermissionsSet_Call{Call: _e.mock.On("PermissionsSet", ctx, organizationId, resourceType, resourceId, in)}
}

func (_c *MockClient_PermissionsSet_Call) Run(run func(ctx context.Context, organizationId string, resourceType organization.ResourceType, resourceId string, in *organization.PermissionsSetIn)) *MockClient_PermissionsSet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(organization.ResourceType), args[3].(string), args[4].(*organization.PermissionsSetIn))
	})
	return _c
}

func (_c *MockClient_PermissionsSet_Call) Return(err error) *MockClient_PermissionsSet_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_PermissionsSet_Call) RunAndReturn(run func(ctx context.Context, organizationId string, resourceType organization.ResourceType, resourceId string, in *organization.PermissionsSetIn) error) *MockClient_PermissionsSet_Call {
	_c.Call.Return(run)
	return _c
}

// PermissionsUpdate provides a mock function for the type MockClient
func (_mock *MockClient) PermissionsUpdate(ctx context.Context, organizationId string, resourceType organization.ResourceType, resourceId string, in *organization.PermissionsUpdateIn) error {
	ret := _mock.Called(ctx, organizationId, resourceType, resourceId, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, organization.ResourceType, string, *organization.PermissionsUpdateIn) error); ok {
		r0 = returnFunc(ctx, organizationId, resourceType, resourceId, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// PermissionsUpdate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - resourceType
//   - resourceId
//   - in
func (_e *MockClient_Expecter) PermissionsUpdate(ctx interface{}, organizationId interface{}, resourceType interface{}, resourceId interface{}, in interface{}) *MockClient_PermissionsUpdate_Call {
	return &MockClient_PermissionsUpdate_Call{Call: _e.mock.On("PermissionsUpdate", ctx, organizationId, resourceType, resourceId, in)}
}

func (_c *MockClient_PermissionsUpdate_Call) Run(run func(ctx context.Context, organizationId string, resourceType organization.ResourceType, resourceId string, in *organization.PermissionsUpdateIn)) *MockClient_PermissionsUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(organization.ResourceType), args[3].(string), args[4].(*organization.PermissionsUpdateIn))
	})
	return _c
}

func (_c *MockClient_PermissionsUpdate_Call) Return(err error) *MockClient_PermissionsUpdate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_PermissionsUpdate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, resourceType organization.ResourceType, resourceId string, in *organization.PermissionsUpdateIn) error) *MockClient_PermissionsUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// PgAvailableExtensions provides a mock function for the type MockClient
func (_mock *MockClient) PgAvailableExtensions(ctx context.Context, tenant string) ([]postgresql.PgOut, error) {
	ret := _mock.Called(ctx, tenant)

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

	var r0 []postgresql.PgOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]postgresql.PgOut, error)); ok {
		return returnFunc(ctx, tenant)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []postgresql.PgOut); ok {
		r0 = returnFunc(ctx, tenant)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]postgresql.PgOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, tenant)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// PgAvailableExtensions is a helper method to define mock.On call
//   - ctx
//   - tenant
func (_e *MockClient_Expecter) PgAvailableExtensions(ctx interface{}, tenant interface{}) *MockClient_PgAvailableExtensions_Call {
	return &MockClient_PgAvailableExtensions_Call{Call: _e.mock.On("PgAvailableExtensions", ctx, tenant)}
}

func (_c *MockClient_PgAvailableExtensions_Call) Run(run func(ctx context.Context, tenant string)) *MockClient_PgAvailableExtensions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_PgAvailableExtensions_Call) Return(pgOuts []postgresql.PgOut, err error) *MockClient_PgAvailableExtensions_Call {
	_c.Call.Return(pgOuts, err)
	return _c
}

func (_c *MockClient_PgAvailableExtensions_Call) RunAndReturn(run func(ctx context.Context, tenant string) ([]postgresql.PgOut, error)) *MockClient_PgAvailableExtensions_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectAlertsList provides a mock function for the type MockClient
func (_mock *MockClient) ProjectAlertsList(ctx context.Context, project1 string) ([]project.AlertOut, error) {
	ret := _mock.Called(ctx, project1)

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

	var r0 []project.AlertOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]project.AlertOut, error)); ok {
		return returnFunc(ctx, project1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []project.AlertOut); ok {
		r0 = returnFunc(ctx, project1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]project.AlertOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, project1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectAlertsList is a helper method to define mock.On call
//   - ctx
//   - project1
func (_e *MockClient_Expecter) ProjectAlertsList(ctx interface{}, project1 interface{}) *MockClient_ProjectAlertsList_Call {
	return &MockClient_ProjectAlertsList_Call{Call: _e.mock.On("ProjectAlertsList", ctx, project1)}
}

func (_c *MockClient_ProjectAlertsList_Call) Run(run func(ctx context.Context, project1 string)) *MockClient_ProjectAlertsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ProjectAlertsList_Call) Return(alertOuts []project.AlertOut, err error) *MockClient_ProjectAlertsList_Call {
	_c.Call.Return(alertOuts, err)
	return _c
}

func (_c *MockClient_ProjectAlertsList_Call) RunAndReturn(run func(ctx context.Context, project1 string) ([]project.AlertOut, error)) *MockClient_ProjectAlertsList_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectCreate provides a mock function for the type MockClient
func (_mock *MockClient) ProjectCreate(ctx context.Context, in *project.ProjectCreateIn) (*project.ProjectCreateOut, error) {
	ret := _mock.Called(ctx, in)

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

	var r0 *project.ProjectCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *project.ProjectCreateIn) (*project.ProjectCreateOut, error)); ok {
		return returnFunc(ctx, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *project.ProjectCreateIn) *project.ProjectCreateOut); ok {
		r0 = returnFunc(ctx, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*project.ProjectCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *project.ProjectCreateIn) error); ok {
		r1 = returnFunc(ctx, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectCreate is a helper method to define mock.On call
//   - ctx
//   - in
func (_e *MockClient_Expecter) ProjectCreate(ctx interface{}, in interface{}) *MockClient_ProjectCreate_Call {
	return &MockClient_ProjectCreate_Call{Call: _e.mock.On("ProjectCreate", ctx, in)}
}

func (_c *MockClient_ProjectCreate_Call) Run(run func(ctx context.Context, in *project.ProjectCreateIn)) *MockClient_ProjectCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*project.ProjectCreateIn))
	})
	return _c
}

func (_c *MockClient_ProjectCreate_Call) Return(projectCreateOut *project.ProjectCreateOut, err error) *MockClient_ProjectCreate_Call {
	_c.Call.Return(projectCreateOut, err)
	return _c
}

func (_c *MockClient_ProjectCreate_Call) RunAndReturn(run func(ctx context.Context, in *project.ProjectCreateIn) (*project.ProjectCreateOut, error)) *MockClient_ProjectCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectCreditsClaim provides a mock function for the type MockClient
func (_mock *MockClient) ProjectCreditsClaim(ctx context.Context, project1 string, in *projectbilling.ProjectCreditsClaimIn) (*projectbilling.ProjectCreditsClaimOut, error) {
	ret := _mock.Called(ctx, project1, in)

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

	var r0 *projectbilling.ProjectCreditsClaimOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *projectbilling.ProjectCreditsClaimIn) (*projectbilling.ProjectCreditsClaimOut, error)); ok {
		return returnFunc(ctx, project1, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *projectbilling.ProjectCreditsClaimIn) *projectbilling.ProjectCreditsClaimOut); ok {
		r0 = returnFunc(ctx, project1, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*projectbilling.ProjectCreditsClaimOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *projectbilling.ProjectCreditsClaimIn) error); ok {
		r1 = returnFunc(ctx, project1, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectCreditsClaim is a helper method to define mock.On call
//   - ctx
//   - project1
//   - in
func (_e *MockClient_Expecter) ProjectCreditsClaim(ctx interface{}, project1 interface{}, in interface{}) *MockClient_ProjectCreditsClaim_Call {
	return &MockClient_ProjectCreditsClaim_Call{Call: _e.mock.On("ProjectCreditsClaim", ctx, project1, in)}
}

func (_c *MockClient_ProjectCreditsClaim_Call) Run(run func(ctx context.Context, project1 string, in *projectbilling.ProjectCreditsClaimIn)) *MockClient_ProjectCreditsClaim_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*projectbilling.ProjectCreditsClaimIn))
	})
	return _c
}

func (_c *MockClient_ProjectCreditsClaim_Call) Return(projectCreditsClaimOut *projectbilling.ProjectCreditsClaimOut, err error) *MockClient_ProjectCreditsClaim_Call {
	_c.Call.Return(projectCreditsClaimOut, err)
	return _c
}

func (_c *MockClient_ProjectCreditsClaim_Call) RunAndReturn(run func(ctx context.Context, project1 string, in *projectbilling.ProjectCreditsClaimIn) (*projectbilling.ProjectCreditsClaimOut, error)) *MockClient_ProjectCreditsClaim_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectCreditsList provides a mock function for the type MockClient
func (_mock *MockClient) ProjectCreditsList(ctx context.Context, project1 string) ([]projectbilling.CreditOut, error) {
	ret := _mock.Called(ctx, project1)

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

	var r0 []projectbilling.CreditOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]projectbilling.CreditOut, error)); ok {
		return returnFunc(ctx, project1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []projectbilling.CreditOut); ok {
		r0 = returnFunc(ctx, project1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]projectbilling.CreditOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, project1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectCreditsList is a helper method to define mock.On call
//   - ctx
//   - project1
func (_e *MockClient_Expecter) ProjectCreditsList(ctx interface{}, project1 interface{}) *MockClient_ProjectCreditsList_Call {
	return &MockClient_ProjectCreditsList_Call{Call: _e.mock.On("ProjectCreditsList", ctx, project1)}
}

func (_c *MockClient_ProjectCreditsList_Call) Run(run func(ctx context.Context, project1 string)) *MockClient_ProjectCreditsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ProjectCreditsList_Call) Return(creditOuts []projectbilling.CreditOut, err error) *MockClient_ProjectCreditsList_Call {
	_c.Call.Return(creditOuts, err)
	return _c
}

func (_c *MockClient_ProjectCreditsList_Call) RunAndReturn(run func(ctx context.Context, project1 string) ([]projectbilling.CreditOut, error)) *MockClient_ProjectCreditsList_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectDelete provides a mock function for the type MockClient
func (_mock *MockClient) ProjectDelete(ctx context.Context, project1 string) error {
	ret := _mock.Called(ctx, project1)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(ctx, project1)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ProjectDelete is a helper method to define mock.On call
//   - ctx
//   - project1
func (_e *MockClient_Expecter) ProjectDelete(ctx interface{}, project1 interface{}) *MockClient_ProjectDelete_Call {
	return &MockClient_ProjectDelete_Call{Call: _e.mock.On("ProjectDelete", ctx, project1)}
}

func (_c *MockClient_ProjectDelete_Call) Run(run func(ctx context.Context, project1 string)) *MockClient_ProjectDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ProjectDelete_Call) Return(err error) *MockClient_ProjectDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ProjectDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string) error) *MockClient_ProjectDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectGenerateSbomDownloadUrl provides a mock function for the type MockClient
func (_mock *MockClient) ProjectGenerateSbomDownloadUrl(ctx context.Context, project1 string, fileFormat string) (string, error) {
	ret := _mock.Called(ctx, project1, fileFormat)

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

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
		return returnFunc(ctx, project1, fileFormat)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
		r0 = returnFunc(ctx, project1, fileFormat)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, fileFormat)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectGenerateSbomDownloadUrl is a helper method to define mock.On call
//   - ctx
//   - project1
//   - fileFormat
func (_e *MockClient_Expecter) ProjectGenerateSbomDownloadUrl(ctx interface{}, project1 interface{}, fileFormat interface{}) *MockClient_ProjectGenerateSbomDownloadUrl_Call {
	return &MockClient_ProjectGenerateSbomDownloadUrl_Call{Call: _e.mock.On("ProjectGenerateSbomDownloadUrl", ctx, project1, fileFormat)}
}

func (_c *MockClient_ProjectGenerateSbomDownloadUrl_Call) Run(run func(ctx context.Context, project1 string, fileFormat string)) *MockClient_ProjectGenerateSbomDownloadUrl_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ProjectGenerateSbomDownloadUrl_Call) Return(s string, err error) *MockClient_ProjectGenerateSbomDownloadUrl_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockClient_ProjectGenerateSbomDownloadUrl_Call) RunAndReturn(run func(ctx context.Context, project1 string, fileFormat string) (string, error)) *MockClient_ProjectGenerateSbomDownloadUrl_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectGet provides a mock function for the type MockClient
func (_mock *MockClient) ProjectGet(ctx context.Context, project1 string) (*project.ProjectGetOut, error) {
	ret := _mock.Called(ctx, project1)

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

	var r0 *project.ProjectGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*project.ProjectGetOut, error)); ok {
		return returnFunc(ctx, project1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *project.ProjectGetOut); ok {
		r0 = returnFunc(ctx, project1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*project.ProjectGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, project1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectGet is a helper method to define mock.On call
//   - ctx
//   - project1
func (_e *MockClient_Expecter) ProjectGet(ctx interface{}, project1 interface{}) *MockClient_ProjectGet_Call {
	return &MockClient_ProjectGet_Call{Call: _e.mock.On("ProjectGet", ctx, project1)}
}

func (_c *MockClient_ProjectGet_Call) Run(run func(ctx context.Context, project1 string)) *MockClient_ProjectGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ProjectGet_Call) Return(projectGetOut *project.ProjectGetOut, err error) *MockClient_ProjectGet_Call {
	_c.Call.Return(projectGetOut, err)
	return _c
}

func (_c *MockClient_ProjectGet_Call) RunAndReturn(run func(ctx context.Context, project1 string) (*project.ProjectGetOut, error)) *MockClient_ProjectGet_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectGetEventLogs provides a mock function for the type MockClient
func (_mock *MockClient) ProjectGetEventLogs(ctx context.Context, project1 string) ([]project.EventOut, error) {
	ret := _mock.Called(ctx, project1)

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

	var r0 []project.EventOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]project.EventOut, error)); ok {
		return returnFunc(ctx, project1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []project.EventOut); ok {
		r0 = returnFunc(ctx, project1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]project.EventOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, project1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectGetEventLogs is a helper method to define mock.On call
//   - ctx
//   - project1
func (_e *MockClient_Expecter) ProjectGetEventLogs(ctx interface{}, project1 interface{}) *MockClient_ProjectGetEventLogs_Call {
	return &MockClient_ProjectGetEventLogs_Call{Call: _e.mock.On("ProjectGetEventLogs", ctx, project1)}
}

func (_c *MockClient_ProjectGetEventLogs_Call) Run(run func(ctx context.Context, project1 string)) *MockClient_ProjectGetEventLogs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ProjectGetEventLogs_Call) Return(eventOuts []project.EventOut, err error) *MockClient_ProjectGetEventLogs_Call {
	_c.Call.Return(eventOuts, err)
	return _c
}

func (_c *MockClient_ProjectGetEventLogs_Call) RunAndReturn(run func(ctx context.Context, project1 string) ([]project.EventOut, error)) *MockClient_ProjectGetEventLogs_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectGetServiceLogs provides a mock function for the type MockClient
func (_mock *MockClient) ProjectGetServiceLogs(ctx context.Context, project1 string, serviceName string, in *service.ProjectGetServiceLogsIn) (*service.ProjectGetServiceLogsOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 *service.ProjectGetServiceLogsOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ProjectGetServiceLogsIn) (*service.ProjectGetServiceLogsOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ProjectGetServiceLogsIn) *service.ProjectGetServiceLogsOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ProjectGetServiceLogsOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *service.ProjectGetServiceLogsIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectGetServiceLogs is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ProjectGetServiceLogs(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ProjectGetServiceLogs_Call {
	return &MockClient_ProjectGetServiceLogs_Call{Call: _e.mock.On("ProjectGetServiceLogs", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ProjectGetServiceLogs_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *service.ProjectGetServiceLogsIn)) *MockClient_ProjectGetServiceLogs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*service.ProjectGetServiceLogsIn))
	})
	return _c
}

func (_c *MockClient_ProjectGetServiceLogs_Call) Return(projectGetServiceLogsOut *service.ProjectGetServiceLogsOut, err error) *MockClient_ProjectGetServiceLogs_Call {
	_c.Call.Return(projectGetServiceLogsOut, err)
	return _c
}

func (_c *MockClient_ProjectGetServiceLogs_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *service.ProjectGetServiceLogsIn) (*service.ProjectGetServiceLogsOut, error)) *MockClient_ProjectGetServiceLogs_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectInvite provides a mock function for the type MockClient
func (_mock *MockClient) ProjectInvite(ctx context.Context, project1 string, in *project.ProjectInviteIn) error {
	ret := _mock.Called(ctx, project1, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *project.ProjectInviteIn) error); ok {
		r0 = returnFunc(ctx, project1, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ProjectInvite is a helper method to define mock.On call
//   - ctx
//   - project1
//   - in
func (_e *MockClient_Expecter) ProjectInvite(ctx interface{}, project1 interface{}, in interface{}) *MockClient_ProjectInvite_Call {
	return &MockClient_ProjectInvite_Call{Call: _e.mock.On("ProjectInvite", ctx, project1, in)}
}

func (_c *MockClient_ProjectInvite_Call) Run(run func(ctx context.Context, project1 string, in *project.ProjectInviteIn)) *MockClient_ProjectInvite_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*project.ProjectInviteIn))
	})
	return _c
}

func (_c *MockClient_ProjectInvite_Call) Return(err error) *MockClient_ProjectInvite_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ProjectInvite_Call) RunAndReturn(run func(ctx context.Context, project1 string, in *project.ProjectInviteIn) error) *MockClient_ProjectInvite_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectInviteAccept provides a mock function for the type MockClient
func (_mock *MockClient) ProjectInviteAccept(ctx context.Context, project1 string, inviteVerificationCode string) (*project.ProjectInviteAcceptOut, error) {
	ret := _mock.Called(ctx, project1, inviteVerificationCode)

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

	var r0 *project.ProjectInviteAcceptOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*project.ProjectInviteAcceptOut, error)); ok {
		return returnFunc(ctx, project1, inviteVerificationCode)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *project.ProjectInviteAcceptOut); ok {
		r0 = returnFunc(ctx, project1, inviteVerificationCode)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*project.ProjectInviteAcceptOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, inviteVerificationCode)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectInviteAccept is a helper method to define mock.On call
//   - ctx
//   - project1
//   - inviteVerificationCode
func (_e *MockClient_Expecter) ProjectInviteAccept(ctx interface{}, project1 interface{}, inviteVerificationCode interface{}) *MockClient_ProjectInviteAccept_Call {
	return &MockClient_ProjectInviteAccept_Call{Call: _e.mock.On("ProjectInviteAccept", ctx, project1, inviteVerificationCode)}
}

func (_c *MockClient_ProjectInviteAccept_Call) Run(run func(ctx context.Context, project1 string, inviteVerificationCode string)) *MockClient_ProjectInviteAccept_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ProjectInviteAccept_Call) Return(projectInviteAcceptOut *project.ProjectInviteAcceptOut, err error) *MockClient_ProjectInviteAccept_Call {
	_c.Call.Return(projectInviteAcceptOut, err)
	return _c
}

func (_c *MockClient_ProjectInviteAccept_Call) RunAndReturn(run func(ctx context.Context, project1 string, inviteVerificationCode string) (*project.ProjectInviteAcceptOut, error)) *MockClient_ProjectInviteAccept_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectInviteDelete provides a mock function for the type MockClient
func (_mock *MockClient) ProjectInviteDelete(ctx context.Context, project1 string, invitedEmail string) error {
	ret := _mock.Called(ctx, project1, invitedEmail)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, project1, invitedEmail)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ProjectInviteDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - invitedEmail
func (_e *MockClient_Expecter) ProjectInviteDelete(ctx interface{}, project1 interface{}, invitedEmail interface{}) *MockClient_ProjectInviteDelete_Call {
	return &MockClient_ProjectInviteDelete_Call{Call: _e.mock.On("ProjectInviteDelete", ctx, project1, invitedEmail)}
}

func (_c *MockClient_ProjectInviteDelete_Call) Run(run func(ctx context.Context, project1 string, invitedEmail string)) *MockClient_ProjectInviteDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ProjectInviteDelete_Call) Return(err error) *MockClient_ProjectInviteDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ProjectInviteDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, invitedEmail string) error) *MockClient_ProjectInviteDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectInvoiceList provides a mock function for the type MockClient
func (_mock *MockClient) ProjectInvoiceList(ctx context.Context, project1 string) ([]projectbilling.InvoiceOut, error) {
	ret := _mock.Called(ctx, project1)

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

	var r0 []projectbilling.InvoiceOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]projectbilling.InvoiceOut, error)); ok {
		return returnFunc(ctx, project1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []projectbilling.InvoiceOut); ok {
		r0 = returnFunc(ctx, project1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]projectbilling.InvoiceOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, project1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectInvoiceList is a helper method to define mock.On call
//   - ctx
//   - project1
func (_e *MockClient_Expecter) ProjectInvoiceList(ctx interface{}, project1 interface{}) *MockClient_ProjectInvoiceList_Call {
	return &MockClient_ProjectInvoiceList_Call{Call: _e.mock.On("ProjectInvoiceList", ctx, project1)}
}

func (_c *MockClient_ProjectInvoiceList_Call) Run(run func(ctx context.Context, project1 string)) *MockClient_ProjectInvoiceList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ProjectInvoiceList_Call) Return(invoiceOuts []projectbilling.InvoiceOut, err error) *MockClient_ProjectInvoiceList_Call {
	_c.Call.Return(invoiceOuts, err)
	return _c
}

func (_c *MockClient_ProjectInvoiceList_Call) RunAndReturn(run func(ctx context.Context, project1 string) ([]projectbilling.InvoiceOut, error)) *MockClient_ProjectInvoiceList_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectKmsGetCA provides a mock function for the type MockClient
func (_mock *MockClient) ProjectKmsGetCA(ctx context.Context, project1 string) (string, error) {
	ret := _mock.Called(ctx, project1)

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

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

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

// ProjectKmsGetCA is a helper method to define mock.On call
//   - ctx
//   - project1
func (_e *MockClient_Expecter) ProjectKmsGetCA(ctx interface{}, project1 interface{}) *MockClient_ProjectKmsGetCA_Call {
	return &MockClient_ProjectKmsGetCA_Call{Call: _e.mock.On("ProjectKmsGetCA", ctx, project1)}
}

func (_c *MockClient_ProjectKmsGetCA_Call) Run(run func(ctx context.Context, project1 string)) *MockClient_ProjectKmsGetCA_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ProjectKmsGetCA_Call) Return(s string, err error) *MockClient_ProjectKmsGetCA_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockClient_ProjectKmsGetCA_Call) RunAndReturn(run func(ctx context.Context, project1 string) (string, error)) *MockClient_ProjectKmsGetCA_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectList provides a mock function for the type MockClient
func (_mock *MockClient) ProjectList(ctx context.Context) (*project.ProjectListOut, error) {
	ret := _mock.Called(ctx)

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

	var r0 *project.ProjectListOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (*project.ProjectListOut, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) *project.ProjectListOut); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*project.ProjectListOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectList is a helper method to define mock.On call
//   - ctx
func (_e *MockClient_Expecter) ProjectList(ctx interface{}) *MockClient_ProjectList_Call {
	return &MockClient_ProjectList_Call{Call: _e.mock.On("ProjectList", ctx)}
}

func (_c *MockClient_ProjectList_Call) Run(run func(ctx context.Context)) *MockClient_ProjectList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockClient_ProjectList_Call) Return(projectListOut *project.ProjectListOut, err error) *MockClient_ProjectList_Call {
	_c.Call.Return(projectListOut, err)
	return _c
}

func (_c *MockClient_ProjectList_Call) RunAndReturn(run func(ctx context.Context) (*project.ProjectListOut, error)) *MockClient_ProjectList_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectPrivatelinkAvailabilityList provides a mock function for the type MockClient
func (_mock *MockClient) ProjectPrivatelinkAvailabilityList(ctx context.Context, project1 string) ([]project.PrivatelinkAvailabilityOut, error) {
	ret := _mock.Called(ctx, project1)

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

	var r0 []project.PrivatelinkAvailabilityOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]project.PrivatelinkAvailabilityOut, error)); ok {
		return returnFunc(ctx, project1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []project.PrivatelinkAvailabilityOut); ok {
		r0 = returnFunc(ctx, project1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]project.PrivatelinkAvailabilityOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, project1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectPrivatelinkAvailabilityList is a helper method to define mock.On call
//   - ctx
//   - project1
func (_e *MockClient_Expecter) ProjectPrivatelinkAvailabilityList(ctx interface{}, project1 interface{}) *MockClient_ProjectPrivatelinkAvailabilityList_Call {
	return &MockClient_ProjectPrivatelinkAvailabilityList_Call{Call: _e.mock.On("ProjectPrivatelinkAvailabilityList", ctx, project1)}
}

func (_c *MockClient_ProjectPrivatelinkAvailabilityList_Call) Run(run func(ctx context.Context, project1 string)) *MockClient_ProjectPrivatelinkAvailabilityList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ProjectPrivatelinkAvailabilityList_Call) Return(privatelinkAvailabilityOuts []project.PrivatelinkAvailabilityOut, err error) *MockClient_ProjectPrivatelinkAvailabilityList_Call {
	_c.Call.Return(privatelinkAvailabilityOuts, err)
	return _c
}

func (_c *MockClient_ProjectPrivatelinkAvailabilityList_Call) RunAndReturn(run func(ctx context.Context, project1 string) ([]project.PrivatelinkAvailabilityOut, error)) *MockClient_ProjectPrivatelinkAvailabilityList_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectServicePlanList provides a mock function for the type MockClient
func (_mock *MockClient) ProjectServicePlanList(ctx context.Context, project1 string, serviceType string) ([]project.ServicePlanOut, error) {
	ret := _mock.Called(ctx, project1, serviceType)

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

	var r0 []project.ServicePlanOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]project.ServicePlanOut, error)); ok {
		return returnFunc(ctx, project1, serviceType)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []project.ServicePlanOut); ok {
		r0 = returnFunc(ctx, project1, serviceType)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]project.ServicePlanOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceType)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectServicePlanList is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceType
func (_e *MockClient_Expecter) ProjectServicePlanList(ctx interface{}, project1 interface{}, serviceType interface{}) *MockClient_ProjectServicePlanList_Call {
	return &MockClient_ProjectServicePlanList_Call{Call: _e.mock.On("ProjectServicePlanList", ctx, project1, serviceType)}
}

func (_c *MockClient_ProjectServicePlanList_Call) Run(run func(ctx context.Context, project1 string, serviceType string)) *MockClient_ProjectServicePlanList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ProjectServicePlanList_Call) Return(servicePlanOuts []project.ServicePlanOut, err error) *MockClient_ProjectServicePlanList_Call {
	_c.Call.Return(servicePlanOuts, err)
	return _c
}

func (_c *MockClient_ProjectServicePlanList_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceType string) ([]project.ServicePlanOut, error)) *MockClient_ProjectServicePlanList_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectServicePlanPriceGet provides a mock function for the type MockClient
func (_mock *MockClient) ProjectServicePlanPriceGet(ctx context.Context, project1 string, serviceType string, servicePlan string, cloud1 string) (*project.ProjectServicePlanPriceGetOut, error) {
	ret := _mock.Called(ctx, project1, serviceType, servicePlan, cloud1)

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

	var r0 *project.ProjectServicePlanPriceGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (*project.ProjectServicePlanPriceGetOut, error)); ok {
		return returnFunc(ctx, project1, serviceType, servicePlan, cloud1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) *project.ProjectServicePlanPriceGetOut); ok {
		r0 = returnFunc(ctx, project1, serviceType, servicePlan, cloud1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*project.ProjectServicePlanPriceGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceType, servicePlan, cloud1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectServicePlanPriceGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceType
//   - servicePlan
//   - cloud1
func (_e *MockClient_Expecter) ProjectServicePlanPriceGet(ctx interface{}, project1 interface{}, serviceType interface{}, servicePlan interface{}, cloud1 interface{}) *MockClient_ProjectServicePlanPriceGet_Call {
	return &MockClient_ProjectServicePlanPriceGet_Call{Call: _e.mock.On("ProjectServicePlanPriceGet", ctx, project1, serviceType, servicePlan, cloud1)}
}

func (_c *MockClient_ProjectServicePlanPriceGet_Call) Run(run func(ctx context.Context, project1 string, serviceType string, servicePlan string, cloud1 string)) *MockClient_ProjectServicePlanPriceGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockClient_ProjectServicePlanPriceGet_Call) Return(projectServicePlanPriceGetOut *project.ProjectServicePlanPriceGetOut, err error) *MockClient_ProjectServicePlanPriceGet_Call {
	_c.Call.Return(projectServicePlanPriceGetOut, err)
	return _c
}

func (_c *MockClient_ProjectServicePlanPriceGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceType string, servicePlan string, cloud1 string) (*project.ProjectServicePlanPriceGetOut, error)) *MockClient_ProjectServicePlanPriceGet_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectServicePlanSpecsGet provides a mock function for the type MockClient
func (_mock *MockClient) ProjectServicePlanSpecsGet(ctx context.Context, project1 string, serviceType string, servicePlan string) (*project.ProjectServicePlanSpecsGetOut, error) {
	ret := _mock.Called(ctx, project1, serviceType, servicePlan)

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

	var r0 *project.ProjectServicePlanSpecsGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*project.ProjectServicePlanSpecsGetOut, error)); ok {
		return returnFunc(ctx, project1, serviceType, servicePlan)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *project.ProjectServicePlanSpecsGetOut); ok {
		r0 = returnFunc(ctx, project1, serviceType, servicePlan)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*project.ProjectServicePlanSpecsGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceType, servicePlan)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectServicePlanSpecsGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceType
//   - servicePlan
func (_e *MockClient_Expecter) ProjectServicePlanSpecsGet(ctx interface{}, project1 interface{}, serviceType interface{}, servicePlan interface{}) *MockClient_ProjectServicePlanSpecsGet_Call {
	return &MockClient_ProjectServicePlanSpecsGet_Call{Call: _e.mock.On("ProjectServicePlanSpecsGet", ctx, project1, serviceType, servicePlan)}
}

func (_c *MockClient_ProjectServicePlanSpecsGet_Call) Run(run func(ctx context.Context, project1 string, serviceType string, servicePlan string)) *MockClient_ProjectServicePlanSpecsGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ProjectServicePlanSpecsGet_Call) Return(projectServicePlanSpecsGetOut *project.ProjectServicePlanSpecsGetOut, err error) *MockClient_ProjectServicePlanSpecsGet_Call {
	_c.Call.Return(projectServicePlanSpecsGetOut, err)
	return _c
}

func (_c *MockClient_ProjectServicePlanSpecsGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceType string, servicePlan string) (*project.ProjectServicePlanSpecsGetOut, error)) *MockClient_ProjectServicePlanSpecsGet_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectServiceTagsList provides a mock function for the type MockClient
func (_mock *MockClient) ProjectServiceTagsList(ctx context.Context, project1 string, serviceName string) (map[string]string, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 map[string]string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (map[string]string, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) map[string]string); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectServiceTagsList is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ProjectServiceTagsList(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ProjectServiceTagsList_Call {
	return &MockClient_ProjectServiceTagsList_Call{Call: _e.mock.On("ProjectServiceTagsList", ctx, project1, serviceName)}
}

func (_c *MockClient_ProjectServiceTagsList_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ProjectServiceTagsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ProjectServiceTagsList_Call) Return(stringToString map[string]string, err error) *MockClient_ProjectServiceTagsList_Call {
	_c.Call.Return(stringToString, err)
	return _c
}

func (_c *MockClient_ProjectServiceTagsList_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) (map[string]string, error)) *MockClient_ProjectServiceTagsList_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectServiceTagsReplace provides a mock function for the type MockClient
func (_mock *MockClient) ProjectServiceTagsReplace(ctx context.Context, project1 string, serviceName string, in *service.ProjectServiceTagsReplaceIn) error {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ProjectServiceTagsReplaceIn) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ProjectServiceTagsReplace is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ProjectServiceTagsReplace(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ProjectServiceTagsReplace_Call {
	return &MockClient_ProjectServiceTagsReplace_Call{Call: _e.mock.On("ProjectServiceTagsReplace", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ProjectServiceTagsReplace_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *service.ProjectServiceTagsReplaceIn)) *MockClient_ProjectServiceTagsReplace_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*service.ProjectServiceTagsReplaceIn))
	})
	return _c
}

func (_c *MockClient_ProjectServiceTagsReplace_Call) Return(err error) *MockClient_ProjectServiceTagsReplace_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ProjectServiceTagsReplace_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *service.ProjectServiceTagsReplaceIn) error) *MockClient_ProjectServiceTagsReplace_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectServiceTagsUpdate provides a mock function for the type MockClient
func (_mock *MockClient) ProjectServiceTagsUpdate(ctx context.Context, project1 string, serviceName string, in *service.ProjectServiceTagsUpdateIn) error {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ProjectServiceTagsUpdateIn) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ProjectServiceTagsUpdate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ProjectServiceTagsUpdate(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ProjectServiceTagsUpdate_Call {
	return &MockClient_ProjectServiceTagsUpdate_Call{Call: _e.mock.On("ProjectServiceTagsUpdate", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ProjectServiceTagsUpdate_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *service.ProjectServiceTagsUpdateIn)) *MockClient_ProjectServiceTagsUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*service.ProjectServiceTagsUpdateIn))
	})
	return _c
}

func (_c *MockClient_ProjectServiceTagsUpdate_Call) Return(err error) *MockClient_ProjectServiceTagsUpdate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ProjectServiceTagsUpdate_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *service.ProjectServiceTagsUpdateIn) error) *MockClient_ProjectServiceTagsUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectServiceTypesGet provides a mock function for the type MockClient
func (_mock *MockClient) ProjectServiceTypesGet(ctx context.Context, project1 string, serviceType string) (*project.ProjectServiceTypesGetOut, error) {
	ret := _mock.Called(ctx, project1, serviceType)

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

	var r0 *project.ProjectServiceTypesGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*project.ProjectServiceTypesGetOut, error)); ok {
		return returnFunc(ctx, project1, serviceType)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *project.ProjectServiceTypesGetOut); ok {
		r0 = returnFunc(ctx, project1, serviceType)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*project.ProjectServiceTypesGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceType)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectServiceTypesGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceType
func (_e *MockClient_Expecter) ProjectServiceTypesGet(ctx interface{}, project1 interface{}, serviceType interface{}) *MockClient_ProjectServiceTypesGet_Call {
	return &MockClient_ProjectServiceTypesGet_Call{Call: _e.mock.On("ProjectServiceTypesGet", ctx, project1, serviceType)}
}

func (_c *MockClient_ProjectServiceTypesGet_Call) Run(run func(ctx context.Context, project1 string, serviceType string)) *MockClient_ProjectServiceTypesGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ProjectServiceTypesGet_Call) Return(projectServiceTypesGetOut *project.ProjectServiceTypesGetOut, err error) *MockClient_ProjectServiceTypesGet_Call {
	_c.Call.Return(projectServiceTypesGetOut, err)
	return _c
}

func (_c *MockClient_ProjectServiceTypesGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceType string) (*project.ProjectServiceTypesGetOut, error)) *MockClient_ProjectServiceTypesGet_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectServiceTypesList provides a mock function for the type MockClient
func (_mock *MockClient) ProjectServiceTypesList(ctx context.Context, project1 string) (*project.ProjectServiceTypesListOut, error) {
	ret := _mock.Called(ctx, project1)

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

	var r0 *project.ProjectServiceTypesListOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*project.ProjectServiceTypesListOut, error)); ok {
		return returnFunc(ctx, project1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *project.ProjectServiceTypesListOut); ok {
		r0 = returnFunc(ctx, project1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*project.ProjectServiceTypesListOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, project1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectServiceTypesList is a helper method to define mock.On call
//   - ctx
//   - project1
func (_e *MockClient_Expecter) ProjectServiceTypesList(ctx interface{}, project1 interface{}) *MockClient_ProjectServiceTypesList_Call {
	return &MockClient_ProjectServiceTypesList_Call{Call: _e.mock.On("ProjectServiceTypesList", ctx, project1)}
}

func (_c *MockClient_ProjectServiceTypesList_Call) Run(run func(ctx context.Context, project1 string)) *MockClient_ProjectServiceTypesList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ProjectServiceTypesList_Call) Return(projectServiceTypesListOut *project.ProjectServiceTypesListOut, err error) *MockClient_ProjectServiceTypesList_Call {
	_c.Call.Return(projectServiceTypesListOut, err)
	return _c
}

func (_c *MockClient_ProjectServiceTypesList_Call) RunAndReturn(run func(ctx context.Context, project1 string) (*project.ProjectServiceTypesListOut, error)) *MockClient_ProjectServiceTypesList_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectStaticIPAssociate provides a mock function for the type MockClient
func (_mock *MockClient) ProjectStaticIPAssociate(ctx context.Context, project1 string, staticIpAddressId string, in *staticip.ProjectStaticIpassociateIn) (*staticip.ProjectStaticIpassociateOut, error) {
	ret := _mock.Called(ctx, project1, staticIpAddressId, in)

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

	var r0 *staticip.ProjectStaticIpassociateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *staticip.ProjectStaticIpassociateIn) (*staticip.ProjectStaticIpassociateOut, error)); ok {
		return returnFunc(ctx, project1, staticIpAddressId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *staticip.ProjectStaticIpassociateIn) *staticip.ProjectStaticIpassociateOut); ok {
		r0 = returnFunc(ctx, project1, staticIpAddressId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*staticip.ProjectStaticIpassociateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *staticip.ProjectStaticIpassociateIn) error); ok {
		r1 = returnFunc(ctx, project1, staticIpAddressId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectStaticIPAssociate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - staticIpAddressId
//   - in
func (_e *MockClient_Expecter) ProjectStaticIPAssociate(ctx interface{}, project1 interface{}, staticIpAddressId interface{}, in interface{}) *MockClient_ProjectStaticIPAssociate_Call {
	return &MockClient_ProjectStaticIPAssociate_Call{Call: _e.mock.On("ProjectStaticIPAssociate", ctx, project1, staticIpAddressId, in)}
}

func (_c *MockClient_ProjectStaticIPAssociate_Call) Run(run func(ctx context.Context, project1 string, staticIpAddressId string, in *staticip.ProjectStaticIpassociateIn)) *MockClient_ProjectStaticIPAssociate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*staticip.ProjectStaticIpassociateIn))
	})
	return _c
}

func (_c *MockClient_ProjectStaticIPAssociate_Call) Return(projectStaticIpassociateOut *staticip.ProjectStaticIpassociateOut, err error) *MockClient_ProjectStaticIPAssociate_Call {
	_c.Call.Return(projectStaticIpassociateOut, err)
	return _c
}

func (_c *MockClient_ProjectStaticIPAssociate_Call) RunAndReturn(run func(ctx context.Context, project1 string, staticIpAddressId string, in *staticip.ProjectStaticIpassociateIn) (*staticip.ProjectStaticIpassociateOut, error)) *MockClient_ProjectStaticIPAssociate_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectStaticIPAvailabilityList provides a mock function for the type MockClient
func (_mock *MockClient) ProjectStaticIPAvailabilityList(ctx context.Context, project1 string) ([]staticip.StaticIpAddressAvailabilityOut, error) {
	ret := _mock.Called(ctx, project1)

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

	var r0 []staticip.StaticIpAddressAvailabilityOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]staticip.StaticIpAddressAvailabilityOut, error)); ok {
		return returnFunc(ctx, project1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []staticip.StaticIpAddressAvailabilityOut); ok {
		r0 = returnFunc(ctx, project1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]staticip.StaticIpAddressAvailabilityOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, project1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectStaticIPAvailabilityList is a helper method to define mock.On call
//   - ctx
//   - project1
func (_e *MockClient_Expecter) ProjectStaticIPAvailabilityList(ctx interface{}, project1 interface{}) *MockClient_ProjectStaticIPAvailabilityList_Call {
	return &MockClient_ProjectStaticIPAvailabilityList_Call{Call: _e.mock.On("ProjectStaticIPAvailabilityList", ctx, project1)}
}

func (_c *MockClient_ProjectStaticIPAvailabilityList_Call) Run(run func(ctx context.Context, project1 string)) *MockClient_ProjectStaticIPAvailabilityList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ProjectStaticIPAvailabilityList_Call) Return(staticIpAddressAvailabilityOuts []staticip.StaticIpAddressAvailabilityOut, err error) *MockClient_ProjectStaticIPAvailabilityList_Call {
	_c.Call.Return(staticIpAddressAvailabilityOuts, err)
	return _c
}

func (_c *MockClient_ProjectStaticIPAvailabilityList_Call) RunAndReturn(run func(ctx context.Context, project1 string) ([]staticip.StaticIpAddressAvailabilityOut, error)) *MockClient_ProjectStaticIPAvailabilityList_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectStaticIPDissociate provides a mock function for the type MockClient
func (_mock *MockClient) ProjectStaticIPDissociate(ctx context.Context, project1 string, staticIpAddressId string) (*staticip.ProjectStaticIpdissociateOut, error) {
	ret := _mock.Called(ctx, project1, staticIpAddressId)

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

	var r0 *staticip.ProjectStaticIpdissociateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*staticip.ProjectStaticIpdissociateOut, error)); ok {
		return returnFunc(ctx, project1, staticIpAddressId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *staticip.ProjectStaticIpdissociateOut); ok {
		r0 = returnFunc(ctx, project1, staticIpAddressId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*staticip.ProjectStaticIpdissociateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, staticIpAddressId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectStaticIPDissociate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - staticIpAddressId
func (_e *MockClient_Expecter) ProjectStaticIPDissociate(ctx interface{}, project1 interface{}, staticIpAddressId interface{}) *MockClient_ProjectStaticIPDissociate_Call {
	return &MockClient_ProjectStaticIPDissociate_Call{Call: _e.mock.On("ProjectStaticIPDissociate", ctx, project1, staticIpAddressId)}
}

func (_c *MockClient_ProjectStaticIPDissociate_Call) Run(run func(ctx context.Context, project1 string, staticIpAddressId string)) *MockClient_ProjectStaticIPDissociate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ProjectStaticIPDissociate_Call) Return(projectStaticIpdissociateOut *staticip.ProjectStaticIpdissociateOut, err error) *MockClient_ProjectStaticIPDissociate_Call {
	_c.Call.Return(projectStaticIpdissociateOut, err)
	return _c
}

func (_c *MockClient_ProjectStaticIPDissociate_Call) RunAndReturn(run func(ctx context.Context, project1 string, staticIpAddressId string) (*staticip.ProjectStaticIpdissociateOut, error)) *MockClient_ProjectStaticIPDissociate_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectStaticIPPatch provides a mock function for the type MockClient
func (_mock *MockClient) ProjectStaticIPPatch(ctx context.Context, project1 string, staticIpAddressId string, in *staticip.ProjectStaticIppatchIn) (*staticip.ProjectStaticIppatchOut, error) {
	ret := _mock.Called(ctx, project1, staticIpAddressId, in)

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

	var r0 *staticip.ProjectStaticIppatchOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *staticip.ProjectStaticIppatchIn) (*staticip.ProjectStaticIppatchOut, error)); ok {
		return returnFunc(ctx, project1, staticIpAddressId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *staticip.ProjectStaticIppatchIn) *staticip.ProjectStaticIppatchOut); ok {
		r0 = returnFunc(ctx, project1, staticIpAddressId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*staticip.ProjectStaticIppatchOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *staticip.ProjectStaticIppatchIn) error); ok {
		r1 = returnFunc(ctx, project1, staticIpAddressId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectStaticIPPatch is a helper method to define mock.On call
//   - ctx
//   - project1
//   - staticIpAddressId
//   - in
func (_e *MockClient_Expecter) ProjectStaticIPPatch(ctx interface{}, project1 interface{}, staticIpAddressId interface{}, in interface{}) *MockClient_ProjectStaticIPPatch_Call {
	return &MockClient_ProjectStaticIPPatch_Call{Call: _e.mock.On("ProjectStaticIPPatch", ctx, project1, staticIpAddressId, in)}
}

func (_c *MockClient_ProjectStaticIPPatch_Call) Run(run func(ctx context.Context, project1 string, staticIpAddressId string, in *staticip.ProjectStaticIppatchIn)) *MockClient_ProjectStaticIPPatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*staticip.ProjectStaticIppatchIn))
	})
	return _c
}

func (_c *MockClient_ProjectStaticIPPatch_Call) Return(projectStaticIppatchOut *staticip.ProjectStaticIppatchOut, err error) *MockClient_ProjectStaticIPPatch_Call {
	_c.Call.Return(projectStaticIppatchOut, err)
	return _c
}

func (_c *MockClient_ProjectStaticIPPatch_Call) RunAndReturn(run func(ctx context.Context, project1 string, staticIpAddressId string, in *staticip.ProjectStaticIppatchIn) (*staticip.ProjectStaticIppatchOut, error)) *MockClient_ProjectStaticIPPatch_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectTagsList provides a mock function for the type MockClient
func (_mock *MockClient) ProjectTagsList(ctx context.Context, project1 string) (map[string]string, error) {
	ret := _mock.Called(ctx, project1)

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

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

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

// ProjectTagsList is a helper method to define mock.On call
//   - ctx
//   - project1
func (_e *MockClient_Expecter) ProjectTagsList(ctx interface{}, project1 interface{}) *MockClient_ProjectTagsList_Call {
	return &MockClient_ProjectTagsList_Call{Call: _e.mock.On("ProjectTagsList", ctx, project1)}
}

func (_c *MockClient_ProjectTagsList_Call) Run(run func(ctx context.Context, project1 string)) *MockClient_ProjectTagsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ProjectTagsList_Call) Return(stringToString map[string]string, err error) *MockClient_ProjectTagsList_Call {
	_c.Call.Return(stringToString, err)
	return _c
}

func (_c *MockClient_ProjectTagsList_Call) RunAndReturn(run func(ctx context.Context, project1 string) (map[string]string, error)) *MockClient_ProjectTagsList_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectTagsReplace provides a mock function for the type MockClient
func (_mock *MockClient) ProjectTagsReplace(ctx context.Context, project1 string, in *project.ProjectTagsReplaceIn) error {
	ret := _mock.Called(ctx, project1, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *project.ProjectTagsReplaceIn) error); ok {
		r0 = returnFunc(ctx, project1, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ProjectTagsReplace is a helper method to define mock.On call
//   - ctx
//   - project1
//   - in
func (_e *MockClient_Expecter) ProjectTagsReplace(ctx interface{}, project1 interface{}, in interface{}) *MockClient_ProjectTagsReplace_Call {
	return &MockClient_ProjectTagsReplace_Call{Call: _e.mock.On("ProjectTagsReplace", ctx, project1, in)}
}

func (_c *MockClient_ProjectTagsReplace_Call) Run(run func(ctx context.Context, project1 string, in *project.ProjectTagsReplaceIn)) *MockClient_ProjectTagsReplace_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*project.ProjectTagsReplaceIn))
	})
	return _c
}

func (_c *MockClient_ProjectTagsReplace_Call) Return(err error) *MockClient_ProjectTagsReplace_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ProjectTagsReplace_Call) RunAndReturn(run func(ctx context.Context, project1 string, in *project.ProjectTagsReplaceIn) error) *MockClient_ProjectTagsReplace_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectTagsUpdate provides a mock function for the type MockClient
func (_mock *MockClient) ProjectTagsUpdate(ctx context.Context, project1 string, in *project.ProjectTagsUpdateIn) error {
	ret := _mock.Called(ctx, project1, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *project.ProjectTagsUpdateIn) error); ok {
		r0 = returnFunc(ctx, project1, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ProjectTagsUpdate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - in
func (_e *MockClient_Expecter) ProjectTagsUpdate(ctx interface{}, project1 interface{}, in interface{}) *MockClient_ProjectTagsUpdate_Call {
	return &MockClient_ProjectTagsUpdate_Call{Call: _e.mock.On("ProjectTagsUpdate", ctx, project1, in)}
}

func (_c *MockClient_ProjectTagsUpdate_Call) Run(run func(ctx context.Context, project1 string, in *project.ProjectTagsUpdateIn)) *MockClient_ProjectTagsUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*project.ProjectTagsUpdateIn))
	})
	return _c
}

func (_c *MockClient_ProjectTagsUpdate_Call) Return(err error) *MockClient_ProjectTagsUpdate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ProjectTagsUpdate_Call) RunAndReturn(run func(ctx context.Context, project1 string, in *project.ProjectTagsUpdateIn) error) *MockClient_ProjectTagsUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectUpdate provides a mock function for the type MockClient
func (_mock *MockClient) ProjectUpdate(ctx context.Context, project1 string, in *project.ProjectUpdateIn) (*project.ProjectUpdateOut, error) {
	ret := _mock.Called(ctx, project1, in)

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

	var r0 *project.ProjectUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *project.ProjectUpdateIn) (*project.ProjectUpdateOut, error)); ok {
		return returnFunc(ctx, project1, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *project.ProjectUpdateIn) *project.ProjectUpdateOut); ok {
		r0 = returnFunc(ctx, project1, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*project.ProjectUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *project.ProjectUpdateIn) error); ok {
		r1 = returnFunc(ctx, project1, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectUpdate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - in
func (_e *MockClient_Expecter) ProjectUpdate(ctx interface{}, project1 interface{}, in interface{}) *MockClient_ProjectUpdate_Call {
	return &MockClient_ProjectUpdate_Call{Call: _e.mock.On("ProjectUpdate", ctx, project1, in)}
}

func (_c *MockClient_ProjectUpdate_Call) Run(run func(ctx context.Context, project1 string, in *project.ProjectUpdateIn)) *MockClient_ProjectUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*project.ProjectUpdateIn))
	})
	return _c
}

func (_c *MockClient_ProjectUpdate_Call) Return(projectUpdateOut *project.ProjectUpdateOut, err error) *MockClient_ProjectUpdate_Call {
	_c.Call.Return(projectUpdateOut, err)
	return _c
}

func (_c *MockClient_ProjectUpdate_Call) RunAndReturn(run func(ctx context.Context, project1 string, in *project.ProjectUpdateIn) (*project.ProjectUpdateOut, error)) *MockClient_ProjectUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectUserList provides a mock function for the type MockClient
func (_mock *MockClient) ProjectUserList(ctx context.Context, project1 string) (*project.ProjectUserListOut, error) {
	ret := _mock.Called(ctx, project1)

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

	var r0 *project.ProjectUserListOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*project.ProjectUserListOut, error)); ok {
		return returnFunc(ctx, project1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *project.ProjectUserListOut); ok {
		r0 = returnFunc(ctx, project1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*project.ProjectUserListOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, project1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ProjectUserList is a helper method to define mock.On call
//   - ctx
//   - project1
func (_e *MockClient_Expecter) ProjectUserList(ctx interface{}, project1 interface{}) *MockClient_ProjectUserList_Call {
	return &MockClient_ProjectUserList_Call{Call: _e.mock.On("ProjectUserList", ctx, project1)}
}

func (_c *MockClient_ProjectUserList_Call) Run(run func(ctx context.Context, project1 string)) *MockClient_ProjectUserList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ProjectUserList_Call) Return(projectUserListOut *project.ProjectUserListOut, err error) *MockClient_ProjectUserList_Call {
	_c.Call.Return(projectUserListOut, err)
	return _c
}

func (_c *MockClient_ProjectUserList_Call) RunAndReturn(run func(ctx context.Context, project1 string) (*project.ProjectUserListOut, error)) *MockClient_ProjectUserList_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectUserRemove provides a mock function for the type MockClient
func (_mock *MockClient) ProjectUserRemove(ctx context.Context, project1 string, userEmail string) error {
	ret := _mock.Called(ctx, project1, userEmail)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, project1, userEmail)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ProjectUserRemove is a helper method to define mock.On call
//   - ctx
//   - project1
//   - userEmail
func (_e *MockClient_Expecter) ProjectUserRemove(ctx interface{}, project1 interface{}, userEmail interface{}) *MockClient_ProjectUserRemove_Call {
	return &MockClient_ProjectUserRemove_Call{Call: _e.mock.On("ProjectUserRemove", ctx, project1, userEmail)}
}

func (_c *MockClient_ProjectUserRemove_Call) Run(run func(ctx context.Context, project1 string, userEmail string)) *MockClient_ProjectUserRemove_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ProjectUserRemove_Call) Return(err error) *MockClient_ProjectUserRemove_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ProjectUserRemove_Call) RunAndReturn(run func(ctx context.Context, project1 string, userEmail string) error) *MockClient_ProjectUserRemove_Call {
	_c.Call.Return(run)
	return _c
}

// ProjectUserUpdate provides a mock function for the type MockClient
func (_mock *MockClient) ProjectUserUpdate(ctx context.Context, project1 string, userEmail string, in *project.ProjectUserUpdateIn) error {
	ret := _mock.Called(ctx, project1, userEmail, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *project.ProjectUserUpdateIn) error); ok {
		r0 = returnFunc(ctx, project1, userEmail, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ProjectUserUpdate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - userEmail
//   - in
func (_e *MockClient_Expecter) ProjectUserUpdate(ctx interface{}, project1 interface{}, userEmail interface{}, in interface{}) *MockClient_ProjectUserUpdate_Call {
	return &MockClient_ProjectUserUpdate_Call{Call: _e.mock.On("ProjectUserUpdate", ctx, project1, userEmail, in)}
}

func (_c *MockClient_ProjectUserUpdate_Call) Run(run func(ctx context.Context, project1 string, userEmail string, in *project.ProjectUserUpdateIn)) *MockClient_ProjectUserUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*project.ProjectUserUpdateIn))
	})
	return _c
}

func (_c *MockClient_ProjectUserUpdate_Call) Return(err error) *MockClient_ProjectUserUpdate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ProjectUserUpdate_Call) RunAndReturn(run func(ctx context.Context, project1 string, userEmail string, in *project.ProjectUserUpdateIn) error) *MockClient_ProjectUserUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// PublicPrivatelinkAvailabilityList provides a mock function for the type MockClient
func (_mock *MockClient) PublicPrivatelinkAvailabilityList(ctx context.Context, tenant string) ([]privatelink.PrivatelinkAvailabilityOut, error) {
	ret := _mock.Called(ctx, tenant)

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

	var r0 []privatelink.PrivatelinkAvailabilityOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]privatelink.PrivatelinkAvailabilityOut, error)); ok {
		return returnFunc(ctx, tenant)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []privatelink.PrivatelinkAvailabilityOut); ok {
		r0 = returnFunc(ctx, tenant)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]privatelink.PrivatelinkAvailabilityOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, tenant)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// PublicPrivatelinkAvailabilityList is a helper method to define mock.On call
//   - ctx
//   - tenant
func (_e *MockClient_Expecter) PublicPrivatelinkAvailabilityList(ctx interface{}, tenant interface{}) *MockClient_PublicPrivatelinkAvailabilityList_Call {
	return &MockClient_PublicPrivatelinkAvailabilityList_Call{Call: _e.mock.On("PublicPrivatelinkAvailabilityList", ctx, tenant)}
}

func (_c *MockClient_PublicPrivatelinkAvailabilityList_Call) Run(run func(ctx context.Context, tenant string)) *MockClient_PublicPrivatelinkAvailabilityList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_PublicPrivatelinkAvailabilityList_Call) Return(privatelinkAvailabilityOuts []privatelink.PrivatelinkAvailabilityOut, err error) *MockClient_PublicPrivatelinkAvailabilityList_Call {
	_c.Call.Return(privatelinkAvailabilityOuts, err)
	return _c
}

func (_c *MockClient_PublicPrivatelinkAvailabilityList_Call) RunAndReturn(run func(ctx context.Context, tenant string) ([]privatelink.PrivatelinkAvailabilityOut, error)) *MockClient_PublicPrivatelinkAvailabilityList_Call {
	_c.Call.Return(run)
	return _c
}

// PublicStaticIPAvailabilityList provides a mock function for the type MockClient
func (_mock *MockClient) PublicStaticIPAvailabilityList(ctx context.Context, tenant string) ([]staticip.StaticIpAddressAvailabilityOut, error) {
	ret := _mock.Called(ctx, tenant)

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

	var r0 []staticip.StaticIpAddressAvailabilityOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]staticip.StaticIpAddressAvailabilityOut, error)); ok {
		return returnFunc(ctx, tenant)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []staticip.StaticIpAddressAvailabilityOut); ok {
		r0 = returnFunc(ctx, tenant)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]staticip.StaticIpAddressAvailabilityOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, tenant)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// PublicStaticIPAvailabilityList is a helper method to define mock.On call
//   - ctx
//   - tenant
func (_e *MockClient_Expecter) PublicStaticIPAvailabilityList(ctx interface{}, tenant interface{}) *MockClient_PublicStaticIPAvailabilityList_Call {
	return &MockClient_PublicStaticIPAvailabilityList_Call{Call: _e.mock.On("PublicStaticIPAvailabilityList", ctx, tenant)}
}

func (_c *MockClient_PublicStaticIPAvailabilityList_Call) Run(run func(ctx context.Context, tenant string)) *MockClient_PublicStaticIPAvailabilityList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_PublicStaticIPAvailabilityList_Call) Return(staticIpAddressAvailabilityOuts []staticip.StaticIpAddressAvailabilityOut, err error) *MockClient_PublicStaticIPAvailabilityList_Call {
	_c.Call.Return(staticIpAddressAvailabilityOuts, err)
	return _c
}

func (_c *MockClient_PublicStaticIPAvailabilityList_Call) RunAndReturn(run func(ctx context.Context, tenant string) ([]staticip.StaticIpAddressAvailabilityOut, error)) *MockClient_PublicStaticIPAvailabilityList_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceAlertsList provides a mock function for the type MockClient
func (_mock *MockClient) ServiceAlertsList(ctx context.Context, project1 string, serviceName string) ([]service.AlertOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []service.AlertOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]service.AlertOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []service.AlertOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]service.AlertOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceAlertsList is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceAlertsList(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceAlertsList_Call {
	return &MockClient_ServiceAlertsList_Call{Call: _e.mock.On("ServiceAlertsList", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceAlertsList_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceAlertsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceAlertsList_Call) Return(alertOuts []service.AlertOut, err error) *MockClient_ServiceAlertsList_Call {
	_c.Call.Return(alertOuts, err)
	return _c
}

func (_c *MockClient_ServiceAlertsList_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]service.AlertOut, error)) *MockClient_ServiceAlertsList_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceBackupToAnotherRegionReport provides a mock function for the type MockClient
func (_mock *MockClient) ServiceBackupToAnotherRegionReport(ctx context.Context, project1 string, serviceName string, in *service.ServiceBackupToAnotherRegionReportIn) (map[string]any, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 map[string]any
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ServiceBackupToAnotherRegionReportIn) (map[string]any, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ServiceBackupToAnotherRegionReportIn) map[string]any); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]any)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *service.ServiceBackupToAnotherRegionReportIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceBackupToAnotherRegionReport is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceBackupToAnotherRegionReport(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceBackupToAnotherRegionReport_Call {
	return &MockClient_ServiceBackupToAnotherRegionReport_Call{Call: _e.mock.On("ServiceBackupToAnotherRegionReport", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceBackupToAnotherRegionReport_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *service.ServiceBackupToAnotherRegionReportIn)) *MockClient_ServiceBackupToAnotherRegionReport_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*service.ServiceBackupToAnotherRegionReportIn))
	})
	return _c
}

func (_c *MockClient_ServiceBackupToAnotherRegionReport_Call) Return(stringToV map[string]any, err error) *MockClient_ServiceBackupToAnotherRegionReport_Call {
	_c.Call.Return(stringToV, err)
	return _c
}

func (_c *MockClient_ServiceBackupToAnotherRegionReport_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *service.ServiceBackupToAnotherRegionReportIn) (map[string]any, error)) *MockClient_ServiceBackupToAnotherRegionReport_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceBackupsGet provides a mock function for the type MockClient
func (_mock *MockClient) ServiceBackupsGet(ctx context.Context, project1 string, serviceName string) (*service.ServiceBackupsGetOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 *service.ServiceBackupsGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*service.ServiceBackupsGetOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *service.ServiceBackupsGetOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ServiceBackupsGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceBackupsGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceBackupsGet(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceBackupsGet_Call {
	return &MockClient_ServiceBackupsGet_Call{Call: _e.mock.On("ServiceBackupsGet", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceBackupsGet_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceBackupsGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceBackupsGet_Call) Return(serviceBackupsGetOut *service.ServiceBackupsGetOut, err error) *MockClient_ServiceBackupsGet_Call {
	_c.Call.Return(serviceBackupsGetOut, err)
	return _c
}

func (_c *MockClient_ServiceBackupsGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) (*service.ServiceBackupsGetOut, error)) *MockClient_ServiceBackupsGet_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceCancelQuery provides a mock function for the type MockClient
func (_mock *MockClient) ServiceCancelQuery(ctx context.Context, project1 string, serviceName string, in *service.ServiceCancelQueryIn) (bool, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ServiceCancelQueryIn) (bool, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ServiceCancelQueryIn) bool); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *service.ServiceCancelQueryIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceCancelQuery is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceCancelQuery(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceCancelQuery_Call {
	return &MockClient_ServiceCancelQuery_Call{Call: _e.mock.On("ServiceCancelQuery", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceCancelQuery_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *service.ServiceCancelQueryIn)) *MockClient_ServiceCancelQuery_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*service.ServiceCancelQueryIn))
	})
	return _c
}

func (_c *MockClient_ServiceCancelQuery_Call) Return(b bool, err error) *MockClient_ServiceCancelQuery_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *MockClient_ServiceCancelQuery_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *service.ServiceCancelQueryIn) (bool, error)) *MockClient_ServiceCancelQuery_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceClickHouseCurrentQueries provides a mock function for the type MockClient
func (_mock *MockClient) ServiceClickHouseCurrentQueries(ctx context.Context, project1 string, serviceName string) ([]clickhouse.QueryOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []clickhouse.QueryOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]clickhouse.QueryOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []clickhouse.QueryOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]clickhouse.QueryOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceClickHouseCurrentQueries is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceClickHouseCurrentQueries(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceClickHouseCurrentQueries_Call {
	return &MockClient_ServiceClickHouseCurrentQueries_Call{Call: _e.mock.On("ServiceClickHouseCurrentQueries", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceClickHouseCurrentQueries_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceClickHouseCurrentQueries_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceClickHouseCurrentQueries_Call) Return(queryOuts []clickhouse.QueryOut, err error) *MockClient_ServiceClickHouseCurrentQueries_Call {
	_c.Call.Return(queryOuts, err)
	return _c
}

func (_c *MockClient_ServiceClickHouseCurrentQueries_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]clickhouse.QueryOut, error)) *MockClient_ServiceClickHouseCurrentQueries_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceClickHouseDatabaseCreate provides a mock function for the type MockClient
func (_mock *MockClient) ServiceClickHouseDatabaseCreate(ctx context.Context, project1 string, serviceName string, in *clickhouse.ServiceClickHouseDatabaseCreateIn) error {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *clickhouse.ServiceClickHouseDatabaseCreateIn) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceClickHouseDatabaseCreate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceClickHouseDatabaseCreate(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceClickHouseDatabaseCreate_Call {
	return &MockClient_ServiceClickHouseDatabaseCreate_Call{Call: _e.mock.On("ServiceClickHouseDatabaseCreate", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceClickHouseDatabaseCreate_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *clickhouse.ServiceClickHouseDatabaseCreateIn)) *MockClient_ServiceClickHouseDatabaseCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*clickhouse.ServiceClickHouseDatabaseCreateIn))
	})
	return _c
}

func (_c *MockClient_ServiceClickHouseDatabaseCreate_Call) Return(err error) *MockClient_ServiceClickHouseDatabaseCreate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceClickHouseDatabaseCreate_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *clickhouse.ServiceClickHouseDatabaseCreateIn) error) *MockClient_ServiceClickHouseDatabaseCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceClickHouseDatabaseDelete provides a mock function for the type MockClient
func (_mock *MockClient) ServiceClickHouseDatabaseDelete(ctx context.Context, project1 string, serviceName string, database string) error {
	ret := _mock.Called(ctx, project1, serviceName, database)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, database)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceClickHouseDatabaseDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - database
func (_e *MockClient_Expecter) ServiceClickHouseDatabaseDelete(ctx interface{}, project1 interface{}, serviceName interface{}, database interface{}) *MockClient_ServiceClickHouseDatabaseDelete_Call {
	return &MockClient_ServiceClickHouseDatabaseDelete_Call{Call: _e.mock.On("ServiceClickHouseDatabaseDelete", ctx, project1, serviceName, database)}
}

func (_c *MockClient_ServiceClickHouseDatabaseDelete_Call) Run(run func(ctx context.Context, project1 string, serviceName string, database string)) *MockClient_ServiceClickHouseDatabaseDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceClickHouseDatabaseDelete_Call) Return(err error) *MockClient_ServiceClickHouseDatabaseDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceClickHouseDatabaseDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, database string) error) *MockClient_ServiceClickHouseDatabaseDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceClickHouseDatabaseList provides a mock function for the type MockClient
func (_mock *MockClient) ServiceClickHouseDatabaseList(ctx context.Context, project1 string, serviceName string) ([]clickhouse.DatabaseOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []clickhouse.DatabaseOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]clickhouse.DatabaseOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []clickhouse.DatabaseOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]clickhouse.DatabaseOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceClickHouseDatabaseList is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceClickHouseDatabaseList(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceClickHouseDatabaseList_Call {
	return &MockClient_ServiceClickHouseDatabaseList_Call{Call: _e.mock.On("ServiceClickHouseDatabaseList", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceClickHouseDatabaseList_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceClickHouseDatabaseList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceClickHouseDatabaseList_Call) Return(databaseOuts []clickhouse.DatabaseOut, err error) *MockClient_ServiceClickHouseDatabaseList_Call {
	_c.Call.Return(databaseOuts, err)
	return _c
}

func (_c *MockClient_ServiceClickHouseDatabaseList_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]clickhouse.DatabaseOut, error)) *MockClient_ServiceClickHouseDatabaseList_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceClickHousePasswordReset provides a mock function for the type MockClient
func (_mock *MockClient) ServiceClickHousePasswordReset(ctx context.Context, project1 string, serviceName string, userUuid string, in *clickhouse.ServiceClickHousePasswordResetIn) (string, error) {
	ret := _mock.Called(ctx, project1, serviceName, userUuid, in)

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

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *clickhouse.ServiceClickHousePasswordResetIn) (string, error)); ok {
		return returnFunc(ctx, project1, serviceName, userUuid, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *clickhouse.ServiceClickHousePasswordResetIn) string); ok {
		r0 = returnFunc(ctx, project1, serviceName, userUuid, in)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, *clickhouse.ServiceClickHousePasswordResetIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, userUuid, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceClickHousePasswordReset is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - userUuid
//   - in
func (_e *MockClient_Expecter) ServiceClickHousePasswordReset(ctx interface{}, project1 interface{}, serviceName interface{}, userUuid interface{}, in interface{}) *MockClient_ServiceClickHousePasswordReset_Call {
	return &MockClient_ServiceClickHousePasswordReset_Call{Call: _e.mock.On("ServiceClickHousePasswordReset", ctx, project1, serviceName, userUuid, in)}
}

func (_c *MockClient_ServiceClickHousePasswordReset_Call) Run(run func(ctx context.Context, project1 string, serviceName string, userUuid string, in *clickhouse.ServiceClickHousePasswordResetIn)) *MockClient_ServiceClickHousePasswordReset_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*clickhouse.ServiceClickHousePasswordResetIn))
	})
	return _c
}

func (_c *MockClient_ServiceClickHousePasswordReset_Call) Return(s string, err error) *MockClient_ServiceClickHousePasswordReset_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockClient_ServiceClickHousePasswordReset_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, userUuid string, in *clickhouse.ServiceClickHousePasswordResetIn) (string, error)) *MockClient_ServiceClickHousePasswordReset_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceClickHouseQuery provides a mock function for the type MockClient
func (_mock *MockClient) ServiceClickHouseQuery(ctx context.Context, project1 string, serviceName string, in *clickhouse.ServiceClickHouseQueryIn) (*clickhouse.ServiceClickHouseQueryOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 *clickhouse.ServiceClickHouseQueryOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *clickhouse.ServiceClickHouseQueryIn) (*clickhouse.ServiceClickHouseQueryOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *clickhouse.ServiceClickHouseQueryIn) *clickhouse.ServiceClickHouseQueryOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*clickhouse.ServiceClickHouseQueryOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *clickhouse.ServiceClickHouseQueryIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceClickHouseQuery is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceClickHouseQuery(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceClickHouseQuery_Call {
	return &MockClient_ServiceClickHouseQuery_Call{Call: _e.mock.On("ServiceClickHouseQuery", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceClickHouseQuery_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *clickhouse.ServiceClickHouseQueryIn)) *MockClient_ServiceClickHouseQuery_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*clickhouse.ServiceClickHouseQueryIn))
	})
	return _c
}

func (_c *MockClient_ServiceClickHouseQuery_Call) Return(serviceClickHouseQueryOut *clickhouse.ServiceClickHouseQueryOut, err error) *MockClient_ServiceClickHouseQuery_Call {
	_c.Call.Return(serviceClickHouseQueryOut, err)
	return _c
}

func (_c *MockClient_ServiceClickHouseQuery_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *clickhouse.ServiceClickHouseQueryIn) (*clickhouse.ServiceClickHouseQueryOut, error)) *MockClient_ServiceClickHouseQuery_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceClickHouseQueryStats provides a mock function for the type MockClient
func (_mock *MockClient) ServiceClickHouseQueryStats(ctx context.Context, project1 string, serviceName string, query ...[2]string) ([]clickhouse.ServiceClickHouseQueryStatsOut, error) {
	var tmpRet mock.Arguments
	if len(query) > 0 {
		tmpRet = _mock.Called(ctx, project1, serviceName, query)
	} else {
		tmpRet = _mock.Called(ctx, project1, serviceName)
	}
	ret := tmpRet

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

	var r0 []clickhouse.ServiceClickHouseQueryStatsOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, ...[2]string) ([]clickhouse.ServiceClickHouseQueryStatsOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, query...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, ...[2]string) []clickhouse.ServiceClickHouseQueryStatsOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, query...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]clickhouse.ServiceClickHouseQueryStatsOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, ...[2]string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, query...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceClickHouseQueryStats is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - query
func (_e *MockClient_Expecter) ServiceClickHouseQueryStats(ctx interface{}, project1 interface{}, serviceName interface{}, query ...interface{}) *MockClient_ServiceClickHouseQueryStats_Call {
	return &MockClient_ServiceClickHouseQueryStats_Call{Call: _e.mock.On("ServiceClickHouseQueryStats",
		append([]interface{}{ctx, project1, serviceName}, query...)...)}
}

func (_c *MockClient_ServiceClickHouseQueryStats_Call) Run(run func(ctx context.Context, project1 string, serviceName string, query ...[2]string)) *MockClient_ServiceClickHouseQueryStats_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := args[3].([][2]string)
		run(args[0].(context.Context), args[1].(string), args[2].(string), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_ServiceClickHouseQueryStats_Call) Return(serviceClickHouseQueryStatsOuts []clickhouse.ServiceClickHouseQueryStatsOut, err error) *MockClient_ServiceClickHouseQueryStats_Call {
	_c.Call.Return(serviceClickHouseQueryStatsOuts, err)
	return _c
}

func (_c *MockClient_ServiceClickHouseQueryStats_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, query ...[2]string) ([]clickhouse.ServiceClickHouseQueryStatsOut, error)) *MockClient_ServiceClickHouseQueryStats_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceClickHouseTieredStorageSummary provides a mock function for the type MockClient
func (_mock *MockClient) ServiceClickHouseTieredStorageSummary(ctx context.Context, project1 string, serviceName string) (*clickhouse.ServiceClickHouseTieredStorageSummaryOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 *clickhouse.ServiceClickHouseTieredStorageSummaryOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*clickhouse.ServiceClickHouseTieredStorageSummaryOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *clickhouse.ServiceClickHouseTieredStorageSummaryOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*clickhouse.ServiceClickHouseTieredStorageSummaryOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceClickHouseTieredStorageSummary is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceClickHouseTieredStorageSummary(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceClickHouseTieredStorageSummary_Call {
	return &MockClient_ServiceClickHouseTieredStorageSummary_Call{Call: _e.mock.On("ServiceClickHouseTieredStorageSummary", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceClickHouseTieredStorageSummary_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceClickHouseTieredStorageSummary_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceClickHouseTieredStorageSummary_Call) Return(serviceClickHouseTieredStorageSummaryOut *clickhouse.ServiceClickHouseTieredStorageSummaryOut, err error) *MockClient_ServiceClickHouseTieredStorageSummary_Call {
	_c.Call.Return(serviceClickHouseTieredStorageSummaryOut, err)
	return _c
}

func (_c *MockClient_ServiceClickHouseTieredStorageSummary_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) (*clickhouse.ServiceClickHouseTieredStorageSummaryOut, error)) *MockClient_ServiceClickHouseTieredStorageSummary_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceClickHouseUserCreate provides a mock function for the type MockClient
func (_mock *MockClient) ServiceClickHouseUserCreate(ctx context.Context, project1 string, serviceName string, in *clickhouse.ServiceClickHouseUserCreateIn) (*clickhouse.ServiceClickHouseUserCreateOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 *clickhouse.ServiceClickHouseUserCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *clickhouse.ServiceClickHouseUserCreateIn) (*clickhouse.ServiceClickHouseUserCreateOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *clickhouse.ServiceClickHouseUserCreateIn) *clickhouse.ServiceClickHouseUserCreateOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*clickhouse.ServiceClickHouseUserCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *clickhouse.ServiceClickHouseUserCreateIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceClickHouseUserCreate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceClickHouseUserCreate(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceClickHouseUserCreate_Call {
	return &MockClient_ServiceClickHouseUserCreate_Call{Call: _e.mock.On("ServiceClickHouseUserCreate", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceClickHouseUserCreate_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *clickhouse.ServiceClickHouseUserCreateIn)) *MockClient_ServiceClickHouseUserCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*clickhouse.ServiceClickHouseUserCreateIn))
	})
	return _c
}

func (_c *MockClient_ServiceClickHouseUserCreate_Call) Return(serviceClickHouseUserCreateOut *clickhouse.ServiceClickHouseUserCreateOut, err error) *MockClient_ServiceClickHouseUserCreate_Call {
	_c.Call.Return(serviceClickHouseUserCreateOut, err)
	return _c
}

func (_c *MockClient_ServiceClickHouseUserCreate_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *clickhouse.ServiceClickHouseUserCreateIn) (*clickhouse.ServiceClickHouseUserCreateOut, error)) *MockClient_ServiceClickHouseUserCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceClickHouseUserDelete provides a mock function for the type MockClient
func (_mock *MockClient) ServiceClickHouseUserDelete(ctx context.Context, project1 string, serviceName string, userUuid string) error {
	ret := _mock.Called(ctx, project1, serviceName, userUuid)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, userUuid)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceClickHouseUserDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - userUuid
func (_e *MockClient_Expecter) ServiceClickHouseUserDelete(ctx interface{}, project1 interface{}, serviceName interface{}, userUuid interface{}) *MockClient_ServiceClickHouseUserDelete_Call {
	return &MockClient_ServiceClickHouseUserDelete_Call{Call: _e.mock.On("ServiceClickHouseUserDelete", ctx, project1, serviceName, userUuid)}
}

func (_c *MockClient_ServiceClickHouseUserDelete_Call) Run(run func(ctx context.Context, project1 string, serviceName string, userUuid string)) *MockClient_ServiceClickHouseUserDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceClickHouseUserDelete_Call) Return(err error) *MockClient_ServiceClickHouseUserDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceClickHouseUserDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, userUuid string) error) *MockClient_ServiceClickHouseUserDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceClickHouseUserList provides a mock function for the type MockClient
func (_mock *MockClient) ServiceClickHouseUserList(ctx context.Context, project1 string, serviceName string) ([]clickhouse.UserOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []clickhouse.UserOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]clickhouse.UserOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []clickhouse.UserOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]clickhouse.UserOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceClickHouseUserList is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceClickHouseUserList(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceClickHouseUserList_Call {
	return &MockClient_ServiceClickHouseUserList_Call{Call: _e.mock.On("ServiceClickHouseUserList", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceClickHouseUserList_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceClickHouseUserList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceClickHouseUserList_Call) Return(userOuts []clickhouse.UserOut, err error) *MockClient_ServiceClickHouseUserList_Call {
	_c.Call.Return(userOuts, err)
	return _c
}

func (_c *MockClient_ServiceClickHouseUserList_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]clickhouse.UserOut, error)) *MockClient_ServiceClickHouseUserList_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceCreate provides a mock function for the type MockClient
func (_mock *MockClient) ServiceCreate(ctx context.Context, project1 string, in *service.ServiceCreateIn) (*service.ServiceCreateOut, error) {
	ret := _mock.Called(ctx, project1, in)

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

	var r0 *service.ServiceCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *service.ServiceCreateIn) (*service.ServiceCreateOut, error)); ok {
		return returnFunc(ctx, project1, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *service.ServiceCreateIn) *service.ServiceCreateOut); ok {
		r0 = returnFunc(ctx, project1, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ServiceCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *service.ServiceCreateIn) error); ok {
		r1 = returnFunc(ctx, project1, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceCreate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - in
func (_e *MockClient_Expecter) ServiceCreate(ctx interface{}, project1 interface{}, in interface{}) *MockClient_ServiceCreate_Call {
	return &MockClient_ServiceCreate_Call{Call: _e.mock.On("ServiceCreate", ctx, project1, in)}
}

func (_c *MockClient_ServiceCreate_Call) Run(run func(ctx context.Context, project1 string, in *service.ServiceCreateIn)) *MockClient_ServiceCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*service.ServiceCreateIn))
	})
	return _c
}

func (_c *MockClient_ServiceCreate_Call) Return(serviceCreateOut *service.ServiceCreateOut, err error) *MockClient_ServiceCreate_Call {
	_c.Call.Return(serviceCreateOut, err)
	return _c
}

func (_c *MockClient_ServiceCreate_Call) RunAndReturn(run func(ctx context.Context, project1 string, in *service.ServiceCreateIn) (*service.ServiceCreateOut, error)) *MockClient_ServiceCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceDatabaseCreate provides a mock function for the type MockClient
func (_mock *MockClient) ServiceDatabaseCreate(ctx context.Context, project1 string, serviceName string, in *service.ServiceDatabaseCreateIn) error {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ServiceDatabaseCreateIn) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceDatabaseCreate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceDatabaseCreate(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceDatabaseCreate_Call {
	return &MockClient_ServiceDatabaseCreate_Call{Call: _e.mock.On("ServiceDatabaseCreate", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceDatabaseCreate_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *service.ServiceDatabaseCreateIn)) *MockClient_ServiceDatabaseCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*service.ServiceDatabaseCreateIn))
	})
	return _c
}

func (_c *MockClient_ServiceDatabaseCreate_Call) Return(err error) *MockClient_ServiceDatabaseCreate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceDatabaseCreate_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *service.ServiceDatabaseCreateIn) error) *MockClient_ServiceDatabaseCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceDatabaseDelete provides a mock function for the type MockClient
func (_mock *MockClient) ServiceDatabaseDelete(ctx context.Context, project1 string, serviceName string, dbname string) error {
	ret := _mock.Called(ctx, project1, serviceName, dbname)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, dbname)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceDatabaseDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - dbname
func (_e *MockClient_Expecter) ServiceDatabaseDelete(ctx interface{}, project1 interface{}, serviceName interface{}, dbname interface{}) *MockClient_ServiceDatabaseDelete_Call {
	return &MockClient_ServiceDatabaseDelete_Call{Call: _e.mock.On("ServiceDatabaseDelete", ctx, project1, serviceName, dbname)}
}

func (_c *MockClient_ServiceDatabaseDelete_Call) Run(run func(ctx context.Context, project1 string, serviceName string, dbname string)) *MockClient_ServiceDatabaseDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceDatabaseDelete_Call) Return(err error) *MockClient_ServiceDatabaseDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceDatabaseDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, dbname string) error) *MockClient_ServiceDatabaseDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceDatabaseList provides a mock function for the type MockClient
func (_mock *MockClient) ServiceDatabaseList(ctx context.Context, project1 string, serviceName string) ([]service.DatabaseOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []service.DatabaseOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]service.DatabaseOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []service.DatabaseOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]service.DatabaseOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceDatabaseList is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceDatabaseList(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceDatabaseList_Call {
	return &MockClient_ServiceDatabaseList_Call{Call: _e.mock.On("ServiceDatabaseList", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceDatabaseList_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceDatabaseList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceDatabaseList_Call) Return(databaseOuts []service.DatabaseOut, err error) *MockClient_ServiceDatabaseList_Call {
	_c.Call.Return(databaseOuts, err)
	return _c
}

func (_c *MockClient_ServiceDatabaseList_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]service.DatabaseOut, error)) *MockClient_ServiceDatabaseList_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceDelete provides a mock function for the type MockClient
func (_mock *MockClient) ServiceDelete(ctx context.Context, project1 string, serviceName string) error {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceDelete(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceDelete_Call {
	return &MockClient_ServiceDelete_Call{Call: _e.mock.On("ServiceDelete", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceDelete_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceDelete_Call) Return(err error) *MockClient_ServiceDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) error) *MockClient_ServiceDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceEnableWrites provides a mock function for the type MockClient
func (_mock *MockClient) ServiceEnableWrites(ctx context.Context, project1 string, serviceName string) (*string, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 *string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*string, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *string); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceEnableWrites is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceEnableWrites(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceEnableWrites_Call {
	return &MockClient_ServiceEnableWrites_Call{Call: _e.mock.On("ServiceEnableWrites", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceEnableWrites_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceEnableWrites_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceEnableWrites_Call) Return(s *string, err error) *MockClient_ServiceEnableWrites_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockClient_ServiceEnableWrites_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) (*string, error)) *MockClient_ServiceEnableWrites_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkCancelApplicationDeployment provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkCancelApplicationDeployment(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string) (*flinkapplicationdeployment.ServiceFlinkCancelApplicationDeploymentOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId, deploymentId)

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

	var r0 *flinkapplicationdeployment.ServiceFlinkCancelApplicationDeploymentOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (*flinkapplicationdeployment.ServiceFlinkCancelApplicationDeploymentOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) *flinkapplicationdeployment.ServiceFlinkCancelApplicationDeploymentOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkapplicationdeployment.ServiceFlinkCancelApplicationDeploymentOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkCancelApplicationDeployment is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
//   - deploymentId
func (_e *MockClient_Expecter) ServiceFlinkCancelApplicationDeployment(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}, deploymentId interface{}) *MockClient_ServiceFlinkCancelApplicationDeployment_Call {
	return &MockClient_ServiceFlinkCancelApplicationDeployment_Call{Call: _e.mock.On("ServiceFlinkCancelApplicationDeployment", ctx, project1, serviceName, applicationId, deploymentId)}
}

func (_c *MockClient_ServiceFlinkCancelApplicationDeployment_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string)) *MockClient_ServiceFlinkCancelApplicationDeployment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkCancelApplicationDeployment_Call) Return(serviceFlinkCancelApplicationDeploymentOut *flinkapplicationdeployment.ServiceFlinkCancelApplicationDeploymentOut, err error) *MockClient_ServiceFlinkCancelApplicationDeployment_Call {
	_c.Call.Return(serviceFlinkCancelApplicationDeploymentOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkCancelApplicationDeployment_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string) (*flinkapplicationdeployment.ServiceFlinkCancelApplicationDeploymentOut, error)) *MockClient_ServiceFlinkCancelApplicationDeployment_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkCancelJarApplicationDeployment provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkCancelJarApplicationDeployment(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string) (*flinkjarapplicationdeployment.ServiceFlinkCancelJarApplicationDeploymentOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId, deploymentId)

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

	var r0 *flinkjarapplicationdeployment.ServiceFlinkCancelJarApplicationDeploymentOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (*flinkjarapplicationdeployment.ServiceFlinkCancelJarApplicationDeploymentOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) *flinkjarapplicationdeployment.ServiceFlinkCancelJarApplicationDeploymentOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkjarapplicationdeployment.ServiceFlinkCancelJarApplicationDeploymentOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkCancelJarApplicationDeployment is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
//   - deploymentId
func (_e *MockClient_Expecter) ServiceFlinkCancelJarApplicationDeployment(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}, deploymentId interface{}) *MockClient_ServiceFlinkCancelJarApplicationDeployment_Call {
	return &MockClient_ServiceFlinkCancelJarApplicationDeployment_Call{Call: _e.mock.On("ServiceFlinkCancelJarApplicationDeployment", ctx, project1, serviceName, applicationId, deploymentId)}
}

func (_c *MockClient_ServiceFlinkCancelJarApplicationDeployment_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string)) *MockClient_ServiceFlinkCancelJarApplicationDeployment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkCancelJarApplicationDeployment_Call) Return(serviceFlinkCancelJarApplicationDeploymentOut *flinkjarapplicationdeployment.ServiceFlinkCancelJarApplicationDeploymentOut, err error) *MockClient_ServiceFlinkCancelJarApplicationDeployment_Call {
	_c.Call.Return(serviceFlinkCancelJarApplicationDeploymentOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkCancelJarApplicationDeployment_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string) (*flinkjarapplicationdeployment.ServiceFlinkCancelJarApplicationDeploymentOut, error)) *MockClient_ServiceFlinkCancelJarApplicationDeployment_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkCreateApplication provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkCreateApplication(ctx context.Context, project1 string, serviceName string, in *flinkapplication.ServiceFlinkCreateApplicationIn) (*flinkapplication.ServiceFlinkCreateApplicationOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 *flinkapplication.ServiceFlinkCreateApplicationOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *flinkapplication.ServiceFlinkCreateApplicationIn) (*flinkapplication.ServiceFlinkCreateApplicationOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *flinkapplication.ServiceFlinkCreateApplicationIn) *flinkapplication.ServiceFlinkCreateApplicationOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkapplication.ServiceFlinkCreateApplicationOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *flinkapplication.ServiceFlinkCreateApplicationIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkCreateApplication is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceFlinkCreateApplication(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceFlinkCreateApplication_Call {
	return &MockClient_ServiceFlinkCreateApplication_Call{Call: _e.mock.On("ServiceFlinkCreateApplication", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceFlinkCreateApplication_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *flinkapplication.ServiceFlinkCreateApplicationIn)) *MockClient_ServiceFlinkCreateApplication_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*flinkapplication.ServiceFlinkCreateApplicationIn))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkCreateApplication_Call) Return(serviceFlinkCreateApplicationOut *flinkapplication.ServiceFlinkCreateApplicationOut, err error) *MockClient_ServiceFlinkCreateApplication_Call {
	_c.Call.Return(serviceFlinkCreateApplicationOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkCreateApplication_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *flinkapplication.ServiceFlinkCreateApplicationIn) (*flinkapplication.ServiceFlinkCreateApplicationOut, error)) *MockClient_ServiceFlinkCreateApplication_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkCreateApplicationDeployment provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkCreateApplicationDeployment(ctx context.Context, project1 string, serviceName string, applicationId string, in *flinkapplicationdeployment.ServiceFlinkCreateApplicationDeploymentIn) (*flinkapplicationdeployment.ServiceFlinkCreateApplicationDeploymentOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId, in)

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

	var r0 *flinkapplicationdeployment.ServiceFlinkCreateApplicationDeploymentOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *flinkapplicationdeployment.ServiceFlinkCreateApplicationDeploymentIn) (*flinkapplicationdeployment.ServiceFlinkCreateApplicationDeploymentOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *flinkapplicationdeployment.ServiceFlinkCreateApplicationDeploymentIn) *flinkapplicationdeployment.ServiceFlinkCreateApplicationDeploymentOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkapplicationdeployment.ServiceFlinkCreateApplicationDeploymentOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, *flinkapplicationdeployment.ServiceFlinkCreateApplicationDeploymentIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkCreateApplicationDeployment is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
//   - in
func (_e *MockClient_Expecter) ServiceFlinkCreateApplicationDeployment(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}, in interface{}) *MockClient_ServiceFlinkCreateApplicationDeployment_Call {
	return &MockClient_ServiceFlinkCreateApplicationDeployment_Call{Call: _e.mock.On("ServiceFlinkCreateApplicationDeployment", ctx, project1, serviceName, applicationId, in)}
}

func (_c *MockClient_ServiceFlinkCreateApplicationDeployment_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string, in *flinkapplicationdeployment.ServiceFlinkCreateApplicationDeploymentIn)) *MockClient_ServiceFlinkCreateApplicationDeployment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*flinkapplicationdeployment.ServiceFlinkCreateApplicationDeploymentIn))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkCreateApplicationDeployment_Call) Return(serviceFlinkCreateApplicationDeploymentOut *flinkapplicationdeployment.ServiceFlinkCreateApplicationDeploymentOut, err error) *MockClient_ServiceFlinkCreateApplicationDeployment_Call {
	_c.Call.Return(serviceFlinkCreateApplicationDeploymentOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkCreateApplicationDeployment_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string, in *flinkapplicationdeployment.ServiceFlinkCreateApplicationDeploymentIn) (*flinkapplicationdeployment.ServiceFlinkCreateApplicationDeploymentOut, error)) *MockClient_ServiceFlinkCreateApplicationDeployment_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkCreateApplicationVersion provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkCreateApplicationVersion(ctx context.Context, project1 string, serviceName string, applicationId string, in *flinkapplicationversion.ServiceFlinkCreateApplicationVersionIn) (*flinkapplicationversion.ServiceFlinkCreateApplicationVersionOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId, in)

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

	var r0 *flinkapplicationversion.ServiceFlinkCreateApplicationVersionOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *flinkapplicationversion.ServiceFlinkCreateApplicationVersionIn) (*flinkapplicationversion.ServiceFlinkCreateApplicationVersionOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *flinkapplicationversion.ServiceFlinkCreateApplicationVersionIn) *flinkapplicationversion.ServiceFlinkCreateApplicationVersionOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkapplicationversion.ServiceFlinkCreateApplicationVersionOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, *flinkapplicationversion.ServiceFlinkCreateApplicationVersionIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkCreateApplicationVersion is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
//   - in
func (_e *MockClient_Expecter) ServiceFlinkCreateApplicationVersion(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}, in interface{}) *MockClient_ServiceFlinkCreateApplicationVersion_Call {
	return &MockClient_ServiceFlinkCreateApplicationVersion_Call{Call: _e.mock.On("ServiceFlinkCreateApplicationVersion", ctx, project1, serviceName, applicationId, in)}
}

func (_c *MockClient_ServiceFlinkCreateApplicationVersion_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string, in *flinkapplicationversion.ServiceFlinkCreateApplicationVersionIn)) *MockClient_ServiceFlinkCreateApplicationVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*flinkapplicationversion.ServiceFlinkCreateApplicationVersionIn))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkCreateApplicationVersion_Call) Return(serviceFlinkCreateApplicationVersionOut *flinkapplicationversion.ServiceFlinkCreateApplicationVersionOut, err error) *MockClient_ServiceFlinkCreateApplicationVersion_Call {
	_c.Call.Return(serviceFlinkCreateApplicationVersionOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkCreateApplicationVersion_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string, in *flinkapplicationversion.ServiceFlinkCreateApplicationVersionIn) (*flinkapplicationversion.ServiceFlinkCreateApplicationVersionOut, error)) *MockClient_ServiceFlinkCreateApplicationVersion_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkCreateJarApplication provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkCreateJarApplication(ctx context.Context, project1 string, serviceName string, in *flinkjarapplication.ServiceFlinkCreateJarApplicationIn) (*flinkjarapplication.ServiceFlinkCreateJarApplicationOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 *flinkjarapplication.ServiceFlinkCreateJarApplicationOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *flinkjarapplication.ServiceFlinkCreateJarApplicationIn) (*flinkjarapplication.ServiceFlinkCreateJarApplicationOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *flinkjarapplication.ServiceFlinkCreateJarApplicationIn) *flinkjarapplication.ServiceFlinkCreateJarApplicationOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkjarapplication.ServiceFlinkCreateJarApplicationOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *flinkjarapplication.ServiceFlinkCreateJarApplicationIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkCreateJarApplication is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceFlinkCreateJarApplication(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceFlinkCreateJarApplication_Call {
	return &MockClient_ServiceFlinkCreateJarApplication_Call{Call: _e.mock.On("ServiceFlinkCreateJarApplication", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceFlinkCreateJarApplication_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *flinkjarapplication.ServiceFlinkCreateJarApplicationIn)) *MockClient_ServiceFlinkCreateJarApplication_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*flinkjarapplication.ServiceFlinkCreateJarApplicationIn))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkCreateJarApplication_Call) Return(serviceFlinkCreateJarApplicationOut *flinkjarapplication.ServiceFlinkCreateJarApplicationOut, err error) *MockClient_ServiceFlinkCreateJarApplication_Call {
	_c.Call.Return(serviceFlinkCreateJarApplicationOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkCreateJarApplication_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *flinkjarapplication.ServiceFlinkCreateJarApplicationIn) (*flinkjarapplication.ServiceFlinkCreateJarApplicationOut, error)) *MockClient_ServiceFlinkCreateJarApplication_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkCreateJarApplicationDeployment provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkCreateJarApplicationDeployment(ctx context.Context, project1 string, serviceName string, applicationId string, in *flinkjarapplicationdeployment.ServiceFlinkCreateJarApplicationDeploymentIn) (*flinkjarapplicationdeployment.ServiceFlinkCreateJarApplicationDeploymentOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId, in)

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

	var r0 *flinkjarapplicationdeployment.ServiceFlinkCreateJarApplicationDeploymentOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *flinkjarapplicationdeployment.ServiceFlinkCreateJarApplicationDeploymentIn) (*flinkjarapplicationdeployment.ServiceFlinkCreateJarApplicationDeploymentOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *flinkjarapplicationdeployment.ServiceFlinkCreateJarApplicationDeploymentIn) *flinkjarapplicationdeployment.ServiceFlinkCreateJarApplicationDeploymentOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkjarapplicationdeployment.ServiceFlinkCreateJarApplicationDeploymentOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, *flinkjarapplicationdeployment.ServiceFlinkCreateJarApplicationDeploymentIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkCreateJarApplicationDeployment is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
//   - in
func (_e *MockClient_Expecter) ServiceFlinkCreateJarApplicationDeployment(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}, in interface{}) *MockClient_ServiceFlinkCreateJarApplicationDeployment_Call {
	return &MockClient_ServiceFlinkCreateJarApplicationDeployment_Call{Call: _e.mock.On("ServiceFlinkCreateJarApplicationDeployment", ctx, project1, serviceName, applicationId, in)}
}

func (_c *MockClient_ServiceFlinkCreateJarApplicationDeployment_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string, in *flinkjarapplicationdeployment.ServiceFlinkCreateJarApplicationDeploymentIn)) *MockClient_ServiceFlinkCreateJarApplicationDeployment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*flinkjarapplicationdeployment.ServiceFlinkCreateJarApplicationDeploymentIn))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkCreateJarApplicationDeployment_Call) Return(serviceFlinkCreateJarApplicationDeploymentOut *flinkjarapplicationdeployment.ServiceFlinkCreateJarApplicationDeploymentOut, err error) *MockClient_ServiceFlinkCreateJarApplicationDeployment_Call {
	_c.Call.Return(serviceFlinkCreateJarApplicationDeploymentOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkCreateJarApplicationDeployment_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string, in *flinkjarapplicationdeployment.ServiceFlinkCreateJarApplicationDeploymentIn) (*flinkjarapplicationdeployment.ServiceFlinkCreateJarApplicationDeploymentOut, error)) *MockClient_ServiceFlinkCreateJarApplicationDeployment_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkCreateJarApplicationVersion provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkCreateJarApplicationVersion(ctx context.Context, project1 string, serviceName string, applicationId string) (*flinkjarapplicationversion.ServiceFlinkCreateJarApplicationVersionOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId)

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

	var r0 *flinkjarapplicationversion.ServiceFlinkCreateJarApplicationVersionOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*flinkjarapplicationversion.ServiceFlinkCreateJarApplicationVersionOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *flinkjarapplicationversion.ServiceFlinkCreateJarApplicationVersionOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkjarapplicationversion.ServiceFlinkCreateJarApplicationVersionOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkCreateJarApplicationVersion is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
func (_e *MockClient_Expecter) ServiceFlinkCreateJarApplicationVersion(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}) *MockClient_ServiceFlinkCreateJarApplicationVersion_Call {
	return &MockClient_ServiceFlinkCreateJarApplicationVersion_Call{Call: _e.mock.On("ServiceFlinkCreateJarApplicationVersion", ctx, project1, serviceName, applicationId)}
}

func (_c *MockClient_ServiceFlinkCreateJarApplicationVersion_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string)) *MockClient_ServiceFlinkCreateJarApplicationVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkCreateJarApplicationVersion_Call) Return(serviceFlinkCreateJarApplicationVersionOut *flinkjarapplicationversion.ServiceFlinkCreateJarApplicationVersionOut, err error) *MockClient_ServiceFlinkCreateJarApplicationVersion_Call {
	_c.Call.Return(serviceFlinkCreateJarApplicationVersionOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkCreateJarApplicationVersion_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string) (*flinkjarapplicationversion.ServiceFlinkCreateJarApplicationVersionOut, error)) *MockClient_ServiceFlinkCreateJarApplicationVersion_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkDeleteApplication provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkDeleteApplication(ctx context.Context, project1 string, serviceName string, applicationId string) (*flinkapplication.ServiceFlinkDeleteApplicationOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId)

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

	var r0 *flinkapplication.ServiceFlinkDeleteApplicationOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*flinkapplication.ServiceFlinkDeleteApplicationOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *flinkapplication.ServiceFlinkDeleteApplicationOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkapplication.ServiceFlinkDeleteApplicationOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkDeleteApplication is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
func (_e *MockClient_Expecter) ServiceFlinkDeleteApplication(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}) *MockClient_ServiceFlinkDeleteApplication_Call {
	return &MockClient_ServiceFlinkDeleteApplication_Call{Call: _e.mock.On("ServiceFlinkDeleteApplication", ctx, project1, serviceName, applicationId)}
}

func (_c *MockClient_ServiceFlinkDeleteApplication_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string)) *MockClient_ServiceFlinkDeleteApplication_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkDeleteApplication_Call) Return(serviceFlinkDeleteApplicationOut *flinkapplication.ServiceFlinkDeleteApplicationOut, err error) *MockClient_ServiceFlinkDeleteApplication_Call {
	_c.Call.Return(serviceFlinkDeleteApplicationOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkDeleteApplication_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string) (*flinkapplication.ServiceFlinkDeleteApplicationOut, error)) *MockClient_ServiceFlinkDeleteApplication_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkDeleteApplicationDeployment provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkDeleteApplicationDeployment(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string) (*flinkapplicationdeployment.ServiceFlinkDeleteApplicationDeploymentOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId, deploymentId)

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

	var r0 *flinkapplicationdeployment.ServiceFlinkDeleteApplicationDeploymentOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (*flinkapplicationdeployment.ServiceFlinkDeleteApplicationDeploymentOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) *flinkapplicationdeployment.ServiceFlinkDeleteApplicationDeploymentOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkapplicationdeployment.ServiceFlinkDeleteApplicationDeploymentOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkDeleteApplicationDeployment is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
//   - deploymentId
func (_e *MockClient_Expecter) ServiceFlinkDeleteApplicationDeployment(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}, deploymentId interface{}) *MockClient_ServiceFlinkDeleteApplicationDeployment_Call {
	return &MockClient_ServiceFlinkDeleteApplicationDeployment_Call{Call: _e.mock.On("ServiceFlinkDeleteApplicationDeployment", ctx, project1, serviceName, applicationId, deploymentId)}
}

func (_c *MockClient_ServiceFlinkDeleteApplicationDeployment_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string)) *MockClient_ServiceFlinkDeleteApplicationDeployment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkDeleteApplicationDeployment_Call) Return(serviceFlinkDeleteApplicationDeploymentOut *flinkapplicationdeployment.ServiceFlinkDeleteApplicationDeploymentOut, err error) *MockClient_ServiceFlinkDeleteApplicationDeployment_Call {
	_c.Call.Return(serviceFlinkDeleteApplicationDeploymentOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkDeleteApplicationDeployment_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string) (*flinkapplicationdeployment.ServiceFlinkDeleteApplicationDeploymentOut, error)) *MockClient_ServiceFlinkDeleteApplicationDeployment_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkDeleteApplicationVersion provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkDeleteApplicationVersion(ctx context.Context, project1 string, serviceName string, applicationId string, applicationVersionId string) (*flinkapplicationversion.ServiceFlinkDeleteApplicationVersionOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId, applicationVersionId)

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

	var r0 *flinkapplicationversion.ServiceFlinkDeleteApplicationVersionOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (*flinkapplicationversion.ServiceFlinkDeleteApplicationVersionOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId, applicationVersionId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) *flinkapplicationversion.ServiceFlinkDeleteApplicationVersionOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId, applicationVersionId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkapplicationversion.ServiceFlinkDeleteApplicationVersionOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId, applicationVersionId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkDeleteApplicationVersion is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
//   - applicationVersionId
func (_e *MockClient_Expecter) ServiceFlinkDeleteApplicationVersion(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}, applicationVersionId interface{}) *MockClient_ServiceFlinkDeleteApplicationVersion_Call {
	return &MockClient_ServiceFlinkDeleteApplicationVersion_Call{Call: _e.mock.On("ServiceFlinkDeleteApplicationVersion", ctx, project1, serviceName, applicationId, applicationVersionId)}
}

func (_c *MockClient_ServiceFlinkDeleteApplicationVersion_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string, applicationVersionId string)) *MockClient_ServiceFlinkDeleteApplicationVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkDeleteApplicationVersion_Call) Return(serviceFlinkDeleteApplicationVersionOut *flinkapplicationversion.ServiceFlinkDeleteApplicationVersionOut, err error) *MockClient_ServiceFlinkDeleteApplicationVersion_Call {
	_c.Call.Return(serviceFlinkDeleteApplicationVersionOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkDeleteApplicationVersion_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string, applicationVersionId string) (*flinkapplicationversion.ServiceFlinkDeleteApplicationVersionOut, error)) *MockClient_ServiceFlinkDeleteApplicationVersion_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkDeleteJarApplication provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkDeleteJarApplication(ctx context.Context, project1 string, serviceName string, applicationId string) (*flinkjarapplication.ServiceFlinkDeleteJarApplicationOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId)

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

	var r0 *flinkjarapplication.ServiceFlinkDeleteJarApplicationOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*flinkjarapplication.ServiceFlinkDeleteJarApplicationOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *flinkjarapplication.ServiceFlinkDeleteJarApplicationOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkjarapplication.ServiceFlinkDeleteJarApplicationOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkDeleteJarApplication is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
func (_e *MockClient_Expecter) ServiceFlinkDeleteJarApplication(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}) *MockClient_ServiceFlinkDeleteJarApplication_Call {
	return &MockClient_ServiceFlinkDeleteJarApplication_Call{Call: _e.mock.On("ServiceFlinkDeleteJarApplication", ctx, project1, serviceName, applicationId)}
}

func (_c *MockClient_ServiceFlinkDeleteJarApplication_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string)) *MockClient_ServiceFlinkDeleteJarApplication_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkDeleteJarApplication_Call) Return(serviceFlinkDeleteJarApplicationOut *flinkjarapplication.ServiceFlinkDeleteJarApplicationOut, err error) *MockClient_ServiceFlinkDeleteJarApplication_Call {
	_c.Call.Return(serviceFlinkDeleteJarApplicationOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkDeleteJarApplication_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string) (*flinkjarapplication.ServiceFlinkDeleteJarApplicationOut, error)) *MockClient_ServiceFlinkDeleteJarApplication_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkDeleteJarApplicationDeployment provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkDeleteJarApplicationDeployment(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string) (*flinkjarapplicationdeployment.ServiceFlinkDeleteJarApplicationDeploymentOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId, deploymentId)

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

	var r0 *flinkjarapplicationdeployment.ServiceFlinkDeleteJarApplicationDeploymentOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (*flinkjarapplicationdeployment.ServiceFlinkDeleteJarApplicationDeploymentOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) *flinkjarapplicationdeployment.ServiceFlinkDeleteJarApplicationDeploymentOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkjarapplicationdeployment.ServiceFlinkDeleteJarApplicationDeploymentOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkDeleteJarApplicationDeployment is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
//   - deploymentId
func (_e *MockClient_Expecter) ServiceFlinkDeleteJarApplicationDeployment(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}, deploymentId interface{}) *MockClient_ServiceFlinkDeleteJarApplicationDeployment_Call {
	return &MockClient_ServiceFlinkDeleteJarApplicationDeployment_Call{Call: _e.mock.On("ServiceFlinkDeleteJarApplicationDeployment", ctx, project1, serviceName, applicationId, deploymentId)}
}

func (_c *MockClient_ServiceFlinkDeleteJarApplicationDeployment_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string)) *MockClient_ServiceFlinkDeleteJarApplicationDeployment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkDeleteJarApplicationDeployment_Call) Return(serviceFlinkDeleteJarApplicationDeploymentOut *flinkjarapplicationdeployment.ServiceFlinkDeleteJarApplicationDeploymentOut, err error) *MockClient_ServiceFlinkDeleteJarApplicationDeployment_Call {
	_c.Call.Return(serviceFlinkDeleteJarApplicationDeploymentOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkDeleteJarApplicationDeployment_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string) (*flinkjarapplicationdeployment.ServiceFlinkDeleteJarApplicationDeploymentOut, error)) *MockClient_ServiceFlinkDeleteJarApplicationDeployment_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkDeleteJarApplicationVersion provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkDeleteJarApplicationVersion(ctx context.Context, project1 string, serviceName string, applicationId string, applicationVersionId string) (*flinkjarapplicationversion.ServiceFlinkDeleteJarApplicationVersionOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId, applicationVersionId)

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

	var r0 *flinkjarapplicationversion.ServiceFlinkDeleteJarApplicationVersionOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (*flinkjarapplicationversion.ServiceFlinkDeleteJarApplicationVersionOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId, applicationVersionId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) *flinkjarapplicationversion.ServiceFlinkDeleteJarApplicationVersionOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId, applicationVersionId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkjarapplicationversion.ServiceFlinkDeleteJarApplicationVersionOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId, applicationVersionId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkDeleteJarApplicationVersion is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
//   - applicationVersionId
func (_e *MockClient_Expecter) ServiceFlinkDeleteJarApplicationVersion(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}, applicationVersionId interface{}) *MockClient_ServiceFlinkDeleteJarApplicationVersion_Call {
	return &MockClient_ServiceFlinkDeleteJarApplicationVersion_Call{Call: _e.mock.On("ServiceFlinkDeleteJarApplicationVersion", ctx, project1, serviceName, applicationId, applicationVersionId)}
}

func (_c *MockClient_ServiceFlinkDeleteJarApplicationVersion_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string, applicationVersionId string)) *MockClient_ServiceFlinkDeleteJarApplicationVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkDeleteJarApplicationVersion_Call) Return(serviceFlinkDeleteJarApplicationVersionOut *flinkjarapplicationversion.ServiceFlinkDeleteJarApplicationVersionOut, err error) *MockClient_ServiceFlinkDeleteJarApplicationVersion_Call {
	_c.Call.Return(serviceFlinkDeleteJarApplicationVersionOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkDeleteJarApplicationVersion_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string, applicationVersionId string) (*flinkjarapplicationversion.ServiceFlinkDeleteJarApplicationVersionOut, error)) *MockClient_ServiceFlinkDeleteJarApplicationVersion_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkGetApplication provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkGetApplication(ctx context.Context, project1 string, serviceName string, applicationId string) (*flinkapplication.ServiceFlinkGetApplicationOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId)

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

	var r0 *flinkapplication.ServiceFlinkGetApplicationOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*flinkapplication.ServiceFlinkGetApplicationOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *flinkapplication.ServiceFlinkGetApplicationOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkapplication.ServiceFlinkGetApplicationOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkGetApplication is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
func (_e *MockClient_Expecter) ServiceFlinkGetApplication(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}) *MockClient_ServiceFlinkGetApplication_Call {
	return &MockClient_ServiceFlinkGetApplication_Call{Call: _e.mock.On("ServiceFlinkGetApplication", ctx, project1, serviceName, applicationId)}
}

func (_c *MockClient_ServiceFlinkGetApplication_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string)) *MockClient_ServiceFlinkGetApplication_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkGetApplication_Call) Return(serviceFlinkGetApplicationOut *flinkapplication.ServiceFlinkGetApplicationOut, err error) *MockClient_ServiceFlinkGetApplication_Call {
	_c.Call.Return(serviceFlinkGetApplicationOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkGetApplication_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string) (*flinkapplication.ServiceFlinkGetApplicationOut, error)) *MockClient_ServiceFlinkGetApplication_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkGetApplicationDeployment provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkGetApplicationDeployment(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string) (*flinkapplicationdeployment.ServiceFlinkGetApplicationDeploymentOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId, deploymentId)

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

	var r0 *flinkapplicationdeployment.ServiceFlinkGetApplicationDeploymentOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (*flinkapplicationdeployment.ServiceFlinkGetApplicationDeploymentOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) *flinkapplicationdeployment.ServiceFlinkGetApplicationDeploymentOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkapplicationdeployment.ServiceFlinkGetApplicationDeploymentOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkGetApplicationDeployment is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
//   - deploymentId
func (_e *MockClient_Expecter) ServiceFlinkGetApplicationDeployment(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}, deploymentId interface{}) *MockClient_ServiceFlinkGetApplicationDeployment_Call {
	return &MockClient_ServiceFlinkGetApplicationDeployment_Call{Call: _e.mock.On("ServiceFlinkGetApplicationDeployment", ctx, project1, serviceName, applicationId, deploymentId)}
}

func (_c *MockClient_ServiceFlinkGetApplicationDeployment_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string)) *MockClient_ServiceFlinkGetApplicationDeployment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkGetApplicationDeployment_Call) Return(serviceFlinkGetApplicationDeploymentOut *flinkapplicationdeployment.ServiceFlinkGetApplicationDeploymentOut, err error) *MockClient_ServiceFlinkGetApplicationDeployment_Call {
	_c.Call.Return(serviceFlinkGetApplicationDeploymentOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkGetApplicationDeployment_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string) (*flinkapplicationdeployment.ServiceFlinkGetApplicationDeploymentOut, error)) *MockClient_ServiceFlinkGetApplicationDeployment_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkGetApplicationVersion provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkGetApplicationVersion(ctx context.Context, project1 string, serviceName string, applicationId string, applicationVersionId string) (*flinkapplicationversion.ServiceFlinkGetApplicationVersionOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId, applicationVersionId)

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

	var r0 *flinkapplicationversion.ServiceFlinkGetApplicationVersionOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (*flinkapplicationversion.ServiceFlinkGetApplicationVersionOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId, applicationVersionId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) *flinkapplicationversion.ServiceFlinkGetApplicationVersionOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId, applicationVersionId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkapplicationversion.ServiceFlinkGetApplicationVersionOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId, applicationVersionId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkGetApplicationVersion is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
//   - applicationVersionId
func (_e *MockClient_Expecter) ServiceFlinkGetApplicationVersion(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}, applicationVersionId interface{}) *MockClient_ServiceFlinkGetApplicationVersion_Call {
	return &MockClient_ServiceFlinkGetApplicationVersion_Call{Call: _e.mock.On("ServiceFlinkGetApplicationVersion", ctx, project1, serviceName, applicationId, applicationVersionId)}
}

func (_c *MockClient_ServiceFlinkGetApplicationVersion_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string, applicationVersionId string)) *MockClient_ServiceFlinkGetApplicationVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkGetApplicationVersion_Call) Return(serviceFlinkGetApplicationVersionOut *flinkapplicationversion.ServiceFlinkGetApplicationVersionOut, err error) *MockClient_ServiceFlinkGetApplicationVersion_Call {
	_c.Call.Return(serviceFlinkGetApplicationVersionOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkGetApplicationVersion_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string, applicationVersionId string) (*flinkapplicationversion.ServiceFlinkGetApplicationVersionOut, error)) *MockClient_ServiceFlinkGetApplicationVersion_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkGetJarApplication provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkGetJarApplication(ctx context.Context, project1 string, serviceName string, applicationId string) (*flinkjarapplication.ServiceFlinkGetJarApplicationOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId)

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

	var r0 *flinkjarapplication.ServiceFlinkGetJarApplicationOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*flinkjarapplication.ServiceFlinkGetJarApplicationOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *flinkjarapplication.ServiceFlinkGetJarApplicationOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkjarapplication.ServiceFlinkGetJarApplicationOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkGetJarApplication is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
func (_e *MockClient_Expecter) ServiceFlinkGetJarApplication(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}) *MockClient_ServiceFlinkGetJarApplication_Call {
	return &MockClient_ServiceFlinkGetJarApplication_Call{Call: _e.mock.On("ServiceFlinkGetJarApplication", ctx, project1, serviceName, applicationId)}
}

func (_c *MockClient_ServiceFlinkGetJarApplication_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string)) *MockClient_ServiceFlinkGetJarApplication_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkGetJarApplication_Call) Return(serviceFlinkGetJarApplicationOut *flinkjarapplication.ServiceFlinkGetJarApplicationOut, err error) *MockClient_ServiceFlinkGetJarApplication_Call {
	_c.Call.Return(serviceFlinkGetJarApplicationOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkGetJarApplication_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string) (*flinkjarapplication.ServiceFlinkGetJarApplicationOut, error)) *MockClient_ServiceFlinkGetJarApplication_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkGetJarApplicationDeployment provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkGetJarApplicationDeployment(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string) (*flinkjarapplicationdeployment.ServiceFlinkGetJarApplicationDeploymentOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId, deploymentId)

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

	var r0 *flinkjarapplicationdeployment.ServiceFlinkGetJarApplicationDeploymentOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (*flinkjarapplicationdeployment.ServiceFlinkGetJarApplicationDeploymentOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) *flinkjarapplicationdeployment.ServiceFlinkGetJarApplicationDeploymentOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkjarapplicationdeployment.ServiceFlinkGetJarApplicationDeploymentOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkGetJarApplicationDeployment is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
//   - deploymentId
func (_e *MockClient_Expecter) ServiceFlinkGetJarApplicationDeployment(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}, deploymentId interface{}) *MockClient_ServiceFlinkGetJarApplicationDeployment_Call {
	return &MockClient_ServiceFlinkGetJarApplicationDeployment_Call{Call: _e.mock.On("ServiceFlinkGetJarApplicationDeployment", ctx, project1, serviceName, applicationId, deploymentId)}
}

func (_c *MockClient_ServiceFlinkGetJarApplicationDeployment_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string)) *MockClient_ServiceFlinkGetJarApplicationDeployment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkGetJarApplicationDeployment_Call) Return(serviceFlinkGetJarApplicationDeploymentOut *flinkjarapplicationdeployment.ServiceFlinkGetJarApplicationDeploymentOut, err error) *MockClient_ServiceFlinkGetJarApplicationDeployment_Call {
	_c.Call.Return(serviceFlinkGetJarApplicationDeploymentOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkGetJarApplicationDeployment_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string) (*flinkjarapplicationdeployment.ServiceFlinkGetJarApplicationDeploymentOut, error)) *MockClient_ServiceFlinkGetJarApplicationDeployment_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkGetJarApplicationVersion provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkGetJarApplicationVersion(ctx context.Context, project1 string, serviceName string, applicationId string, applicationVersionId string) (*flinkjarapplicationversion.ServiceFlinkGetJarApplicationVersionOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId, applicationVersionId)

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

	var r0 *flinkjarapplicationversion.ServiceFlinkGetJarApplicationVersionOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (*flinkjarapplicationversion.ServiceFlinkGetJarApplicationVersionOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId, applicationVersionId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) *flinkjarapplicationversion.ServiceFlinkGetJarApplicationVersionOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId, applicationVersionId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkjarapplicationversion.ServiceFlinkGetJarApplicationVersionOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId, applicationVersionId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkGetJarApplicationVersion is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
//   - applicationVersionId
func (_e *MockClient_Expecter) ServiceFlinkGetJarApplicationVersion(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}, applicationVersionId interface{}) *MockClient_ServiceFlinkGetJarApplicationVersion_Call {
	return &MockClient_ServiceFlinkGetJarApplicationVersion_Call{Call: _e.mock.On("ServiceFlinkGetJarApplicationVersion", ctx, project1, serviceName, applicationId, applicationVersionId)}
}

func (_c *MockClient_ServiceFlinkGetJarApplicationVersion_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string, applicationVersionId string)) *MockClient_ServiceFlinkGetJarApplicationVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkGetJarApplicationVersion_Call) Return(serviceFlinkGetJarApplicationVersionOut *flinkjarapplicationversion.ServiceFlinkGetJarApplicationVersionOut, err error) *MockClient_ServiceFlinkGetJarApplicationVersion_Call {
	_c.Call.Return(serviceFlinkGetJarApplicationVersionOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkGetJarApplicationVersion_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string, applicationVersionId string) (*flinkjarapplicationversion.ServiceFlinkGetJarApplicationVersionOut, error)) *MockClient_ServiceFlinkGetJarApplicationVersion_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkJobDetails provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkJobDetails(ctx context.Context, project1 string, serviceName string, jobId string) (*flinkjob.ServiceFlinkJobDetailsOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, jobId)

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

	var r0 *flinkjob.ServiceFlinkJobDetailsOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*flinkjob.ServiceFlinkJobDetailsOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, jobId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *flinkjob.ServiceFlinkJobDetailsOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, jobId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkjob.ServiceFlinkJobDetailsOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, jobId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkJobDetails is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - jobId
func (_e *MockClient_Expecter) ServiceFlinkJobDetails(ctx interface{}, project1 interface{}, serviceName interface{}, jobId interface{}) *MockClient_ServiceFlinkJobDetails_Call {
	return &MockClient_ServiceFlinkJobDetails_Call{Call: _e.mock.On("ServiceFlinkJobDetails", ctx, project1, serviceName, jobId)}
}

func (_c *MockClient_ServiceFlinkJobDetails_Call) Run(run func(ctx context.Context, project1 string, serviceName string, jobId string)) *MockClient_ServiceFlinkJobDetails_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkJobDetails_Call) Return(serviceFlinkJobDetailsOut *flinkjob.ServiceFlinkJobDetailsOut, err error) *MockClient_ServiceFlinkJobDetails_Call {
	_c.Call.Return(serviceFlinkJobDetailsOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkJobDetails_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, jobId string) (*flinkjob.ServiceFlinkJobDetailsOut, error)) *MockClient_ServiceFlinkJobDetails_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkJobsList provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkJobsList(ctx context.Context, project1 string, serviceName string) ([]flinkjob.JobOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []flinkjob.JobOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]flinkjob.JobOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []flinkjob.JobOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]flinkjob.JobOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkJobsList is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceFlinkJobsList(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceFlinkJobsList_Call {
	return &MockClient_ServiceFlinkJobsList_Call{Call: _e.mock.On("ServiceFlinkJobsList", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceFlinkJobsList_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceFlinkJobsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkJobsList_Call) Return(jobOuts []flinkjob.JobOut, err error) *MockClient_ServiceFlinkJobsList_Call {
	_c.Call.Return(jobOuts, err)
	return _c
}

func (_c *MockClient_ServiceFlinkJobsList_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]flinkjob.JobOut, error)) *MockClient_ServiceFlinkJobsList_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkListApplicationDeployments provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkListApplicationDeployments(ctx context.Context, project1 string, serviceName string, applicationId string) ([]flinkapplicationdeployment.DeploymentOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId)

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

	var r0 []flinkapplicationdeployment.DeploymentOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) ([]flinkapplicationdeployment.DeploymentOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) []flinkapplicationdeployment.DeploymentOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]flinkapplicationdeployment.DeploymentOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkListApplicationDeployments is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
func (_e *MockClient_Expecter) ServiceFlinkListApplicationDeployments(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}) *MockClient_ServiceFlinkListApplicationDeployments_Call {
	return &MockClient_ServiceFlinkListApplicationDeployments_Call{Call: _e.mock.On("ServiceFlinkListApplicationDeployments", ctx, project1, serviceName, applicationId)}
}

func (_c *MockClient_ServiceFlinkListApplicationDeployments_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string)) *MockClient_ServiceFlinkListApplicationDeployments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkListApplicationDeployments_Call) Return(deploymentOuts []flinkapplicationdeployment.DeploymentOut, err error) *MockClient_ServiceFlinkListApplicationDeployments_Call {
	_c.Call.Return(deploymentOuts, err)
	return _c
}

func (_c *MockClient_ServiceFlinkListApplicationDeployments_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string) ([]flinkapplicationdeployment.DeploymentOut, error)) *MockClient_ServiceFlinkListApplicationDeployments_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkListApplications provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkListApplications(ctx context.Context, project1 string, serviceName string) ([]flinkapplication.ApplicationOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []flinkapplication.ApplicationOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]flinkapplication.ApplicationOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []flinkapplication.ApplicationOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]flinkapplication.ApplicationOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkListApplications is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceFlinkListApplications(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceFlinkListApplications_Call {
	return &MockClient_ServiceFlinkListApplications_Call{Call: _e.mock.On("ServiceFlinkListApplications", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceFlinkListApplications_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceFlinkListApplications_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkListApplications_Call) Return(applicationOuts []flinkapplication.ApplicationOut, err error) *MockClient_ServiceFlinkListApplications_Call {
	_c.Call.Return(applicationOuts, err)
	return _c
}

func (_c *MockClient_ServiceFlinkListApplications_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]flinkapplication.ApplicationOut, error)) *MockClient_ServiceFlinkListApplications_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkListJarApplicationDeployments provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkListJarApplicationDeployments(ctx context.Context, project1 string, serviceName string, applicationId string) ([]flinkjarapplicationdeployment.DeploymentOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId)

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

	var r0 []flinkjarapplicationdeployment.DeploymentOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) ([]flinkjarapplicationdeployment.DeploymentOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) []flinkjarapplicationdeployment.DeploymentOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]flinkjarapplicationdeployment.DeploymentOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkListJarApplicationDeployments is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
func (_e *MockClient_Expecter) ServiceFlinkListJarApplicationDeployments(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}) *MockClient_ServiceFlinkListJarApplicationDeployments_Call {
	return &MockClient_ServiceFlinkListJarApplicationDeployments_Call{Call: _e.mock.On("ServiceFlinkListJarApplicationDeployments", ctx, project1, serviceName, applicationId)}
}

func (_c *MockClient_ServiceFlinkListJarApplicationDeployments_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string)) *MockClient_ServiceFlinkListJarApplicationDeployments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkListJarApplicationDeployments_Call) Return(deploymentOuts []flinkjarapplicationdeployment.DeploymentOut, err error) *MockClient_ServiceFlinkListJarApplicationDeployments_Call {
	_c.Call.Return(deploymentOuts, err)
	return _c
}

func (_c *MockClient_ServiceFlinkListJarApplicationDeployments_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string) ([]flinkjarapplicationdeployment.DeploymentOut, error)) *MockClient_ServiceFlinkListJarApplicationDeployments_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkListJarApplications provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkListJarApplications(ctx context.Context, project1 string, serviceName string) ([]flinkjarapplication.ApplicationOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []flinkjarapplication.ApplicationOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]flinkjarapplication.ApplicationOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []flinkjarapplication.ApplicationOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]flinkjarapplication.ApplicationOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkListJarApplications is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceFlinkListJarApplications(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceFlinkListJarApplications_Call {
	return &MockClient_ServiceFlinkListJarApplications_Call{Call: _e.mock.On("ServiceFlinkListJarApplications", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceFlinkListJarApplications_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceFlinkListJarApplications_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkListJarApplications_Call) Return(applicationOuts []flinkjarapplication.ApplicationOut, err error) *MockClient_ServiceFlinkListJarApplications_Call {
	_c.Call.Return(applicationOuts, err)
	return _c
}

func (_c *MockClient_ServiceFlinkListJarApplications_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]flinkjarapplication.ApplicationOut, error)) *MockClient_ServiceFlinkListJarApplications_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkOverview provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkOverview(ctx context.Context, project1 string, serviceName string) (*flink.ServiceFlinkOverviewOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 *flink.ServiceFlinkOverviewOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*flink.ServiceFlinkOverviewOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *flink.ServiceFlinkOverviewOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flink.ServiceFlinkOverviewOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkOverview is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceFlinkOverview(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceFlinkOverview_Call {
	return &MockClient_ServiceFlinkOverview_Call{Call: _e.mock.On("ServiceFlinkOverview", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceFlinkOverview_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceFlinkOverview_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkOverview_Call) Return(serviceFlinkOverviewOut *flink.ServiceFlinkOverviewOut, err error) *MockClient_ServiceFlinkOverview_Call {
	_c.Call.Return(serviceFlinkOverviewOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkOverview_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) (*flink.ServiceFlinkOverviewOut, error)) *MockClient_ServiceFlinkOverview_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkStopApplicationDeployment provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkStopApplicationDeployment(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string) (*flinkapplicationdeployment.ServiceFlinkStopApplicationDeploymentOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId, deploymentId)

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

	var r0 *flinkapplicationdeployment.ServiceFlinkStopApplicationDeploymentOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (*flinkapplicationdeployment.ServiceFlinkStopApplicationDeploymentOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) *flinkapplicationdeployment.ServiceFlinkStopApplicationDeploymentOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkapplicationdeployment.ServiceFlinkStopApplicationDeploymentOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkStopApplicationDeployment is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
//   - deploymentId
func (_e *MockClient_Expecter) ServiceFlinkStopApplicationDeployment(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}, deploymentId interface{}) *MockClient_ServiceFlinkStopApplicationDeployment_Call {
	return &MockClient_ServiceFlinkStopApplicationDeployment_Call{Call: _e.mock.On("ServiceFlinkStopApplicationDeployment", ctx, project1, serviceName, applicationId, deploymentId)}
}

func (_c *MockClient_ServiceFlinkStopApplicationDeployment_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string)) *MockClient_ServiceFlinkStopApplicationDeployment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkStopApplicationDeployment_Call) Return(serviceFlinkStopApplicationDeploymentOut *flinkapplicationdeployment.ServiceFlinkStopApplicationDeploymentOut, err error) *MockClient_ServiceFlinkStopApplicationDeployment_Call {
	_c.Call.Return(serviceFlinkStopApplicationDeploymentOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkStopApplicationDeployment_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string) (*flinkapplicationdeployment.ServiceFlinkStopApplicationDeploymentOut, error)) *MockClient_ServiceFlinkStopApplicationDeployment_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkStopJarApplicationDeployment provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkStopJarApplicationDeployment(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string) (*flinkjarapplicationdeployment.ServiceFlinkStopJarApplicationDeploymentOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId, deploymentId)

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

	var r0 *flinkjarapplicationdeployment.ServiceFlinkStopJarApplicationDeploymentOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (*flinkjarapplicationdeployment.ServiceFlinkStopJarApplicationDeploymentOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) *flinkjarapplicationdeployment.ServiceFlinkStopJarApplicationDeploymentOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkjarapplicationdeployment.ServiceFlinkStopJarApplicationDeploymentOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId, deploymentId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkStopJarApplicationDeployment is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
//   - deploymentId
func (_e *MockClient_Expecter) ServiceFlinkStopJarApplicationDeployment(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}, deploymentId interface{}) *MockClient_ServiceFlinkStopJarApplicationDeployment_Call {
	return &MockClient_ServiceFlinkStopJarApplicationDeployment_Call{Call: _e.mock.On("ServiceFlinkStopJarApplicationDeployment", ctx, project1, serviceName, applicationId, deploymentId)}
}

func (_c *MockClient_ServiceFlinkStopJarApplicationDeployment_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string)) *MockClient_ServiceFlinkStopJarApplicationDeployment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkStopJarApplicationDeployment_Call) Return(serviceFlinkStopJarApplicationDeploymentOut *flinkjarapplicationdeployment.ServiceFlinkStopJarApplicationDeploymentOut, err error) *MockClient_ServiceFlinkStopJarApplicationDeployment_Call {
	_c.Call.Return(serviceFlinkStopJarApplicationDeploymentOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkStopJarApplicationDeployment_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string, deploymentId string) (*flinkjarapplicationdeployment.ServiceFlinkStopJarApplicationDeploymentOut, error)) *MockClient_ServiceFlinkStopJarApplicationDeployment_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkUpdateApplication provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkUpdateApplication(ctx context.Context, project1 string, serviceName string, applicationId string, in *flinkapplication.ServiceFlinkUpdateApplicationIn) (*flinkapplication.ServiceFlinkUpdateApplicationOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId, in)

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

	var r0 *flinkapplication.ServiceFlinkUpdateApplicationOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *flinkapplication.ServiceFlinkUpdateApplicationIn) (*flinkapplication.ServiceFlinkUpdateApplicationOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *flinkapplication.ServiceFlinkUpdateApplicationIn) *flinkapplication.ServiceFlinkUpdateApplicationOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkapplication.ServiceFlinkUpdateApplicationOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, *flinkapplication.ServiceFlinkUpdateApplicationIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkUpdateApplication is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
//   - in
func (_e *MockClient_Expecter) ServiceFlinkUpdateApplication(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}, in interface{}) *MockClient_ServiceFlinkUpdateApplication_Call {
	return &MockClient_ServiceFlinkUpdateApplication_Call{Call: _e.mock.On("ServiceFlinkUpdateApplication", ctx, project1, serviceName, applicationId, in)}
}

func (_c *MockClient_ServiceFlinkUpdateApplication_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string, in *flinkapplication.ServiceFlinkUpdateApplicationIn)) *MockClient_ServiceFlinkUpdateApplication_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*flinkapplication.ServiceFlinkUpdateApplicationIn))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkUpdateApplication_Call) Return(serviceFlinkUpdateApplicationOut *flinkapplication.ServiceFlinkUpdateApplicationOut, err error) *MockClient_ServiceFlinkUpdateApplication_Call {
	_c.Call.Return(serviceFlinkUpdateApplicationOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkUpdateApplication_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string, in *flinkapplication.ServiceFlinkUpdateApplicationIn) (*flinkapplication.ServiceFlinkUpdateApplicationOut, error)) *MockClient_ServiceFlinkUpdateApplication_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkUpdateJarApplication provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkUpdateJarApplication(ctx context.Context, project1 string, serviceName string, applicationId string, in *flinkjarapplication.ServiceFlinkUpdateJarApplicationIn) (*flinkjarapplication.ServiceFlinkUpdateJarApplicationOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId, in)

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

	var r0 *flinkjarapplication.ServiceFlinkUpdateJarApplicationOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *flinkjarapplication.ServiceFlinkUpdateJarApplicationIn) (*flinkjarapplication.ServiceFlinkUpdateJarApplicationOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *flinkjarapplication.ServiceFlinkUpdateJarApplicationIn) *flinkjarapplication.ServiceFlinkUpdateJarApplicationOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkjarapplication.ServiceFlinkUpdateJarApplicationOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, *flinkjarapplication.ServiceFlinkUpdateJarApplicationIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkUpdateJarApplication is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
//   - in
func (_e *MockClient_Expecter) ServiceFlinkUpdateJarApplication(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}, in interface{}) *MockClient_ServiceFlinkUpdateJarApplication_Call {
	return &MockClient_ServiceFlinkUpdateJarApplication_Call{Call: _e.mock.On("ServiceFlinkUpdateJarApplication", ctx, project1, serviceName, applicationId, in)}
}

func (_c *MockClient_ServiceFlinkUpdateJarApplication_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string, in *flinkjarapplication.ServiceFlinkUpdateJarApplicationIn)) *MockClient_ServiceFlinkUpdateJarApplication_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*flinkjarapplication.ServiceFlinkUpdateJarApplicationIn))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkUpdateJarApplication_Call) Return(serviceFlinkUpdateJarApplicationOut *flinkjarapplication.ServiceFlinkUpdateJarApplicationOut, err error) *MockClient_ServiceFlinkUpdateJarApplication_Call {
	_c.Call.Return(serviceFlinkUpdateJarApplicationOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkUpdateJarApplication_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string, in *flinkjarapplication.ServiceFlinkUpdateJarApplicationIn) (*flinkjarapplication.ServiceFlinkUpdateJarApplicationOut, error)) *MockClient_ServiceFlinkUpdateJarApplication_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceFlinkValidateApplicationVersion provides a mock function for the type MockClient
func (_mock *MockClient) ServiceFlinkValidateApplicationVersion(ctx context.Context, project1 string, serviceName string, applicationId string, in *flinkapplicationversion.ServiceFlinkValidateApplicationVersionIn) (*flinkapplicationversion.ServiceFlinkValidateApplicationVersionOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, applicationId, in)

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

	var r0 *flinkapplicationversion.ServiceFlinkValidateApplicationVersionOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *flinkapplicationversion.ServiceFlinkValidateApplicationVersionIn) (*flinkapplicationversion.ServiceFlinkValidateApplicationVersionOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, applicationId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *flinkapplicationversion.ServiceFlinkValidateApplicationVersionIn) *flinkapplicationversion.ServiceFlinkValidateApplicationVersionOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, applicationId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*flinkapplicationversion.ServiceFlinkValidateApplicationVersionOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, *flinkapplicationversion.ServiceFlinkValidateApplicationVersionIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, applicationId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceFlinkValidateApplicationVersion is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - applicationId
//   - in
func (_e *MockClient_Expecter) ServiceFlinkValidateApplicationVersion(ctx interface{}, project1 interface{}, serviceName interface{}, applicationId interface{}, in interface{}) *MockClient_ServiceFlinkValidateApplicationVersion_Call {
	return &MockClient_ServiceFlinkValidateApplicationVersion_Call{Call: _e.mock.On("ServiceFlinkValidateApplicationVersion", ctx, project1, serviceName, applicationId, in)}
}

func (_c *MockClient_ServiceFlinkValidateApplicationVersion_Call) Run(run func(ctx context.Context, project1 string, serviceName string, applicationId string, in *flinkapplicationversion.ServiceFlinkValidateApplicationVersionIn)) *MockClient_ServiceFlinkValidateApplicationVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*flinkapplicationversion.ServiceFlinkValidateApplicationVersionIn))
	})
	return _c
}

func (_c *MockClient_ServiceFlinkValidateApplicationVersion_Call) Return(serviceFlinkValidateApplicationVersionOut *flinkapplicationversion.ServiceFlinkValidateApplicationVersionOut, err error) *MockClient_ServiceFlinkValidateApplicationVersion_Call {
	_c.Call.Return(serviceFlinkValidateApplicationVersionOut, err)
	return _c
}

func (_c *MockClient_ServiceFlinkValidateApplicationVersion_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, applicationId string, in *flinkapplicationversion.ServiceFlinkValidateApplicationVersionIn) (*flinkapplicationversion.ServiceFlinkValidateApplicationVersionOut, error)) *MockClient_ServiceFlinkValidateApplicationVersion_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceGet provides a mock function for the type MockClient
func (_mock *MockClient) ServiceGet(ctx context.Context, project1 string, serviceName string, query ...[2]string) (*service.ServiceGetOut, error) {
	var tmpRet mock.Arguments
	if len(query) > 0 {
		tmpRet = _mock.Called(ctx, project1, serviceName, query)
	} else {
		tmpRet = _mock.Called(ctx, project1, serviceName)
	}
	ret := tmpRet

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

	var r0 *service.ServiceGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, ...[2]string) (*service.ServiceGetOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, query...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, ...[2]string) *service.ServiceGetOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, query...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ServiceGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, ...[2]string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, query...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - query
func (_e *MockClient_Expecter) ServiceGet(ctx interface{}, project1 interface{}, serviceName interface{}, query ...interface{}) *MockClient_ServiceGet_Call {
	return &MockClient_ServiceGet_Call{Call: _e.mock.On("ServiceGet",
		append([]interface{}{ctx, project1, serviceName}, query...)...)}
}

func (_c *MockClient_ServiceGet_Call) Run(run func(ctx context.Context, project1 string, serviceName string, query ...[2]string)) *MockClient_ServiceGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := args[3].([][2]string)
		run(args[0].(context.Context), args[1].(string), args[2].(string), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_ServiceGet_Call) Return(serviceGetOut *service.ServiceGetOut, err error) *MockClient_ServiceGet_Call {
	_c.Call.Return(serviceGetOut, err)
	return _c
}

func (_c *MockClient_ServiceGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, query ...[2]string) (*service.ServiceGetOut, error)) *MockClient_ServiceGet_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceGetMigrationStatus provides a mock function for the type MockClient
func (_mock *MockClient) ServiceGetMigrationStatus(ctx context.Context, project1 string, serviceName string) (*service.ServiceGetMigrationStatusOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 *service.ServiceGetMigrationStatusOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*service.ServiceGetMigrationStatusOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *service.ServiceGetMigrationStatusOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ServiceGetMigrationStatusOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceGetMigrationStatus is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceGetMigrationStatus(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceGetMigrationStatus_Call {
	return &MockClient_ServiceGetMigrationStatus_Call{Call: _e.mock.On("ServiceGetMigrationStatus", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceGetMigrationStatus_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceGetMigrationStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceGetMigrationStatus_Call) Return(serviceGetMigrationStatusOut *service.ServiceGetMigrationStatusOut, err error) *MockClient_ServiceGetMigrationStatus_Call {
	_c.Call.Return(serviceGetMigrationStatusOut, err)
	return _c
}

func (_c *MockClient_ServiceGetMigrationStatus_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) (*service.ServiceGetMigrationStatusOut, error)) *MockClient_ServiceGetMigrationStatus_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceIntegrationCreate provides a mock function for the type MockClient
func (_mock *MockClient) ServiceIntegrationCreate(ctx context.Context, project1 string, in *service.ServiceIntegrationCreateIn) (*service.ServiceIntegrationCreateOut, error) {
	ret := _mock.Called(ctx, project1, in)

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

	var r0 *service.ServiceIntegrationCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *service.ServiceIntegrationCreateIn) (*service.ServiceIntegrationCreateOut, error)); ok {
		return returnFunc(ctx, project1, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *service.ServiceIntegrationCreateIn) *service.ServiceIntegrationCreateOut); ok {
		r0 = returnFunc(ctx, project1, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ServiceIntegrationCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *service.ServiceIntegrationCreateIn) error); ok {
		r1 = returnFunc(ctx, project1, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceIntegrationCreate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - in
func (_e *MockClient_Expecter) ServiceIntegrationCreate(ctx interface{}, project1 interface{}, in interface{}) *MockClient_ServiceIntegrationCreate_Call {
	return &MockClient_ServiceIntegrationCreate_Call{Call: _e.mock.On("ServiceIntegrationCreate", ctx, project1, in)}
}

func (_c *MockClient_ServiceIntegrationCreate_Call) Run(run func(ctx context.Context, project1 string, in *service.ServiceIntegrationCreateIn)) *MockClient_ServiceIntegrationCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*service.ServiceIntegrationCreateIn))
	})
	return _c
}

func (_c *MockClient_ServiceIntegrationCreate_Call) Return(serviceIntegrationCreateOut *service.ServiceIntegrationCreateOut, err error) *MockClient_ServiceIntegrationCreate_Call {
	_c.Call.Return(serviceIntegrationCreateOut, err)
	return _c
}

func (_c *MockClient_ServiceIntegrationCreate_Call) RunAndReturn(run func(ctx context.Context, project1 string, in *service.ServiceIntegrationCreateIn) (*service.ServiceIntegrationCreateOut, error)) *MockClient_ServiceIntegrationCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceIntegrationDelete provides a mock function for the type MockClient
func (_mock *MockClient) ServiceIntegrationDelete(ctx context.Context, project1 string, integrationId string) error {
	ret := _mock.Called(ctx, project1, integrationId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, project1, integrationId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceIntegrationDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - integrationId
func (_e *MockClient_Expecter) ServiceIntegrationDelete(ctx interface{}, project1 interface{}, integrationId interface{}) *MockClient_ServiceIntegrationDelete_Call {
	return &MockClient_ServiceIntegrationDelete_Call{Call: _e.mock.On("ServiceIntegrationDelete", ctx, project1, integrationId)}
}

func (_c *MockClient_ServiceIntegrationDelete_Call) Run(run func(ctx context.Context, project1 string, integrationId string)) *MockClient_ServiceIntegrationDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceIntegrationDelete_Call) Return(err error) *MockClient_ServiceIntegrationDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceIntegrationDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, integrationId string) error) *MockClient_ServiceIntegrationDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceIntegrationEndpointCreate provides a mock function for the type MockClient
func (_mock *MockClient) ServiceIntegrationEndpointCreate(ctx context.Context, project1 string, in *service.ServiceIntegrationEndpointCreateIn) (*service.ServiceIntegrationEndpointCreateOut, error) {
	ret := _mock.Called(ctx, project1, in)

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

	var r0 *service.ServiceIntegrationEndpointCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *service.ServiceIntegrationEndpointCreateIn) (*service.ServiceIntegrationEndpointCreateOut, error)); ok {
		return returnFunc(ctx, project1, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *service.ServiceIntegrationEndpointCreateIn) *service.ServiceIntegrationEndpointCreateOut); ok {
		r0 = returnFunc(ctx, project1, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ServiceIntegrationEndpointCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *service.ServiceIntegrationEndpointCreateIn) error); ok {
		r1 = returnFunc(ctx, project1, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceIntegrationEndpointCreate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - in
func (_e *MockClient_Expecter) ServiceIntegrationEndpointCreate(ctx interface{}, project1 interface{}, in interface{}) *MockClient_ServiceIntegrationEndpointCreate_Call {
	return &MockClient_ServiceIntegrationEndpointCreate_Call{Call: _e.mock.On("ServiceIntegrationEndpointCreate", ctx, project1, in)}
}

func (_c *MockClient_ServiceIntegrationEndpointCreate_Call) Run(run func(ctx context.Context, project1 string, in *service.ServiceIntegrationEndpointCreateIn)) *MockClient_ServiceIntegrationEndpointCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*service.ServiceIntegrationEndpointCreateIn))
	})
	return _c
}

func (_c *MockClient_ServiceIntegrationEndpointCreate_Call) Return(serviceIntegrationEndpointCreateOut *service.ServiceIntegrationEndpointCreateOut, err error) *MockClient_ServiceIntegrationEndpointCreate_Call {
	_c.Call.Return(serviceIntegrationEndpointCreateOut, err)
	return _c
}

func (_c *MockClient_ServiceIntegrationEndpointCreate_Call) RunAndReturn(run func(ctx context.Context, project1 string, in *service.ServiceIntegrationEndpointCreateIn) (*service.ServiceIntegrationEndpointCreateOut, error)) *MockClient_ServiceIntegrationEndpointCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceIntegrationEndpointDelete provides a mock function for the type MockClient
func (_mock *MockClient) ServiceIntegrationEndpointDelete(ctx context.Context, project1 string, integrationEndpointId string) error {
	ret := _mock.Called(ctx, project1, integrationEndpointId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, project1, integrationEndpointId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceIntegrationEndpointDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - integrationEndpointId
func (_e *MockClient_Expecter) ServiceIntegrationEndpointDelete(ctx interface{}, project1 interface{}, integrationEndpointId interface{}) *MockClient_ServiceIntegrationEndpointDelete_Call {
	return &MockClient_ServiceIntegrationEndpointDelete_Call{Call: _e.mock.On("ServiceIntegrationEndpointDelete", ctx, project1, integrationEndpointId)}
}

func (_c *MockClient_ServiceIntegrationEndpointDelete_Call) Run(run func(ctx context.Context, project1 string, integrationEndpointId string)) *MockClient_ServiceIntegrationEndpointDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceIntegrationEndpointDelete_Call) Return(err error) *MockClient_ServiceIntegrationEndpointDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceIntegrationEndpointDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, integrationEndpointId string) error) *MockClient_ServiceIntegrationEndpointDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceIntegrationEndpointGet provides a mock function for the type MockClient
func (_mock *MockClient) ServiceIntegrationEndpointGet(ctx context.Context, project1 string, integrationEndpointId string, query ...[2]string) (*service.ServiceIntegrationEndpointGetOut, error) {
	var tmpRet mock.Arguments
	if len(query) > 0 {
		tmpRet = _mock.Called(ctx, project1, integrationEndpointId, query)
	} else {
		tmpRet = _mock.Called(ctx, project1, integrationEndpointId)
	}
	ret := tmpRet

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

	var r0 *service.ServiceIntegrationEndpointGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, ...[2]string) (*service.ServiceIntegrationEndpointGetOut, error)); ok {
		return returnFunc(ctx, project1, integrationEndpointId, query...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, ...[2]string) *service.ServiceIntegrationEndpointGetOut); ok {
		r0 = returnFunc(ctx, project1, integrationEndpointId, query...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ServiceIntegrationEndpointGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, ...[2]string) error); ok {
		r1 = returnFunc(ctx, project1, integrationEndpointId, query...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceIntegrationEndpointGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - integrationEndpointId
//   - query
func (_e *MockClient_Expecter) ServiceIntegrationEndpointGet(ctx interface{}, project1 interface{}, integrationEndpointId interface{}, query ...interface{}) *MockClient_ServiceIntegrationEndpointGet_Call {
	return &MockClient_ServiceIntegrationEndpointGet_Call{Call: _e.mock.On("ServiceIntegrationEndpointGet",
		append([]interface{}{ctx, project1, integrationEndpointId}, query...)...)}
}

func (_c *MockClient_ServiceIntegrationEndpointGet_Call) Run(run func(ctx context.Context, project1 string, integrationEndpointId string, query ...[2]string)) *MockClient_ServiceIntegrationEndpointGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := args[3].([][2]string)
		run(args[0].(context.Context), args[1].(string), args[2].(string), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_ServiceIntegrationEndpointGet_Call) Return(serviceIntegrationEndpointGetOut *service.ServiceIntegrationEndpointGetOut, err error) *MockClient_ServiceIntegrationEndpointGet_Call {
	_c.Call.Return(serviceIntegrationEndpointGetOut, err)
	return _c
}

func (_c *MockClient_ServiceIntegrationEndpointGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, integrationEndpointId string, query ...[2]string) (*service.ServiceIntegrationEndpointGetOut, error)) *MockClient_ServiceIntegrationEndpointGet_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceIntegrationEndpointList provides a mock function for the type MockClient
func (_mock *MockClient) ServiceIntegrationEndpointList(ctx context.Context, project1 string) ([]service.ServiceIntegrationEndpointOut, error) {
	ret := _mock.Called(ctx, project1)

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

	var r0 []service.ServiceIntegrationEndpointOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]service.ServiceIntegrationEndpointOut, error)); ok {
		return returnFunc(ctx, project1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []service.ServiceIntegrationEndpointOut); ok {
		r0 = returnFunc(ctx, project1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]service.ServiceIntegrationEndpointOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, project1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceIntegrationEndpointList is a helper method to define mock.On call
//   - ctx
//   - project1
func (_e *MockClient_Expecter) ServiceIntegrationEndpointList(ctx interface{}, project1 interface{}) *MockClient_ServiceIntegrationEndpointList_Call {
	return &MockClient_ServiceIntegrationEndpointList_Call{Call: _e.mock.On("ServiceIntegrationEndpointList", ctx, project1)}
}

func (_c *MockClient_ServiceIntegrationEndpointList_Call) Run(run func(ctx context.Context, project1 string)) *MockClient_ServiceIntegrationEndpointList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ServiceIntegrationEndpointList_Call) Return(serviceIntegrationEndpointOuts []service.ServiceIntegrationEndpointOut, err error) *MockClient_ServiceIntegrationEndpointList_Call {
	_c.Call.Return(serviceIntegrationEndpointOuts, err)
	return _c
}

func (_c *MockClient_ServiceIntegrationEndpointList_Call) RunAndReturn(run func(ctx context.Context, project1 string) ([]service.ServiceIntegrationEndpointOut, error)) *MockClient_ServiceIntegrationEndpointList_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceIntegrationEndpointTypes provides a mock function for the type MockClient
func (_mock *MockClient) ServiceIntegrationEndpointTypes(ctx context.Context, project1 string) ([]service.EndpointTypeOut, error) {
	ret := _mock.Called(ctx, project1)

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

	var r0 []service.EndpointTypeOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]service.EndpointTypeOut, error)); ok {
		return returnFunc(ctx, project1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []service.EndpointTypeOut); ok {
		r0 = returnFunc(ctx, project1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]service.EndpointTypeOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, project1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceIntegrationEndpointTypes is a helper method to define mock.On call
//   - ctx
//   - project1
func (_e *MockClient_Expecter) ServiceIntegrationEndpointTypes(ctx interface{}, project1 interface{}) *MockClient_ServiceIntegrationEndpointTypes_Call {
	return &MockClient_ServiceIntegrationEndpointTypes_Call{Call: _e.mock.On("ServiceIntegrationEndpointTypes", ctx, project1)}
}

func (_c *MockClient_ServiceIntegrationEndpointTypes_Call) Run(run func(ctx context.Context, project1 string)) *MockClient_ServiceIntegrationEndpointTypes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ServiceIntegrationEndpointTypes_Call) Return(endpointTypeOuts []service.EndpointTypeOut, err error) *MockClient_ServiceIntegrationEndpointTypes_Call {
	_c.Call.Return(endpointTypeOuts, err)
	return _c
}

func (_c *MockClient_ServiceIntegrationEndpointTypes_Call) RunAndReturn(run func(ctx context.Context, project1 string) ([]service.EndpointTypeOut, error)) *MockClient_ServiceIntegrationEndpointTypes_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceIntegrationEndpointUpdate provides a mock function for the type MockClient
func (_mock *MockClient) ServiceIntegrationEndpointUpdate(ctx context.Context, project1 string, integrationEndpointId string, in *service.ServiceIntegrationEndpointUpdateIn) (*service.ServiceIntegrationEndpointUpdateOut, error) {
	ret := _mock.Called(ctx, project1, integrationEndpointId, in)

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

	var r0 *service.ServiceIntegrationEndpointUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ServiceIntegrationEndpointUpdateIn) (*service.ServiceIntegrationEndpointUpdateOut, error)); ok {
		return returnFunc(ctx, project1, integrationEndpointId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ServiceIntegrationEndpointUpdateIn) *service.ServiceIntegrationEndpointUpdateOut); ok {
		r0 = returnFunc(ctx, project1, integrationEndpointId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ServiceIntegrationEndpointUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *service.ServiceIntegrationEndpointUpdateIn) error); ok {
		r1 = returnFunc(ctx, project1, integrationEndpointId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceIntegrationEndpointUpdate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - integrationEndpointId
//   - in
func (_e *MockClient_Expecter) ServiceIntegrationEndpointUpdate(ctx interface{}, project1 interface{}, integrationEndpointId interface{}, in interface{}) *MockClient_ServiceIntegrationEndpointUpdate_Call {
	return &MockClient_ServiceIntegrationEndpointUpdate_Call{Call: _e.mock.On("ServiceIntegrationEndpointUpdate", ctx, project1, integrationEndpointId, in)}
}

func (_c *MockClient_ServiceIntegrationEndpointUpdate_Call) Run(run func(ctx context.Context, project1 string, integrationEndpointId string, in *service.ServiceIntegrationEndpointUpdateIn)) *MockClient_ServiceIntegrationEndpointUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*service.ServiceIntegrationEndpointUpdateIn))
	})
	return _c
}

func (_c *MockClient_ServiceIntegrationEndpointUpdate_Call) Return(serviceIntegrationEndpointUpdateOut *service.ServiceIntegrationEndpointUpdateOut, err error) *MockClient_ServiceIntegrationEndpointUpdate_Call {
	_c.Call.Return(serviceIntegrationEndpointUpdateOut, err)
	return _c
}

func (_c *MockClient_ServiceIntegrationEndpointUpdate_Call) RunAndReturn(run func(ctx context.Context, project1 string, integrationEndpointId string, in *service.ServiceIntegrationEndpointUpdateIn) (*service.ServiceIntegrationEndpointUpdateOut, error)) *MockClient_ServiceIntegrationEndpointUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceIntegrationGet provides a mock function for the type MockClient
func (_mock *MockClient) ServiceIntegrationGet(ctx context.Context, project1 string, integrationId string) (*service.ServiceIntegrationGetOut, error) {
	ret := _mock.Called(ctx, project1, integrationId)

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

	var r0 *service.ServiceIntegrationGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*service.ServiceIntegrationGetOut, error)); ok {
		return returnFunc(ctx, project1, integrationId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *service.ServiceIntegrationGetOut); ok {
		r0 = returnFunc(ctx, project1, integrationId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ServiceIntegrationGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, integrationId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceIntegrationGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - integrationId
func (_e *MockClient_Expecter) ServiceIntegrationGet(ctx interface{}, project1 interface{}, integrationId interface{}) *MockClient_ServiceIntegrationGet_Call {
	return &MockClient_ServiceIntegrationGet_Call{Call: _e.mock.On("ServiceIntegrationGet", ctx, project1, integrationId)}
}

func (_c *MockClient_ServiceIntegrationGet_Call) Run(run func(ctx context.Context, project1 string, integrationId string)) *MockClient_ServiceIntegrationGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceIntegrationGet_Call) Return(serviceIntegrationGetOut *service.ServiceIntegrationGetOut, err error) *MockClient_ServiceIntegrationGet_Call {
	_c.Call.Return(serviceIntegrationGetOut, err)
	return _c
}

func (_c *MockClient_ServiceIntegrationGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, integrationId string) (*service.ServiceIntegrationGetOut, error)) *MockClient_ServiceIntegrationGet_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceIntegrationList provides a mock function for the type MockClient
func (_mock *MockClient) ServiceIntegrationList(ctx context.Context, project1 string, serviceName string) ([]service.ServiceIntegrationOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []service.ServiceIntegrationOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]service.ServiceIntegrationOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []service.ServiceIntegrationOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]service.ServiceIntegrationOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceIntegrationList is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceIntegrationList(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceIntegrationList_Call {
	return &MockClient_ServiceIntegrationList_Call{Call: _e.mock.On("ServiceIntegrationList", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceIntegrationList_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceIntegrationList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceIntegrationList_Call) Return(serviceIntegrationOuts []service.ServiceIntegrationOut, err error) *MockClient_ServiceIntegrationList_Call {
	_c.Call.Return(serviceIntegrationOuts, err)
	return _c
}

func (_c *MockClient_ServiceIntegrationList_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]service.ServiceIntegrationOut, error)) *MockClient_ServiceIntegrationList_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceIntegrationTypes provides a mock function for the type MockClient
func (_mock *MockClient) ServiceIntegrationTypes(ctx context.Context, project1 string) ([]service.IntegrationTypeOut, error) {
	ret := _mock.Called(ctx, project1)

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

	var r0 []service.IntegrationTypeOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]service.IntegrationTypeOut, error)); ok {
		return returnFunc(ctx, project1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []service.IntegrationTypeOut); ok {
		r0 = returnFunc(ctx, project1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]service.IntegrationTypeOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, project1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceIntegrationTypes is a helper method to define mock.On call
//   - ctx
//   - project1
func (_e *MockClient_Expecter) ServiceIntegrationTypes(ctx interface{}, project1 interface{}) *MockClient_ServiceIntegrationTypes_Call {
	return &MockClient_ServiceIntegrationTypes_Call{Call: _e.mock.On("ServiceIntegrationTypes", ctx, project1)}
}

func (_c *MockClient_ServiceIntegrationTypes_Call) Run(run func(ctx context.Context, project1 string)) *MockClient_ServiceIntegrationTypes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ServiceIntegrationTypes_Call) Return(integrationTypeOuts []service.IntegrationTypeOut, err error) *MockClient_ServiceIntegrationTypes_Call {
	_c.Call.Return(integrationTypeOuts, err)
	return _c
}

func (_c *MockClient_ServiceIntegrationTypes_Call) RunAndReturn(run func(ctx context.Context, project1 string) ([]service.IntegrationTypeOut, error)) *MockClient_ServiceIntegrationTypes_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceIntegrationUpdate provides a mock function for the type MockClient
func (_mock *MockClient) ServiceIntegrationUpdate(ctx context.Context, project1 string, integrationId string, in *service.ServiceIntegrationUpdateIn) (*service.ServiceIntegrationUpdateOut, error) {
	ret := _mock.Called(ctx, project1, integrationId, in)

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

	var r0 *service.ServiceIntegrationUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ServiceIntegrationUpdateIn) (*service.ServiceIntegrationUpdateOut, error)); ok {
		return returnFunc(ctx, project1, integrationId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ServiceIntegrationUpdateIn) *service.ServiceIntegrationUpdateOut); ok {
		r0 = returnFunc(ctx, project1, integrationId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ServiceIntegrationUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *service.ServiceIntegrationUpdateIn) error); ok {
		r1 = returnFunc(ctx, project1, integrationId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceIntegrationUpdate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - integrationId
//   - in
func (_e *MockClient_Expecter) ServiceIntegrationUpdate(ctx interface{}, project1 interface{}, integrationId interface{}, in interface{}) *MockClient_ServiceIntegrationUpdate_Call {
	return &MockClient_ServiceIntegrationUpdate_Call{Call: _e.mock.On("ServiceIntegrationUpdate", ctx, project1, integrationId, in)}
}

func (_c *MockClient_ServiceIntegrationUpdate_Call) Run(run func(ctx context.Context, project1 string, integrationId string, in *service.ServiceIntegrationUpdateIn)) *MockClient_ServiceIntegrationUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*service.ServiceIntegrationUpdateIn))
	})
	return _c
}

func (_c *MockClient_ServiceIntegrationUpdate_Call) Return(serviceIntegrationUpdateOut *service.ServiceIntegrationUpdateOut, err error) *MockClient_ServiceIntegrationUpdate_Call {
	_c.Call.Return(serviceIntegrationUpdateOut, err)
	return _c
}

func (_c *MockClient_ServiceIntegrationUpdate_Call) RunAndReturn(run func(ctx context.Context, project1 string, integrationId string, in *service.ServiceIntegrationUpdateIn) (*service.ServiceIntegrationUpdateOut, error)) *MockClient_ServiceIntegrationUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaAclAdd provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaAclAdd(ctx context.Context, project1 string, serviceName string, in *kafka.ServiceKafkaAclAddIn) ([]kafka.AclOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 []kafka.AclOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *kafka.ServiceKafkaAclAddIn) ([]kafka.AclOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *kafka.ServiceKafkaAclAddIn) []kafka.AclOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]kafka.AclOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *kafka.ServiceKafkaAclAddIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaAclAdd is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceKafkaAclAdd(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceKafkaAclAdd_Call {
	return &MockClient_ServiceKafkaAclAdd_Call{Call: _e.mock.On("ServiceKafkaAclAdd", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceKafkaAclAdd_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *kafka.ServiceKafkaAclAddIn)) *MockClient_ServiceKafkaAclAdd_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*kafka.ServiceKafkaAclAddIn))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaAclAdd_Call) Return(aclOuts []kafka.AclOut, err error) *MockClient_ServiceKafkaAclAdd_Call {
	_c.Call.Return(aclOuts, err)
	return _c
}

func (_c *MockClient_ServiceKafkaAclAdd_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *kafka.ServiceKafkaAclAddIn) ([]kafka.AclOut, error)) *MockClient_ServiceKafkaAclAdd_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaAclDelete provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaAclDelete(ctx context.Context, project1 string, serviceName string, kafkaAclId string) ([]kafka.AclOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, kafkaAclId)

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

	var r0 []kafka.AclOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) ([]kafka.AclOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, kafkaAclId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) []kafka.AclOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, kafkaAclId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]kafka.AclOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, kafkaAclId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaAclDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - kafkaAclId
func (_e *MockClient_Expecter) ServiceKafkaAclDelete(ctx interface{}, project1 interface{}, serviceName interface{}, kafkaAclId interface{}) *MockClient_ServiceKafkaAclDelete_Call {
	return &MockClient_ServiceKafkaAclDelete_Call{Call: _e.mock.On("ServiceKafkaAclDelete", ctx, project1, serviceName, kafkaAclId)}
}

func (_c *MockClient_ServiceKafkaAclDelete_Call) Run(run func(ctx context.Context, project1 string, serviceName string, kafkaAclId string)) *MockClient_ServiceKafkaAclDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaAclDelete_Call) Return(aclOuts []kafka.AclOut, err error) *MockClient_ServiceKafkaAclDelete_Call {
	_c.Call.Return(aclOuts, err)
	return _c
}

func (_c *MockClient_ServiceKafkaAclDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, kafkaAclId string) ([]kafka.AclOut, error)) *MockClient_ServiceKafkaAclDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaAclList provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaAclList(ctx context.Context, project1 string, serviceName string) ([]kafka.AclOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []kafka.AclOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]kafka.AclOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []kafka.AclOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]kafka.AclOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaAclList is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceKafkaAclList(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceKafkaAclList_Call {
	return &MockClient_ServiceKafkaAclList_Call{Call: _e.mock.On("ServiceKafkaAclList", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceKafkaAclList_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceKafkaAclList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaAclList_Call) Return(aclOuts []kafka.AclOut, err error) *MockClient_ServiceKafkaAclList_Call {
	_c.Call.Return(aclOuts, err)
	return _c
}

func (_c *MockClient_ServiceKafkaAclList_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]kafka.AclOut, error)) *MockClient_ServiceKafkaAclList_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaConnectCreateConnector provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaConnectCreateConnector(ctx context.Context, project1 string, serviceName string, in map[string]any) (*kafkaconnect.ServiceKafkaConnectCreateConnectorOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 *kafkaconnect.ServiceKafkaConnectCreateConnectorOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, map[string]any) (*kafkaconnect.ServiceKafkaConnectCreateConnectorOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, map[string]any) *kafkaconnect.ServiceKafkaConnectCreateConnectorOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*kafkaconnect.ServiceKafkaConnectCreateConnectorOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, map[string]any) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaConnectCreateConnector is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceKafkaConnectCreateConnector(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceKafkaConnectCreateConnector_Call {
	return &MockClient_ServiceKafkaConnectCreateConnector_Call{Call: _e.mock.On("ServiceKafkaConnectCreateConnector", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceKafkaConnectCreateConnector_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in map[string]any)) *MockClient_ServiceKafkaConnectCreateConnector_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(map[string]any))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaConnectCreateConnector_Call) Return(serviceKafkaConnectCreateConnectorOut *kafkaconnect.ServiceKafkaConnectCreateConnectorOut, err error) *MockClient_ServiceKafkaConnectCreateConnector_Call {
	_c.Call.Return(serviceKafkaConnectCreateConnectorOut, err)
	return _c
}

func (_c *MockClient_ServiceKafkaConnectCreateConnector_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in map[string]any) (*kafkaconnect.ServiceKafkaConnectCreateConnectorOut, error)) *MockClient_ServiceKafkaConnectCreateConnector_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaConnectDeleteConnector provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaConnectDeleteConnector(ctx context.Context, project1 string, serviceName string, connectorName string) error {
	ret := _mock.Called(ctx, project1, serviceName, connectorName)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, connectorName)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceKafkaConnectDeleteConnector is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - connectorName
func (_e *MockClient_Expecter) ServiceKafkaConnectDeleteConnector(ctx interface{}, project1 interface{}, serviceName interface{}, connectorName interface{}) *MockClient_ServiceKafkaConnectDeleteConnector_Call {
	return &MockClient_ServiceKafkaConnectDeleteConnector_Call{Call: _e.mock.On("ServiceKafkaConnectDeleteConnector", ctx, project1, serviceName, connectorName)}
}

func (_c *MockClient_ServiceKafkaConnectDeleteConnector_Call) Run(run func(ctx context.Context, project1 string, serviceName string, connectorName string)) *MockClient_ServiceKafkaConnectDeleteConnector_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaConnectDeleteConnector_Call) Return(err error) *MockClient_ServiceKafkaConnectDeleteConnector_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceKafkaConnectDeleteConnector_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, connectorName string) error) *MockClient_ServiceKafkaConnectDeleteConnector_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaConnectEditConnector provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaConnectEditConnector(ctx context.Context, project1 string, serviceName string, connectorName string, in map[string]any) (*kafkaconnect.ServiceKafkaConnectEditConnectorOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, connectorName, in)

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

	var r0 *kafkaconnect.ServiceKafkaConnectEditConnectorOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, map[string]any) (*kafkaconnect.ServiceKafkaConnectEditConnectorOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, connectorName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, map[string]any) *kafkaconnect.ServiceKafkaConnectEditConnectorOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, connectorName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*kafkaconnect.ServiceKafkaConnectEditConnectorOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, map[string]any) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, connectorName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaConnectEditConnector is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - connectorName
//   - in
func (_e *MockClient_Expecter) ServiceKafkaConnectEditConnector(ctx interface{}, project1 interface{}, serviceName interface{}, connectorName interface{}, in interface{}) *MockClient_ServiceKafkaConnectEditConnector_Call {
	return &MockClient_ServiceKafkaConnectEditConnector_Call{Call: _e.mock.On("ServiceKafkaConnectEditConnector", ctx, project1, serviceName, connectorName, in)}
}

func (_c *MockClient_ServiceKafkaConnectEditConnector_Call) Run(run func(ctx context.Context, project1 string, serviceName string, connectorName string, in map[string]any)) *MockClient_ServiceKafkaConnectEditConnector_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(map[string]any))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaConnectEditConnector_Call) Return(serviceKafkaConnectEditConnectorOut *kafkaconnect.ServiceKafkaConnectEditConnectorOut, err error) *MockClient_ServiceKafkaConnectEditConnector_Call {
	_c.Call.Return(serviceKafkaConnectEditConnectorOut, err)
	return _c
}

func (_c *MockClient_ServiceKafkaConnectEditConnector_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, connectorName string, in map[string]any) (*kafkaconnect.ServiceKafkaConnectEditConnectorOut, error)) *MockClient_ServiceKafkaConnectEditConnector_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaConnectGetAvailableConnectors provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaConnectGetAvailableConnectors(ctx context.Context, project1 string, serviceName string) ([]kafkaconnect.ServiceKafkaConnectGetAvailableConnectorsOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []kafkaconnect.ServiceKafkaConnectGetAvailableConnectorsOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]kafkaconnect.ServiceKafkaConnectGetAvailableConnectorsOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []kafkaconnect.ServiceKafkaConnectGetAvailableConnectorsOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]kafkaconnect.ServiceKafkaConnectGetAvailableConnectorsOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaConnectGetAvailableConnectors is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceKafkaConnectGetAvailableConnectors(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceKafkaConnectGetAvailableConnectors_Call {
	return &MockClient_ServiceKafkaConnectGetAvailableConnectors_Call{Call: _e.mock.On("ServiceKafkaConnectGetAvailableConnectors", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceKafkaConnectGetAvailableConnectors_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceKafkaConnectGetAvailableConnectors_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaConnectGetAvailableConnectors_Call) Return(serviceKafkaConnectGetAvailableConnectorsOuts []kafkaconnect.ServiceKafkaConnectGetAvailableConnectorsOut, err error) *MockClient_ServiceKafkaConnectGetAvailableConnectors_Call {
	_c.Call.Return(serviceKafkaConnectGetAvailableConnectorsOuts, err)
	return _c
}

func (_c *MockClient_ServiceKafkaConnectGetAvailableConnectors_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]kafkaconnect.ServiceKafkaConnectGetAvailableConnectorsOut, error)) *MockClient_ServiceKafkaConnectGetAvailableConnectors_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaConnectGetConnectorConfiguration provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaConnectGetConnectorConfiguration(ctx context.Context, project1 string, serviceName string, connectorName string) ([]kafkaconnect.ConfigurationSchemaOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, connectorName)

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

	var r0 []kafkaconnect.ConfigurationSchemaOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) ([]kafkaconnect.ConfigurationSchemaOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, connectorName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) []kafkaconnect.ConfigurationSchemaOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, connectorName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]kafkaconnect.ConfigurationSchemaOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, connectorName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaConnectGetConnectorConfiguration is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - connectorName
func (_e *MockClient_Expecter) ServiceKafkaConnectGetConnectorConfiguration(ctx interface{}, project1 interface{}, serviceName interface{}, connectorName interface{}) *MockClient_ServiceKafkaConnectGetConnectorConfiguration_Call {
	return &MockClient_ServiceKafkaConnectGetConnectorConfiguration_Call{Call: _e.mock.On("ServiceKafkaConnectGetConnectorConfiguration", ctx, project1, serviceName, connectorName)}
}

func (_c *MockClient_ServiceKafkaConnectGetConnectorConfiguration_Call) Run(run func(ctx context.Context, project1 string, serviceName string, connectorName string)) *MockClient_ServiceKafkaConnectGetConnectorConfiguration_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaConnectGetConnectorConfiguration_Call) Return(configurationSchemaOuts []kafkaconnect.ConfigurationSchemaOut, err error) *MockClient_ServiceKafkaConnectGetConnectorConfiguration_Call {
	_c.Call.Return(configurationSchemaOuts, err)
	return _c
}

func (_c *MockClient_ServiceKafkaConnectGetConnectorConfiguration_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, connectorName string) ([]kafkaconnect.ConfigurationSchemaOut, error)) *MockClient_ServiceKafkaConnectGetConnectorConfiguration_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaConnectGetConnectorStatus provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaConnectGetConnectorStatus(ctx context.Context, project1 string, serviceName string, connectorName string) (*kafkaconnect.ServiceKafkaConnectGetConnectorStatusOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, connectorName)

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

	var r0 *kafkaconnect.ServiceKafkaConnectGetConnectorStatusOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*kafkaconnect.ServiceKafkaConnectGetConnectorStatusOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, connectorName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *kafkaconnect.ServiceKafkaConnectGetConnectorStatusOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, connectorName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*kafkaconnect.ServiceKafkaConnectGetConnectorStatusOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, connectorName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaConnectGetConnectorStatus is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - connectorName
func (_e *MockClient_Expecter) ServiceKafkaConnectGetConnectorStatus(ctx interface{}, project1 interface{}, serviceName interface{}, connectorName interface{}) *MockClient_ServiceKafkaConnectGetConnectorStatus_Call {
	return &MockClient_ServiceKafkaConnectGetConnectorStatus_Call{Call: _e.mock.On("ServiceKafkaConnectGetConnectorStatus", ctx, project1, serviceName, connectorName)}
}

func (_c *MockClient_ServiceKafkaConnectGetConnectorStatus_Call) Run(run func(ctx context.Context, project1 string, serviceName string, connectorName string)) *MockClient_ServiceKafkaConnectGetConnectorStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaConnectGetConnectorStatus_Call) Return(serviceKafkaConnectGetConnectorStatusOut *kafkaconnect.ServiceKafkaConnectGetConnectorStatusOut, err error) *MockClient_ServiceKafkaConnectGetConnectorStatus_Call {
	_c.Call.Return(serviceKafkaConnectGetConnectorStatusOut, err)
	return _c
}

func (_c *MockClient_ServiceKafkaConnectGetConnectorStatus_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, connectorName string) (*kafkaconnect.ServiceKafkaConnectGetConnectorStatusOut, error)) *MockClient_ServiceKafkaConnectGetConnectorStatus_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaConnectList provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaConnectList(ctx context.Context, project1 string, serviceName string) ([]kafkaconnect.ConnectorOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []kafkaconnect.ConnectorOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]kafkaconnect.ConnectorOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []kafkaconnect.ConnectorOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]kafkaconnect.ConnectorOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaConnectList is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceKafkaConnectList(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceKafkaConnectList_Call {
	return &MockClient_ServiceKafkaConnectList_Call{Call: _e.mock.On("ServiceKafkaConnectList", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceKafkaConnectList_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceKafkaConnectList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaConnectList_Call) Return(connectorOuts []kafkaconnect.ConnectorOut, err error) *MockClient_ServiceKafkaConnectList_Call {
	_c.Call.Return(connectorOuts, err)
	return _c
}

func (_c *MockClient_ServiceKafkaConnectList_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]kafkaconnect.ConnectorOut, error)) *MockClient_ServiceKafkaConnectList_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaConnectPauseConnector provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaConnectPauseConnector(ctx context.Context, project1 string, serviceName string, connectorName string) error {
	ret := _mock.Called(ctx, project1, serviceName, connectorName)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, connectorName)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceKafkaConnectPauseConnector is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - connectorName
func (_e *MockClient_Expecter) ServiceKafkaConnectPauseConnector(ctx interface{}, project1 interface{}, serviceName interface{}, connectorName interface{}) *MockClient_ServiceKafkaConnectPauseConnector_Call {
	return &MockClient_ServiceKafkaConnectPauseConnector_Call{Call: _e.mock.On("ServiceKafkaConnectPauseConnector", ctx, project1, serviceName, connectorName)}
}

func (_c *MockClient_ServiceKafkaConnectPauseConnector_Call) Run(run func(ctx context.Context, project1 string, serviceName string, connectorName string)) *MockClient_ServiceKafkaConnectPauseConnector_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaConnectPauseConnector_Call) Return(err error) *MockClient_ServiceKafkaConnectPauseConnector_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceKafkaConnectPauseConnector_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, connectorName string) error) *MockClient_ServiceKafkaConnectPauseConnector_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaConnectRestartConnector provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaConnectRestartConnector(ctx context.Context, project1 string, serviceName string, connectorName string) error {
	ret := _mock.Called(ctx, project1, serviceName, connectorName)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, connectorName)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceKafkaConnectRestartConnector is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - connectorName
func (_e *MockClient_Expecter) ServiceKafkaConnectRestartConnector(ctx interface{}, project1 interface{}, serviceName interface{}, connectorName interface{}) *MockClient_ServiceKafkaConnectRestartConnector_Call {
	return &MockClient_ServiceKafkaConnectRestartConnector_Call{Call: _e.mock.On("ServiceKafkaConnectRestartConnector", ctx, project1, serviceName, connectorName)}
}

func (_c *MockClient_ServiceKafkaConnectRestartConnector_Call) Run(run func(ctx context.Context, project1 string, serviceName string, connectorName string)) *MockClient_ServiceKafkaConnectRestartConnector_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaConnectRestartConnector_Call) Return(err error) *MockClient_ServiceKafkaConnectRestartConnector_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceKafkaConnectRestartConnector_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, connectorName string) error) *MockClient_ServiceKafkaConnectRestartConnector_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaConnectRestartConnectorTask provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaConnectRestartConnectorTask(ctx context.Context, project1 string, serviceName string, connectorName string, taskId string) error {
	ret := _mock.Called(ctx, project1, serviceName, connectorName, taskId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, connectorName, taskId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceKafkaConnectRestartConnectorTask is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - connectorName
//   - taskId
func (_e *MockClient_Expecter) ServiceKafkaConnectRestartConnectorTask(ctx interface{}, project1 interface{}, serviceName interface{}, connectorName interface{}, taskId interface{}) *MockClient_ServiceKafkaConnectRestartConnectorTask_Call {
	return &MockClient_ServiceKafkaConnectRestartConnectorTask_Call{Call: _e.mock.On("ServiceKafkaConnectRestartConnectorTask", ctx, project1, serviceName, connectorName, taskId)}
}

func (_c *MockClient_ServiceKafkaConnectRestartConnectorTask_Call) Run(run func(ctx context.Context, project1 string, serviceName string, connectorName string, taskId string)) *MockClient_ServiceKafkaConnectRestartConnectorTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaConnectRestartConnectorTask_Call) Return(err error) *MockClient_ServiceKafkaConnectRestartConnectorTask_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceKafkaConnectRestartConnectorTask_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, connectorName string, taskId string) error) *MockClient_ServiceKafkaConnectRestartConnectorTask_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaConnectResumeConnector provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaConnectResumeConnector(ctx context.Context, project1 string, serviceName string, connectorName string) error {
	ret := _mock.Called(ctx, project1, serviceName, connectorName)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, connectorName)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceKafkaConnectResumeConnector is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - connectorName
func (_e *MockClient_Expecter) ServiceKafkaConnectResumeConnector(ctx interface{}, project1 interface{}, serviceName interface{}, connectorName interface{}) *MockClient_ServiceKafkaConnectResumeConnector_Call {
	return &MockClient_ServiceKafkaConnectResumeConnector_Call{Call: _e.mock.On("ServiceKafkaConnectResumeConnector", ctx, project1, serviceName, connectorName)}
}

func (_c *MockClient_ServiceKafkaConnectResumeConnector_Call) Run(run func(ctx context.Context, project1 string, serviceName string, connectorName string)) *MockClient_ServiceKafkaConnectResumeConnector_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaConnectResumeConnector_Call) Return(err error) *MockClient_ServiceKafkaConnectResumeConnector_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceKafkaConnectResumeConnector_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, connectorName string) error) *MockClient_ServiceKafkaConnectResumeConnector_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaMirrorMakerCreateReplicationFlow provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaMirrorMakerCreateReplicationFlow(ctx context.Context, project1 string, serviceName string, in *kafkamirrormaker.ServiceKafkaMirrorMakerCreateReplicationFlowIn) error {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *kafkamirrormaker.ServiceKafkaMirrorMakerCreateReplicationFlowIn) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceKafkaMirrorMakerCreateReplicationFlow is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceKafkaMirrorMakerCreateReplicationFlow(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceKafkaMirrorMakerCreateReplicationFlow_Call {
	return &MockClient_ServiceKafkaMirrorMakerCreateReplicationFlow_Call{Call: _e.mock.On("ServiceKafkaMirrorMakerCreateReplicationFlow", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceKafkaMirrorMakerCreateReplicationFlow_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *kafkamirrormaker.ServiceKafkaMirrorMakerCreateReplicationFlowIn)) *MockClient_ServiceKafkaMirrorMakerCreateReplicationFlow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*kafkamirrormaker.ServiceKafkaMirrorMakerCreateReplicationFlowIn))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaMirrorMakerCreateReplicationFlow_Call) Return(err error) *MockClient_ServiceKafkaMirrorMakerCreateReplicationFlow_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceKafkaMirrorMakerCreateReplicationFlow_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *kafkamirrormaker.ServiceKafkaMirrorMakerCreateReplicationFlowIn) error) *MockClient_ServiceKafkaMirrorMakerCreateReplicationFlow_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaMirrorMakerDeleteReplicationFlow provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaMirrorMakerDeleteReplicationFlow(ctx context.Context, project1 string, serviceName string, sourceCluster string, targetCluster string) error {
	ret := _mock.Called(ctx, project1, serviceName, sourceCluster, targetCluster)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, sourceCluster, targetCluster)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceKafkaMirrorMakerDeleteReplicationFlow is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - sourceCluster
//   - targetCluster
func (_e *MockClient_Expecter) ServiceKafkaMirrorMakerDeleteReplicationFlow(ctx interface{}, project1 interface{}, serviceName interface{}, sourceCluster interface{}, targetCluster interface{}) *MockClient_ServiceKafkaMirrorMakerDeleteReplicationFlow_Call {
	return &MockClient_ServiceKafkaMirrorMakerDeleteReplicationFlow_Call{Call: _e.mock.On("ServiceKafkaMirrorMakerDeleteReplicationFlow", ctx, project1, serviceName, sourceCluster, targetCluster)}
}

func (_c *MockClient_ServiceKafkaMirrorMakerDeleteReplicationFlow_Call) Run(run func(ctx context.Context, project1 string, serviceName string, sourceCluster string, targetCluster string)) *MockClient_ServiceKafkaMirrorMakerDeleteReplicationFlow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaMirrorMakerDeleteReplicationFlow_Call) Return(err error) *MockClient_ServiceKafkaMirrorMakerDeleteReplicationFlow_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceKafkaMirrorMakerDeleteReplicationFlow_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, sourceCluster string, targetCluster string) error) *MockClient_ServiceKafkaMirrorMakerDeleteReplicationFlow_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaMirrorMakerGetReplicationFlow provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaMirrorMakerGetReplicationFlow(ctx context.Context, project1 string, serviceName string, sourceCluster string, targetCluster string) (*kafkamirrormaker.ServiceKafkaMirrorMakerGetReplicationFlowOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, sourceCluster, targetCluster)

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

	var r0 *kafkamirrormaker.ServiceKafkaMirrorMakerGetReplicationFlowOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (*kafkamirrormaker.ServiceKafkaMirrorMakerGetReplicationFlowOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, sourceCluster, targetCluster)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) *kafkamirrormaker.ServiceKafkaMirrorMakerGetReplicationFlowOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, sourceCluster, targetCluster)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*kafkamirrormaker.ServiceKafkaMirrorMakerGetReplicationFlowOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, sourceCluster, targetCluster)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaMirrorMakerGetReplicationFlow is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - sourceCluster
//   - targetCluster
func (_e *MockClient_Expecter) ServiceKafkaMirrorMakerGetReplicationFlow(ctx interface{}, project1 interface{}, serviceName interface{}, sourceCluster interface{}, targetCluster interface{}) *MockClient_ServiceKafkaMirrorMakerGetReplicationFlow_Call {
	return &MockClient_ServiceKafkaMirrorMakerGetReplicationFlow_Call{Call: _e.mock.On("ServiceKafkaMirrorMakerGetReplicationFlow", ctx, project1, serviceName, sourceCluster, targetCluster)}
}

func (_c *MockClient_ServiceKafkaMirrorMakerGetReplicationFlow_Call) Run(run func(ctx context.Context, project1 string, serviceName string, sourceCluster string, targetCluster string)) *MockClient_ServiceKafkaMirrorMakerGetReplicationFlow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaMirrorMakerGetReplicationFlow_Call) Return(serviceKafkaMirrorMakerGetReplicationFlowOut *kafkamirrormaker.ServiceKafkaMirrorMakerGetReplicationFlowOut, err error) *MockClient_ServiceKafkaMirrorMakerGetReplicationFlow_Call {
	_c.Call.Return(serviceKafkaMirrorMakerGetReplicationFlowOut, err)
	return _c
}

func (_c *MockClient_ServiceKafkaMirrorMakerGetReplicationFlow_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, sourceCluster string, targetCluster string) (*kafkamirrormaker.ServiceKafkaMirrorMakerGetReplicationFlowOut, error)) *MockClient_ServiceKafkaMirrorMakerGetReplicationFlow_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaMirrorMakerGetReplicationFlows provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaMirrorMakerGetReplicationFlows(ctx context.Context, project1 string, serviceName string) ([]kafkamirrormaker.ReplicationFlowOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []kafkamirrormaker.ReplicationFlowOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]kafkamirrormaker.ReplicationFlowOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []kafkamirrormaker.ReplicationFlowOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]kafkamirrormaker.ReplicationFlowOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaMirrorMakerGetReplicationFlows is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceKafkaMirrorMakerGetReplicationFlows(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceKafkaMirrorMakerGetReplicationFlows_Call {
	return &MockClient_ServiceKafkaMirrorMakerGetReplicationFlows_Call{Call: _e.mock.On("ServiceKafkaMirrorMakerGetReplicationFlows", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceKafkaMirrorMakerGetReplicationFlows_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceKafkaMirrorMakerGetReplicationFlows_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaMirrorMakerGetReplicationFlows_Call) Return(replicationFlowOuts []kafkamirrormaker.ReplicationFlowOut, err error) *MockClient_ServiceKafkaMirrorMakerGetReplicationFlows_Call {
	_c.Call.Return(replicationFlowOuts, err)
	return _c
}

func (_c *MockClient_ServiceKafkaMirrorMakerGetReplicationFlows_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]kafkamirrormaker.ReplicationFlowOut, error)) *MockClient_ServiceKafkaMirrorMakerGetReplicationFlows_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaMirrorMakerPatchReplicationFlow provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaMirrorMakerPatchReplicationFlow(ctx context.Context, project1 string, serviceName string, sourceCluster string, targetCluster string, in *kafkamirrormaker.ServiceKafkaMirrorMakerPatchReplicationFlowIn) (*kafkamirrormaker.ServiceKafkaMirrorMakerPatchReplicationFlowOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, sourceCluster, targetCluster, in)

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

	var r0 *kafkamirrormaker.ServiceKafkaMirrorMakerPatchReplicationFlowOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string, *kafkamirrormaker.ServiceKafkaMirrorMakerPatchReplicationFlowIn) (*kafkamirrormaker.ServiceKafkaMirrorMakerPatchReplicationFlowOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, sourceCluster, targetCluster, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string, *kafkamirrormaker.ServiceKafkaMirrorMakerPatchReplicationFlowIn) *kafkamirrormaker.ServiceKafkaMirrorMakerPatchReplicationFlowOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, sourceCluster, targetCluster, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*kafkamirrormaker.ServiceKafkaMirrorMakerPatchReplicationFlowOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string, *kafkamirrormaker.ServiceKafkaMirrorMakerPatchReplicationFlowIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, sourceCluster, targetCluster, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaMirrorMakerPatchReplicationFlow is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - sourceCluster
//   - targetCluster
//   - in
func (_e *MockClient_Expecter) ServiceKafkaMirrorMakerPatchReplicationFlow(ctx interface{}, project1 interface{}, serviceName interface{}, sourceCluster interface{}, targetCluster interface{}, in interface{}) *MockClient_ServiceKafkaMirrorMakerPatchReplicationFlow_Call {
	return &MockClient_ServiceKafkaMirrorMakerPatchReplicationFlow_Call{Call: _e.mock.On("ServiceKafkaMirrorMakerPatchReplicationFlow", ctx, project1, serviceName, sourceCluster, targetCluster, in)}
}

func (_c *MockClient_ServiceKafkaMirrorMakerPatchReplicationFlow_Call) Run(run func(ctx context.Context, project1 string, serviceName string, sourceCluster string, targetCluster string, in *kafkamirrormaker.ServiceKafkaMirrorMakerPatchReplicationFlowIn)) *MockClient_ServiceKafkaMirrorMakerPatchReplicationFlow_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(*kafkamirrormaker.ServiceKafkaMirrorMakerPatchReplicationFlowIn))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaMirrorMakerPatchReplicationFlow_Call) Return(serviceKafkaMirrorMakerPatchReplicationFlowOut *kafkamirrormaker.ServiceKafkaMirrorMakerPatchReplicationFlowOut, err error) *MockClient_ServiceKafkaMirrorMakerPatchReplicationFlow_Call {
	_c.Call.Return(serviceKafkaMirrorMakerPatchReplicationFlowOut, err)
	return _c
}

func (_c *MockClient_ServiceKafkaMirrorMakerPatchReplicationFlow_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, sourceCluster string, targetCluster string, in *kafkamirrormaker.ServiceKafkaMirrorMakerPatchReplicationFlowIn) (*kafkamirrormaker.ServiceKafkaMirrorMakerPatchReplicationFlowOut, error)) *MockClient_ServiceKafkaMirrorMakerPatchReplicationFlow_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaNativeAclAdd provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaNativeAclAdd(ctx context.Context, project1 string, serviceName string, in *kafka.ServiceKafkaNativeAclAddIn) (*kafka.ServiceKafkaNativeAclAddOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 *kafka.ServiceKafkaNativeAclAddOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *kafka.ServiceKafkaNativeAclAddIn) (*kafka.ServiceKafkaNativeAclAddOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *kafka.ServiceKafkaNativeAclAddIn) *kafka.ServiceKafkaNativeAclAddOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*kafka.ServiceKafkaNativeAclAddOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *kafka.ServiceKafkaNativeAclAddIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaNativeAclAdd is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceKafkaNativeAclAdd(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceKafkaNativeAclAdd_Call {
	return &MockClient_ServiceKafkaNativeAclAdd_Call{Call: _e.mock.On("ServiceKafkaNativeAclAdd", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceKafkaNativeAclAdd_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *kafka.ServiceKafkaNativeAclAddIn)) *MockClient_ServiceKafkaNativeAclAdd_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*kafka.ServiceKafkaNativeAclAddIn))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaNativeAclAdd_Call) Return(serviceKafkaNativeAclAddOut *kafka.ServiceKafkaNativeAclAddOut, err error) *MockClient_ServiceKafkaNativeAclAdd_Call {
	_c.Call.Return(serviceKafkaNativeAclAddOut, err)
	return _c
}

func (_c *MockClient_ServiceKafkaNativeAclAdd_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *kafka.ServiceKafkaNativeAclAddIn) (*kafka.ServiceKafkaNativeAclAddOut, error)) *MockClient_ServiceKafkaNativeAclAdd_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaNativeAclDelete provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaNativeAclDelete(ctx context.Context, project1 string, serviceName string, kafkaAclId string) error {
	ret := _mock.Called(ctx, project1, serviceName, kafkaAclId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, kafkaAclId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceKafkaNativeAclDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - kafkaAclId
func (_e *MockClient_Expecter) ServiceKafkaNativeAclDelete(ctx interface{}, project1 interface{}, serviceName interface{}, kafkaAclId interface{}) *MockClient_ServiceKafkaNativeAclDelete_Call {
	return &MockClient_ServiceKafkaNativeAclDelete_Call{Call: _e.mock.On("ServiceKafkaNativeAclDelete", ctx, project1, serviceName, kafkaAclId)}
}

func (_c *MockClient_ServiceKafkaNativeAclDelete_Call) Run(run func(ctx context.Context, project1 string, serviceName string, kafkaAclId string)) *MockClient_ServiceKafkaNativeAclDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaNativeAclDelete_Call) Return(err error) *MockClient_ServiceKafkaNativeAclDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceKafkaNativeAclDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, kafkaAclId string) error) *MockClient_ServiceKafkaNativeAclDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaNativeAclGet provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaNativeAclGet(ctx context.Context, project1 string, serviceName string, kafkaAclId string) (*kafka.ServiceKafkaNativeAclGetOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, kafkaAclId)

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

	var r0 *kafka.ServiceKafkaNativeAclGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*kafka.ServiceKafkaNativeAclGetOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, kafkaAclId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *kafka.ServiceKafkaNativeAclGetOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, kafkaAclId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*kafka.ServiceKafkaNativeAclGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, kafkaAclId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaNativeAclGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - kafkaAclId
func (_e *MockClient_Expecter) ServiceKafkaNativeAclGet(ctx interface{}, project1 interface{}, serviceName interface{}, kafkaAclId interface{}) *MockClient_ServiceKafkaNativeAclGet_Call {
	return &MockClient_ServiceKafkaNativeAclGet_Call{Call: _e.mock.On("ServiceKafkaNativeAclGet", ctx, project1, serviceName, kafkaAclId)}
}

func (_c *MockClient_ServiceKafkaNativeAclGet_Call) Run(run func(ctx context.Context, project1 string, serviceName string, kafkaAclId string)) *MockClient_ServiceKafkaNativeAclGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaNativeAclGet_Call) Return(serviceKafkaNativeAclGetOut *kafka.ServiceKafkaNativeAclGetOut, err error) *MockClient_ServiceKafkaNativeAclGet_Call {
	_c.Call.Return(serviceKafkaNativeAclGetOut, err)
	return _c
}

func (_c *MockClient_ServiceKafkaNativeAclGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, kafkaAclId string) (*kafka.ServiceKafkaNativeAclGetOut, error)) *MockClient_ServiceKafkaNativeAclGet_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaNativeAclList provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaNativeAclList(ctx context.Context, project1 string, serviceName string) (*kafka.ServiceKafkaNativeAclListOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 *kafka.ServiceKafkaNativeAclListOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*kafka.ServiceKafkaNativeAclListOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *kafka.ServiceKafkaNativeAclListOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*kafka.ServiceKafkaNativeAclListOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaNativeAclList is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceKafkaNativeAclList(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceKafkaNativeAclList_Call {
	return &MockClient_ServiceKafkaNativeAclList_Call{Call: _e.mock.On("ServiceKafkaNativeAclList", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceKafkaNativeAclList_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceKafkaNativeAclList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaNativeAclList_Call) Return(serviceKafkaNativeAclListOut *kafka.ServiceKafkaNativeAclListOut, err error) *MockClient_ServiceKafkaNativeAclList_Call {
	_c.Call.Return(serviceKafkaNativeAclListOut, err)
	return _c
}

func (_c *MockClient_ServiceKafkaNativeAclList_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) (*kafka.ServiceKafkaNativeAclListOut, error)) *MockClient_ServiceKafkaNativeAclList_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaQuotaCreate provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaQuotaCreate(ctx context.Context, project1 string, serviceName string, in *kafka.ServiceKafkaQuotaCreateIn) error {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *kafka.ServiceKafkaQuotaCreateIn) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceKafkaQuotaCreate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceKafkaQuotaCreate(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceKafkaQuotaCreate_Call {
	return &MockClient_ServiceKafkaQuotaCreate_Call{Call: _e.mock.On("ServiceKafkaQuotaCreate", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceKafkaQuotaCreate_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *kafka.ServiceKafkaQuotaCreateIn)) *MockClient_ServiceKafkaQuotaCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*kafka.ServiceKafkaQuotaCreateIn))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaQuotaCreate_Call) Return(err error) *MockClient_ServiceKafkaQuotaCreate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceKafkaQuotaCreate_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *kafka.ServiceKafkaQuotaCreateIn) error) *MockClient_ServiceKafkaQuotaCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaQuotaDelete provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaQuotaDelete(ctx context.Context, project1 string, serviceName string, query ...[2]string) error {
	var tmpRet mock.Arguments
	if len(query) > 0 {
		tmpRet = _mock.Called(ctx, project1, serviceName, query)
	} else {
		tmpRet = _mock.Called(ctx, project1, serviceName)
	}
	ret := tmpRet

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, ...[2]string) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, query...)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceKafkaQuotaDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - query
func (_e *MockClient_Expecter) ServiceKafkaQuotaDelete(ctx interface{}, project1 interface{}, serviceName interface{}, query ...interface{}) *MockClient_ServiceKafkaQuotaDelete_Call {
	return &MockClient_ServiceKafkaQuotaDelete_Call{Call: _e.mock.On("ServiceKafkaQuotaDelete",
		append([]interface{}{ctx, project1, serviceName}, query...)...)}
}

func (_c *MockClient_ServiceKafkaQuotaDelete_Call) Run(run func(ctx context.Context, project1 string, serviceName string, query ...[2]string)) *MockClient_ServiceKafkaQuotaDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := args[3].([][2]string)
		run(args[0].(context.Context), args[1].(string), args[2].(string), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_ServiceKafkaQuotaDelete_Call) Return(err error) *MockClient_ServiceKafkaQuotaDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceKafkaQuotaDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, query ...[2]string) error) *MockClient_ServiceKafkaQuotaDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaQuotaDescribe provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaQuotaDescribe(ctx context.Context, project1 string, serviceName string, query ...[2]string) (*kafka.ServiceKafkaQuotaDescribeOut, error) {
	var tmpRet mock.Arguments
	if len(query) > 0 {
		tmpRet = _mock.Called(ctx, project1, serviceName, query)
	} else {
		tmpRet = _mock.Called(ctx, project1, serviceName)
	}
	ret := tmpRet

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

	var r0 *kafka.ServiceKafkaQuotaDescribeOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, ...[2]string) (*kafka.ServiceKafkaQuotaDescribeOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, query...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, ...[2]string) *kafka.ServiceKafkaQuotaDescribeOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, query...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*kafka.ServiceKafkaQuotaDescribeOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, ...[2]string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, query...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaQuotaDescribe is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - query
func (_e *MockClient_Expecter) ServiceKafkaQuotaDescribe(ctx interface{}, project1 interface{}, serviceName interface{}, query ...interface{}) *MockClient_ServiceKafkaQuotaDescribe_Call {
	return &MockClient_ServiceKafkaQuotaDescribe_Call{Call: _e.mock.On("ServiceKafkaQuotaDescribe",
		append([]interface{}{ctx, project1, serviceName}, query...)...)}
}

func (_c *MockClient_ServiceKafkaQuotaDescribe_Call) Run(run func(ctx context.Context, project1 string, serviceName string, query ...[2]string)) *MockClient_ServiceKafkaQuotaDescribe_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := args[3].([][2]string)
		run(args[0].(context.Context), args[1].(string), args[2].(string), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_ServiceKafkaQuotaDescribe_Call) Return(serviceKafkaQuotaDescribeOut *kafka.ServiceKafkaQuotaDescribeOut, err error) *MockClient_ServiceKafkaQuotaDescribe_Call {
	_c.Call.Return(serviceKafkaQuotaDescribeOut, err)
	return _c
}

func (_c *MockClient_ServiceKafkaQuotaDescribe_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, query ...[2]string) (*kafka.ServiceKafkaQuotaDescribeOut, error)) *MockClient_ServiceKafkaQuotaDescribe_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaQuotaList provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaQuotaList(ctx context.Context, project1 string, serviceName string) ([]kafka.QuotaOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []kafka.QuotaOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]kafka.QuotaOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []kafka.QuotaOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]kafka.QuotaOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaQuotaList is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceKafkaQuotaList(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceKafkaQuotaList_Call {
	return &MockClient_ServiceKafkaQuotaList_Call{Call: _e.mock.On("ServiceKafkaQuotaList", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceKafkaQuotaList_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceKafkaQuotaList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaQuotaList_Call) Return(quotaOuts []kafka.QuotaOut, err error) *MockClient_ServiceKafkaQuotaList_Call {
	_c.Call.Return(quotaOuts, err)
	return _c
}

func (_c *MockClient_ServiceKafkaQuotaList_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]kafka.QuotaOut, error)) *MockClient_ServiceKafkaQuotaList_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaTieredStorageStorageUsageByTopic provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaTieredStorageStorageUsageByTopic(ctx context.Context, project1 string, serviceName string) (map[string]any, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 map[string]any
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (map[string]any, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) map[string]any); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]any)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaTieredStorageStorageUsageByTopic is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceKafkaTieredStorageStorageUsageByTopic(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceKafkaTieredStorageStorageUsageByTopic_Call {
	return &MockClient_ServiceKafkaTieredStorageStorageUsageByTopic_Call{Call: _e.mock.On("ServiceKafkaTieredStorageStorageUsageByTopic", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceKafkaTieredStorageStorageUsageByTopic_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceKafkaTieredStorageStorageUsageByTopic_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaTieredStorageStorageUsageByTopic_Call) Return(stringToV map[string]any, err error) *MockClient_ServiceKafkaTieredStorageStorageUsageByTopic_Call {
	_c.Call.Return(stringToV, err)
	return _c
}

func (_c *MockClient_ServiceKafkaTieredStorageStorageUsageByTopic_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) (map[string]any, error)) *MockClient_ServiceKafkaTieredStorageStorageUsageByTopic_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaTieredStorageStorageUsageTotal provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaTieredStorageStorageUsageTotal(ctx context.Context, project1 string, serviceName string) (int, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 int
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (int, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) int); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		r0 = ret.Get(0).(int)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaTieredStorageStorageUsageTotal is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceKafkaTieredStorageStorageUsageTotal(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceKafkaTieredStorageStorageUsageTotal_Call {
	return &MockClient_ServiceKafkaTieredStorageStorageUsageTotal_Call{Call: _e.mock.On("ServiceKafkaTieredStorageStorageUsageTotal", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceKafkaTieredStorageStorageUsageTotal_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceKafkaTieredStorageStorageUsageTotal_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaTieredStorageStorageUsageTotal_Call) Return(n int, err error) *MockClient_ServiceKafkaTieredStorageStorageUsageTotal_Call {
	_c.Call.Return(n, err)
	return _c
}

func (_c *MockClient_ServiceKafkaTieredStorageStorageUsageTotal_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) (int, error)) *MockClient_ServiceKafkaTieredStorageStorageUsageTotal_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaTieredStorageSummary provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaTieredStorageSummary(ctx context.Context, project1 string, serviceName string) (*kafka.ServiceKafkaTieredStorageSummaryOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 *kafka.ServiceKafkaTieredStorageSummaryOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*kafka.ServiceKafkaTieredStorageSummaryOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *kafka.ServiceKafkaTieredStorageSummaryOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*kafka.ServiceKafkaTieredStorageSummaryOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaTieredStorageSummary is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceKafkaTieredStorageSummary(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceKafkaTieredStorageSummary_Call {
	return &MockClient_ServiceKafkaTieredStorageSummary_Call{Call: _e.mock.On("ServiceKafkaTieredStorageSummary", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceKafkaTieredStorageSummary_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceKafkaTieredStorageSummary_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaTieredStorageSummary_Call) Return(serviceKafkaTieredStorageSummaryOut *kafka.ServiceKafkaTieredStorageSummaryOut, err error) *MockClient_ServiceKafkaTieredStorageSummary_Call {
	_c.Call.Return(serviceKafkaTieredStorageSummaryOut, err)
	return _c
}

func (_c *MockClient_ServiceKafkaTieredStorageSummary_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) (*kafka.ServiceKafkaTieredStorageSummaryOut, error)) *MockClient_ServiceKafkaTieredStorageSummary_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaTopicCreate provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaTopicCreate(ctx context.Context, project1 string, serviceName string, in *kafkatopic.ServiceKafkaTopicCreateIn) error {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *kafkatopic.ServiceKafkaTopicCreateIn) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceKafkaTopicCreate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceKafkaTopicCreate(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceKafkaTopicCreate_Call {
	return &MockClient_ServiceKafkaTopicCreate_Call{Call: _e.mock.On("ServiceKafkaTopicCreate", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceKafkaTopicCreate_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *kafkatopic.ServiceKafkaTopicCreateIn)) *MockClient_ServiceKafkaTopicCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*kafkatopic.ServiceKafkaTopicCreateIn))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaTopicCreate_Call) Return(err error) *MockClient_ServiceKafkaTopicCreate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceKafkaTopicCreate_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *kafkatopic.ServiceKafkaTopicCreateIn) error) *MockClient_ServiceKafkaTopicCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaTopicDelete provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaTopicDelete(ctx context.Context, project1 string, serviceName string, topicName string) error {
	ret := _mock.Called(ctx, project1, serviceName, topicName)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, topicName)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceKafkaTopicDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - topicName
func (_e *MockClient_Expecter) ServiceKafkaTopicDelete(ctx interface{}, project1 interface{}, serviceName interface{}, topicName interface{}) *MockClient_ServiceKafkaTopicDelete_Call {
	return &MockClient_ServiceKafkaTopicDelete_Call{Call: _e.mock.On("ServiceKafkaTopicDelete", ctx, project1, serviceName, topicName)}
}

func (_c *MockClient_ServiceKafkaTopicDelete_Call) Run(run func(ctx context.Context, project1 string, serviceName string, topicName string)) *MockClient_ServiceKafkaTopicDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaTopicDelete_Call) Return(err error) *MockClient_ServiceKafkaTopicDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceKafkaTopicDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, topicName string) error) *MockClient_ServiceKafkaTopicDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaTopicGet provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaTopicGet(ctx context.Context, project1 string, serviceName string, topicName string) (*kafkatopic.ServiceKafkaTopicGetOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, topicName)

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

	var r0 *kafkatopic.ServiceKafkaTopicGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*kafkatopic.ServiceKafkaTopicGetOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, topicName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *kafkatopic.ServiceKafkaTopicGetOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, topicName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*kafkatopic.ServiceKafkaTopicGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, topicName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaTopicGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - topicName
func (_e *MockClient_Expecter) ServiceKafkaTopicGet(ctx interface{}, project1 interface{}, serviceName interface{}, topicName interface{}) *MockClient_ServiceKafkaTopicGet_Call {
	return &MockClient_ServiceKafkaTopicGet_Call{Call: _e.mock.On("ServiceKafkaTopicGet", ctx, project1, serviceName, topicName)}
}

func (_c *MockClient_ServiceKafkaTopicGet_Call) Run(run func(ctx context.Context, project1 string, serviceName string, topicName string)) *MockClient_ServiceKafkaTopicGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaTopicGet_Call) Return(serviceKafkaTopicGetOut *kafkatopic.ServiceKafkaTopicGetOut, err error) *MockClient_ServiceKafkaTopicGet_Call {
	_c.Call.Return(serviceKafkaTopicGetOut, err)
	return _c
}

func (_c *MockClient_ServiceKafkaTopicGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, topicName string) (*kafkatopic.ServiceKafkaTopicGetOut, error)) *MockClient_ServiceKafkaTopicGet_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaTopicList provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaTopicList(ctx context.Context, project1 string, serviceName string) ([]kafkatopic.TopicOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []kafkatopic.TopicOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]kafkatopic.TopicOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []kafkatopic.TopicOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]kafkatopic.TopicOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaTopicList is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceKafkaTopicList(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceKafkaTopicList_Call {
	return &MockClient_ServiceKafkaTopicList_Call{Call: _e.mock.On("ServiceKafkaTopicList", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceKafkaTopicList_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceKafkaTopicList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaTopicList_Call) Return(topicOuts []kafkatopic.TopicOut, err error) *MockClient_ServiceKafkaTopicList_Call {
	_c.Call.Return(topicOuts, err)
	return _c
}

func (_c *MockClient_ServiceKafkaTopicList_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]kafkatopic.TopicOut, error)) *MockClient_ServiceKafkaTopicList_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaTopicListV2 provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaTopicListV2(ctx context.Context, project1 string, serviceName string, in *kafkatopic.ServiceKafkaTopicListV2In) ([]kafkatopic.ServiceKafkaTopicGetOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 []kafkatopic.ServiceKafkaTopicGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *kafkatopic.ServiceKafkaTopicListV2In) ([]kafkatopic.ServiceKafkaTopicGetOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *kafkatopic.ServiceKafkaTopicListV2In) []kafkatopic.ServiceKafkaTopicGetOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]kafkatopic.ServiceKafkaTopicGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *kafkatopic.ServiceKafkaTopicListV2In) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaTopicListV2 is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceKafkaTopicListV2(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceKafkaTopicListV2_Call {
	return &MockClient_ServiceKafkaTopicListV2_Call{Call: _e.mock.On("ServiceKafkaTopicListV2", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceKafkaTopicListV2_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *kafkatopic.ServiceKafkaTopicListV2In)) *MockClient_ServiceKafkaTopicListV2_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*kafkatopic.ServiceKafkaTopicListV2In))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaTopicListV2_Call) Return(serviceKafkaTopicGetOuts []kafkatopic.ServiceKafkaTopicGetOut, err error) *MockClient_ServiceKafkaTopicListV2_Call {
	_c.Call.Return(serviceKafkaTopicGetOuts, err)
	return _c
}

func (_c *MockClient_ServiceKafkaTopicListV2_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *kafkatopic.ServiceKafkaTopicListV2In) ([]kafkatopic.ServiceKafkaTopicGetOut, error)) *MockClient_ServiceKafkaTopicListV2_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaTopicMessageList provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaTopicMessageList(ctx context.Context, project1 string, serviceName string, topicName string, in *kafkatopic.ServiceKafkaTopicMessageListIn) ([]kafkatopic.MessageOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, topicName, in)

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

	var r0 []kafkatopic.MessageOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *kafkatopic.ServiceKafkaTopicMessageListIn) ([]kafkatopic.MessageOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, topicName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *kafkatopic.ServiceKafkaTopicMessageListIn) []kafkatopic.MessageOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, topicName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]kafkatopic.MessageOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, *kafkatopic.ServiceKafkaTopicMessageListIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, topicName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaTopicMessageList is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - topicName
//   - in
func (_e *MockClient_Expecter) ServiceKafkaTopicMessageList(ctx interface{}, project1 interface{}, serviceName interface{}, topicName interface{}, in interface{}) *MockClient_ServiceKafkaTopicMessageList_Call {
	return &MockClient_ServiceKafkaTopicMessageList_Call{Call: _e.mock.On("ServiceKafkaTopicMessageList", ctx, project1, serviceName, topicName, in)}
}

func (_c *MockClient_ServiceKafkaTopicMessageList_Call) Run(run func(ctx context.Context, project1 string, serviceName string, topicName string, in *kafkatopic.ServiceKafkaTopicMessageListIn)) *MockClient_ServiceKafkaTopicMessageList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*kafkatopic.ServiceKafkaTopicMessageListIn))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaTopicMessageList_Call) Return(messageOuts []kafkatopic.MessageOut, err error) *MockClient_ServiceKafkaTopicMessageList_Call {
	_c.Call.Return(messageOuts, err)
	return _c
}

func (_c *MockClient_ServiceKafkaTopicMessageList_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, topicName string, in *kafkatopic.ServiceKafkaTopicMessageListIn) ([]kafkatopic.MessageOut, error)) *MockClient_ServiceKafkaTopicMessageList_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaTopicMessageProduce provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaTopicMessageProduce(ctx context.Context, project1 string, serviceName string, topicName string, in *kafkatopic.ServiceKafkaTopicMessageProduceIn) (*kafkatopic.ServiceKafkaTopicMessageProduceOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, topicName, in)

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

	var r0 *kafkatopic.ServiceKafkaTopicMessageProduceOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *kafkatopic.ServiceKafkaTopicMessageProduceIn) (*kafkatopic.ServiceKafkaTopicMessageProduceOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, topicName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *kafkatopic.ServiceKafkaTopicMessageProduceIn) *kafkatopic.ServiceKafkaTopicMessageProduceOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, topicName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*kafkatopic.ServiceKafkaTopicMessageProduceOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, *kafkatopic.ServiceKafkaTopicMessageProduceIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, topicName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKafkaTopicMessageProduce is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - topicName
//   - in
func (_e *MockClient_Expecter) ServiceKafkaTopicMessageProduce(ctx interface{}, project1 interface{}, serviceName interface{}, topicName interface{}, in interface{}) *MockClient_ServiceKafkaTopicMessageProduce_Call {
	return &MockClient_ServiceKafkaTopicMessageProduce_Call{Call: _e.mock.On("ServiceKafkaTopicMessageProduce", ctx, project1, serviceName, topicName, in)}
}

func (_c *MockClient_ServiceKafkaTopicMessageProduce_Call) Run(run func(ctx context.Context, project1 string, serviceName string, topicName string, in *kafkatopic.ServiceKafkaTopicMessageProduceIn)) *MockClient_ServiceKafkaTopicMessageProduce_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*kafkatopic.ServiceKafkaTopicMessageProduceIn))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaTopicMessageProduce_Call) Return(serviceKafkaTopicMessageProduceOut *kafkatopic.ServiceKafkaTopicMessageProduceOut, err error) *MockClient_ServiceKafkaTopicMessageProduce_Call {
	_c.Call.Return(serviceKafkaTopicMessageProduceOut, err)
	return _c
}

func (_c *MockClient_ServiceKafkaTopicMessageProduce_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, topicName string, in *kafkatopic.ServiceKafkaTopicMessageProduceIn) (*kafkatopic.ServiceKafkaTopicMessageProduceOut, error)) *MockClient_ServiceKafkaTopicMessageProduce_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKafkaTopicUpdate provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKafkaTopicUpdate(ctx context.Context, project1 string, serviceName string, topicName string, in *kafkatopic.ServiceKafkaTopicUpdateIn) error {
	ret := _mock.Called(ctx, project1, serviceName, topicName, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *kafkatopic.ServiceKafkaTopicUpdateIn) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, topicName, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceKafkaTopicUpdate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - topicName
//   - in
func (_e *MockClient_Expecter) ServiceKafkaTopicUpdate(ctx interface{}, project1 interface{}, serviceName interface{}, topicName interface{}, in interface{}) *MockClient_ServiceKafkaTopicUpdate_Call {
	return &MockClient_ServiceKafkaTopicUpdate_Call{Call: _e.mock.On("ServiceKafkaTopicUpdate", ctx, project1, serviceName, topicName, in)}
}

func (_c *MockClient_ServiceKafkaTopicUpdate_Call) Run(run func(ctx context.Context, project1 string, serviceName string, topicName string, in *kafkatopic.ServiceKafkaTopicUpdateIn)) *MockClient_ServiceKafkaTopicUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*kafkatopic.ServiceKafkaTopicUpdateIn))
	})
	return _c
}

func (_c *MockClient_ServiceKafkaTopicUpdate_Call) Return(err error) *MockClient_ServiceKafkaTopicUpdate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceKafkaTopicUpdate_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, topicName string, in *kafkatopic.ServiceKafkaTopicUpdateIn) error) *MockClient_ServiceKafkaTopicUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKmsGetCA provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKmsGetCA(ctx context.Context, project1 string, serviceName string, caName string) (string, error) {
	ret := _mock.Called(ctx, project1, serviceName, caName)

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

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (string, error)); ok {
		return returnFunc(ctx, project1, serviceName, caName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) string); ok {
		r0 = returnFunc(ctx, project1, serviceName, caName)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, caName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKmsGetCA is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - caName
func (_e *MockClient_Expecter) ServiceKmsGetCA(ctx interface{}, project1 interface{}, serviceName interface{}, caName interface{}) *MockClient_ServiceKmsGetCA_Call {
	return &MockClient_ServiceKmsGetCA_Call{Call: _e.mock.On("ServiceKmsGetCA", ctx, project1, serviceName, caName)}
}

func (_c *MockClient_ServiceKmsGetCA_Call) Run(run func(ctx context.Context, project1 string, serviceName string, caName string)) *MockClient_ServiceKmsGetCA_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKmsGetCA_Call) Return(s string, err error) *MockClient_ServiceKmsGetCA_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockClient_ServiceKmsGetCA_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, caName string) (string, error)) *MockClient_ServiceKmsGetCA_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceKmsGetKeypair provides a mock function for the type MockClient
func (_mock *MockClient) ServiceKmsGetKeypair(ctx context.Context, project1 string, serviceName string, keypairName string) (*service.ServiceKmsGetKeypairOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, keypairName)

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

	var r0 *service.ServiceKmsGetKeypairOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*service.ServiceKmsGetKeypairOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, keypairName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *service.ServiceKmsGetKeypairOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, keypairName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ServiceKmsGetKeypairOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, keypairName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceKmsGetKeypair is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - keypairName
func (_e *MockClient_Expecter) ServiceKmsGetKeypair(ctx interface{}, project1 interface{}, serviceName interface{}, keypairName interface{}) *MockClient_ServiceKmsGetKeypair_Call {
	return &MockClient_ServiceKmsGetKeypair_Call{Call: _e.mock.On("ServiceKmsGetKeypair", ctx, project1, serviceName, keypairName)}
}

func (_c *MockClient_ServiceKmsGetKeypair_Call) Run(run func(ctx context.Context, project1 string, serviceName string, keypairName string)) *MockClient_ServiceKmsGetKeypair_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceKmsGetKeypair_Call) Return(serviceKmsGetKeypairOut *service.ServiceKmsGetKeypairOut, err error) *MockClient_ServiceKmsGetKeypair_Call {
	_c.Call.Return(serviceKmsGetKeypairOut, err)
	return _c
}

func (_c *MockClient_ServiceKmsGetKeypair_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, keypairName string) (*service.ServiceKmsGetKeypairOut, error)) *MockClient_ServiceKmsGetKeypair_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceList provides a mock function for the type MockClient
func (_mock *MockClient) ServiceList(ctx context.Context, project1 string, query ...[2]string) ([]service.ServiceOut, error) {
	var tmpRet mock.Arguments
	if len(query) > 0 {
		tmpRet = _mock.Called(ctx, project1, query)
	} else {
		tmpRet = _mock.Called(ctx, project1)
	}
	ret := tmpRet

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

	var r0 []service.ServiceOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, ...[2]string) ([]service.ServiceOut, error)); ok {
		return returnFunc(ctx, project1, query...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, ...[2]string) []service.ServiceOut); ok {
		r0 = returnFunc(ctx, project1, query...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]service.ServiceOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, ...[2]string) error); ok {
		r1 = returnFunc(ctx, project1, query...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceList is a helper method to define mock.On call
//   - ctx
//   - project1
//   - query
func (_e *MockClient_Expecter) ServiceList(ctx interface{}, project1 interface{}, query ...interface{}) *MockClient_ServiceList_Call {
	return &MockClient_ServiceList_Call{Call: _e.mock.On("ServiceList",
		append([]interface{}{ctx, project1}, query...)...)}
}

func (_c *MockClient_ServiceList_Call) Run(run func(ctx context.Context, project1 string, query ...[2]string)) *MockClient_ServiceList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := args[2].([][2]string)
		run(args[0].(context.Context), args[1].(string), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_ServiceList_Call) Return(serviceOuts []service.ServiceOut, err error) *MockClient_ServiceList_Call {
	_c.Call.Return(serviceOuts, err)
	return _c
}

func (_c *MockClient_ServiceList_Call) RunAndReturn(run func(ctx context.Context, project1 string, query ...[2]string) ([]service.ServiceOut, error)) *MockClient_ServiceList_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceMaintenanceStart provides a mock function for the type MockClient
func (_mock *MockClient) ServiceMaintenanceStart(ctx context.Context, project1 string, serviceName string) error {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceMaintenanceStart is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceMaintenanceStart(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceMaintenanceStart_Call {
	return &MockClient_ServiceMaintenanceStart_Call{Call: _e.mock.On("ServiceMaintenanceStart", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceMaintenanceStart_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceMaintenanceStart_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceMaintenanceStart_Call) Return(err error) *MockClient_ServiceMaintenanceStart_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceMaintenanceStart_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) error) *MockClient_ServiceMaintenanceStart_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceMetricsFetch provides a mock function for the type MockClient
func (_mock *MockClient) ServiceMetricsFetch(ctx context.Context, project1 string, serviceName string, in *service.ServiceMetricsFetchIn) (map[string]any, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 map[string]any
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ServiceMetricsFetchIn) (map[string]any, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ServiceMetricsFetchIn) map[string]any); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]any)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *service.ServiceMetricsFetchIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceMetricsFetch is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceMetricsFetch(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceMetricsFetch_Call {
	return &MockClient_ServiceMetricsFetch_Call{Call: _e.mock.On("ServiceMetricsFetch", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceMetricsFetch_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *service.ServiceMetricsFetchIn)) *MockClient_ServiceMetricsFetch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*service.ServiceMetricsFetchIn))
	})
	return _c
}

func (_c *MockClient_ServiceMetricsFetch_Call) Return(stringToV map[string]any, err error) *MockClient_ServiceMetricsFetch_Call {
	_c.Call.Return(stringToV, err)
	return _c
}

func (_c *MockClient_ServiceMetricsFetch_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *service.ServiceMetricsFetchIn) (map[string]any, error)) *MockClient_ServiceMetricsFetch_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceOpenSearchAclGet provides a mock function for the type MockClient
func (_mock *MockClient) ServiceOpenSearchAclGet(ctx context.Context, project1 string, serviceName string) (*opensearch.ServiceOpenSearchAclGetOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 *opensearch.ServiceOpenSearchAclGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*opensearch.ServiceOpenSearchAclGetOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *opensearch.ServiceOpenSearchAclGetOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*opensearch.ServiceOpenSearchAclGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceOpenSearchAclGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceOpenSearchAclGet(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceOpenSearchAclGet_Call {
	return &MockClient_ServiceOpenSearchAclGet_Call{Call: _e.mock.On("ServiceOpenSearchAclGet", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceOpenSearchAclGet_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceOpenSearchAclGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceOpenSearchAclGet_Call) Return(serviceOpenSearchAclGetOut *opensearch.ServiceOpenSearchAclGetOut, err error) *MockClient_ServiceOpenSearchAclGet_Call {
	_c.Call.Return(serviceOpenSearchAclGetOut, err)
	return _c
}

func (_c *MockClient_ServiceOpenSearchAclGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) (*opensearch.ServiceOpenSearchAclGetOut, error)) *MockClient_ServiceOpenSearchAclGet_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceOpenSearchAclSet provides a mock function for the type MockClient
func (_mock *MockClient) ServiceOpenSearchAclSet(ctx context.Context, project1 string, serviceName string, in *opensearch.ServiceOpenSearchAclSetIn) (*opensearch.ServiceOpenSearchAclSetOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 *opensearch.ServiceOpenSearchAclSetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *opensearch.ServiceOpenSearchAclSetIn) (*opensearch.ServiceOpenSearchAclSetOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *opensearch.ServiceOpenSearchAclSetIn) *opensearch.ServiceOpenSearchAclSetOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*opensearch.ServiceOpenSearchAclSetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *opensearch.ServiceOpenSearchAclSetIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceOpenSearchAclSet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceOpenSearchAclSet(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceOpenSearchAclSet_Call {
	return &MockClient_ServiceOpenSearchAclSet_Call{Call: _e.mock.On("ServiceOpenSearchAclSet", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceOpenSearchAclSet_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *opensearch.ServiceOpenSearchAclSetIn)) *MockClient_ServiceOpenSearchAclSet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*opensearch.ServiceOpenSearchAclSetIn))
	})
	return _c
}

func (_c *MockClient_ServiceOpenSearchAclSet_Call) Return(serviceOpenSearchAclSetOut *opensearch.ServiceOpenSearchAclSetOut, err error) *MockClient_ServiceOpenSearchAclSet_Call {
	_c.Call.Return(serviceOpenSearchAclSetOut, err)
	return _c
}

func (_c *MockClient_ServiceOpenSearchAclSet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *opensearch.ServiceOpenSearchAclSetIn) (*opensearch.ServiceOpenSearchAclSetOut, error)) *MockClient_ServiceOpenSearchAclSet_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceOpenSearchAclUpdate provides a mock function for the type MockClient
func (_mock *MockClient) ServiceOpenSearchAclUpdate(ctx context.Context, project1 string, serviceName string, in *opensearch.ServiceOpenSearchAclUpdateIn) (*opensearch.ServiceOpenSearchAclUpdateOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 *opensearch.ServiceOpenSearchAclUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *opensearch.ServiceOpenSearchAclUpdateIn) (*opensearch.ServiceOpenSearchAclUpdateOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *opensearch.ServiceOpenSearchAclUpdateIn) *opensearch.ServiceOpenSearchAclUpdateOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*opensearch.ServiceOpenSearchAclUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *opensearch.ServiceOpenSearchAclUpdateIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceOpenSearchAclUpdate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceOpenSearchAclUpdate(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceOpenSearchAclUpdate_Call {
	return &MockClient_ServiceOpenSearchAclUpdate_Call{Call: _e.mock.On("ServiceOpenSearchAclUpdate", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceOpenSearchAclUpdate_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *opensearch.ServiceOpenSearchAclUpdateIn)) *MockClient_ServiceOpenSearchAclUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*opensearch.ServiceOpenSearchAclUpdateIn))
	})
	return _c
}

func (_c *MockClient_ServiceOpenSearchAclUpdate_Call) Return(serviceOpenSearchAclUpdateOut *opensearch.ServiceOpenSearchAclUpdateOut, err error) *MockClient_ServiceOpenSearchAclUpdate_Call {
	_c.Call.Return(serviceOpenSearchAclUpdateOut, err)
	return _c
}

func (_c *MockClient_ServiceOpenSearchAclUpdate_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *opensearch.ServiceOpenSearchAclUpdateIn) (*opensearch.ServiceOpenSearchAclUpdateOut, error)) *MockClient_ServiceOpenSearchAclUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceOpenSearchIndexDelete provides a mock function for the type MockClient
func (_mock *MockClient) ServiceOpenSearchIndexDelete(ctx context.Context, project1 string, serviceName string, indexPattern string) error {
	ret := _mock.Called(ctx, project1, serviceName, indexPattern)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, indexPattern)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceOpenSearchIndexDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - indexPattern
func (_e *MockClient_Expecter) ServiceOpenSearchIndexDelete(ctx interface{}, project1 interface{}, serviceName interface{}, indexPattern interface{}) *MockClient_ServiceOpenSearchIndexDelete_Call {
	return &MockClient_ServiceOpenSearchIndexDelete_Call{Call: _e.mock.On("ServiceOpenSearchIndexDelete", ctx, project1, serviceName, indexPattern)}
}

func (_c *MockClient_ServiceOpenSearchIndexDelete_Call) Run(run func(ctx context.Context, project1 string, serviceName string, indexPattern string)) *MockClient_ServiceOpenSearchIndexDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceOpenSearchIndexDelete_Call) Return(err error) *MockClient_ServiceOpenSearchIndexDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceOpenSearchIndexDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, indexPattern string) error) *MockClient_ServiceOpenSearchIndexDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceOpenSearchIndexList provides a mock function for the type MockClient
func (_mock *MockClient) ServiceOpenSearchIndexList(ctx context.Context, project1 string, serviceName string) ([]opensearch.IndexeOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []opensearch.IndexeOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]opensearch.IndexeOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []opensearch.IndexeOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]opensearch.IndexeOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceOpenSearchIndexList is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceOpenSearchIndexList(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceOpenSearchIndexList_Call {
	return &MockClient_ServiceOpenSearchIndexList_Call{Call: _e.mock.On("ServiceOpenSearchIndexList", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceOpenSearchIndexList_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceOpenSearchIndexList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceOpenSearchIndexList_Call) Return(indexeOuts []opensearch.IndexeOut, err error) *MockClient_ServiceOpenSearchIndexList_Call {
	_c.Call.Return(indexeOuts, err)
	return _c
}

func (_c *MockClient_ServiceOpenSearchIndexList_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]opensearch.IndexeOut, error)) *MockClient_ServiceOpenSearchIndexList_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceOpenSearchSecurityGet provides a mock function for the type MockClient
func (_mock *MockClient) ServiceOpenSearchSecurityGet(ctx context.Context, project1 string, serviceName string) (*opensearch.ServiceOpenSearchSecurityGetOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 *opensearch.ServiceOpenSearchSecurityGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*opensearch.ServiceOpenSearchSecurityGetOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *opensearch.ServiceOpenSearchSecurityGetOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*opensearch.ServiceOpenSearchSecurityGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceOpenSearchSecurityGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceOpenSearchSecurityGet(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceOpenSearchSecurityGet_Call {
	return &MockClient_ServiceOpenSearchSecurityGet_Call{Call: _e.mock.On("ServiceOpenSearchSecurityGet", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceOpenSearchSecurityGet_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceOpenSearchSecurityGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceOpenSearchSecurityGet_Call) Return(serviceOpenSearchSecurityGetOut *opensearch.ServiceOpenSearchSecurityGetOut, err error) *MockClient_ServiceOpenSearchSecurityGet_Call {
	_c.Call.Return(serviceOpenSearchSecurityGetOut, err)
	return _c
}

func (_c *MockClient_ServiceOpenSearchSecurityGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) (*opensearch.ServiceOpenSearchSecurityGetOut, error)) *MockClient_ServiceOpenSearchSecurityGet_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceOpenSearchSecurityReset provides a mock function for the type MockClient
func (_mock *MockClient) ServiceOpenSearchSecurityReset(ctx context.Context, project1 string, serviceName string, in *opensearch.ServiceOpenSearchSecurityResetIn) (*opensearch.ServiceOpenSearchSecurityResetOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 *opensearch.ServiceOpenSearchSecurityResetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *opensearch.ServiceOpenSearchSecurityResetIn) (*opensearch.ServiceOpenSearchSecurityResetOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *opensearch.ServiceOpenSearchSecurityResetIn) *opensearch.ServiceOpenSearchSecurityResetOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*opensearch.ServiceOpenSearchSecurityResetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *opensearch.ServiceOpenSearchSecurityResetIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceOpenSearchSecurityReset is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceOpenSearchSecurityReset(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceOpenSearchSecurityReset_Call {
	return &MockClient_ServiceOpenSearchSecurityReset_Call{Call: _e.mock.On("ServiceOpenSearchSecurityReset", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceOpenSearchSecurityReset_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *opensearch.ServiceOpenSearchSecurityResetIn)) *MockClient_ServiceOpenSearchSecurityReset_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*opensearch.ServiceOpenSearchSecurityResetIn))
	})
	return _c
}

func (_c *MockClient_ServiceOpenSearchSecurityReset_Call) Return(serviceOpenSearchSecurityResetOut *opensearch.ServiceOpenSearchSecurityResetOut, err error) *MockClient_ServiceOpenSearchSecurityReset_Call {
	_c.Call.Return(serviceOpenSearchSecurityResetOut, err)
	return _c
}

func (_c *MockClient_ServiceOpenSearchSecurityReset_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *opensearch.ServiceOpenSearchSecurityResetIn) (*opensearch.ServiceOpenSearchSecurityResetOut, error)) *MockClient_ServiceOpenSearchSecurityReset_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceOpenSearchSecuritySet provides a mock function for the type MockClient
func (_mock *MockClient) ServiceOpenSearchSecuritySet(ctx context.Context, project1 string, serviceName string, in *opensearch.ServiceOpenSearchSecuritySetIn) (*opensearch.ServiceOpenSearchSecuritySetOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 *opensearch.ServiceOpenSearchSecuritySetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *opensearch.ServiceOpenSearchSecuritySetIn) (*opensearch.ServiceOpenSearchSecuritySetOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *opensearch.ServiceOpenSearchSecuritySetIn) *opensearch.ServiceOpenSearchSecuritySetOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*opensearch.ServiceOpenSearchSecuritySetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *opensearch.ServiceOpenSearchSecuritySetIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceOpenSearchSecuritySet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceOpenSearchSecuritySet(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceOpenSearchSecuritySet_Call {
	return &MockClient_ServiceOpenSearchSecuritySet_Call{Call: _e.mock.On("ServiceOpenSearchSecuritySet", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceOpenSearchSecuritySet_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *opensearch.ServiceOpenSearchSecuritySetIn)) *MockClient_ServiceOpenSearchSecuritySet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*opensearch.ServiceOpenSearchSecuritySetIn))
	})
	return _c
}

func (_c *MockClient_ServiceOpenSearchSecuritySet_Call) Return(serviceOpenSearchSecuritySetOut *opensearch.ServiceOpenSearchSecuritySetOut, err error) *MockClient_ServiceOpenSearchSecuritySet_Call {
	_c.Call.Return(serviceOpenSearchSecuritySetOut, err)
	return _c
}

func (_c *MockClient_ServiceOpenSearchSecuritySet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *opensearch.ServiceOpenSearchSecuritySetIn) (*opensearch.ServiceOpenSearchSecuritySetOut, error)) *MockClient_ServiceOpenSearchSecuritySet_Call {
	_c.Call.Return(run)
	return _c
}

// ServicePGBouncerCreate provides a mock function for the type MockClient
func (_mock *MockClient) ServicePGBouncerCreate(ctx context.Context, project1 string, serviceName string, in *postgresql.ServicePgbouncerCreateIn) error {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *postgresql.ServicePgbouncerCreateIn) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServicePGBouncerCreate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServicePGBouncerCreate(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServicePGBouncerCreate_Call {
	return &MockClient_ServicePGBouncerCreate_Call{Call: _e.mock.On("ServicePGBouncerCreate", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServicePGBouncerCreate_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *postgresql.ServicePgbouncerCreateIn)) *MockClient_ServicePGBouncerCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*postgresql.ServicePgbouncerCreateIn))
	})
	return _c
}

func (_c *MockClient_ServicePGBouncerCreate_Call) Return(err error) *MockClient_ServicePGBouncerCreate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServicePGBouncerCreate_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *postgresql.ServicePgbouncerCreateIn) error) *MockClient_ServicePGBouncerCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ServicePGBouncerDelete provides a mock function for the type MockClient
func (_mock *MockClient) ServicePGBouncerDelete(ctx context.Context, project1 string, serviceName string, poolName string) error {
	ret := _mock.Called(ctx, project1, serviceName, poolName)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, poolName)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServicePGBouncerDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - poolName
func (_e *MockClient_Expecter) ServicePGBouncerDelete(ctx interface{}, project1 interface{}, serviceName interface{}, poolName interface{}) *MockClient_ServicePGBouncerDelete_Call {
	return &MockClient_ServicePGBouncerDelete_Call{Call: _e.mock.On("ServicePGBouncerDelete", ctx, project1, serviceName, poolName)}
}

func (_c *MockClient_ServicePGBouncerDelete_Call) Run(run func(ctx context.Context, project1 string, serviceName string, poolName string)) *MockClient_ServicePGBouncerDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServicePGBouncerDelete_Call) Return(err error) *MockClient_ServicePGBouncerDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServicePGBouncerDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, poolName string) error) *MockClient_ServicePGBouncerDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ServicePGBouncerUpdate provides a mock function for the type MockClient
func (_mock *MockClient) ServicePGBouncerUpdate(ctx context.Context, project1 string, serviceName string, poolName string, in *postgresql.ServicePgbouncerUpdateIn) error {
	ret := _mock.Called(ctx, project1, serviceName, poolName, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *postgresql.ServicePgbouncerUpdateIn) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, poolName, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServicePGBouncerUpdate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - poolName
//   - in
func (_e *MockClient_Expecter) ServicePGBouncerUpdate(ctx interface{}, project1 interface{}, serviceName interface{}, poolName interface{}, in interface{}) *MockClient_ServicePGBouncerUpdate_Call {
	return &MockClient_ServicePGBouncerUpdate_Call{Call: _e.mock.On("ServicePGBouncerUpdate", ctx, project1, serviceName, poolName, in)}
}

func (_c *MockClient_ServicePGBouncerUpdate_Call) Run(run func(ctx context.Context, project1 string, serviceName string, poolName string, in *postgresql.ServicePgbouncerUpdateIn)) *MockClient_ServicePGBouncerUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*postgresql.ServicePgbouncerUpdateIn))
	})
	return _c
}

func (_c *MockClient_ServicePGBouncerUpdate_Call) Return(err error) *MockClient_ServicePGBouncerUpdate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServicePGBouncerUpdate_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, poolName string, in *postgresql.ServicePgbouncerUpdateIn) error) *MockClient_ServicePGBouncerUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// ServicePrivatelinkAWSConnectionList provides a mock function for the type MockClient
func (_mock *MockClient) ServicePrivatelinkAWSConnectionList(ctx context.Context, project1 string, serviceName string) ([]privatelink.ConnectionOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []privatelink.ConnectionOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]privatelink.ConnectionOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []privatelink.ConnectionOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]privatelink.ConnectionOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServicePrivatelinkAWSConnectionList is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServicePrivatelinkAWSConnectionList(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServicePrivatelinkAWSConnectionList_Call {
	return &MockClient_ServicePrivatelinkAWSConnectionList_Call{Call: _e.mock.On("ServicePrivatelinkAWSConnectionList", ctx, project1, serviceName)}
}

func (_c *MockClient_ServicePrivatelinkAWSConnectionList_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServicePrivatelinkAWSConnectionList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServicePrivatelinkAWSConnectionList_Call) Return(connectionOuts []privatelink.ConnectionOut, err error) *MockClient_ServicePrivatelinkAWSConnectionList_Call {
	_c.Call.Return(connectionOuts, err)
	return _c
}

func (_c *MockClient_ServicePrivatelinkAWSConnectionList_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]privatelink.ConnectionOut, error)) *MockClient_ServicePrivatelinkAWSConnectionList_Call {
	_c.Call.Return(run)
	return _c
}

// ServicePrivatelinkAWSCreate provides a mock function for the type MockClient
func (_mock *MockClient) ServicePrivatelinkAWSCreate(ctx context.Context, project1 string, serviceName string, in *privatelink.ServicePrivatelinkAwscreateIn) (*privatelink.ServicePrivatelinkAwscreateOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 *privatelink.ServicePrivatelinkAwscreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *privatelink.ServicePrivatelinkAwscreateIn) (*privatelink.ServicePrivatelinkAwscreateOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *privatelink.ServicePrivatelinkAwscreateIn) *privatelink.ServicePrivatelinkAwscreateOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*privatelink.ServicePrivatelinkAwscreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *privatelink.ServicePrivatelinkAwscreateIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServicePrivatelinkAWSCreate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServicePrivatelinkAWSCreate(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServicePrivatelinkAWSCreate_Call {
	return &MockClient_ServicePrivatelinkAWSCreate_Call{Call: _e.mock.On("ServicePrivatelinkAWSCreate", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServicePrivatelinkAWSCreate_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *privatelink.ServicePrivatelinkAwscreateIn)) *MockClient_ServicePrivatelinkAWSCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*privatelink.ServicePrivatelinkAwscreateIn))
	})
	return _c
}

func (_c *MockClient_ServicePrivatelinkAWSCreate_Call) Return(servicePrivatelinkAwscreateOut *privatelink.ServicePrivatelinkAwscreateOut, err error) *MockClient_ServicePrivatelinkAWSCreate_Call {
	_c.Call.Return(servicePrivatelinkAwscreateOut, err)
	return _c
}

func (_c *MockClient_ServicePrivatelinkAWSCreate_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *privatelink.ServicePrivatelinkAwscreateIn) (*privatelink.ServicePrivatelinkAwscreateOut, error)) *MockClient_ServicePrivatelinkAWSCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ServicePrivatelinkAWSDelete provides a mock function for the type MockClient
func (_mock *MockClient) ServicePrivatelinkAWSDelete(ctx context.Context, project1 string, serviceName string) (*privatelink.ServicePrivatelinkAwsdeleteOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 *privatelink.ServicePrivatelinkAwsdeleteOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*privatelink.ServicePrivatelinkAwsdeleteOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *privatelink.ServicePrivatelinkAwsdeleteOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*privatelink.ServicePrivatelinkAwsdeleteOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServicePrivatelinkAWSDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServicePrivatelinkAWSDelete(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServicePrivatelinkAWSDelete_Call {
	return &MockClient_ServicePrivatelinkAWSDelete_Call{Call: _e.mock.On("ServicePrivatelinkAWSDelete", ctx, project1, serviceName)}
}

func (_c *MockClient_ServicePrivatelinkAWSDelete_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServicePrivatelinkAWSDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServicePrivatelinkAWSDelete_Call) Return(servicePrivatelinkAwsdeleteOut *privatelink.ServicePrivatelinkAwsdeleteOut, err error) *MockClient_ServicePrivatelinkAWSDelete_Call {
	_c.Call.Return(servicePrivatelinkAwsdeleteOut, err)
	return _c
}

func (_c *MockClient_ServicePrivatelinkAWSDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) (*privatelink.ServicePrivatelinkAwsdeleteOut, error)) *MockClient_ServicePrivatelinkAWSDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ServicePrivatelinkAWSGet provides a mock function for the type MockClient
func (_mock *MockClient) ServicePrivatelinkAWSGet(ctx context.Context, project1 string, serviceName string) (*privatelink.ServicePrivatelinkAwsgetOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 *privatelink.ServicePrivatelinkAwsgetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*privatelink.ServicePrivatelinkAwsgetOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *privatelink.ServicePrivatelinkAwsgetOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*privatelink.ServicePrivatelinkAwsgetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServicePrivatelinkAWSGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServicePrivatelinkAWSGet(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServicePrivatelinkAWSGet_Call {
	return &MockClient_ServicePrivatelinkAWSGet_Call{Call: _e.mock.On("ServicePrivatelinkAWSGet", ctx, project1, serviceName)}
}

func (_c *MockClient_ServicePrivatelinkAWSGet_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServicePrivatelinkAWSGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServicePrivatelinkAWSGet_Call) Return(servicePrivatelinkAwsgetOut *privatelink.ServicePrivatelinkAwsgetOut, err error) *MockClient_ServicePrivatelinkAWSGet_Call {
	_c.Call.Return(servicePrivatelinkAwsgetOut, err)
	return _c
}

func (_c *MockClient_ServicePrivatelinkAWSGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) (*privatelink.ServicePrivatelinkAwsgetOut, error)) *MockClient_ServicePrivatelinkAWSGet_Call {
	_c.Call.Return(run)
	return _c
}

// ServicePrivatelinkAWSUpdate provides a mock function for the type MockClient
func (_mock *MockClient) ServicePrivatelinkAWSUpdate(ctx context.Context, project1 string, serviceName string, in *privatelink.ServicePrivatelinkAwsupdateIn) (*privatelink.ServicePrivatelinkAwsupdateOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 *privatelink.ServicePrivatelinkAwsupdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *privatelink.ServicePrivatelinkAwsupdateIn) (*privatelink.ServicePrivatelinkAwsupdateOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *privatelink.ServicePrivatelinkAwsupdateIn) *privatelink.ServicePrivatelinkAwsupdateOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*privatelink.ServicePrivatelinkAwsupdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *privatelink.ServicePrivatelinkAwsupdateIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServicePrivatelinkAWSUpdate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServicePrivatelinkAWSUpdate(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServicePrivatelinkAWSUpdate_Call {
	return &MockClient_ServicePrivatelinkAWSUpdate_Call{Call: _e.mock.On("ServicePrivatelinkAWSUpdate", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServicePrivatelinkAWSUpdate_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *privatelink.ServicePrivatelinkAwsupdateIn)) *MockClient_ServicePrivatelinkAWSUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*privatelink.ServicePrivatelinkAwsupdateIn))
	})
	return _c
}

func (_c *MockClient_ServicePrivatelinkAWSUpdate_Call) Return(servicePrivatelinkAwsupdateOut *privatelink.ServicePrivatelinkAwsupdateOut, err error) *MockClient_ServicePrivatelinkAWSUpdate_Call {
	_c.Call.Return(servicePrivatelinkAwsupdateOut, err)
	return _c
}

func (_c *MockClient_ServicePrivatelinkAWSUpdate_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *privatelink.ServicePrivatelinkAwsupdateIn) (*privatelink.ServicePrivatelinkAwsupdateOut, error)) *MockClient_ServicePrivatelinkAWSUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// ServicePrivatelinkAzureConnectionApproval provides a mock function for the type MockClient
func (_mock *MockClient) ServicePrivatelinkAzureConnectionApproval(ctx context.Context, project1 string, serviceName string, privatelinkConnectionId string) (*privatelink.ServicePrivatelinkAzureConnectionApprovalOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, privatelinkConnectionId)

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

	var r0 *privatelink.ServicePrivatelinkAzureConnectionApprovalOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*privatelink.ServicePrivatelinkAzureConnectionApprovalOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, privatelinkConnectionId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *privatelink.ServicePrivatelinkAzureConnectionApprovalOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, privatelinkConnectionId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*privatelink.ServicePrivatelinkAzureConnectionApprovalOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, privatelinkConnectionId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServicePrivatelinkAzureConnectionApproval is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - privatelinkConnectionId
func (_e *MockClient_Expecter) ServicePrivatelinkAzureConnectionApproval(ctx interface{}, project1 interface{}, serviceName interface{}, privatelinkConnectionId interface{}) *MockClient_ServicePrivatelinkAzureConnectionApproval_Call {
	return &MockClient_ServicePrivatelinkAzureConnectionApproval_Call{Call: _e.mock.On("ServicePrivatelinkAzureConnectionApproval", ctx, project1, serviceName, privatelinkConnectionId)}
}

func (_c *MockClient_ServicePrivatelinkAzureConnectionApproval_Call) Run(run func(ctx context.Context, project1 string, serviceName string, privatelinkConnectionId string)) *MockClient_ServicePrivatelinkAzureConnectionApproval_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServicePrivatelinkAzureConnectionApproval_Call) Return(servicePrivatelinkAzureConnectionApprovalOut *privatelink.ServicePrivatelinkAzureConnectionApprovalOut, err error) *MockClient_ServicePrivatelinkAzureConnectionApproval_Call {
	_c.Call.Return(servicePrivatelinkAzureConnectionApprovalOut, err)
	return _c
}

func (_c *MockClient_ServicePrivatelinkAzureConnectionApproval_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, privatelinkConnectionId string) (*privatelink.ServicePrivatelinkAzureConnectionApprovalOut, error)) *MockClient_ServicePrivatelinkAzureConnectionApproval_Call {
	_c.Call.Return(run)
	return _c
}

// ServicePrivatelinkAzureConnectionList provides a mock function for the type MockClient
func (_mock *MockClient) ServicePrivatelinkAzureConnectionList(ctx context.Context, project1 string, serviceName string) ([]privatelink.ServicePrivatelinkAzureConnectionListOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []privatelink.ServicePrivatelinkAzureConnectionListOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]privatelink.ServicePrivatelinkAzureConnectionListOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []privatelink.ServicePrivatelinkAzureConnectionListOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]privatelink.ServicePrivatelinkAzureConnectionListOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServicePrivatelinkAzureConnectionList is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServicePrivatelinkAzureConnectionList(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServicePrivatelinkAzureConnectionList_Call {
	return &MockClient_ServicePrivatelinkAzureConnectionList_Call{Call: _e.mock.On("ServicePrivatelinkAzureConnectionList", ctx, project1, serviceName)}
}

func (_c *MockClient_ServicePrivatelinkAzureConnectionList_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServicePrivatelinkAzureConnectionList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServicePrivatelinkAzureConnectionList_Call) Return(servicePrivatelinkAzureConnectionListOuts []privatelink.ServicePrivatelinkAzureConnectionListOut, err error) *MockClient_ServicePrivatelinkAzureConnectionList_Call {
	_c.Call.Return(servicePrivatelinkAzureConnectionListOuts, err)
	return _c
}

func (_c *MockClient_ServicePrivatelinkAzureConnectionList_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]privatelink.ServicePrivatelinkAzureConnectionListOut, error)) *MockClient_ServicePrivatelinkAzureConnectionList_Call {
	_c.Call.Return(run)
	return _c
}

// ServicePrivatelinkAzureConnectionUpdate provides a mock function for the type MockClient
func (_mock *MockClient) ServicePrivatelinkAzureConnectionUpdate(ctx context.Context, project1 string, serviceName string, privatelinkConnectionId string, in *privatelink.ServicePrivatelinkAzureConnectionUpdateIn) (*privatelink.ServicePrivatelinkAzureConnectionUpdateOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, privatelinkConnectionId, in)

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

	var r0 *privatelink.ServicePrivatelinkAzureConnectionUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *privatelink.ServicePrivatelinkAzureConnectionUpdateIn) (*privatelink.ServicePrivatelinkAzureConnectionUpdateOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, privatelinkConnectionId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *privatelink.ServicePrivatelinkAzureConnectionUpdateIn) *privatelink.ServicePrivatelinkAzureConnectionUpdateOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, privatelinkConnectionId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*privatelink.ServicePrivatelinkAzureConnectionUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, *privatelink.ServicePrivatelinkAzureConnectionUpdateIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, privatelinkConnectionId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServicePrivatelinkAzureConnectionUpdate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - privatelinkConnectionId
//   - in
func (_e *MockClient_Expecter) ServicePrivatelinkAzureConnectionUpdate(ctx interface{}, project1 interface{}, serviceName interface{}, privatelinkConnectionId interface{}, in interface{}) *MockClient_ServicePrivatelinkAzureConnectionUpdate_Call {
	return &MockClient_ServicePrivatelinkAzureConnectionUpdate_Call{Call: _e.mock.On("ServicePrivatelinkAzureConnectionUpdate", ctx, project1, serviceName, privatelinkConnectionId, in)}
}

func (_c *MockClient_ServicePrivatelinkAzureConnectionUpdate_Call) Run(run func(ctx context.Context, project1 string, serviceName string, privatelinkConnectionId string, in *privatelink.ServicePrivatelinkAzureConnectionUpdateIn)) *MockClient_ServicePrivatelinkAzureConnectionUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*privatelink.ServicePrivatelinkAzureConnectionUpdateIn))
	})
	return _c
}

func (_c *MockClient_ServicePrivatelinkAzureConnectionUpdate_Call) Return(servicePrivatelinkAzureConnectionUpdateOut *privatelink.ServicePrivatelinkAzureConnectionUpdateOut, err error) *MockClient_ServicePrivatelinkAzureConnectionUpdate_Call {
	_c.Call.Return(servicePrivatelinkAzureConnectionUpdateOut, err)
	return _c
}

func (_c *MockClient_ServicePrivatelinkAzureConnectionUpdate_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, privatelinkConnectionId string, in *privatelink.ServicePrivatelinkAzureConnectionUpdateIn) (*privatelink.ServicePrivatelinkAzureConnectionUpdateOut, error)) *MockClient_ServicePrivatelinkAzureConnectionUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// ServicePrivatelinkAzureCreate provides a mock function for the type MockClient
func (_mock *MockClient) ServicePrivatelinkAzureCreate(ctx context.Context, project1 string, serviceName string, in *privatelink.ServicePrivatelinkAzureCreateIn) (*privatelink.ServicePrivatelinkAzureCreateOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 *privatelink.ServicePrivatelinkAzureCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *privatelink.ServicePrivatelinkAzureCreateIn) (*privatelink.ServicePrivatelinkAzureCreateOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *privatelink.ServicePrivatelinkAzureCreateIn) *privatelink.ServicePrivatelinkAzureCreateOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*privatelink.ServicePrivatelinkAzureCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *privatelink.ServicePrivatelinkAzureCreateIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServicePrivatelinkAzureCreate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServicePrivatelinkAzureCreate(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServicePrivatelinkAzureCreate_Call {
	return &MockClient_ServicePrivatelinkAzureCreate_Call{Call: _e.mock.On("ServicePrivatelinkAzureCreate", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServicePrivatelinkAzureCreate_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *privatelink.ServicePrivatelinkAzureCreateIn)) *MockClient_ServicePrivatelinkAzureCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*privatelink.ServicePrivatelinkAzureCreateIn))
	})
	return _c
}

func (_c *MockClient_ServicePrivatelinkAzureCreate_Call) Return(servicePrivatelinkAzureCreateOut *privatelink.ServicePrivatelinkAzureCreateOut, err error) *MockClient_ServicePrivatelinkAzureCreate_Call {
	_c.Call.Return(servicePrivatelinkAzureCreateOut, err)
	return _c
}

func (_c *MockClient_ServicePrivatelinkAzureCreate_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *privatelink.ServicePrivatelinkAzureCreateIn) (*privatelink.ServicePrivatelinkAzureCreateOut, error)) *MockClient_ServicePrivatelinkAzureCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ServicePrivatelinkAzureDelete provides a mock function for the type MockClient
func (_mock *MockClient) ServicePrivatelinkAzureDelete(ctx context.Context, project1 string, serviceName string) (*privatelink.ServicePrivatelinkAzureDeleteOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 *privatelink.ServicePrivatelinkAzureDeleteOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*privatelink.ServicePrivatelinkAzureDeleteOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *privatelink.ServicePrivatelinkAzureDeleteOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*privatelink.ServicePrivatelinkAzureDeleteOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServicePrivatelinkAzureDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServicePrivatelinkAzureDelete(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServicePrivatelinkAzureDelete_Call {
	return &MockClient_ServicePrivatelinkAzureDelete_Call{Call: _e.mock.On("ServicePrivatelinkAzureDelete", ctx, project1, serviceName)}
}

func (_c *MockClient_ServicePrivatelinkAzureDelete_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServicePrivatelinkAzureDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServicePrivatelinkAzureDelete_Call) Return(servicePrivatelinkAzureDeleteOut *privatelink.ServicePrivatelinkAzureDeleteOut, err error) *MockClient_ServicePrivatelinkAzureDelete_Call {
	_c.Call.Return(servicePrivatelinkAzureDeleteOut, err)
	return _c
}

func (_c *MockClient_ServicePrivatelinkAzureDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) (*privatelink.ServicePrivatelinkAzureDeleteOut, error)) *MockClient_ServicePrivatelinkAzureDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ServicePrivatelinkAzureGet provides a mock function for the type MockClient
func (_mock *MockClient) ServicePrivatelinkAzureGet(ctx context.Context, project1 string, serviceName string) (*privatelink.ServicePrivatelinkAzureGetOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 *privatelink.ServicePrivatelinkAzureGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*privatelink.ServicePrivatelinkAzureGetOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *privatelink.ServicePrivatelinkAzureGetOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*privatelink.ServicePrivatelinkAzureGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServicePrivatelinkAzureGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServicePrivatelinkAzureGet(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServicePrivatelinkAzureGet_Call {
	return &MockClient_ServicePrivatelinkAzureGet_Call{Call: _e.mock.On("ServicePrivatelinkAzureGet", ctx, project1, serviceName)}
}

func (_c *MockClient_ServicePrivatelinkAzureGet_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServicePrivatelinkAzureGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServicePrivatelinkAzureGet_Call) Return(servicePrivatelinkAzureGetOut *privatelink.ServicePrivatelinkAzureGetOut, err error) *MockClient_ServicePrivatelinkAzureGet_Call {
	_c.Call.Return(servicePrivatelinkAzureGetOut, err)
	return _c
}

func (_c *MockClient_ServicePrivatelinkAzureGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) (*privatelink.ServicePrivatelinkAzureGetOut, error)) *MockClient_ServicePrivatelinkAzureGet_Call {
	_c.Call.Return(run)
	return _c
}

// ServicePrivatelinkAzureUpdate provides a mock function for the type MockClient
func (_mock *MockClient) ServicePrivatelinkAzureUpdate(ctx context.Context, project1 string, serviceName string, in *privatelink.ServicePrivatelinkAzureUpdateIn) (*privatelink.ServicePrivatelinkAzureUpdateOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 *privatelink.ServicePrivatelinkAzureUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *privatelink.ServicePrivatelinkAzureUpdateIn) (*privatelink.ServicePrivatelinkAzureUpdateOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *privatelink.ServicePrivatelinkAzureUpdateIn) *privatelink.ServicePrivatelinkAzureUpdateOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*privatelink.ServicePrivatelinkAzureUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *privatelink.ServicePrivatelinkAzureUpdateIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServicePrivatelinkAzureUpdate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServicePrivatelinkAzureUpdate(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServicePrivatelinkAzureUpdate_Call {
	return &MockClient_ServicePrivatelinkAzureUpdate_Call{Call: _e.mock.On("ServicePrivatelinkAzureUpdate", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServicePrivatelinkAzureUpdate_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *privatelink.ServicePrivatelinkAzureUpdateIn)) *MockClient_ServicePrivatelinkAzureUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*privatelink.ServicePrivatelinkAzureUpdateIn))
	})
	return _c
}

func (_c *MockClient_ServicePrivatelinkAzureUpdate_Call) Return(servicePrivatelinkAzureUpdateOut *privatelink.ServicePrivatelinkAzureUpdateOut, err error) *MockClient_ServicePrivatelinkAzureUpdate_Call {
	_c.Call.Return(servicePrivatelinkAzureUpdateOut, err)
	return _c
}

func (_c *MockClient_ServicePrivatelinkAzureUpdate_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *privatelink.ServicePrivatelinkAzureUpdateIn) (*privatelink.ServicePrivatelinkAzureUpdateOut, error)) *MockClient_ServicePrivatelinkAzureUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceQueryActivity provides a mock function for the type MockClient
func (_mock *MockClient) ServiceQueryActivity(ctx context.Context, project1 string, serviceName string, in *service.ServiceQueryActivityIn) ([]service.QueryOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 []service.QueryOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ServiceQueryActivityIn) ([]service.QueryOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ServiceQueryActivityIn) []service.QueryOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]service.QueryOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *service.ServiceQueryActivityIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceQueryActivity is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceQueryActivity(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceQueryActivity_Call {
	return &MockClient_ServiceQueryActivity_Call{Call: _e.mock.On("ServiceQueryActivity", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceQueryActivity_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *service.ServiceQueryActivityIn)) *MockClient_ServiceQueryActivity_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*service.ServiceQueryActivityIn))
	})
	return _c
}

func (_c *MockClient_ServiceQueryActivity_Call) Return(queryOuts []service.QueryOut, err error) *MockClient_ServiceQueryActivity_Call {
	_c.Call.Return(queryOuts, err)
	return _c
}

func (_c *MockClient_ServiceQueryActivity_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *service.ServiceQueryActivityIn) ([]service.QueryOut, error)) *MockClient_ServiceQueryActivity_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceQueryStatisticsReset provides a mock function for the type MockClient
func (_mock *MockClient) ServiceQueryStatisticsReset(ctx context.Context, project1 string, serviceName string) ([]map[string]any, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []map[string]any
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]map[string]any, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []map[string]any); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]map[string]any)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceQueryStatisticsReset is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceQueryStatisticsReset(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceQueryStatisticsReset_Call {
	return &MockClient_ServiceQueryStatisticsReset_Call{Call: _e.mock.On("ServiceQueryStatisticsReset", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceQueryStatisticsReset_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceQueryStatisticsReset_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceQueryStatisticsReset_Call) Return(stringToVs []map[string]any, err error) *MockClient_ServiceQueryStatisticsReset_Call {
	_c.Call.Return(stringToVs, err)
	return _c
}

func (_c *MockClient_ServiceQueryStatisticsReset_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]map[string]any, error)) *MockClient_ServiceQueryStatisticsReset_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceSchemaRegistryAclAdd provides a mock function for the type MockClient
func (_mock *MockClient) ServiceSchemaRegistryAclAdd(ctx context.Context, project1 string, serviceName string, in *kafkaschemaregistry.ServiceSchemaRegistryAclAddIn) ([]kafkaschemaregistry.AclOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 []kafkaschemaregistry.AclOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *kafkaschemaregistry.ServiceSchemaRegistryAclAddIn) ([]kafkaschemaregistry.AclOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *kafkaschemaregistry.ServiceSchemaRegistryAclAddIn) []kafkaschemaregistry.AclOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]kafkaschemaregistry.AclOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *kafkaschemaregistry.ServiceSchemaRegistryAclAddIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceSchemaRegistryAclAdd is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceSchemaRegistryAclAdd(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceSchemaRegistryAclAdd_Call {
	return &MockClient_ServiceSchemaRegistryAclAdd_Call{Call: _e.mock.On("ServiceSchemaRegistryAclAdd", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceSchemaRegistryAclAdd_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *kafkaschemaregistry.ServiceSchemaRegistryAclAddIn)) *MockClient_ServiceSchemaRegistryAclAdd_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*kafkaschemaregistry.ServiceSchemaRegistryAclAddIn))
	})
	return _c
}

func (_c *MockClient_ServiceSchemaRegistryAclAdd_Call) Return(aclOuts []kafkaschemaregistry.AclOut, err error) *MockClient_ServiceSchemaRegistryAclAdd_Call {
	_c.Call.Return(aclOuts, err)
	return _c
}

func (_c *MockClient_ServiceSchemaRegistryAclAdd_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *kafkaschemaregistry.ServiceSchemaRegistryAclAddIn) ([]kafkaschemaregistry.AclOut, error)) *MockClient_ServiceSchemaRegistryAclAdd_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceSchemaRegistryAclDelete provides a mock function for the type MockClient
func (_mock *MockClient) ServiceSchemaRegistryAclDelete(ctx context.Context, project1 string, serviceName string, schemaRegistryAclId string) ([]kafkaschemaregistry.AclOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, schemaRegistryAclId)

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

	var r0 []kafkaschemaregistry.AclOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) ([]kafkaschemaregistry.AclOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, schemaRegistryAclId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) []kafkaschemaregistry.AclOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, schemaRegistryAclId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]kafkaschemaregistry.AclOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, schemaRegistryAclId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceSchemaRegistryAclDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - schemaRegistryAclId
func (_e *MockClient_Expecter) ServiceSchemaRegistryAclDelete(ctx interface{}, project1 interface{}, serviceName interface{}, schemaRegistryAclId interface{}) *MockClient_ServiceSchemaRegistryAclDelete_Call {
	return &MockClient_ServiceSchemaRegistryAclDelete_Call{Call: _e.mock.On("ServiceSchemaRegistryAclDelete", ctx, project1, serviceName, schemaRegistryAclId)}
}

func (_c *MockClient_ServiceSchemaRegistryAclDelete_Call) Run(run func(ctx context.Context, project1 string, serviceName string, schemaRegistryAclId string)) *MockClient_ServiceSchemaRegistryAclDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceSchemaRegistryAclDelete_Call) Return(aclOuts []kafkaschemaregistry.AclOut, err error) *MockClient_ServiceSchemaRegistryAclDelete_Call {
	_c.Call.Return(aclOuts, err)
	return _c
}

func (_c *MockClient_ServiceSchemaRegistryAclDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, schemaRegistryAclId string) ([]kafkaschemaregistry.AclOut, error)) *MockClient_ServiceSchemaRegistryAclDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceSchemaRegistryAclList provides a mock function for the type MockClient
func (_mock *MockClient) ServiceSchemaRegistryAclList(ctx context.Context, project1 string, serviceName string) ([]kafkaschemaregistry.AclOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 []kafkaschemaregistry.AclOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]kafkaschemaregistry.AclOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []kafkaschemaregistry.AclOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]kafkaschemaregistry.AclOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceSchemaRegistryAclList is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceSchemaRegistryAclList(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceSchemaRegistryAclList_Call {
	return &MockClient_ServiceSchemaRegistryAclList_Call{Call: _e.mock.On("ServiceSchemaRegistryAclList", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceSchemaRegistryAclList_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceSchemaRegistryAclList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceSchemaRegistryAclList_Call) Return(aclOuts []kafkaschemaregistry.AclOut, err error) *MockClient_ServiceSchemaRegistryAclList_Call {
	_c.Call.Return(aclOuts, err)
	return _c
}

func (_c *MockClient_ServiceSchemaRegistryAclList_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]kafkaschemaregistry.AclOut, error)) *MockClient_ServiceSchemaRegistryAclList_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceSchemaRegistryCompatibility provides a mock function for the type MockClient
func (_mock *MockClient) ServiceSchemaRegistryCompatibility(ctx context.Context, project1 string, serviceName string, subjectName string, versionId int, in *kafkaschemaregistry.ServiceSchemaRegistryCompatibilityIn) (*kafkaschemaregistry.ServiceSchemaRegistryCompatibilityOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, subjectName, versionId, in)

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

	var r0 *kafkaschemaregistry.ServiceSchemaRegistryCompatibilityOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, int, *kafkaschemaregistry.ServiceSchemaRegistryCompatibilityIn) (*kafkaschemaregistry.ServiceSchemaRegistryCompatibilityOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, subjectName, versionId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, int, *kafkaschemaregistry.ServiceSchemaRegistryCompatibilityIn) *kafkaschemaregistry.ServiceSchemaRegistryCompatibilityOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, subjectName, versionId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*kafkaschemaregistry.ServiceSchemaRegistryCompatibilityOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, int, *kafkaschemaregistry.ServiceSchemaRegistryCompatibilityIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, subjectName, versionId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceSchemaRegistryCompatibility is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - subjectName
//   - versionId
//   - in
func (_e *MockClient_Expecter) ServiceSchemaRegistryCompatibility(ctx interface{}, project1 interface{}, serviceName interface{}, subjectName interface{}, versionId interface{}, in interface{}) *MockClient_ServiceSchemaRegistryCompatibility_Call {
	return &MockClient_ServiceSchemaRegistryCompatibility_Call{Call: _e.mock.On("ServiceSchemaRegistryCompatibility", ctx, project1, serviceName, subjectName, versionId, in)}
}

func (_c *MockClient_ServiceSchemaRegistryCompatibility_Call) Run(run func(ctx context.Context, project1 string, serviceName string, subjectName string, versionId int, in *kafkaschemaregistry.ServiceSchemaRegistryCompatibilityIn)) *MockClient_ServiceSchemaRegistryCompatibility_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(int), args[5].(*kafkaschemaregistry.ServiceSchemaRegistryCompatibilityIn))
	})
	return _c
}

func (_c *MockClient_ServiceSchemaRegistryCompatibility_Call) Return(serviceSchemaRegistryCompatibilityOut *kafkaschemaregistry.ServiceSchemaRegistryCompatibilityOut, err error) *MockClient_ServiceSchemaRegistryCompatibility_Call {
	_c.Call.Return(serviceSchemaRegistryCompatibilityOut, err)
	return _c
}

func (_c *MockClient_ServiceSchemaRegistryCompatibility_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, subjectName string, versionId int, in *kafkaschemaregistry.ServiceSchemaRegistryCompatibilityIn) (*kafkaschemaregistry.ServiceSchemaRegistryCompatibilityOut, error)) *MockClient_ServiceSchemaRegistryCompatibility_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceSchemaRegistryGlobalConfigGet provides a mock function for the type MockClient
func (_mock *MockClient) ServiceSchemaRegistryGlobalConfigGet(ctx context.Context, project1 string, serviceName string) (kafkaschemaregistry.CompatibilityType, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 kafkaschemaregistry.CompatibilityType
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (kafkaschemaregistry.CompatibilityType, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) kafkaschemaregistry.CompatibilityType); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		r0 = ret.Get(0).(kafkaschemaregistry.CompatibilityType)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceSchemaRegistryGlobalConfigGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceSchemaRegistryGlobalConfigGet(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceSchemaRegistryGlobalConfigGet_Call {
	return &MockClient_ServiceSchemaRegistryGlobalConfigGet_Call{Call: _e.mock.On("ServiceSchemaRegistryGlobalConfigGet", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceSchemaRegistryGlobalConfigGet_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceSchemaRegistryGlobalConfigGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceSchemaRegistryGlobalConfigGet_Call) Return(compatibilityType kafkaschemaregistry.CompatibilityType, err error) *MockClient_ServiceSchemaRegistryGlobalConfigGet_Call {
	_c.Call.Return(compatibilityType, err)
	return _c
}

func (_c *MockClient_ServiceSchemaRegistryGlobalConfigGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) (kafkaschemaregistry.CompatibilityType, error)) *MockClient_ServiceSchemaRegistryGlobalConfigGet_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceSchemaRegistryGlobalConfigPut provides a mock function for the type MockClient
func (_mock *MockClient) ServiceSchemaRegistryGlobalConfigPut(ctx context.Context, project1 string, serviceName string, in *kafkaschemaregistry.ServiceSchemaRegistryGlobalConfigPutIn) (kafkaschemaregistry.CompatibilityType, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 kafkaschemaregistry.CompatibilityType
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *kafkaschemaregistry.ServiceSchemaRegistryGlobalConfigPutIn) (kafkaschemaregistry.CompatibilityType, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *kafkaschemaregistry.ServiceSchemaRegistryGlobalConfigPutIn) kafkaschemaregistry.CompatibilityType); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r0 = ret.Get(0).(kafkaschemaregistry.CompatibilityType)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *kafkaschemaregistry.ServiceSchemaRegistryGlobalConfigPutIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceSchemaRegistryGlobalConfigPut is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceSchemaRegistryGlobalConfigPut(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceSchemaRegistryGlobalConfigPut_Call {
	return &MockClient_ServiceSchemaRegistryGlobalConfigPut_Call{Call: _e.mock.On("ServiceSchemaRegistryGlobalConfigPut", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceSchemaRegistryGlobalConfigPut_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *kafkaschemaregistry.ServiceSchemaRegistryGlobalConfigPutIn)) *MockClient_ServiceSchemaRegistryGlobalConfigPut_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*kafkaschemaregistry.ServiceSchemaRegistryGlobalConfigPutIn))
	})
	return _c
}

func (_c *MockClient_ServiceSchemaRegistryGlobalConfigPut_Call) Return(compatibilityType kafkaschemaregistry.CompatibilityType, err error) *MockClient_ServiceSchemaRegistryGlobalConfigPut_Call {
	_c.Call.Return(compatibilityType, err)
	return _c
}

func (_c *MockClient_ServiceSchemaRegistryGlobalConfigPut_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *kafkaschemaregistry.ServiceSchemaRegistryGlobalConfigPutIn) (kafkaschemaregistry.CompatibilityType, error)) *MockClient_ServiceSchemaRegistryGlobalConfigPut_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceSchemaRegistrySchemaGet provides a mock function for the type MockClient
func (_mock *MockClient) ServiceSchemaRegistrySchemaGet(ctx context.Context, project1 string, serviceName string, schemaId string) error {
	ret := _mock.Called(ctx, project1, serviceName, schemaId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, schemaId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceSchemaRegistrySchemaGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - schemaId
func (_e *MockClient_Expecter) ServiceSchemaRegistrySchemaGet(ctx interface{}, project1 interface{}, serviceName interface{}, schemaId interface{}) *MockClient_ServiceSchemaRegistrySchemaGet_Call {
	return &MockClient_ServiceSchemaRegistrySchemaGet_Call{Call: _e.mock.On("ServiceSchemaRegistrySchemaGet", ctx, project1, serviceName, schemaId)}
}

func (_c *MockClient_ServiceSchemaRegistrySchemaGet_Call) Run(run func(ctx context.Context, project1 string, serviceName string, schemaId string)) *MockClient_ServiceSchemaRegistrySchemaGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceSchemaRegistrySchemaGet_Call) Return(err error) *MockClient_ServiceSchemaRegistrySchemaGet_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceSchemaRegistrySchemaGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, schemaId string) error) *MockClient_ServiceSchemaRegistrySchemaGet_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceSchemaRegistrySubjectConfigGet provides a mock function for the type MockClient
func (_mock *MockClient) ServiceSchemaRegistrySubjectConfigGet(ctx context.Context, project1 string, serviceName string, subjectName string) (kafkaschemaregistry.CompatibilityType, error) {
	ret := _mock.Called(ctx, project1, serviceName, subjectName)

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

	var r0 kafkaschemaregistry.CompatibilityType
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (kafkaschemaregistry.CompatibilityType, error)); ok {
		return returnFunc(ctx, project1, serviceName, subjectName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) kafkaschemaregistry.CompatibilityType); ok {
		r0 = returnFunc(ctx, project1, serviceName, subjectName)
	} else {
		r0 = ret.Get(0).(kafkaschemaregistry.CompatibilityType)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, subjectName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceSchemaRegistrySubjectConfigGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - subjectName
func (_e *MockClient_Expecter) ServiceSchemaRegistrySubjectConfigGet(ctx interface{}, project1 interface{}, serviceName interface{}, subjectName interface{}) *MockClient_ServiceSchemaRegistrySubjectConfigGet_Call {
	return &MockClient_ServiceSchemaRegistrySubjectConfigGet_Call{Call: _e.mock.On("ServiceSchemaRegistrySubjectConfigGet", ctx, project1, serviceName, subjectName)}
}

func (_c *MockClient_ServiceSchemaRegistrySubjectConfigGet_Call) Run(run func(ctx context.Context, project1 string, serviceName string, subjectName string)) *MockClient_ServiceSchemaRegistrySubjectConfigGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceSchemaRegistrySubjectConfigGet_Call) Return(compatibilityType kafkaschemaregistry.CompatibilityType, err error) *MockClient_ServiceSchemaRegistrySubjectConfigGet_Call {
	_c.Call.Return(compatibilityType, err)
	return _c
}

func (_c *MockClient_ServiceSchemaRegistrySubjectConfigGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, subjectName string) (kafkaschemaregistry.CompatibilityType, error)) *MockClient_ServiceSchemaRegistrySubjectConfigGet_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceSchemaRegistrySubjectConfigPut provides a mock function for the type MockClient
func (_mock *MockClient) ServiceSchemaRegistrySubjectConfigPut(ctx context.Context, project1 string, serviceName string, subjectName string, in *kafkaschemaregistry.ServiceSchemaRegistrySubjectConfigPutIn) (kafkaschemaregistry.CompatibilityType, error) {
	ret := _mock.Called(ctx, project1, serviceName, subjectName, in)

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

	var r0 kafkaschemaregistry.CompatibilityType
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *kafkaschemaregistry.ServiceSchemaRegistrySubjectConfigPutIn) (kafkaschemaregistry.CompatibilityType, error)); ok {
		return returnFunc(ctx, project1, serviceName, subjectName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *kafkaschemaregistry.ServiceSchemaRegistrySubjectConfigPutIn) kafkaschemaregistry.CompatibilityType); ok {
		r0 = returnFunc(ctx, project1, serviceName, subjectName, in)
	} else {
		r0 = ret.Get(0).(kafkaschemaregistry.CompatibilityType)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, *kafkaschemaregistry.ServiceSchemaRegistrySubjectConfigPutIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, subjectName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceSchemaRegistrySubjectConfigPut is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - subjectName
//   - in
func (_e *MockClient_Expecter) ServiceSchemaRegistrySubjectConfigPut(ctx interface{}, project1 interface{}, serviceName interface{}, subjectName interface{}, in interface{}) *MockClient_ServiceSchemaRegistrySubjectConfigPut_Call {
	return &MockClient_ServiceSchemaRegistrySubjectConfigPut_Call{Call: _e.mock.On("ServiceSchemaRegistrySubjectConfigPut", ctx, project1, serviceName, subjectName, in)}
}

func (_c *MockClient_ServiceSchemaRegistrySubjectConfigPut_Call) Run(run func(ctx context.Context, project1 string, serviceName string, subjectName string, in *kafkaschemaregistry.ServiceSchemaRegistrySubjectConfigPutIn)) *MockClient_ServiceSchemaRegistrySubjectConfigPut_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*kafkaschemaregistry.ServiceSchemaRegistrySubjectConfigPutIn))
	})
	return _c
}

func (_c *MockClient_ServiceSchemaRegistrySubjectConfigPut_Call) Return(compatibilityType kafkaschemaregistry.CompatibilityType, err error) *MockClient_ServiceSchemaRegistrySubjectConfigPut_Call {
	_c.Call.Return(compatibilityType, err)
	return _c
}

func (_c *MockClient_ServiceSchemaRegistrySubjectConfigPut_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, subjectName string, in *kafkaschemaregistry.ServiceSchemaRegistrySubjectConfigPutIn) (kafkaschemaregistry.CompatibilityType, error)) *MockClient_ServiceSchemaRegistrySubjectConfigPut_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceSchemaRegistrySubjectDelete provides a mock function for the type MockClient
func (_mock *MockClient) ServiceSchemaRegistrySubjectDelete(ctx context.Context, project1 string, serviceName string, subjectName string) error {
	ret := _mock.Called(ctx, project1, serviceName, subjectName)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, subjectName)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceSchemaRegistrySubjectDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - subjectName
func (_e *MockClient_Expecter) ServiceSchemaRegistrySubjectDelete(ctx interface{}, project1 interface{}, serviceName interface{}, subjectName interface{}) *MockClient_ServiceSchemaRegistrySubjectDelete_Call {
	return &MockClient_ServiceSchemaRegistrySubjectDelete_Call{Call: _e.mock.On("ServiceSchemaRegistrySubjectDelete", ctx, project1, serviceName, subjectName)}
}

func (_c *MockClient_ServiceSchemaRegistrySubjectDelete_Call) Run(run func(ctx context.Context, project1 string, serviceName string, subjectName string)) *MockClient_ServiceSchemaRegistrySubjectDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceSchemaRegistrySubjectDelete_Call) Return(err error) *MockClient_ServiceSchemaRegistrySubjectDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceSchemaRegistrySubjectDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, subjectName string) error) *MockClient_ServiceSchemaRegistrySubjectDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceSchemaRegistrySubjectVersionDelete provides a mock function for the type MockClient
func (_mock *MockClient) ServiceSchemaRegistrySubjectVersionDelete(ctx context.Context, project1 string, serviceName string, subjectName string, versionId int) error {
	ret := _mock.Called(ctx, project1, serviceName, subjectName, versionId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, int) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, subjectName, versionId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceSchemaRegistrySubjectVersionDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - subjectName
//   - versionId
func (_e *MockClient_Expecter) ServiceSchemaRegistrySubjectVersionDelete(ctx interface{}, project1 interface{}, serviceName interface{}, subjectName interface{}, versionId interface{}) *MockClient_ServiceSchemaRegistrySubjectVersionDelete_Call {
	return &MockClient_ServiceSchemaRegistrySubjectVersionDelete_Call{Call: _e.mock.On("ServiceSchemaRegistrySubjectVersionDelete", ctx, project1, serviceName, subjectName, versionId)}
}

func (_c *MockClient_ServiceSchemaRegistrySubjectVersionDelete_Call) Run(run func(ctx context.Context, project1 string, serviceName string, subjectName string, versionId int)) *MockClient_ServiceSchemaRegistrySubjectVersionDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(int))
	})
	return _c
}

func (_c *MockClient_ServiceSchemaRegistrySubjectVersionDelete_Call) Return(err error) *MockClient_ServiceSchemaRegistrySubjectVersionDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceSchemaRegistrySubjectVersionDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, subjectName string, versionId int) error) *MockClient_ServiceSchemaRegistrySubjectVersionDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceSchemaRegistrySubjectVersionGet provides a mock function for the type MockClient
func (_mock *MockClient) ServiceSchemaRegistrySubjectVersionGet(ctx context.Context, project1 string, serviceName string, subjectName string, versionId int) (*kafkaschemaregistry.ServiceSchemaRegistrySubjectVersionGetOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, subjectName, versionId)

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

	var r0 *kafkaschemaregistry.ServiceSchemaRegistrySubjectVersionGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, int) (*kafkaschemaregistry.ServiceSchemaRegistrySubjectVersionGetOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, subjectName, versionId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, int) *kafkaschemaregistry.ServiceSchemaRegistrySubjectVersionGetOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, subjectName, versionId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*kafkaschemaregistry.ServiceSchemaRegistrySubjectVersionGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, int) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, subjectName, versionId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceSchemaRegistrySubjectVersionGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - subjectName
//   - versionId
func (_e *MockClient_Expecter) ServiceSchemaRegistrySubjectVersionGet(ctx interface{}, project1 interface{}, serviceName interface{}, subjectName interface{}, versionId interface{}) *MockClient_ServiceSchemaRegistrySubjectVersionGet_Call {
	return &MockClient_ServiceSchemaRegistrySubjectVersionGet_Call{Call: _e.mock.On("ServiceSchemaRegistrySubjectVersionGet", ctx, project1, serviceName, subjectName, versionId)}
}

func (_c *MockClient_ServiceSchemaRegistrySubjectVersionGet_Call) Run(run func(ctx context.Context, project1 string, serviceName string, subjectName string, versionId int)) *MockClient_ServiceSchemaRegistrySubjectVersionGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(int))
	})
	return _c
}

func (_c *MockClient_ServiceSchemaRegistrySubjectVersionGet_Call) Return(serviceSchemaRegistrySubjectVersionGetOut *kafkaschemaregistry.ServiceSchemaRegistrySubjectVersionGetOut, err error) *MockClient_ServiceSchemaRegistrySubjectVersionGet_Call {
	_c.Call.Return(serviceSchemaRegistrySubjectVersionGetOut, err)
	return _c
}

func (_c *MockClient_ServiceSchemaRegistrySubjectVersionGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, subjectName string, versionId int) (*kafkaschemaregistry.ServiceSchemaRegistrySubjectVersionGetOut, error)) *MockClient_ServiceSchemaRegistrySubjectVersionGet_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceSchemaRegistrySubjectVersionPost provides a mock function for the type MockClient
func (_mock *MockClient) ServiceSchemaRegistrySubjectVersionPost(ctx context.Context, project1 string, serviceName string, subjectName string, in *kafkaschemaregistry.ServiceSchemaRegistrySubjectVersionPostIn) (int, error) {
	ret := _mock.Called(ctx, project1, serviceName, subjectName, in)

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

	var r0 int
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *kafkaschemaregistry.ServiceSchemaRegistrySubjectVersionPostIn) (int, error)); ok {
		return returnFunc(ctx, project1, serviceName, subjectName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *kafkaschemaregistry.ServiceSchemaRegistrySubjectVersionPostIn) int); ok {
		r0 = returnFunc(ctx, project1, serviceName, subjectName, in)
	} else {
		r0 = ret.Get(0).(int)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, *kafkaschemaregistry.ServiceSchemaRegistrySubjectVersionPostIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, subjectName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceSchemaRegistrySubjectVersionPost is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - subjectName
//   - in
func (_e *MockClient_Expecter) ServiceSchemaRegistrySubjectVersionPost(ctx interface{}, project1 interface{}, serviceName interface{}, subjectName interface{}, in interface{}) *MockClient_ServiceSchemaRegistrySubjectVersionPost_Call {
	return &MockClient_ServiceSchemaRegistrySubjectVersionPost_Call{Call: _e.mock.On("ServiceSchemaRegistrySubjectVersionPost", ctx, project1, serviceName, subjectName, in)}
}

func (_c *MockClient_ServiceSchemaRegistrySubjectVersionPost_Call) Run(run func(ctx context.Context, project1 string, serviceName string, subjectName string, in *kafkaschemaregistry.ServiceSchemaRegistrySubjectVersionPostIn)) *MockClient_ServiceSchemaRegistrySubjectVersionPost_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*kafkaschemaregistry.ServiceSchemaRegistrySubjectVersionPostIn))
	})
	return _c
}

func (_c *MockClient_ServiceSchemaRegistrySubjectVersionPost_Call) Return(n int, err error) *MockClient_ServiceSchemaRegistrySubjectVersionPost_Call {
	_c.Call.Return(n, err)
	return _c
}

func (_c *MockClient_ServiceSchemaRegistrySubjectVersionPost_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, subjectName string, in *kafkaschemaregistry.ServiceSchemaRegistrySubjectVersionPostIn) (int, error)) *MockClient_ServiceSchemaRegistrySubjectVersionPost_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceSchemaRegistrySubjectVersionSchemaGet provides a mock function for the type MockClient
func (_mock *MockClient) ServiceSchemaRegistrySubjectVersionSchemaGet(ctx context.Context, project1 string, serviceName string, subjectName string, versionId int) error {
	ret := _mock.Called(ctx, project1, serviceName, subjectName, versionId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, int) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, subjectName, versionId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceSchemaRegistrySubjectVersionSchemaGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - subjectName
//   - versionId
func (_e *MockClient_Expecter) ServiceSchemaRegistrySubjectVersionSchemaGet(ctx interface{}, project1 interface{}, serviceName interface{}, subjectName interface{}, versionId interface{}) *MockClient_ServiceSchemaRegistrySubjectVersionSchemaGet_Call {
	return &MockClient_ServiceSchemaRegistrySubjectVersionSchemaGet_Call{Call: _e.mock.On("ServiceSchemaRegistrySubjectVersionSchemaGet", ctx, project1, serviceName, subjectName, versionId)}
}

func (_c *MockClient_ServiceSchemaRegistrySubjectVersionSchemaGet_Call) Run(run func(ctx context.Context, project1 string, serviceName string, subjectName string, versionId int)) *MockClient_ServiceSchemaRegistrySubjectVersionSchemaGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(int))
	})
	return _c
}

func (_c *MockClient_ServiceSchemaRegistrySubjectVersionSchemaGet_Call) Return(err error) *MockClient_ServiceSchemaRegistrySubjectVersionSchemaGet_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceSchemaRegistrySubjectVersionSchemaGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, subjectName string, versionId int) error) *MockClient_ServiceSchemaRegistrySubjectVersionSchemaGet_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceSchemaRegistrySubjectVersionsGet provides a mock function for the type MockClient
func (_mock *MockClient) ServiceSchemaRegistrySubjectVersionsGet(ctx context.Context, project1 string, serviceName string, subjectName string) ([]int, error) {
	ret := _mock.Called(ctx, project1, serviceName, subjectName)

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

	var r0 []int
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) ([]int, error)); ok {
		return returnFunc(ctx, project1, serviceName, subjectName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) []int); ok {
		r0 = returnFunc(ctx, project1, serviceName, subjectName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]int)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, subjectName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceSchemaRegistrySubjectVersionsGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - subjectName
func (_e *MockClient_Expecter) ServiceSchemaRegistrySubjectVersionsGet(ctx interface{}, project1 interface{}, serviceName interface{}, subjectName interface{}) *MockClient_ServiceSchemaRegistrySubjectVersionsGet_Call {
	return &MockClient_ServiceSchemaRegistrySubjectVersionsGet_Call{Call: _e.mock.On("ServiceSchemaRegistrySubjectVersionsGet", ctx, project1, serviceName, subjectName)}
}

func (_c *MockClient_ServiceSchemaRegistrySubjectVersionsGet_Call) Run(run func(ctx context.Context, project1 string, serviceName string, subjectName string)) *MockClient_ServiceSchemaRegistrySubjectVersionsGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceSchemaRegistrySubjectVersionsGet_Call) Return(ints []int, err error) *MockClient_ServiceSchemaRegistrySubjectVersionsGet_Call {
	_c.Call.Return(ints, err)
	return _c
}

func (_c *MockClient_ServiceSchemaRegistrySubjectVersionsGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, subjectName string) ([]int, error)) *MockClient_ServiceSchemaRegistrySubjectVersionsGet_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceSchemaRegistrySubjects provides a mock function for the type MockClient
func (_mock *MockClient) ServiceSchemaRegistrySubjects(ctx context.Context, project1 string, serviceName string) ([]string, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

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

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

// ServiceSchemaRegistrySubjects is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceSchemaRegistrySubjects(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceSchemaRegistrySubjects_Call {
	return &MockClient_ServiceSchemaRegistrySubjects_Call{Call: _e.mock.On("ServiceSchemaRegistrySubjects", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceSchemaRegistrySubjects_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceSchemaRegistrySubjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceSchemaRegistrySubjects_Call) Return(strings []string, err error) *MockClient_ServiceSchemaRegistrySubjects_Call {
	_c.Call.Return(strings, err)
	return _c
}

func (_c *MockClient_ServiceSchemaRegistrySubjects_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) ([]string, error)) *MockClient_ServiceSchemaRegistrySubjects_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceTaskCreate provides a mock function for the type MockClient
func (_mock *MockClient) ServiceTaskCreate(ctx context.Context, project1 string, serviceName string, in *service.ServiceTaskCreateIn) (*service.ServiceTaskCreateOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 *service.ServiceTaskCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ServiceTaskCreateIn) (*service.ServiceTaskCreateOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ServiceTaskCreateIn) *service.ServiceTaskCreateOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ServiceTaskCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *service.ServiceTaskCreateIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceTaskCreate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceTaskCreate(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceTaskCreate_Call {
	return &MockClient_ServiceTaskCreate_Call{Call: _e.mock.On("ServiceTaskCreate", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceTaskCreate_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *service.ServiceTaskCreateIn)) *MockClient_ServiceTaskCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*service.ServiceTaskCreateIn))
	})
	return _c
}

func (_c *MockClient_ServiceTaskCreate_Call) Return(serviceTaskCreateOut *service.ServiceTaskCreateOut, err error) *MockClient_ServiceTaskCreate_Call {
	_c.Call.Return(serviceTaskCreateOut, err)
	return _c
}

func (_c *MockClient_ServiceTaskCreate_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *service.ServiceTaskCreateIn) (*service.ServiceTaskCreateOut, error)) *MockClient_ServiceTaskCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceTaskGet provides a mock function for the type MockClient
func (_mock *MockClient) ServiceTaskGet(ctx context.Context, project1 string, serviceName string, taskId string) (*service.ServiceTaskGetOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, taskId)

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

	var r0 *service.ServiceTaskGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*service.ServiceTaskGetOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, taskId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *service.ServiceTaskGetOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, taskId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ServiceTaskGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, taskId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceTaskGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - taskId
func (_e *MockClient_Expecter) ServiceTaskGet(ctx interface{}, project1 interface{}, serviceName interface{}, taskId interface{}) *MockClient_ServiceTaskGet_Call {
	return &MockClient_ServiceTaskGet_Call{Call: _e.mock.On("ServiceTaskGet", ctx, project1, serviceName, taskId)}
}

func (_c *MockClient_ServiceTaskGet_Call) Run(run func(ctx context.Context, project1 string, serviceName string, taskId string)) *MockClient_ServiceTaskGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceTaskGet_Call) Return(serviceTaskGetOut *service.ServiceTaskGetOut, err error) *MockClient_ServiceTaskGet_Call {
	_c.Call.Return(serviceTaskGetOut, err)
	return _c
}

func (_c *MockClient_ServiceTaskGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, taskId string) (*service.ServiceTaskGetOut, error)) *MockClient_ServiceTaskGet_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceThanosStorageSummary provides a mock function for the type MockClient
func (_mock *MockClient) ServiceThanosStorageSummary(ctx context.Context, project1 string, serviceName string) (*thanos.ServiceThanosStorageSummaryOut, error) {
	ret := _mock.Called(ctx, project1, serviceName)

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

	var r0 *thanos.ServiceThanosStorageSummaryOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*thanos.ServiceThanosStorageSummaryOut, error)); ok {
		return returnFunc(ctx, project1, serviceName)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *thanos.ServiceThanosStorageSummaryOut); ok {
		r0 = returnFunc(ctx, project1, serviceName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*thanos.ServiceThanosStorageSummaryOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceThanosStorageSummary is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
func (_e *MockClient_Expecter) ServiceThanosStorageSummary(ctx interface{}, project1 interface{}, serviceName interface{}) *MockClient_ServiceThanosStorageSummary_Call {
	return &MockClient_ServiceThanosStorageSummary_Call{Call: _e.mock.On("ServiceThanosStorageSummary", ctx, project1, serviceName)}
}

func (_c *MockClient_ServiceThanosStorageSummary_Call) Run(run func(ctx context.Context, project1 string, serviceName string)) *MockClient_ServiceThanosStorageSummary_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_ServiceThanosStorageSummary_Call) Return(serviceThanosStorageSummaryOut *thanos.ServiceThanosStorageSummaryOut, err error) *MockClient_ServiceThanosStorageSummary_Call {
	_c.Call.Return(serviceThanosStorageSummaryOut, err)
	return _c
}

func (_c *MockClient_ServiceThanosStorageSummary_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string) (*thanos.ServiceThanosStorageSummaryOut, error)) *MockClient_ServiceThanosStorageSummary_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceUpdate provides a mock function for the type MockClient
func (_mock *MockClient) ServiceUpdate(ctx context.Context, project1 string, serviceName string, in *service.ServiceUpdateIn, query ...[2]string) (*service.ServiceUpdateOut, error) {
	var tmpRet mock.Arguments
	if len(query) > 0 {
		tmpRet = _mock.Called(ctx, project1, serviceName, in, query)
	} else {
		tmpRet = _mock.Called(ctx, project1, serviceName, in)
	}
	ret := tmpRet

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

	var r0 *service.ServiceUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ServiceUpdateIn, ...[2]string) (*service.ServiceUpdateOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in, query...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ServiceUpdateIn, ...[2]string) *service.ServiceUpdateOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in, query...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ServiceUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *service.ServiceUpdateIn, ...[2]string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in, query...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceUpdate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
//   - query
func (_e *MockClient_Expecter) ServiceUpdate(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}, query ...interface{}) *MockClient_ServiceUpdate_Call {
	return &MockClient_ServiceUpdate_Call{Call: _e.mock.On("ServiceUpdate",
		append([]interface{}{ctx, project1, serviceName, in}, query...)...)}
}

func (_c *MockClient_ServiceUpdate_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *service.ServiceUpdateIn, query ...[2]string)) *MockClient_ServiceUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := args[4].([][2]string)
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*service.ServiceUpdateIn), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_ServiceUpdate_Call) Return(serviceUpdateOut *service.ServiceUpdateOut, err error) *MockClient_ServiceUpdate_Call {
	_c.Call.Return(serviceUpdateOut, err)
	return _c
}

func (_c *MockClient_ServiceUpdate_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *service.ServiceUpdateIn, query ...[2]string) (*service.ServiceUpdateOut, error)) *MockClient_ServiceUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceUserCreate provides a mock function for the type MockClient
func (_mock *MockClient) ServiceUserCreate(ctx context.Context, project1 string, serviceName string, in *service.ServiceUserCreateIn) (*service.ServiceUserCreateOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, in)

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

	var r0 *service.ServiceUserCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ServiceUserCreateIn) (*service.ServiceUserCreateOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *service.ServiceUserCreateIn) *service.ServiceUserCreateOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ServiceUserCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *service.ServiceUserCreateIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceUserCreate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - in
func (_e *MockClient_Expecter) ServiceUserCreate(ctx interface{}, project1 interface{}, serviceName interface{}, in interface{}) *MockClient_ServiceUserCreate_Call {
	return &MockClient_ServiceUserCreate_Call{Call: _e.mock.On("ServiceUserCreate", ctx, project1, serviceName, in)}
}

func (_c *MockClient_ServiceUserCreate_Call) Run(run func(ctx context.Context, project1 string, serviceName string, in *service.ServiceUserCreateIn)) *MockClient_ServiceUserCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*service.ServiceUserCreateIn))
	})
	return _c
}

func (_c *MockClient_ServiceUserCreate_Call) Return(serviceUserCreateOut *service.ServiceUserCreateOut, err error) *MockClient_ServiceUserCreate_Call {
	_c.Call.Return(serviceUserCreateOut, err)
	return _c
}

func (_c *MockClient_ServiceUserCreate_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, in *service.ServiceUserCreateIn) (*service.ServiceUserCreateOut, error)) *MockClient_ServiceUserCreate_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceUserCredentialsModify provides a mock function for the type MockClient
func (_mock *MockClient) ServiceUserCredentialsModify(ctx context.Context, project1 string, serviceName string, serviceUsername string, in *service.ServiceUserCredentialsModifyIn) (*service.ServiceUserCredentialsModifyOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, serviceUsername, in)

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

	var r0 *service.ServiceUserCredentialsModifyOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *service.ServiceUserCredentialsModifyIn) (*service.ServiceUserCredentialsModifyOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, serviceUsername, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, *service.ServiceUserCredentialsModifyIn) *service.ServiceUserCredentialsModifyOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, serviceUsername, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ServiceUserCredentialsModifyOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, *service.ServiceUserCredentialsModifyIn) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, serviceUsername, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceUserCredentialsModify is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - serviceUsername
//   - in
func (_e *MockClient_Expecter) ServiceUserCredentialsModify(ctx interface{}, project1 interface{}, serviceName interface{}, serviceUsername interface{}, in interface{}) *MockClient_ServiceUserCredentialsModify_Call {
	return &MockClient_ServiceUserCredentialsModify_Call{Call: _e.mock.On("ServiceUserCredentialsModify", ctx, project1, serviceName, serviceUsername, in)}
}

func (_c *MockClient_ServiceUserCredentialsModify_Call) Run(run func(ctx context.Context, project1 string, serviceName string, serviceUsername string, in *service.ServiceUserCredentialsModifyIn)) *MockClient_ServiceUserCredentialsModify_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*service.ServiceUserCredentialsModifyIn))
	})
	return _c
}

func (_c *MockClient_ServiceUserCredentialsModify_Call) Return(serviceUserCredentialsModifyOut *service.ServiceUserCredentialsModifyOut, err error) *MockClient_ServiceUserCredentialsModify_Call {
	_c.Call.Return(serviceUserCredentialsModifyOut, err)
	return _c
}

func (_c *MockClient_ServiceUserCredentialsModify_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, serviceUsername string, in *service.ServiceUserCredentialsModifyIn) (*service.ServiceUserCredentialsModifyOut, error)) *MockClient_ServiceUserCredentialsModify_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceUserCredentialsReset provides a mock function for the type MockClient
func (_mock *MockClient) ServiceUserCredentialsReset(ctx context.Context, project1 string, serviceName string, serviceUsername string) (*service.ServiceUserCredentialsResetOut, error) {
	ret := _mock.Called(ctx, project1, serviceName, serviceUsername)

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

	var r0 *service.ServiceUserCredentialsResetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*service.ServiceUserCredentialsResetOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, serviceUsername)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *service.ServiceUserCredentialsResetOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, serviceUsername)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ServiceUserCredentialsResetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, serviceUsername)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceUserCredentialsReset is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - serviceUsername
func (_e *MockClient_Expecter) ServiceUserCredentialsReset(ctx interface{}, project1 interface{}, serviceName interface{}, serviceUsername interface{}) *MockClient_ServiceUserCredentialsReset_Call {
	return &MockClient_ServiceUserCredentialsReset_Call{Call: _e.mock.On("ServiceUserCredentialsReset", ctx, project1, serviceName, serviceUsername)}
}

func (_c *MockClient_ServiceUserCredentialsReset_Call) Run(run func(ctx context.Context, project1 string, serviceName string, serviceUsername string)) *MockClient_ServiceUserCredentialsReset_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceUserCredentialsReset_Call) Return(serviceUserCredentialsResetOut *service.ServiceUserCredentialsResetOut, err error) *MockClient_ServiceUserCredentialsReset_Call {
	_c.Call.Return(serviceUserCredentialsResetOut, err)
	return _c
}

func (_c *MockClient_ServiceUserCredentialsReset_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, serviceUsername string) (*service.ServiceUserCredentialsResetOut, error)) *MockClient_ServiceUserCredentialsReset_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceUserDelete provides a mock function for the type MockClient
func (_mock *MockClient) ServiceUserDelete(ctx context.Context, project1 string, serviceName string, serviceUsername string) error {
	ret := _mock.Called(ctx, project1, serviceName, serviceUsername)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok {
		r0 = returnFunc(ctx, project1, serviceName, serviceUsername)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ServiceUserDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - serviceUsername
func (_e *MockClient_Expecter) ServiceUserDelete(ctx interface{}, project1 interface{}, serviceName interface{}, serviceUsername interface{}) *MockClient_ServiceUserDelete_Call {
	return &MockClient_ServiceUserDelete_Call{Call: _e.mock.On("ServiceUserDelete", ctx, project1, serviceName, serviceUsername)}
}

func (_c *MockClient_ServiceUserDelete_Call) Run(run func(ctx context.Context, project1 string, serviceName string, serviceUsername string)) *MockClient_ServiceUserDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string))
	})
	return _c
}

func (_c *MockClient_ServiceUserDelete_Call) Return(err error) *MockClient_ServiceUserDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ServiceUserDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, serviceUsername string) error) *MockClient_ServiceUserDelete_Call {
	_c.Call.Return(run)
	return _c
}

// ServiceUserGet provides a mock function for the type MockClient
func (_mock *MockClient) ServiceUserGet(ctx context.Context, project1 string, serviceName string, serviceUsername string, query ...[2]string) (*service.ServiceUserGetOut, error) {
	var tmpRet mock.Arguments
	if len(query) > 0 {
		tmpRet = _mock.Called(ctx, project1, serviceName, serviceUsername, query)
	} else {
		tmpRet = _mock.Called(ctx, project1, serviceName, serviceUsername)
	}
	ret := tmpRet

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

	var r0 *service.ServiceUserGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, ...[2]string) (*service.ServiceUserGetOut, error)); ok {
		return returnFunc(ctx, project1, serviceName, serviceUsername, query...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, ...[2]string) *service.ServiceUserGetOut); ok {
		r0 = returnFunc(ctx, project1, serviceName, serviceUsername, query...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*service.ServiceUserGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, ...[2]string) error); ok {
		r1 = returnFunc(ctx, project1, serviceName, serviceUsername, query...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ServiceUserGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - serviceName
//   - serviceUsername
//   - query
func (_e *MockClient_Expecter) ServiceUserGet(ctx interface{}, project1 interface{}, serviceName interface{}, serviceUsername interface{}, query ...interface{}) *MockClient_ServiceUserGet_Call {
	return &MockClient_ServiceUserGet_Call{Call: _e.mock.On("ServiceUserGet",
		append([]interface{}{ctx, project1, serviceName, serviceUsername}, query...)...)}
}

func (_c *MockClient_ServiceUserGet_Call) Run(run func(ctx context.Context, project1 string, serviceName string, serviceUsername string, query ...[2]string)) *MockClient_ServiceUserGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := args[4].([][2]string)
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_ServiceUserGet_Call) Return(serviceUserGetOut *service.ServiceUserGetOut, err error) *MockClient_ServiceUserGet_Call {
	_c.Call.Return(serviceUserGetOut, err)
	return _c
}

func (_c *MockClient_ServiceUserGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, serviceName string, serviceUsername string, query ...[2]string) (*service.ServiceUserGetOut, error)) *MockClient_ServiceUserGet_Call {
	_c.Call.Return(run)
	return _c
}

// StaticIPCreate provides a mock function for the type MockClient
func (_mock *MockClient) StaticIPCreate(ctx context.Context, project1 string, in *staticip.StaticIpcreateIn) (*staticip.StaticIpcreateOut, error) {
	ret := _mock.Called(ctx, project1, in)

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

	var r0 *staticip.StaticIpcreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *staticip.StaticIpcreateIn) (*staticip.StaticIpcreateOut, error)); ok {
		return returnFunc(ctx, project1, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *staticip.StaticIpcreateIn) *staticip.StaticIpcreateOut); ok {
		r0 = returnFunc(ctx, project1, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*staticip.StaticIpcreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *staticip.StaticIpcreateIn) error); ok {
		r1 = returnFunc(ctx, project1, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// StaticIPCreate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - in
func (_e *MockClient_Expecter) StaticIPCreate(ctx interface{}, project1 interface{}, in interface{}) *MockClient_StaticIPCreate_Call {
	return &MockClient_StaticIPCreate_Call{Call: _e.mock.On("StaticIPCreate", ctx, project1, in)}
}

func (_c *MockClient_StaticIPCreate_Call) Run(run func(ctx context.Context, project1 string, in *staticip.StaticIpcreateIn)) *MockClient_StaticIPCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*staticip.StaticIpcreateIn))
	})
	return _c
}

func (_c *MockClient_StaticIPCreate_Call) Return(staticIpcreateOut *staticip.StaticIpcreateOut, err error) *MockClient_StaticIPCreate_Call {
	_c.Call.Return(staticIpcreateOut, err)
	return _c
}

func (_c *MockClient_StaticIPCreate_Call) RunAndReturn(run func(ctx context.Context, project1 string, in *staticip.StaticIpcreateIn) (*staticip.StaticIpcreateOut, error)) *MockClient_StaticIPCreate_Call {
	_c.Call.Return(run)
	return _c
}

// StaticIPList provides a mock function for the type MockClient
func (_mock *MockClient) StaticIPList(ctx context.Context, project1 string) ([]staticip.StaticIpOut, error) {
	ret := _mock.Called(ctx, project1)

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

	var r0 []staticip.StaticIpOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]staticip.StaticIpOut, error)); ok {
		return returnFunc(ctx, project1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []staticip.StaticIpOut); ok {
		r0 = returnFunc(ctx, project1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]staticip.StaticIpOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, project1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// StaticIPList is a helper method to define mock.On call
//   - ctx
//   - project1
func (_e *MockClient_Expecter) StaticIPList(ctx interface{}, project1 interface{}) *MockClient_StaticIPList_Call {
	return &MockClient_StaticIPList_Call{Call: _e.mock.On("StaticIPList", ctx, project1)}
}

func (_c *MockClient_StaticIPList_Call) Run(run func(ctx context.Context, project1 string)) *MockClient_StaticIPList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_StaticIPList_Call) Return(staticIpOuts []staticip.StaticIpOut, err error) *MockClient_StaticIPList_Call {
	_c.Call.Return(staticIpOuts, err)
	return _c
}

func (_c *MockClient_StaticIPList_Call) RunAndReturn(run func(ctx context.Context, project1 string) ([]staticip.StaticIpOut, error)) *MockClient_StaticIPList_Call {
	_c.Call.Return(run)
	return _c
}

// TwoFactorAuthConfigure provides a mock function for the type MockClient
func (_mock *MockClient) TwoFactorAuthConfigure(ctx context.Context, in *user.TwoFactorAuthConfigureIn) (*user.TwoFactorAuthConfigureOut, error) {
	ret := _mock.Called(ctx, in)

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

	var r0 *user.TwoFactorAuthConfigureOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.TwoFactorAuthConfigureIn) (*user.TwoFactorAuthConfigureOut, error)); ok {
		return returnFunc(ctx, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.TwoFactorAuthConfigureIn) *user.TwoFactorAuthConfigureOut); ok {
		r0 = returnFunc(ctx, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*user.TwoFactorAuthConfigureOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *user.TwoFactorAuthConfigureIn) error); ok {
		r1 = returnFunc(ctx, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// TwoFactorAuthConfigure is a helper method to define mock.On call
//   - ctx
//   - in
func (_e *MockClient_Expecter) TwoFactorAuthConfigure(ctx interface{}, in interface{}) *MockClient_TwoFactorAuthConfigure_Call {
	return &MockClient_TwoFactorAuthConfigure_Call{Call: _e.mock.On("TwoFactorAuthConfigure", ctx, in)}
}

func (_c *MockClient_TwoFactorAuthConfigure_Call) Run(run func(ctx context.Context, in *user.TwoFactorAuthConfigureIn)) *MockClient_TwoFactorAuthConfigure_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*user.TwoFactorAuthConfigureIn))
	})
	return _c
}

func (_c *MockClient_TwoFactorAuthConfigure_Call) Return(twoFactorAuthConfigureOut *user.TwoFactorAuthConfigureOut, err error) *MockClient_TwoFactorAuthConfigure_Call {
	_c.Call.Return(twoFactorAuthConfigureOut, err)
	return _c
}

func (_c *MockClient_TwoFactorAuthConfigure_Call) RunAndReturn(run func(ctx context.Context, in *user.TwoFactorAuthConfigureIn) (*user.TwoFactorAuthConfigureOut, error)) *MockClient_TwoFactorAuthConfigure_Call {
	_c.Call.Return(run)
	return _c
}

// TwoFactorAuthConfigureOTP provides a mock function for the type MockClient
func (_mock *MockClient) TwoFactorAuthConfigureOTP(ctx context.Context, in *user.TwoFactorAuthConfigureOtpIn) (*user.TwoFactorAuthConfigureOtpOut, error) {
	ret := _mock.Called(ctx, in)

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

	var r0 *user.TwoFactorAuthConfigureOtpOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.TwoFactorAuthConfigureOtpIn) (*user.TwoFactorAuthConfigureOtpOut, error)); ok {
		return returnFunc(ctx, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.TwoFactorAuthConfigureOtpIn) *user.TwoFactorAuthConfigureOtpOut); ok {
		r0 = returnFunc(ctx, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*user.TwoFactorAuthConfigureOtpOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *user.TwoFactorAuthConfigureOtpIn) error); ok {
		r1 = returnFunc(ctx, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// TwoFactorAuthConfigureOTP is a helper method to define mock.On call
//   - ctx
//   - in
func (_e *MockClient_Expecter) TwoFactorAuthConfigureOTP(ctx interface{}, in interface{}) *MockClient_TwoFactorAuthConfigureOTP_Call {
	return &MockClient_TwoFactorAuthConfigureOTP_Call{Call: _e.mock.On("TwoFactorAuthConfigureOTP", ctx, in)}
}

func (_c *MockClient_TwoFactorAuthConfigureOTP_Call) Run(run func(ctx context.Context, in *user.TwoFactorAuthConfigureOtpIn)) *MockClient_TwoFactorAuthConfigureOTP_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*user.TwoFactorAuthConfigureOtpIn))
	})
	return _c
}

func (_c *MockClient_TwoFactorAuthConfigureOTP_Call) Return(twoFactorAuthConfigureOtpOut *user.TwoFactorAuthConfigureOtpOut, err error) *MockClient_TwoFactorAuthConfigureOTP_Call {
	_c.Call.Return(twoFactorAuthConfigureOtpOut, err)
	return _c
}

func (_c *MockClient_TwoFactorAuthConfigureOTP_Call) RunAndReturn(run func(ctx context.Context, in *user.TwoFactorAuthConfigureOtpIn) (*user.TwoFactorAuthConfigureOtpOut, error)) *MockClient_TwoFactorAuthConfigureOTP_Call {
	_c.Call.Return(run)
	return _c
}

// UserAccountDelete provides a mock function for the type MockClient
func (_mock *MockClient) UserAccountDelete(ctx context.Context, userId string) error {
	ret := _mock.Called(ctx, userId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(ctx, userId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// UserAccountDelete is a helper method to define mock.On call
//   - ctx
//   - userId
func (_e *MockClient_Expecter) UserAccountDelete(ctx interface{}, userId interface{}) *MockClient_UserAccountDelete_Call {
	return &MockClient_UserAccountDelete_Call{Call: _e.mock.On("UserAccountDelete", ctx, userId)}
}

func (_c *MockClient_UserAccountDelete_Call) Run(run func(ctx context.Context, userId string)) *MockClient_UserAccountDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_UserAccountDelete_Call) Return(err error) *MockClient_UserAccountDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_UserAccountDelete_Call) RunAndReturn(run func(ctx context.Context, userId string) error) *MockClient_UserAccountDelete_Call {
	_c.Call.Return(run)
	return _c
}

// UserAccountInvitesAccept provides a mock function for the type MockClient
func (_mock *MockClient) UserAccountInvitesAccept(ctx context.Context, in *user.UserAccountInvitesAcceptIn) ([]user.AccountInviteOut, error) {
	ret := _mock.Called(ctx, in)

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

	var r0 []user.AccountInviteOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.UserAccountInvitesAcceptIn) ([]user.AccountInviteOut, error)); ok {
		return returnFunc(ctx, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.UserAccountInvitesAcceptIn) []user.AccountInviteOut); ok {
		r0 = returnFunc(ctx, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]user.AccountInviteOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *user.UserAccountInvitesAcceptIn) error); ok {
		r1 = returnFunc(ctx, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UserAccountInvitesAccept is a helper method to define mock.On call
//   - ctx
//   - in
func (_e *MockClient_Expecter) UserAccountInvitesAccept(ctx interface{}, in interface{}) *MockClient_UserAccountInvitesAccept_Call {
	return &MockClient_UserAccountInvitesAccept_Call{Call: _e.mock.On("UserAccountInvitesAccept", ctx, in)}
}

func (_c *MockClient_UserAccountInvitesAccept_Call) Run(run func(ctx context.Context, in *user.UserAccountInvitesAcceptIn)) *MockClient_UserAccountInvitesAccept_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*user.UserAccountInvitesAcceptIn))
	})
	return _c
}

func (_c *MockClient_UserAccountInvitesAccept_Call) Return(accountInviteOuts []user.AccountInviteOut, err error) *MockClient_UserAccountInvitesAccept_Call {
	_c.Call.Return(accountInviteOuts, err)
	return _c
}

func (_c *MockClient_UserAccountInvitesAccept_Call) RunAndReturn(run func(ctx context.Context, in *user.UserAccountInvitesAcceptIn) ([]user.AccountInviteOut, error)) *MockClient_UserAccountInvitesAccept_Call {
	_c.Call.Return(run)
	return _c
}

// UserAccountInvitesList provides a mock function for the type MockClient
func (_mock *MockClient) UserAccountInvitesList(ctx context.Context) ([]user.AccountInviteOut, error) {
	ret := _mock.Called(ctx)

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

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

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

// UserAccountInvitesList is a helper method to define mock.On call
//   - ctx
func (_e *MockClient_Expecter) UserAccountInvitesList(ctx interface{}) *MockClient_UserAccountInvitesList_Call {
	return &MockClient_UserAccountInvitesList_Call{Call: _e.mock.On("UserAccountInvitesList", ctx)}
}

func (_c *MockClient_UserAccountInvitesList_Call) Run(run func(ctx context.Context)) *MockClient_UserAccountInvitesList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockClient_UserAccountInvitesList_Call) Return(accountInviteOuts []user.AccountInviteOut, err error) *MockClient_UserAccountInvitesList_Call {
	_c.Call.Return(accountInviteOuts, err)
	return _c
}

func (_c *MockClient_UserAccountInvitesList_Call) RunAndReturn(run func(ctx context.Context) ([]user.AccountInviteOut, error)) *MockClient_UserAccountInvitesList_Call {
	_c.Call.Return(run)
	return _c
}

// UserAuth provides a mock function for the type MockClient
func (_mock *MockClient) UserAuth(ctx context.Context, in *user.UserAuthIn) (*user.UserAuthOut, error) {
	ret := _mock.Called(ctx, in)

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

	var r0 *user.UserAuthOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.UserAuthIn) (*user.UserAuthOut, error)); ok {
		return returnFunc(ctx, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.UserAuthIn) *user.UserAuthOut); ok {
		r0 = returnFunc(ctx, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*user.UserAuthOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *user.UserAuthIn) error); ok {
		r1 = returnFunc(ctx, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UserAuth is a helper method to define mock.On call
//   - ctx
//   - in
func (_e *MockClient_Expecter) UserAuth(ctx interface{}, in interface{}) *MockClient_UserAuth_Call {
	return &MockClient_UserAuth_Call{Call: _e.mock.On("UserAuth", ctx, in)}
}

func (_c *MockClient_UserAuth_Call) Run(run func(ctx context.Context, in *user.UserAuthIn)) *MockClient_UserAuth_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*user.UserAuthIn))
	})
	return _c
}

func (_c *MockClient_UserAuth_Call) Return(userAuthOut *user.UserAuthOut, err error) *MockClient_UserAuth_Call {
	_c.Call.Return(userAuthOut, err)
	return _c
}

func (_c *MockClient_UserAuth_Call) RunAndReturn(run func(ctx context.Context, in *user.UserAuthIn) (*user.UserAuthOut, error)) *MockClient_UserAuth_Call {
	_c.Call.Return(run)
	return _c
}

// UserAuthLoginOptions provides a mock function for the type MockClient
func (_mock *MockClient) UserAuthLoginOptions(ctx context.Context, in *user.UserAuthLoginOptionsIn) (*user.UserAuthLoginOptionsOut, error) {
	ret := _mock.Called(ctx, in)

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

	var r0 *user.UserAuthLoginOptionsOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.UserAuthLoginOptionsIn) (*user.UserAuthLoginOptionsOut, error)); ok {
		return returnFunc(ctx, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.UserAuthLoginOptionsIn) *user.UserAuthLoginOptionsOut); ok {
		r0 = returnFunc(ctx, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*user.UserAuthLoginOptionsOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *user.UserAuthLoginOptionsIn) error); ok {
		r1 = returnFunc(ctx, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UserAuthLoginOptions is a helper method to define mock.On call
//   - ctx
//   - in
func (_e *MockClient_Expecter) UserAuthLoginOptions(ctx interface{}, in interface{}) *MockClient_UserAuthLoginOptions_Call {
	return &MockClient_UserAuthLoginOptions_Call{Call: _e.mock.On("UserAuthLoginOptions", ctx, in)}
}

func (_c *MockClient_UserAuthLoginOptions_Call) Run(run func(ctx context.Context, in *user.UserAuthLoginOptionsIn)) *MockClient_UserAuthLoginOptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*user.UserAuthLoginOptionsIn))
	})
	return _c
}

func (_c *MockClient_UserAuthLoginOptions_Call) Return(userAuthLoginOptionsOut *user.UserAuthLoginOptionsOut, err error) *MockClient_UserAuthLoginOptions_Call {
	_c.Call.Return(userAuthLoginOptionsOut, err)
	return _c
}

func (_c *MockClient_UserAuthLoginOptions_Call) RunAndReturn(run func(ctx context.Context, in *user.UserAuthLoginOptionsIn) (*user.UserAuthLoginOptionsOut, error)) *MockClient_UserAuthLoginOptions_Call {
	_c.Call.Return(run)
	return _c
}

// UserAuthenticationMethodDelete provides a mock function for the type MockClient
func (_mock *MockClient) UserAuthenticationMethodDelete(ctx context.Context, userAuthenticationMethodId string) error {
	ret := _mock.Called(ctx, userAuthenticationMethodId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(ctx, userAuthenticationMethodId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// UserAuthenticationMethodDelete is a helper method to define mock.On call
//   - ctx
//   - userAuthenticationMethodId
func (_e *MockClient_Expecter) UserAuthenticationMethodDelete(ctx interface{}, userAuthenticationMethodId interface{}) *MockClient_UserAuthenticationMethodDelete_Call {
	return &MockClient_UserAuthenticationMethodDelete_Call{Call: _e.mock.On("UserAuthenticationMethodDelete", ctx, userAuthenticationMethodId)}
}

func (_c *MockClient_UserAuthenticationMethodDelete_Call) Run(run func(ctx context.Context, userAuthenticationMethodId string)) *MockClient_UserAuthenticationMethodDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_UserAuthenticationMethodDelete_Call) Return(err error) *MockClient_UserAuthenticationMethodDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_UserAuthenticationMethodDelete_Call) RunAndReturn(run func(ctx context.Context, userAuthenticationMethodId string) error) *MockClient_UserAuthenticationMethodDelete_Call {
	_c.Call.Return(run)
	return _c
}

// UserAuthenticationMethodsList provides a mock function for the type MockClient
func (_mock *MockClient) UserAuthenticationMethodsList(ctx context.Context) ([]user.AuthenticationMethodOut, error) {
	ret := _mock.Called(ctx)

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

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

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

// UserAuthenticationMethodsList is a helper method to define mock.On call
//   - ctx
func (_e *MockClient_Expecter) UserAuthenticationMethodsList(ctx interface{}) *MockClient_UserAuthenticationMethodsList_Call {
	return &MockClient_UserAuthenticationMethodsList_Call{Call: _e.mock.On("UserAuthenticationMethodsList", ctx)}
}

func (_c *MockClient_UserAuthenticationMethodsList_Call) Run(run func(ctx context.Context)) *MockClient_UserAuthenticationMethodsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockClient_UserAuthenticationMethodsList_Call) Return(authenticationMethodOuts []user.AuthenticationMethodOut, err error) *MockClient_UserAuthenticationMethodsList_Call {
	_c.Call.Return(authenticationMethodOuts, err)
	return _c
}

func (_c *MockClient_UserAuthenticationMethodsList_Call) RunAndReturn(run func(ctx context.Context) ([]user.AuthenticationMethodOut, error)) *MockClient_UserAuthenticationMethodsList_Call {
	_c.Call.Return(run)
	return _c
}

// UserCreate provides a mock function for the type MockClient
func (_mock *MockClient) UserCreate(ctx context.Context, in *user.UserCreateIn) (*user.UserCreateOut, error) {
	ret := _mock.Called(ctx, in)

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

	var r0 *user.UserCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.UserCreateIn) (*user.UserCreateOut, error)); ok {
		return returnFunc(ctx, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.UserCreateIn) *user.UserCreateOut); ok {
		r0 = returnFunc(ctx, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*user.UserCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *user.UserCreateIn) error); ok {
		r1 = returnFunc(ctx, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UserCreate is a helper method to define mock.On call
//   - ctx
//   - in
func (_e *MockClient_Expecter) UserCreate(ctx interface{}, in interface{}) *MockClient_UserCreate_Call {
	return &MockClient_UserCreate_Call{Call: _e.mock.On("UserCreate", ctx, in)}
}

func (_c *MockClient_UserCreate_Call) Run(run func(ctx context.Context, in *user.UserCreateIn)) *MockClient_UserCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*user.UserCreateIn))
	})
	return _c
}

func (_c *MockClient_UserCreate_Call) Return(userCreateOut *user.UserCreateOut, err error) *MockClient_UserCreate_Call {
	_c.Call.Return(userCreateOut, err)
	return _c
}

func (_c *MockClient_UserCreate_Call) RunAndReturn(run func(ctx context.Context, in *user.UserCreateIn) (*user.UserCreateOut, error)) *MockClient_UserCreate_Call {
	_c.Call.Return(run)
	return _c
}

// UserCreditCardsList provides a mock function for the type MockClient
func (_mock *MockClient) UserCreditCardsList(ctx context.Context) ([]user.CardOut, error) {
	ret := _mock.Called(ctx)

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

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

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

// UserCreditCardsList is a helper method to define mock.On call
//   - ctx
func (_e *MockClient_Expecter) UserCreditCardsList(ctx interface{}) *MockClient_UserCreditCardsList_Call {
	return &MockClient_UserCreditCardsList_Call{Call: _e.mock.On("UserCreditCardsList", ctx)}
}

func (_c *MockClient_UserCreditCardsList_Call) Run(run func(ctx context.Context)) *MockClient_UserCreditCardsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockClient_UserCreditCardsList_Call) Return(cardOuts []user.CardOut, err error) *MockClient_UserCreditCardsList_Call {
	_c.Call.Return(cardOuts, err)
	return _c
}

func (_c *MockClient_UserCreditCardsList_Call) RunAndReturn(run func(ctx context.Context) ([]user.CardOut, error)) *MockClient_UserCreditCardsList_Call {
	_c.Call.Return(run)
	return _c
}

// UserExpireTokens provides a mock function for the type MockClient
func (_mock *MockClient) UserExpireTokens(ctx context.Context) error {
	ret := _mock.Called(ctx)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// UserExpireTokens is a helper method to define mock.On call
//   - ctx
func (_e *MockClient_Expecter) UserExpireTokens(ctx interface{}) *MockClient_UserExpireTokens_Call {
	return &MockClient_UserExpireTokens_Call{Call: _e.mock.On("UserExpireTokens", ctx)}
}

func (_c *MockClient_UserExpireTokens_Call) Run(run func(ctx context.Context)) *MockClient_UserExpireTokens_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockClient_UserExpireTokens_Call) Return(err error) *MockClient_UserExpireTokens_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_UserExpireTokens_Call) RunAndReturn(run func(ctx context.Context) error) *MockClient_UserExpireTokens_Call {
	_c.Call.Return(run)
	return _c
}

// UserGroupCreate provides a mock function for the type MockClient
func (_mock *MockClient) UserGroupCreate(ctx context.Context, organizationId string, in *usergroup.UserGroupCreateIn) (*usergroup.UserGroupCreateOut, error) {
	ret := _mock.Called(ctx, organizationId, in)

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

	var r0 *usergroup.UserGroupCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *usergroup.UserGroupCreateIn) (*usergroup.UserGroupCreateOut, error)); ok {
		return returnFunc(ctx, organizationId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *usergroup.UserGroupCreateIn) *usergroup.UserGroupCreateOut); ok {
		r0 = returnFunc(ctx, organizationId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*usergroup.UserGroupCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *usergroup.UserGroupCreateIn) error); ok {
		r1 = returnFunc(ctx, organizationId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UserGroupCreate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - in
func (_e *MockClient_Expecter) UserGroupCreate(ctx interface{}, organizationId interface{}, in interface{}) *MockClient_UserGroupCreate_Call {
	return &MockClient_UserGroupCreate_Call{Call: _e.mock.On("UserGroupCreate", ctx, organizationId, in)}
}

func (_c *MockClient_UserGroupCreate_Call) Run(run func(ctx context.Context, organizationId string, in *usergroup.UserGroupCreateIn)) *MockClient_UserGroupCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*usergroup.UserGroupCreateIn))
	})
	return _c
}

func (_c *MockClient_UserGroupCreate_Call) Return(userGroupCreateOut *usergroup.UserGroupCreateOut, err error) *MockClient_UserGroupCreate_Call {
	_c.Call.Return(userGroupCreateOut, err)
	return _c
}

func (_c *MockClient_UserGroupCreate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, in *usergroup.UserGroupCreateIn) (*usergroup.UserGroupCreateOut, error)) *MockClient_UserGroupCreate_Call {
	_c.Call.Return(run)
	return _c
}

// UserGroupDelete provides a mock function for the type MockClient
func (_mock *MockClient) UserGroupDelete(ctx context.Context, organizationId string, userGroupId string) error {
	ret := _mock.Called(ctx, organizationId, userGroupId)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = returnFunc(ctx, organizationId, userGroupId)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// UserGroupDelete is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - userGroupId
func (_e *MockClient_Expecter) UserGroupDelete(ctx interface{}, organizationId interface{}, userGroupId interface{}) *MockClient_UserGroupDelete_Call {
	return &MockClient_UserGroupDelete_Call{Call: _e.mock.On("UserGroupDelete", ctx, organizationId, userGroupId)}
}

func (_c *MockClient_UserGroupDelete_Call) Run(run func(ctx context.Context, organizationId string, userGroupId string)) *MockClient_UserGroupDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_UserGroupDelete_Call) Return(err error) *MockClient_UserGroupDelete_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_UserGroupDelete_Call) RunAndReturn(run func(ctx context.Context, organizationId string, userGroupId string) error) *MockClient_UserGroupDelete_Call {
	_c.Call.Return(run)
	return _c
}

// UserGroupGet provides a mock function for the type MockClient
func (_mock *MockClient) UserGroupGet(ctx context.Context, organizationId string, userGroupId string) (*usergroup.UserGroupGetOut, error) {
	ret := _mock.Called(ctx, organizationId, userGroupId)

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

	var r0 *usergroup.UserGroupGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*usergroup.UserGroupGetOut, error)); ok {
		return returnFunc(ctx, organizationId, userGroupId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *usergroup.UserGroupGetOut); ok {
		r0 = returnFunc(ctx, organizationId, userGroupId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*usergroup.UserGroupGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, organizationId, userGroupId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UserGroupGet is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - userGroupId
func (_e *MockClient_Expecter) UserGroupGet(ctx interface{}, organizationId interface{}, userGroupId interface{}) *MockClient_UserGroupGet_Call {
	return &MockClient_UserGroupGet_Call{Call: _e.mock.On("UserGroupGet", ctx, organizationId, userGroupId)}
}

func (_c *MockClient_UserGroupGet_Call) Run(run func(ctx context.Context, organizationId string, userGroupId string)) *MockClient_UserGroupGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_UserGroupGet_Call) Return(userGroupGetOut *usergroup.UserGroupGetOut, err error) *MockClient_UserGroupGet_Call {
	_c.Call.Return(userGroupGetOut, err)
	return _c
}

func (_c *MockClient_UserGroupGet_Call) RunAndReturn(run func(ctx context.Context, organizationId string, userGroupId string) (*usergroup.UserGroupGetOut, error)) *MockClient_UserGroupGet_Call {
	_c.Call.Return(run)
	return _c
}

// UserGroupMemberList provides a mock function for the type MockClient
func (_mock *MockClient) UserGroupMemberList(ctx context.Context, organizationId string, userGroupId string) ([]usergroup.MemberOut, error) {
	ret := _mock.Called(ctx, organizationId, userGroupId)

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

	var r0 []usergroup.MemberOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) ([]usergroup.MemberOut, error)); ok {
		return returnFunc(ctx, organizationId, userGroupId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) []usergroup.MemberOut); ok {
		r0 = returnFunc(ctx, organizationId, userGroupId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]usergroup.MemberOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, organizationId, userGroupId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UserGroupMemberList is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - userGroupId
func (_e *MockClient_Expecter) UserGroupMemberList(ctx interface{}, organizationId interface{}, userGroupId interface{}) *MockClient_UserGroupMemberList_Call {
	return &MockClient_UserGroupMemberList_Call{Call: _e.mock.On("UserGroupMemberList", ctx, organizationId, userGroupId)}
}

func (_c *MockClient_UserGroupMemberList_Call) Run(run func(ctx context.Context, organizationId string, userGroupId string)) *MockClient_UserGroupMemberList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_UserGroupMemberList_Call) Return(memberOuts []usergroup.MemberOut, err error) *MockClient_UserGroupMemberList_Call {
	_c.Call.Return(memberOuts, err)
	return _c
}

func (_c *MockClient_UserGroupMemberList_Call) RunAndReturn(run func(ctx context.Context, organizationId string, userGroupId string) ([]usergroup.MemberOut, error)) *MockClient_UserGroupMemberList_Call {
	_c.Call.Return(run)
	return _c
}

// UserGroupMembersUpdate provides a mock function for the type MockClient
func (_mock *MockClient) UserGroupMembersUpdate(ctx context.Context, organizationId string, userGroupId string, in *usergroup.UserGroupMembersUpdateIn) error {
	ret := _mock.Called(ctx, organizationId, userGroupId, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *usergroup.UserGroupMembersUpdateIn) error); ok {
		r0 = returnFunc(ctx, organizationId, userGroupId, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// UserGroupMembersUpdate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - userGroupId
//   - in
func (_e *MockClient_Expecter) UserGroupMembersUpdate(ctx interface{}, organizationId interface{}, userGroupId interface{}, in interface{}) *MockClient_UserGroupMembersUpdate_Call {
	return &MockClient_UserGroupMembersUpdate_Call{Call: _e.mock.On("UserGroupMembersUpdate", ctx, organizationId, userGroupId, in)}
}

func (_c *MockClient_UserGroupMembersUpdate_Call) Run(run func(ctx context.Context, organizationId string, userGroupId string, in *usergroup.UserGroupMembersUpdateIn)) *MockClient_UserGroupMembersUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*usergroup.UserGroupMembersUpdateIn))
	})
	return _c
}

func (_c *MockClient_UserGroupMembersUpdate_Call) Return(err error) *MockClient_UserGroupMembersUpdate_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_UserGroupMembersUpdate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, userGroupId string, in *usergroup.UserGroupMembersUpdateIn) error) *MockClient_UserGroupMembersUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// UserGroupUpdate provides a mock function for the type MockClient
func (_mock *MockClient) UserGroupUpdate(ctx context.Context, organizationId string, userGroupId string, in *usergroup.UserGroupUpdateIn) (*usergroup.UserGroupUpdateOut, error) {
	ret := _mock.Called(ctx, organizationId, userGroupId, in)

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

	var r0 *usergroup.UserGroupUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *usergroup.UserGroupUpdateIn) (*usergroup.UserGroupUpdateOut, error)); ok {
		return returnFunc(ctx, organizationId, userGroupId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *usergroup.UserGroupUpdateIn) *usergroup.UserGroupUpdateOut); ok {
		r0 = returnFunc(ctx, organizationId, userGroupId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*usergroup.UserGroupUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *usergroup.UserGroupUpdateIn) error); ok {
		r1 = returnFunc(ctx, organizationId, userGroupId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UserGroupUpdate is a helper method to define mock.On call
//   - ctx
//   - organizationId
//   - userGroupId
//   - in
func (_e *MockClient_Expecter) UserGroupUpdate(ctx interface{}, organizationId interface{}, userGroupId interface{}, in interface{}) *MockClient_UserGroupUpdate_Call {
	return &MockClient_UserGroupUpdate_Call{Call: _e.mock.On("UserGroupUpdate", ctx, organizationId, userGroupId, in)}
}

func (_c *MockClient_UserGroupUpdate_Call) Run(run func(ctx context.Context, organizationId string, userGroupId string, in *usergroup.UserGroupUpdateIn)) *MockClient_UserGroupUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*usergroup.UserGroupUpdateIn))
	})
	return _c
}

func (_c *MockClient_UserGroupUpdate_Call) Return(userGroupUpdateOut *usergroup.UserGroupUpdateOut, err error) *MockClient_UserGroupUpdate_Call {
	_c.Call.Return(userGroupUpdateOut, err)
	return _c
}

func (_c *MockClient_UserGroupUpdate_Call) RunAndReturn(run func(ctx context.Context, organizationId string, userGroupId string, in *usergroup.UserGroupUpdateIn) (*usergroup.UserGroupUpdateOut, error)) *MockClient_UserGroupUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// UserGroupsList provides a mock function for the type MockClient
func (_mock *MockClient) UserGroupsList(ctx context.Context, organizationId string) ([]usergroup.UserGroupOut, error) {
	ret := _mock.Called(ctx, organizationId)

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

	var r0 []usergroup.UserGroupOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]usergroup.UserGroupOut, error)); ok {
		return returnFunc(ctx, organizationId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []usergroup.UserGroupOut); ok {
		r0 = returnFunc(ctx, organizationId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]usergroup.UserGroupOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, organizationId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UserGroupsList is a helper method to define mock.On call
//   - ctx
//   - organizationId
func (_e *MockClient_Expecter) UserGroupsList(ctx interface{}, organizationId interface{}) *MockClient_UserGroupsList_Call {
	return &MockClient_UserGroupsList_Call{Call: _e.mock.On("UserGroupsList", ctx, organizationId)}
}

func (_c *MockClient_UserGroupsList_Call) Run(run func(ctx context.Context, organizationId string)) *MockClient_UserGroupsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_UserGroupsList_Call) Return(userGroupOuts []usergroup.UserGroupOut, err error) *MockClient_UserGroupsList_Call {
	_c.Call.Return(userGroupOuts, err)
	return _c
}

func (_c *MockClient_UserGroupsList_Call) RunAndReturn(run func(ctx context.Context, organizationId string) ([]usergroup.UserGroupOut, error)) *MockClient_UserGroupsList_Call {
	_c.Call.Return(run)
	return _c
}

// UserInfo provides a mock function for the type MockClient
func (_mock *MockClient) UserInfo(ctx context.Context) (*user.UserInfoOut, error) {
	ret := _mock.Called(ctx)

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

	var r0 *user.UserInfoOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) (*user.UserInfoOut, error)); ok {
		return returnFunc(ctx)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context) *user.UserInfoOut); ok {
		r0 = returnFunc(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*user.UserInfoOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = returnFunc(ctx)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UserInfo is a helper method to define mock.On call
//   - ctx
func (_e *MockClient_Expecter) UserInfo(ctx interface{}) *MockClient_UserInfo_Call {
	return &MockClient_UserInfo_Call{Call: _e.mock.On("UserInfo", ctx)}
}

func (_c *MockClient_UserInfo_Call) Run(run func(ctx context.Context)) *MockClient_UserInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockClient_UserInfo_Call) Return(userInfoOut *user.UserInfoOut, err error) *MockClient_UserInfo_Call {
	_c.Call.Return(userInfoOut, err)
	return _c
}

func (_c *MockClient_UserInfo_Call) RunAndReturn(run func(ctx context.Context) (*user.UserInfoOut, error)) *MockClient_UserInfo_Call {
	_c.Call.Return(run)
	return _c
}

// UserLogout provides a mock function for the type MockClient
func (_mock *MockClient) UserLogout(ctx context.Context) error {
	ret := _mock.Called(ctx)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
		r0 = returnFunc(ctx)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// UserLogout is a helper method to define mock.On call
//   - ctx
func (_e *MockClient_Expecter) UserLogout(ctx interface{}) *MockClient_UserLogout_Call {
	return &MockClient_UserLogout_Call{Call: _e.mock.On("UserLogout", ctx)}
}

func (_c *MockClient_UserLogout_Call) Run(run func(ctx context.Context)) *MockClient_UserLogout_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockClient_UserLogout_Call) Return(err error) *MockClient_UserLogout_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_UserLogout_Call) RunAndReturn(run func(ctx context.Context) error) *MockClient_UserLogout_Call {
	_c.Call.Return(run)
	return _c
}

// UserOrganizationCreate provides a mock function for the type MockClient
func (_mock *MockClient) UserOrganizationCreate(ctx context.Context, in *organization.UserOrganizationCreateIn) (*organization.UserOrganizationCreateOut, error) {
	ret := _mock.Called(ctx, in)

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

	var r0 *organization.UserOrganizationCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *organization.UserOrganizationCreateIn) (*organization.UserOrganizationCreateOut, error)); ok {
		return returnFunc(ctx, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *organization.UserOrganizationCreateIn) *organization.UserOrganizationCreateOut); ok {
		r0 = returnFunc(ctx, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*organization.UserOrganizationCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *organization.UserOrganizationCreateIn) error); ok {
		r1 = returnFunc(ctx, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UserOrganizationCreate is a helper method to define mock.On call
//   - ctx
//   - in
func (_e *MockClient_Expecter) UserOrganizationCreate(ctx interface{}, in interface{}) *MockClient_UserOrganizationCreate_Call {
	return &MockClient_UserOrganizationCreate_Call{Call: _e.mock.On("UserOrganizationCreate", ctx, in)}
}

func (_c *MockClient_UserOrganizationCreate_Call) Run(run func(ctx context.Context, in *organization.UserOrganizationCreateIn)) *MockClient_UserOrganizationCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*organization.UserOrganizationCreateIn))
	})
	return _c
}

func (_c *MockClient_UserOrganizationCreate_Call) Return(userOrganizationCreateOut *organization.UserOrganizationCreateOut, err error) *MockClient_UserOrganizationCreate_Call {
	_c.Call.Return(userOrganizationCreateOut, err)
	return _c
}

func (_c *MockClient_UserOrganizationCreate_Call) RunAndReturn(run func(ctx context.Context, in *organization.UserOrganizationCreateIn) (*organization.UserOrganizationCreateOut, error)) *MockClient_UserOrganizationCreate_Call {
	_c.Call.Return(run)
	return _c
}

// UserOrganizationsList provides a mock function for the type MockClient
func (_mock *MockClient) UserOrganizationsList(ctx context.Context) ([]organization.OrganizationOut, error) {
	ret := _mock.Called(ctx)

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

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

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

// UserOrganizationsList is a helper method to define mock.On call
//   - ctx
func (_e *MockClient_Expecter) UserOrganizationsList(ctx interface{}) *MockClient_UserOrganizationsList_Call {
	return &MockClient_UserOrganizationsList_Call{Call: _e.mock.On("UserOrganizationsList", ctx)}
}

func (_c *MockClient_UserOrganizationsList_Call) Run(run func(ctx context.Context)) *MockClient_UserOrganizationsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *MockClient_UserOrganizationsList_Call) Return(organizationOuts []organization.OrganizationOut, err error) *MockClient_UserOrganizationsList_Call {
	_c.Call.Return(organizationOuts, err)
	return _c
}

func (_c *MockClient_UserOrganizationsList_Call) RunAndReturn(run func(ctx context.Context) ([]organization.OrganizationOut, error)) *MockClient_UserOrganizationsList_Call {
	_c.Call.Return(run)
	return _c
}

// UserPasswordChange provides a mock function for the type MockClient
func (_mock *MockClient) UserPasswordChange(ctx context.Context, in *user.UserPasswordChangeIn) (string, error) {
	ret := _mock.Called(ctx, in)

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

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.UserPasswordChangeIn) (string, error)); ok {
		return returnFunc(ctx, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.UserPasswordChangeIn) string); ok {
		r0 = returnFunc(ctx, in)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *user.UserPasswordChangeIn) error); ok {
		r1 = returnFunc(ctx, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UserPasswordChange is a helper method to define mock.On call
//   - ctx
//   - in
func (_e *MockClient_Expecter) UserPasswordChange(ctx interface{}, in interface{}) *MockClient_UserPasswordChange_Call {
	return &MockClient_UserPasswordChange_Call{Call: _e.mock.On("UserPasswordChange", ctx, in)}
}

func (_c *MockClient_UserPasswordChange_Call) Run(run func(ctx context.Context, in *user.UserPasswordChangeIn)) *MockClient_UserPasswordChange_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*user.UserPasswordChangeIn))
	})
	return _c
}

func (_c *MockClient_UserPasswordChange_Call) Return(s string, err error) *MockClient_UserPasswordChange_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockClient_UserPasswordChange_Call) RunAndReturn(run func(ctx context.Context, in *user.UserPasswordChangeIn) (string, error)) *MockClient_UserPasswordChange_Call {
	_c.Call.Return(run)
	return _c
}

// UserPasswordReset provides a mock function for the type MockClient
func (_mock *MockClient) UserPasswordReset(ctx context.Context, verificationCode string, in *user.UserPasswordResetIn) error {
	ret := _mock.Called(ctx, verificationCode, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *user.UserPasswordResetIn) error); ok {
		r0 = returnFunc(ctx, verificationCode, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// UserPasswordReset is a helper method to define mock.On call
//   - ctx
//   - verificationCode
//   - in
func (_e *MockClient_Expecter) UserPasswordReset(ctx interface{}, verificationCode interface{}, in interface{}) *MockClient_UserPasswordReset_Call {
	return &MockClient_UserPasswordReset_Call{Call: _e.mock.On("UserPasswordReset", ctx, verificationCode, in)}
}

func (_c *MockClient_UserPasswordReset_Call) Run(run func(ctx context.Context, verificationCode string, in *user.UserPasswordResetIn)) *MockClient_UserPasswordReset_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*user.UserPasswordResetIn))
	})
	return _c
}

func (_c *MockClient_UserPasswordReset_Call) Return(err error) *MockClient_UserPasswordReset_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_UserPasswordReset_Call) RunAndReturn(run func(ctx context.Context, verificationCode string, in *user.UserPasswordResetIn) error) *MockClient_UserPasswordReset_Call {
	_c.Call.Return(run)
	return _c
}

// UserPasswordResetRequest provides a mock function for the type MockClient
func (_mock *MockClient) UserPasswordResetRequest(ctx context.Context, in *user.UserPasswordResetRequestIn) error {
	ret := _mock.Called(ctx, in)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.UserPasswordResetRequestIn) error); ok {
		r0 = returnFunc(ctx, in)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// UserPasswordResetRequest is a helper method to define mock.On call
//   - ctx
//   - in
func (_e *MockClient_Expecter) UserPasswordResetRequest(ctx interface{}, in interface{}) *MockClient_UserPasswordResetRequest_Call {
	return &MockClient_UserPasswordResetRequest_Call{Call: _e.mock.On("UserPasswordResetRequest", ctx, in)}
}

func (_c *MockClient_UserPasswordResetRequest_Call) Run(run func(ctx context.Context, in *user.UserPasswordResetRequestIn)) *MockClient_UserPasswordResetRequest_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*user.UserPasswordResetRequestIn))
	})
	return _c
}

func (_c *MockClient_UserPasswordResetRequest_Call) Return(err error) *MockClient_UserPasswordResetRequest_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_UserPasswordResetRequest_Call) RunAndReturn(run func(ctx context.Context, in *user.UserPasswordResetRequestIn) error) *MockClient_UserPasswordResetRequest_Call {
	_c.Call.Return(run)
	return _c
}

// UserUpdate provides a mock function for the type MockClient
func (_mock *MockClient) UserUpdate(ctx context.Context, in *user.UserUpdateIn) (*user.UserUpdateOut, error) {
	ret := _mock.Called(ctx, in)

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

	var r0 *user.UserUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.UserUpdateIn) (*user.UserUpdateOut, error)); ok {
		return returnFunc(ctx, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *user.UserUpdateIn) *user.UserUpdateOut); ok {
		r0 = returnFunc(ctx, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*user.UserUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *user.UserUpdateIn) error); ok {
		r1 = returnFunc(ctx, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UserUpdate is a helper method to define mock.On call
//   - ctx
//   - in
func (_e *MockClient_Expecter) UserUpdate(ctx interface{}, in interface{}) *MockClient_UserUpdate_Call {
	return &MockClient_UserUpdate_Call{Call: _e.mock.On("UserUpdate", ctx, in)}
}

func (_c *MockClient_UserUpdate_Call) Run(run func(ctx context.Context, in *user.UserUpdateIn)) *MockClient_UserUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*user.UserUpdateIn))
	})
	return _c
}

func (_c *MockClient_UserUpdate_Call) Return(userUpdateOut *user.UserUpdateOut, err error) *MockClient_UserUpdate_Call {
	_c.Call.Return(userUpdateOut, err)
	return _c
}

func (_c *MockClient_UserUpdate_Call) RunAndReturn(run func(ctx context.Context, in *user.UserUpdateIn) (*user.UserUpdateOut, error)) *MockClient_UserUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// UserVerifyEmail provides a mock function for the type MockClient
func (_mock *MockClient) UserVerifyEmail(ctx context.Context, verificationCode string) (*user.UserVerifyEmailOut, error) {
	ret := _mock.Called(ctx, verificationCode)

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

	var r0 *user.UserVerifyEmailOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*user.UserVerifyEmailOut, error)); ok {
		return returnFunc(ctx, verificationCode)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) *user.UserVerifyEmailOut); ok {
		r0 = returnFunc(ctx, verificationCode)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*user.UserVerifyEmailOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, verificationCode)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UserVerifyEmail is a helper method to define mock.On call
//   - ctx
//   - verificationCode
func (_e *MockClient_Expecter) UserVerifyEmail(ctx interface{}, verificationCode interface{}) *MockClient_UserVerifyEmail_Call {
	return &MockClient_UserVerifyEmail_Call{Call: _e.mock.On("UserVerifyEmail", ctx, verificationCode)}
}

func (_c *MockClient_UserVerifyEmail_Call) Run(run func(ctx context.Context, verificationCode string)) *MockClient_UserVerifyEmail_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_UserVerifyEmail_Call) Return(userVerifyEmailOut *user.UserVerifyEmailOut, err error) *MockClient_UserVerifyEmail_Call {
	_c.Call.Return(userVerifyEmailOut, err)
	return _c
}

func (_c *MockClient_UserVerifyEmail_Call) RunAndReturn(run func(ctx context.Context, verificationCode string) (*user.UserVerifyEmailOut, error)) *MockClient_UserVerifyEmail_Call {
	_c.Call.Return(run)
	return _c
}

// ValidateCreditCode provides a mock function for the type MockClient
func (_mock *MockClient) ValidateCreditCode(ctx context.Context, creditCode string) error {
	ret := _mock.Called(ctx, creditCode)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(ctx, creditCode)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ValidateCreditCode is a helper method to define mock.On call
//   - ctx
//   - creditCode
func (_e *MockClient_Expecter) ValidateCreditCode(ctx interface{}, creditCode interface{}) *MockClient_ValidateCreditCode_Call {
	return &MockClient_ValidateCreditCode_Call{Call: _e.mock.On("ValidateCreditCode", ctx, creditCode)}
}

func (_c *MockClient_ValidateCreditCode_Call) Run(run func(ctx context.Context, creditCode string)) *MockClient_ValidateCreditCode_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ValidateCreditCode_Call) Return(err error) *MockClient_ValidateCreditCode_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ValidateCreditCode_Call) RunAndReturn(run func(ctx context.Context, creditCode string) error) *MockClient_ValidateCreditCode_Call {
	_c.Call.Return(run)
	return _c
}

// ValidateReferralCode provides a mock function for the type MockClient
func (_mock *MockClient) ValidateReferralCode(ctx context.Context, referralCode string) error {
	ret := _mock.Called(ctx, referralCode)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(ctx, referralCode)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ValidateReferralCode is a helper method to define mock.On call
//   - ctx
//   - referralCode
func (_e *MockClient_Expecter) ValidateReferralCode(ctx interface{}, referralCode interface{}) *MockClient_ValidateReferralCode_Call {
	return &MockClient_ValidateReferralCode_Call{Call: _e.mock.On("ValidateReferralCode", ctx, referralCode)}
}

func (_c *MockClient_ValidateReferralCode_Call) Run(run func(ctx context.Context, referralCode string)) *MockClient_ValidateReferralCode_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_ValidateReferralCode_Call) Return(err error) *MockClient_ValidateReferralCode_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockClient_ValidateReferralCode_Call) RunAndReturn(run func(ctx context.Context, referralCode string) error) *MockClient_ValidateReferralCode_Call {
	_c.Call.Return(run)
	return _c
}

// VpcCreate provides a mock function for the type MockClient
func (_mock *MockClient) VpcCreate(ctx context.Context, project1 string, in *vpc.VpcCreateIn) (*vpc.VpcCreateOut, error) {
	ret := _mock.Called(ctx, project1, in)

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

	var r0 *vpc.VpcCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *vpc.VpcCreateIn) (*vpc.VpcCreateOut, error)); ok {
		return returnFunc(ctx, project1, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *vpc.VpcCreateIn) *vpc.VpcCreateOut); ok {
		r0 = returnFunc(ctx, project1, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*vpc.VpcCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *vpc.VpcCreateIn) error); ok {
		r1 = returnFunc(ctx, project1, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// VpcCreate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - in
func (_e *MockClient_Expecter) VpcCreate(ctx interface{}, project1 interface{}, in interface{}) *MockClient_VpcCreate_Call {
	return &MockClient_VpcCreate_Call{Call: _e.mock.On("VpcCreate", ctx, project1, in)}
}

func (_c *MockClient_VpcCreate_Call) Run(run func(ctx context.Context, project1 string, in *vpc.VpcCreateIn)) *MockClient_VpcCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*vpc.VpcCreateIn))
	})
	return _c
}

func (_c *MockClient_VpcCreate_Call) Return(vpcCreateOut *vpc.VpcCreateOut, err error) *MockClient_VpcCreate_Call {
	_c.Call.Return(vpcCreateOut, err)
	return _c
}

func (_c *MockClient_VpcCreate_Call) RunAndReturn(run func(ctx context.Context, project1 string, in *vpc.VpcCreateIn) (*vpc.VpcCreateOut, error)) *MockClient_VpcCreate_Call {
	_c.Call.Return(run)
	return _c
}

// VpcDelete provides a mock function for the type MockClient
func (_mock *MockClient) VpcDelete(ctx context.Context, project1 string, projectVpcId string) (*vpc.VpcDeleteOut, error) {
	ret := _mock.Called(ctx, project1, projectVpcId)

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

	var r0 *vpc.VpcDeleteOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*vpc.VpcDeleteOut, error)); ok {
		return returnFunc(ctx, project1, projectVpcId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *vpc.VpcDeleteOut); ok {
		r0 = returnFunc(ctx, project1, projectVpcId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*vpc.VpcDeleteOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, projectVpcId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// VpcDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - projectVpcId
func (_e *MockClient_Expecter) VpcDelete(ctx interface{}, project1 interface{}, projectVpcId interface{}) *MockClient_VpcDelete_Call {
	return &MockClient_VpcDelete_Call{Call: _e.mock.On("VpcDelete", ctx, project1, projectVpcId)}
}

func (_c *MockClient_VpcDelete_Call) Run(run func(ctx context.Context, project1 string, projectVpcId string)) *MockClient_VpcDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_VpcDelete_Call) Return(vpcDeleteOut *vpc.VpcDeleteOut, err error) *MockClient_VpcDelete_Call {
	_c.Call.Return(vpcDeleteOut, err)
	return _c
}

func (_c *MockClient_VpcDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, projectVpcId string) (*vpc.VpcDeleteOut, error)) *MockClient_VpcDelete_Call {
	_c.Call.Return(run)
	return _c
}

// VpcGet provides a mock function for the type MockClient
func (_mock *MockClient) VpcGet(ctx context.Context, project1 string, projectVpcId string) (*vpc.VpcGetOut, error) {
	ret := _mock.Called(ctx, project1, projectVpcId)

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

	var r0 *vpc.VpcGetOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*vpc.VpcGetOut, error)); ok {
		return returnFunc(ctx, project1, projectVpcId)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *vpc.VpcGetOut); ok {
		r0 = returnFunc(ctx, project1, projectVpcId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*vpc.VpcGetOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = returnFunc(ctx, project1, projectVpcId)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// VpcGet is a helper method to define mock.On call
//   - ctx
//   - project1
//   - projectVpcId
func (_e *MockClient_Expecter) VpcGet(ctx interface{}, project1 interface{}, projectVpcId interface{}) *MockClient_VpcGet_Call {
	return &MockClient_VpcGet_Call{Call: _e.mock.On("VpcGet", ctx, project1, projectVpcId)}
}

func (_c *MockClient_VpcGet_Call) Run(run func(ctx context.Context, project1 string, projectVpcId string)) *MockClient_VpcGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockClient_VpcGet_Call) Return(vpcGetOut *vpc.VpcGetOut, err error) *MockClient_VpcGet_Call {
	_c.Call.Return(vpcGetOut, err)
	return _c
}

func (_c *MockClient_VpcGet_Call) RunAndReturn(run func(ctx context.Context, project1 string, projectVpcId string) (*vpc.VpcGetOut, error)) *MockClient_VpcGet_Call {
	_c.Call.Return(run)
	return _c
}

// VpcList provides a mock function for the type MockClient
func (_mock *MockClient) VpcList(ctx context.Context, project1 string) ([]vpc.VpcOut, error) {
	ret := _mock.Called(ctx, project1)

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

	var r0 []vpc.VpcOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]vpc.VpcOut, error)); ok {
		return returnFunc(ctx, project1)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) []vpc.VpcOut); ok {
		r0 = returnFunc(ctx, project1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]vpc.VpcOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, project1)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// VpcList is a helper method to define mock.On call
//   - ctx
//   - project1
func (_e *MockClient_Expecter) VpcList(ctx interface{}, project1 interface{}) *MockClient_VpcList_Call {
	return &MockClient_VpcList_Call{Call: _e.mock.On("VpcList", ctx, project1)}
}

func (_c *MockClient_VpcList_Call) Run(run func(ctx context.Context, project1 string)) *MockClient_VpcList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockClient_VpcList_Call) Return(vpcOuts []vpc.VpcOut, err error) *MockClient_VpcList_Call {
	_c.Call.Return(vpcOuts, err)
	return _c
}

func (_c *MockClient_VpcList_Call) RunAndReturn(run func(ctx context.Context, project1 string) ([]vpc.VpcOut, error)) *MockClient_VpcList_Call {
	_c.Call.Return(run)
	return _c
}

// VpcPeeringConnectionCreate provides a mock function for the type MockClient
func (_mock *MockClient) VpcPeeringConnectionCreate(ctx context.Context, project1 string, projectVpcId string, in *vpc.VpcPeeringConnectionCreateIn) (*vpc.VpcPeeringConnectionCreateOut, error) {
	ret := _mock.Called(ctx, project1, projectVpcId, in)

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

	var r0 *vpc.VpcPeeringConnectionCreateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *vpc.VpcPeeringConnectionCreateIn) (*vpc.VpcPeeringConnectionCreateOut, error)); ok {
		return returnFunc(ctx, project1, projectVpcId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *vpc.VpcPeeringConnectionCreateIn) *vpc.VpcPeeringConnectionCreateOut); ok {
		r0 = returnFunc(ctx, project1, projectVpcId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*vpc.VpcPeeringConnectionCreateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *vpc.VpcPeeringConnectionCreateIn) error); ok {
		r1 = returnFunc(ctx, project1, projectVpcId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// VpcPeeringConnectionCreate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - projectVpcId
//   - in
func (_e *MockClient_Expecter) VpcPeeringConnectionCreate(ctx interface{}, project1 interface{}, projectVpcId interface{}, in interface{}) *MockClient_VpcPeeringConnectionCreate_Call {
	return &MockClient_VpcPeeringConnectionCreate_Call{Call: _e.mock.On("VpcPeeringConnectionCreate", ctx, project1, projectVpcId, in)}
}

func (_c *MockClient_VpcPeeringConnectionCreate_Call) Run(run func(ctx context.Context, project1 string, projectVpcId string, in *vpc.VpcPeeringConnectionCreateIn)) *MockClient_VpcPeeringConnectionCreate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*vpc.VpcPeeringConnectionCreateIn))
	})
	return _c
}

func (_c *MockClient_VpcPeeringConnectionCreate_Call) Return(vpcPeeringConnectionCreateOut *vpc.VpcPeeringConnectionCreateOut, err error) *MockClient_VpcPeeringConnectionCreate_Call {
	_c.Call.Return(vpcPeeringConnectionCreateOut, err)
	return _c
}

func (_c *MockClient_VpcPeeringConnectionCreate_Call) RunAndReturn(run func(ctx context.Context, project1 string, projectVpcId string, in *vpc.VpcPeeringConnectionCreateIn) (*vpc.VpcPeeringConnectionCreateOut, error)) *MockClient_VpcPeeringConnectionCreate_Call {
	_c.Call.Return(run)
	return _c
}

// VpcPeeringConnectionDelete provides a mock function for the type MockClient
func (_mock *MockClient) VpcPeeringConnectionDelete(ctx context.Context, project1 string, projectVpcId string, peerCloudAccount string, peerVpc string) (*vpc.VpcPeeringConnectionDeleteOut, error) {
	ret := _mock.Called(ctx, project1, projectVpcId, peerCloudAccount, peerVpc)

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

	var r0 *vpc.VpcPeeringConnectionDeleteOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) (*vpc.VpcPeeringConnectionDeleteOut, error)); ok {
		return returnFunc(ctx, project1, projectVpcId, peerCloudAccount, peerVpc)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) *vpc.VpcPeeringConnectionDeleteOut); ok {
		r0 = returnFunc(ctx, project1, projectVpcId, peerCloudAccount, peerVpc)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*vpc.VpcPeeringConnectionDeleteOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, projectVpcId, peerCloudAccount, peerVpc)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// VpcPeeringConnectionDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - projectVpcId
//   - peerCloudAccount
//   - peerVpc
func (_e *MockClient_Expecter) VpcPeeringConnectionDelete(ctx interface{}, project1 interface{}, projectVpcId interface{}, peerCloudAccount interface{}, peerVpc interface{}) *MockClient_VpcPeeringConnectionDelete_Call {
	return &MockClient_VpcPeeringConnectionDelete_Call{Call: _e.mock.On("VpcPeeringConnectionDelete", ctx, project1, projectVpcId, peerCloudAccount, peerVpc)}
}

func (_c *MockClient_VpcPeeringConnectionDelete_Call) Run(run func(ctx context.Context, project1 string, projectVpcId string, peerCloudAccount string, peerVpc string)) *MockClient_VpcPeeringConnectionDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string))
	})
	return _c
}

func (_c *MockClient_VpcPeeringConnectionDelete_Call) Return(vpcPeeringConnectionDeleteOut *vpc.VpcPeeringConnectionDeleteOut, err error) *MockClient_VpcPeeringConnectionDelete_Call {
	_c.Call.Return(vpcPeeringConnectionDeleteOut, err)
	return _c
}

func (_c *MockClient_VpcPeeringConnectionDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, projectVpcId string, peerCloudAccount string, peerVpc string) (*vpc.VpcPeeringConnectionDeleteOut, error)) *MockClient_VpcPeeringConnectionDelete_Call {
	_c.Call.Return(run)
	return _c
}

// VpcPeeringConnectionUpdate provides a mock function for the type MockClient
func (_mock *MockClient) VpcPeeringConnectionUpdate(ctx context.Context, project1 string, projectVpcId string, in *vpc.VpcPeeringConnectionUpdateIn) (*vpc.VpcPeeringConnectionUpdateOut, error) {
	ret := _mock.Called(ctx, project1, projectVpcId, in)

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

	var r0 *vpc.VpcPeeringConnectionUpdateOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *vpc.VpcPeeringConnectionUpdateIn) (*vpc.VpcPeeringConnectionUpdateOut, error)); ok {
		return returnFunc(ctx, project1, projectVpcId, in)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, *vpc.VpcPeeringConnectionUpdateIn) *vpc.VpcPeeringConnectionUpdateOut); ok {
		r0 = returnFunc(ctx, project1, projectVpcId, in)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*vpc.VpcPeeringConnectionUpdateOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, *vpc.VpcPeeringConnectionUpdateIn) error); ok {
		r1 = returnFunc(ctx, project1, projectVpcId, in)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// VpcPeeringConnectionUpdate is a helper method to define mock.On call
//   - ctx
//   - project1
//   - projectVpcId
//   - in
func (_e *MockClient_Expecter) VpcPeeringConnectionUpdate(ctx interface{}, project1 interface{}, projectVpcId interface{}, in interface{}) *MockClient_VpcPeeringConnectionUpdate_Call {
	return &MockClient_VpcPeeringConnectionUpdate_Call{Call: _e.mock.On("VpcPeeringConnectionUpdate", ctx, project1, projectVpcId, in)}
}

func (_c *MockClient_VpcPeeringConnectionUpdate_Call) Run(run func(ctx context.Context, project1 string, projectVpcId string, in *vpc.VpcPeeringConnectionUpdateIn)) *MockClient_VpcPeeringConnectionUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(*vpc.VpcPeeringConnectionUpdateIn))
	})
	return _c
}

func (_c *MockClient_VpcPeeringConnectionUpdate_Call) Return(vpcPeeringConnectionUpdateOut *vpc.VpcPeeringConnectionUpdateOut, err error) *MockClient_VpcPeeringConnectionUpdate_Call {
	_c.Call.Return(vpcPeeringConnectionUpdateOut, err)
	return _c
}

func (_c *MockClient_VpcPeeringConnectionUpdate_Call) RunAndReturn(run func(ctx context.Context, project1 string, projectVpcId string, in *vpc.VpcPeeringConnectionUpdateIn) (*vpc.VpcPeeringConnectionUpdateOut, error)) *MockClient_VpcPeeringConnectionUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// VpcPeeringConnectionWithRegionDelete provides a mock function for the type MockClient
func (_mock *MockClient) VpcPeeringConnectionWithRegionDelete(ctx context.Context, project1 string, projectVpcId string, peerCloudAccount string, peerVpc string, peerRegion string) (*vpc.VpcPeeringConnectionWithRegionDeleteOut, error) {
	ret := _mock.Called(ctx, project1, projectVpcId, peerCloudAccount, peerVpc, peerRegion)

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

	var r0 *vpc.VpcPeeringConnectionWithRegionDeleteOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string, string) (*vpc.VpcPeeringConnectionWithRegionDeleteOut, error)); ok {
		return returnFunc(ctx, project1, projectVpcId, peerCloudAccount, peerVpc, peerRegion)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string, string) *vpc.VpcPeeringConnectionWithRegionDeleteOut); ok {
		r0 = returnFunc(ctx, project1, projectVpcId, peerCloudAccount, peerVpc, peerRegion)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*vpc.VpcPeeringConnectionWithRegionDeleteOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, projectVpcId, peerCloudAccount, peerVpc, peerRegion)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// VpcPeeringConnectionWithRegionDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - projectVpcId
//   - peerCloudAccount
//   - peerVpc
//   - peerRegion
func (_e *MockClient_Expecter) VpcPeeringConnectionWithRegionDelete(ctx interface{}, project1 interface{}, projectVpcId interface{}, peerCloudAccount interface{}, peerVpc interface{}, peerRegion interface{}) *MockClient_VpcPeeringConnectionWithRegionDelete_Call {
	return &MockClient_VpcPeeringConnectionWithRegionDelete_Call{Call: _e.mock.On("VpcPeeringConnectionWithRegionDelete", ctx, project1, projectVpcId, peerCloudAccount, peerVpc, peerRegion)}
}

func (_c *MockClient_VpcPeeringConnectionWithRegionDelete_Call) Run(run func(ctx context.Context, project1 string, projectVpcId string, peerCloudAccount string, peerVpc string, peerRegion string)) *MockClient_VpcPeeringConnectionWithRegionDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(string))
	})
	return _c
}

func (_c *MockClient_VpcPeeringConnectionWithRegionDelete_Call) Return(vpcPeeringConnectionWithRegionDeleteOut *vpc.VpcPeeringConnectionWithRegionDeleteOut, err error) *MockClient_VpcPeeringConnectionWithRegionDelete_Call {
	_c.Call.Return(vpcPeeringConnectionWithRegionDeleteOut, err)
	return _c
}

func (_c *MockClient_VpcPeeringConnectionWithRegionDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, projectVpcId string, peerCloudAccount string, peerVpc string, peerRegion string) (*vpc.VpcPeeringConnectionWithRegionDeleteOut, error)) *MockClient_VpcPeeringConnectionWithRegionDelete_Call {
	_c.Call.Return(run)
	return _c
}

// VpcPeeringConnectionWithResourceGroupDelete provides a mock function for the type MockClient
func (_mock *MockClient) VpcPeeringConnectionWithResourceGroupDelete(ctx context.Context, project1 string, projectVpcId string, peerCloudAccount string, peerResourceGroup string, peerVpc string) (*vpc.VpcPeeringConnectionWithResourceGroupDeleteOut, error) {
	ret := _mock.Called(ctx, project1, projectVpcId, peerCloudAccount, peerResourceGroup, peerVpc)

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

	var r0 *vpc.VpcPeeringConnectionWithResourceGroupDeleteOut
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string, string) (*vpc.VpcPeeringConnectionWithResourceGroupDeleteOut, error)); ok {
		return returnFunc(ctx, project1, projectVpcId, peerCloudAccount, peerResourceGroup, peerVpc)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string, string) *vpc.VpcPeeringConnectionWithResourceGroupDeleteOut); ok {
		r0 = returnFunc(ctx, project1, projectVpcId, peerCloudAccount, peerResourceGroup, peerVpc)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*vpc.VpcPeeringConnectionWithResourceGroupDeleteOut)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string, string) error); ok {
		r1 = returnFunc(ctx, project1, projectVpcId, peerCloudAccount, peerResourceGroup, peerVpc)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// VpcPeeringConnectionWithResourceGroupDelete is a helper method to define mock.On call
//   - ctx
//   - project1
//   - projectVpcId
//   - peerCloudAccount
//   - peerResourceGroup
//   - peerVpc
func (_e *MockClient_Expecter) VpcPeeringConnectionWithResourceGroupDelete(ctx interface{}, project1 interface{}, projectVpcId interface{}, peerCloudAccount interface{}, peerResourceGroup interface{}, peerVpc interface{}) *MockClient_VpcPeeringConnectionWithResourceGroupDelete_Call {
	return &MockClient_VpcPeeringConnectionWithResourceGroupDelete_Call{Call: _e.mock.On("VpcPeeringConnectionWithResourceGroupDelete", ctx, project1, projectVpcId, peerCloudAccount, peerResourceGroup, peerVpc)}
}

func (_c *MockClient_VpcPeeringConnectionWithResourceGroupDelete_Call) Run(run func(ctx context.Context, project1 string, projectVpcId string, peerCloudAccount string, peerResourceGroup string, peerVpc string)) *MockClient_VpcPeeringConnectionWithResourceGroupDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(string), args[5].(string))
	})
	return _c
}

func (_c *MockClient_VpcPeeringConnectionWithResourceGroupDelete_Call) Return(vpcPeeringConnectionWithResourceGroupDeleteOut *vpc.VpcPeeringConnectionWithResourceGroupDeleteOut, err error) *MockClient_VpcPeeringConnectionWithResourceGroupDelete_Call {
	_c.Call.Return(vpcPeeringConnectionWithResourceGroupDeleteOut, err)
	return _c
}

func (_c *MockClient_VpcPeeringConnectionWithResourceGroupDelete_Call) RunAndReturn(run func(ctx context.Context, project1 string, projectVpcId string, peerCloudAccount string, peerResourceGroup string, peerVpc string) (*vpc.VpcPeeringConnectionWithResourceGroupDeleteOut, error)) *MockClient_VpcPeeringConnectionWithResourceGroupDelete_Call {
	_c.Call.Return(run)
	return _c
}
