// Code generated by MockGen. DO NOT EDIT.
// Source: account.go
//
// Generated by this command:
//
//	mockgen -source=account.go -package=mock_account -destination=./mock_account/mock_account.go
//

// Package mock_account is a generated GoMock package.
package mock_account

import (
	context "context"
	reflect "reflect"

	account "github.com/tidbcloud/account/idl/pbgen/proto/account"
	acl "github.com/tidbcloud/account/idl/pbgen/proto/acl"
	bizerr "github.com/tidbcloud/tidb-management-service/utilities/bizerr"
	gomock "go.uber.org/mock/gomock"
	grpc "google.golang.org/grpc"
)

// MockClient is a mock of Client interface.
type MockClient struct {
	ctrl     *gomock.Controller
	recorder *MockClientMockRecorder
	isgomock struct{}
}

// MockClientMockRecorder is the mock recorder for MockClient.
type MockClientMockRecorder struct {
	mock *MockClient
}

// NewMockClient creates a new mock instance.
func NewMockClient(ctrl *gomock.Controller) *MockClient {
	mock := &MockClient{ctrl: ctrl}
	mock.recorder = &MockClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockClient) EXPECT() *MockClientMockRecorder {
	return m.recorder
}

// GetAccountClient mocks base method.
func (m *MockClient) GetAccountClient() account.AccountAPIServiceClient {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountClient")
	ret0, _ := ret[0].(account.AccountAPIServiceClient)
	return ret0
}

// GetAccountClient indicates an expected call of GetAccountClient.
func (mr *MockClientMockRecorder) GetAccountClient() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountClient", reflect.TypeOf((*MockClient)(nil).GetAccountClient))
}

// GetApiKeyByAccessKey mocks base method.
func (m *MockClient) GetApiKeyByAccessKey(ctx context.Context, accessKey string) (*account.GetApiKeyByAccessKeyRsp, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetApiKeyByAccessKey", ctx, accessKey)
	ret0, _ := ret[0].(*account.GetApiKeyByAccessKeyRsp)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetApiKeyByAccessKey indicates an expected call of GetApiKeyByAccessKey.
func (mr *MockClientMockRecorder) GetApiKeyByAccessKey(ctx, accessKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetApiKeyByAccessKey", reflect.TypeOf((*MockClient)(nil).GetApiKeyByAccessKey), ctx, accessKey)
}

// GetOpenAPIAccess mocks base method.
func (m *MockClient) GetOpenAPIAccess(ctx context.Context, publicKey string) (*acl.GetOpenAPIAccessResp, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOpenAPIAccess", ctx, publicKey)
	ret0, _ := ret[0].(*acl.GetOpenAPIAccessResp)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetOpenAPIAccess indicates an expected call of GetOpenAPIAccess.
func (mr *MockClientMockRecorder) GetOpenAPIAccess(ctx, publicKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpenAPIAccess", reflect.TypeOf((*MockClient)(nil).GetOpenAPIAccess), ctx, publicKey)
}

// GetOrCreateSystemUser mocks base method.
func (m *MockClient) GetOrCreateSystemUser(ctx context.Context, orgID uint64) (*account.User, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrCreateSystemUser", ctx, orgID)
	ret0, _ := ret[0].(*account.User)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetOrCreateSystemUser indicates an expected call of GetOrCreateSystemUser.
func (mr *MockClientMockRecorder) GetOrCreateSystemUser(ctx, orgID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrCreateSystemUser", reflect.TypeOf((*MockClient)(nil).GetOrCreateSystemUser), ctx, orgID)
}

// GetOrgByID mocks base method.
func (m *MockClient) GetOrgByID(ctx context.Context, id uint64) (*account.Org, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrgByID", ctx, id)
	ret0, _ := ret[0].(*account.Org)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetOrgByID indicates an expected call of GetOrgByID.
func (mr *MockClientMockRecorder) GetOrgByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrgByID", reflect.TypeOf((*MockClient)(nil).GetOrgByID), ctx, id)
}

// GetProjectByID mocks base method.
func (m *MockClient) GetProjectByID(ctx context.Context, id uint64) (*account.Project, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProjectByID", ctx, id)
	ret0, _ := ret[0].(*account.Project)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetProjectByID indicates an expected call of GetProjectByID.
func (mr *MockClientMockRecorder) GetProjectByID(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectByID", reflect.TypeOf((*MockClient)(nil).GetProjectByID), ctx, id)
}

// GetUserByEmail mocks base method.
func (m *MockClient) GetUserByEmail(ctx context.Context, email string) (*account.User, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserByEmail", ctx, email)
	ret0, _ := ret[0].(*account.User)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// GetUserByEmail indicates an expected call of GetUserByEmail.
func (mr *MockClientMockRecorder) GetUserByEmail(ctx, email any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByEmail", reflect.TypeOf((*MockClient)(nil).GetUserByEmail), ctx, email)
}

// ListOrgsByUser mocks base method.
func (m *MockClient) ListOrgsByUser(ctx context.Context, userID uint64) ([]*account.Org, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListOrgsByUser", ctx, userID)
	ret0, _ := ret[0].([]*account.Org)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ListOrgsByUser indicates an expected call of ListOrgsByUser.
func (mr *MockClientMockRecorder) ListOrgsByUser(ctx, userID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOrgsByUser", reflect.TypeOf((*MockClient)(nil).ListOrgsByUser), ctx, userID)
}

// ListProjects mocks base method.
func (m *MockClient) ListProjects(ctx context.Context, ids []uint64) ([]*account.Project, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProjects", ctx, ids)
	ret0, _ := ret[0].([]*account.Project)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ListProjects indicates an expected call of ListProjects.
func (mr *MockClientMockRecorder) ListProjects(ctx, ids any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProjects", reflect.TypeOf((*MockClient)(nil).ListProjects), ctx, ids)
}

// ListProjectsByOrgsInUser mocks base method.
func (m *MockClient) ListProjectsByOrgsInUser(ctx context.Context, userID, orgID uint64) ([]*account.Project, bizerr.BizError) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProjectsByOrgsInUser", ctx, userID, orgID)
	ret0, _ := ret[0].([]*account.Project)
	ret1, _ := ret[1].(bizerr.BizError)
	return ret0, ret1
}

// ListProjectsByOrgsInUser indicates an expected call of ListProjectsByOrgsInUser.
func (mr *MockClientMockRecorder) ListProjectsByOrgsInUser(ctx, userID, orgID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProjectsByOrgsInUser", reflect.TypeOf((*MockClient)(nil).ListProjectsByOrgsInUser), ctx, userID, orgID)
}

// MockApiCli is a mock of ApiCli interface.
type MockApiCli struct {
	ctrl     *gomock.Controller
	recorder *MockApiCliMockRecorder
	isgomock struct{}
}

// MockApiCliMockRecorder is the mock recorder for MockApiCli.
type MockApiCliMockRecorder struct {
	mock *MockApiCli
}

// NewMockApiCli creates a new mock instance.
func NewMockApiCli(ctrl *gomock.Controller) *MockApiCli {
	mock := &MockApiCli{ctrl: ctrl}
	mock.recorder = &MockApiCliMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockApiCli) EXPECT() *MockApiCliMockRecorder {
	return m.recorder
}

// AddImpersonateUser mocks base method.
func (m *MockApiCli) AddImpersonateUser(ctx context.Context, in *account.AddImpersonateUserReq, opts ...grpc.CallOption) (*account.AddImpersonateUserRsp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddImpersonateUser", varargs...)
	ret0, _ := ret[0].(*account.AddImpersonateUserRsp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddImpersonateUser indicates an expected call of AddImpersonateUser.
func (mr *MockApiCliMockRecorder) AddImpersonateUser(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddImpersonateUser", reflect.TypeOf((*MockApiCli)(nil).AddImpersonateUser), varargs...)
}

// BatchCreateAuditLogs mocks base method.
func (m *MockApiCli) BatchCreateAuditLogs(ctx context.Context, in *account.BatchCreateAuditLogsRequest, opts ...grpc.CallOption) (*account.BatchCreateAuditLogsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchCreateAuditLogs", varargs...)
	ret0, _ := ret[0].(*account.BatchCreateAuditLogsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchCreateAuditLogs indicates an expected call of BatchCreateAuditLogs.
func (mr *MockApiCliMockRecorder) BatchCreateAuditLogs(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCreateAuditLogs", reflect.TypeOf((*MockApiCli)(nil).BatchCreateAuditLogs), varargs...)
}

// BatchUpdateApiKeyExpireTime mocks base method.
func (m *MockApiCli) BatchUpdateApiKeyExpireTime(ctx context.Context, in *account.BatchUpdateApiKeyExpireTimeReq, opts ...grpc.CallOption) (*account.BatchUpdateApiKeyExpireTimeRsp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchUpdateApiKeyExpireTime", varargs...)
	ret0, _ := ret[0].(*account.BatchUpdateApiKeyExpireTimeRsp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchUpdateApiKeyExpireTime indicates an expected call of BatchUpdateApiKeyExpireTime.
func (mr *MockApiCliMockRecorder) BatchUpdateApiKeyExpireTime(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchUpdateApiKeyExpireTime", reflect.TypeOf((*MockApiCli)(nil).BatchUpdateApiKeyExpireTime), varargs...)
}

// CheckIdentityAndPermission mocks base method.
func (m *MockApiCli) CheckIdentityAndPermission(ctx context.Context, in *account.CheckIdentityAndPermissionRequest, opts ...grpc.CallOption) (*account.CheckIdentityAndPermissionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CheckIdentityAndPermission", varargs...)
	ret0, _ := ret[0].(*account.CheckIdentityAndPermissionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CheckIdentityAndPermission indicates an expected call of CheckIdentityAndPermission.
func (mr *MockApiCliMockRecorder) CheckIdentityAndPermission(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckIdentityAndPermission", reflect.TypeOf((*MockApiCli)(nil).CheckIdentityAndPermission), varargs...)
}

// ClearEmailUniqueID mocks base method.
func (m *MockApiCli) ClearEmailUniqueID(ctx context.Context, in *account.ClearEmailUniqueIDReq, opts ...grpc.CallOption) (*account.ClearEmailUniqueIDResp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ClearEmailUniqueID", varargs...)
	ret0, _ := ret[0].(*account.ClearEmailUniqueIDResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ClearEmailUniqueID indicates an expected call of ClearEmailUniqueID.
func (mr *MockApiCliMockRecorder) ClearEmailUniqueID(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearEmailUniqueID", reflect.TypeOf((*MockApiCli)(nil).ClearEmailUniqueID), varargs...)
}

// CreateApiKey mocks base method.
func (m *MockApiCli) CreateApiKey(ctx context.Context, in *account.CreateApiKeyReq, opts ...grpc.CallOption) (*account.CreateApiKeyRsp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateApiKey", varargs...)
	ret0, _ := ret[0].(*account.CreateApiKeyRsp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateApiKey indicates an expected call of CreateApiKey.
func (mr *MockApiCliMockRecorder) CreateApiKey(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateApiKey", reflect.TypeOf((*MockApiCli)(nil).CreateApiKey), varargs...)
}

// CreateAuditLog mocks base method.
func (m *MockApiCli) CreateAuditLog(ctx context.Context, in *account.CreateAuditLogRequest, opts ...grpc.CallOption) (*account.CreateAuditLogResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateAuditLog", varargs...)
	ret0, _ := ret[0].(*account.CreateAuditLogResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateAuditLog indicates an expected call of CreateAuditLog.
func (mr *MockApiCliMockRecorder) CreateAuditLog(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAuditLog", reflect.TypeOf((*MockApiCli)(nil).CreateAuditLog), varargs...)
}

// CreateCloudAdmin mocks base method.
func (m *MockApiCli) CreateCloudAdmin(ctx context.Context, in *account.CreateCloudAdminReq, opts ...grpc.CallOption) (*account.CreateCloudAdminRsp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateCloudAdmin", varargs...)
	ret0, _ := ret[0].(*account.CreateCloudAdminRsp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCloudAdmin indicates an expected call of CreateCloudAdmin.
func (mr *MockApiCliMockRecorder) CreateCloudAdmin(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCloudAdmin", reflect.TypeOf((*MockApiCli)(nil).CreateCloudAdmin), varargs...)
}

// CreateClusterUser mocks base method.
func (m *MockApiCli) CreateClusterUser(ctx context.Context, in *account.CreateClusterUserReq, opts ...grpc.CallOption) (*account.CreateClusterUserRsp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateClusterUser", varargs...)
	ret0, _ := ret[0].(*account.CreateClusterUserRsp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateClusterUser indicates an expected call of CreateClusterUser.
func (mr *MockApiCliMockRecorder) CreateClusterUser(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClusterUser", reflect.TypeOf((*MockApiCli)(nil).CreateClusterUser), varargs...)
}

// CreateTrial mocks base method.
func (m *MockApiCli) CreateTrial(ctx context.Context, in *account.CreateTrialRequest, opts ...grpc.CallOption) (*account.CreateTrialResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateTrial", varargs...)
	ret0, _ := ret[0].(*account.CreateTrialResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTrial indicates an expected call of CreateTrial.
func (mr *MockApiCliMockRecorder) CreateTrial(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrial", reflect.TypeOf((*MockApiCli)(nil).CreateTrial), varargs...)
}

// DeleteApiKey mocks base method.
func (m *MockApiCli) DeleteApiKey(ctx context.Context, in *account.DeleteApiKeyReq, opts ...grpc.CallOption) (*account.DeleteApiKeyRsp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteApiKey", varargs...)
	ret0, _ := ret[0].(*account.DeleteApiKeyRsp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteApiKey indicates an expected call of DeleteApiKey.
func (mr *MockApiCliMockRecorder) DeleteApiKey(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteApiKey", reflect.TypeOf((*MockApiCli)(nil).DeleteApiKey), varargs...)
}

// DeleteImpersonateUser mocks base method.
func (m *MockApiCli) DeleteImpersonateUser(ctx context.Context, in *account.DeleteImpersonateUserReq, opts ...grpc.CallOption) (*account.DeleteImpersonateUserRsp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteImpersonateUser", varargs...)
	ret0, _ := ret[0].(*account.DeleteImpersonateUserRsp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteImpersonateUser indicates an expected call of DeleteImpersonateUser.
func (mr *MockApiCliMockRecorder) DeleteImpersonateUser(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteImpersonateUser", reflect.TypeOf((*MockApiCli)(nil).DeleteImpersonateUser), varargs...)
}

// DeleteOrgByID mocks base method.
func (m *MockApiCli) DeleteOrgByID(ctx context.Context, in *account.DeleteOrgRequest, opts ...grpc.CallOption) (*account.DeleteOrgResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteOrgByID", varargs...)
	ret0, _ := ret[0].(*account.DeleteOrgResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteOrgByID indicates an expected call of DeleteOrgByID.
func (mr *MockApiCliMockRecorder) DeleteOrgByID(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOrgByID", reflect.TypeOf((*MockApiCli)(nil).DeleteOrgByID), varargs...)
}

// GetApiKeyByAccessKey mocks base method.
func (m *MockApiCli) GetApiKeyByAccessKey(ctx context.Context, in *account.GetApiKeyByAccessKeyReq, opts ...grpc.CallOption) (*account.GetApiKeyByAccessKeyRsp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetApiKeyByAccessKey", varargs...)
	ret0, _ := ret[0].(*account.GetApiKeyByAccessKeyRsp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetApiKeyByAccessKey indicates an expected call of GetApiKeyByAccessKey.
func (mr *MockApiCliMockRecorder) GetApiKeyByAccessKey(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetApiKeyByAccessKey", reflect.TypeOf((*MockApiCli)(nil).GetApiKeyByAccessKey), varargs...)
}

// GetApiKeysByResource mocks base method.
func (m *MockApiCli) GetApiKeysByResource(ctx context.Context, in *account.GetApiKeysByResourceReq, opts ...grpc.CallOption) (*account.GetApiKeysByResourceRsp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetApiKeysByResource", varargs...)
	ret0, _ := ret[0].(*account.GetApiKeysByResourceRsp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetApiKeysByResource indicates an expected call of GetApiKeysByResource.
func (mr *MockApiCliMockRecorder) GetApiKeysByResource(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetApiKeysByResource", reflect.TypeOf((*MockApiCli)(nil).GetApiKeysByResource), varargs...)
}

// GetAuthUser mocks base method.
func (m *MockApiCli) GetAuthUser(ctx context.Context, in *account.GetAuthUserRequest, opts ...grpc.CallOption) (*account.GetAuthUserResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAuthUser", varargs...)
	ret0, _ := ret[0].(*account.GetAuthUserResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAuthUser indicates an expected call of GetAuthUser.
func (mr *MockApiCliMockRecorder) GetAuthUser(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthUser", reflect.TypeOf((*MockApiCli)(nil).GetAuthUser), varargs...)
}

// GetCloudAdminCredential mocks base method.
func (m *MockApiCli) GetCloudAdminCredential(ctx context.Context, in *account.GetCloudAdminCredentialReq, opts ...grpc.CallOption) (*account.GetCloudAdminCredentialRsp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetCloudAdminCredential", varargs...)
	ret0, _ := ret[0].(*account.GetCloudAdminCredentialRsp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCloudAdminCredential indicates an expected call of GetCloudAdminCredential.
func (mr *MockApiCliMockRecorder) GetCloudAdminCredential(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCloudAdminCredential", reflect.TypeOf((*MockApiCli)(nil).GetCloudAdminCredential), varargs...)
}

// GetClusterAuthPubKey mocks base method.
func (m *MockApiCli) GetClusterAuthPubKey(ctx context.Context, in *account.GetClusterAuthPubKeyReq, opts ...grpc.CallOption) (*account.GetClusterAuthPubKeyRsp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClusterAuthPubKey", varargs...)
	ret0, _ := ret[0].(*account.GetClusterAuthPubKeyRsp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterAuthPubKey indicates an expected call of GetClusterAuthPubKey.
func (mr *MockApiCliMockRecorder) GetClusterAuthPubKey(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterAuthPubKey", reflect.TypeOf((*MockApiCli)(nil).GetClusterAuthPubKey), varargs...)
}

// GetClusterUser mocks base method.
func (m *MockApiCli) GetClusterUser(ctx context.Context, in *account.GetClusterUserReq, opts ...grpc.CallOption) (*account.GetClusterUserRsp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClusterUser", varargs...)
	ret0, _ := ret[0].(*account.GetClusterUserRsp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterUser indicates an expected call of GetClusterUser.
func (mr *MockApiCliMockRecorder) GetClusterUser(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterUser", reflect.TypeOf((*MockApiCli)(nil).GetClusterUser), varargs...)
}

// GetDBUsers mocks base method.
func (m *MockApiCli) GetDBUsers(ctx context.Context, in *account.GetDBUsersReq, opts ...grpc.CallOption) (*account.GetDBUsersResp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetDBUsers", varargs...)
	ret0, _ := ret[0].(*account.GetDBUsersResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDBUsers indicates an expected call of GetDBUsers.
func (mr *MockApiCliMockRecorder) GetDBUsers(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDBUsers", reflect.TypeOf((*MockApiCli)(nil).GetDBUsers), varargs...)
}

// GetIdentityByAccessToken mocks base method.
func (m *MockApiCli) GetIdentityByAccessToken(ctx context.Context, in *account.GetIdentityByAccessTokenReq, opts ...grpc.CallOption) (*account.GetIdentityByAccessTokenResp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetIdentityByAccessToken", varargs...)
	ret0, _ := ret[0].(*account.GetIdentityByAccessTokenResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIdentityByAccessToken indicates an expected call of GetIdentityByAccessToken.
func (mr *MockApiCliMockRecorder) GetIdentityByAccessToken(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIdentityByAccessToken", reflect.TypeOf((*MockApiCli)(nil).GetIdentityByAccessToken), varargs...)
}

// GetImpersonateUser mocks base method.
func (m *MockApiCli) GetImpersonateUser(ctx context.Context, in *account.GetImpersonateUserReq, opts ...grpc.CallOption) (*account.GetImpersonateUserRsp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetImpersonateUser", varargs...)
	ret0, _ := ret[0].(*account.GetImpersonateUserRsp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetImpersonateUser indicates an expected call of GetImpersonateUser.
func (mr *MockApiCliMockRecorder) GetImpersonateUser(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImpersonateUser", reflect.TypeOf((*MockApiCli)(nil).GetImpersonateUser), varargs...)
}

// GetOpenAPIAccess mocks base method.
func (m *MockApiCli) GetOpenAPIAccess(ctx context.Context, in *account.GetOpenAPIAccessReq, opts ...grpc.CallOption) (*account.GetOpenAPIAccessResp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetOpenAPIAccess", varargs...)
	ret0, _ := ret[0].(*account.GetOpenAPIAccessResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOpenAPIAccess indicates an expected call of GetOpenAPIAccess.
func (mr *MockApiCliMockRecorder) GetOpenAPIAccess(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpenAPIAccess", reflect.TypeOf((*MockApiCli)(nil).GetOpenAPIAccess), varargs...)
}

// GetOrCreateSystemUser mocks base method.
func (m *MockApiCli) GetOrCreateSystemUser(ctx context.Context, in *account.GetOrCreateSystemUserRequest, opts ...grpc.CallOption) (*account.GetOrCreateSystemUserResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetOrCreateSystemUser", varargs...)
	ret0, _ := ret[0].(*account.GetOrCreateSystemUserResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrCreateSystemUser indicates an expected call of GetOrCreateSystemUser.
func (mr *MockApiCliMockRecorder) GetOrCreateSystemUser(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrCreateSystemUser", reflect.TypeOf((*MockApiCli)(nil).GetOrCreateSystemUser), varargs...)
}

// GetOrgByID mocks base method.
func (m *MockApiCli) GetOrgByID(ctx context.Context, in *account.GetOrgByIDRequest, opts ...grpc.CallOption) (*account.GetOrgByIDResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetOrgByID", varargs...)
	ret0, _ := ret[0].(*account.GetOrgByIDResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrgByID indicates an expected call of GetOrgByID.
func (mr *MockApiCliMockRecorder) GetOrgByID(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrgByID", reflect.TypeOf((*MockApiCli)(nil).GetOrgByID), varargs...)
}

// GetProjectByID mocks base method.
func (m *MockApiCli) GetProjectByID(ctx context.Context, in *account.GetProjectByIDRequest, opts ...grpc.CallOption) (*account.GetProjectByIDResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetProjectByID", varargs...)
	ret0, _ := ret[0].(*account.GetProjectByIDResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProjectByID indicates an expected call of GetProjectByID.
func (mr *MockApiCliMockRecorder) GetProjectByID(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectByID", reflect.TypeOf((*MockApiCli)(nil).GetProjectByID), varargs...)
}

// GetSystemUser mocks base method.
func (m *MockApiCli) GetSystemUser(ctx context.Context, in *account.GetSystemUserRequest, opts ...grpc.CallOption) (*account.GetSystemUserResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSystemUser", varargs...)
	ret0, _ := ret[0].(*account.GetSystemUserResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSystemUser indicates an expected call of GetSystemUser.
func (mr *MockApiCliMockRecorder) GetSystemUser(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSystemUser", reflect.TypeOf((*MockApiCli)(nil).GetSystemUser), varargs...)
}

// GetUserByEmail mocks base method.
func (m *MockApiCli) GetUserByEmail(ctx context.Context, in *account.GetUserByEmailRequest, opts ...grpc.CallOption) (*account.GetUserByEmailResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserByEmail", varargs...)
	ret0, _ := ret[0].(*account.GetUserByEmailResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserByEmail indicates an expected call of GetUserByEmail.
func (mr *MockApiCliMockRecorder) GetUserByEmail(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByEmail", reflect.TypeOf((*MockApiCli)(nil).GetUserByEmail), varargs...)
}

// GetUserByID mocks base method.
func (m *MockApiCli) GetUserByID(ctx context.Context, in *account.GetUserByIDRequest, opts ...grpc.CallOption) (*account.GetUserByIDResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserByID", varargs...)
	ret0, _ := ret[0].(*account.GetUserByIDResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserByID indicates an expected call of GetUserByID.
func (mr *MockApiCliMockRecorder) GetUserByID(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByID", reflect.TypeOf((*MockApiCli)(nil).GetUserByID), varargs...)
}

// GetUserByToken mocks base method.
func (m *MockApiCli) GetUserByToken(ctx context.Context, in *account.GetUserByTokenRequest, opts ...grpc.CallOption) (*account.GetUserByTokenResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserByToken", varargs...)
	ret0, _ := ret[0].(*account.GetUserByTokenResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserByToken indicates an expected call of GetUserByToken.
func (mr *MockApiCliMockRecorder) GetUserByToken(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByToken", reflect.TypeOf((*MockApiCli)(nil).GetUserByToken), varargs...)
}

// HasPermissionForIdentity mocks base method.
func (m *MockApiCli) HasPermissionForIdentity(ctx context.Context, in *account.RbacIdentityPermissionRequest, opts ...grpc.CallOption) (*account.RbacIdentityPermissionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HasPermissionForIdentity", varargs...)
	ret0, _ := ret[0].(*account.RbacIdentityPermissionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HasPermissionForIdentity indicates an expected call of HasPermissionForIdentity.
func (mr *MockApiCliMockRecorder) HasPermissionForIdentity(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasPermissionForIdentity", reflect.TypeOf((*MockApiCli)(nil).HasPermissionForIdentity), varargs...)
}

// HasPermissionForUser mocks base method.
func (m *MockApiCli) HasPermissionForUser(ctx context.Context, in *account.RbacPermissionRequest, opts ...grpc.CallOption) (*account.RbacPermissionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HasPermissionForUser", varargs...)
	ret0, _ := ret[0].(*account.RbacPermissionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HasPermissionForUser indicates an expected call of HasPermissionForUser.
func (mr *MockApiCliMockRecorder) HasPermissionForUser(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasPermissionForUser", reflect.TypeOf((*MockApiCli)(nil).HasPermissionForUser), varargs...)
}

// HoldEmailUniqueID mocks base method.
func (m *MockApiCli) HoldEmailUniqueID(ctx context.Context, in *account.HoldEmailUniqueIDReq, opts ...grpc.CallOption) (*account.HoldEmailUniqueIDResp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HoldEmailUniqueID", varargs...)
	ret0, _ := ret[0].(*account.HoldEmailUniqueIDResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HoldEmailUniqueID indicates an expected call of HoldEmailUniqueID.
func (mr *MockApiCliMockRecorder) HoldEmailUniqueID(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HoldEmailUniqueID", reflect.TypeOf((*MockApiCli)(nil).HoldEmailUniqueID), varargs...)
}

// IsHitExp mocks base method.
func (m *MockApiCli) IsHitExp(ctx context.Context, in *account.HitExpReq, opts ...grpc.CallOption) (*account.HitExpRsp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "IsHitExp", varargs...)
	ret0, _ := ret[0].(*account.HitExpRsp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsHitExp indicates an expected call of IsHitExp.
func (mr *MockApiCliMockRecorder) IsHitExp(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsHitExp", reflect.TypeOf((*MockApiCli)(nil).IsHitExp), varargs...)
}

// ListClusterDbUsers mocks base method.
func (m *MockApiCli) ListClusterDbUsers(ctx context.Context, in *account.ListClusterDbUsersReq, opts ...grpc.CallOption) (*account.ListClusterDbUsersRsp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListClusterDbUsers", varargs...)
	ret0, _ := ret[0].(*account.ListClusterDbUsersRsp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClusterDbUsers indicates an expected call of ListClusterDbUsers.
func (mr *MockApiCliMockRecorder) ListClusterDbUsers(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusterDbUsers", reflect.TypeOf((*MockApiCli)(nil).ListClusterDbUsers), varargs...)
}

// ListMspCustomers mocks base method.
func (m *MockApiCli) ListMspCustomers(ctx context.Context, in *account.ListMspCustomersReq, opts ...grpc.CallOption) (*account.ListMspCustomersResp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListMspCustomers", varargs...)
	ret0, _ := ret[0].(*account.ListMspCustomersResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMspCustomers indicates an expected call of ListMspCustomers.
func (mr *MockApiCliMockRecorder) ListMspCustomers(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMspCustomers", reflect.TypeOf((*MockApiCli)(nil).ListMspCustomers), varargs...)
}

// ListOrgs mocks base method.
func (m *MockApiCli) ListOrgs(ctx context.Context, in *account.OrgFilter, opts ...grpc.CallOption) (*account.ListOrgsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListOrgs", varargs...)
	ret0, _ := ret[0].(*account.ListOrgsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListOrgs indicates an expected call of ListOrgs.
func (mr *MockApiCliMockRecorder) ListOrgs(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOrgs", reflect.TypeOf((*MockApiCli)(nil).ListOrgs), varargs...)
}

// ListOrgsAdvance mocks base method.
func (m *MockApiCli) ListOrgsAdvance(ctx context.Context, in *account.ListOrgsParam, opts ...grpc.CallOption) (*account.ListOrgsAdvanceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListOrgsAdvance", varargs...)
	ret0, _ := ret[0].(*account.ListOrgsAdvanceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListOrgsAdvance indicates an expected call of ListOrgsAdvance.
func (mr *MockApiCliMockRecorder) ListOrgsAdvance(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOrgsAdvance", reflect.TypeOf((*MockApiCli)(nil).ListOrgsAdvance), varargs...)
}

// ListOrgsByUser mocks base method.
func (m *MockApiCli) ListOrgsByUser(ctx context.Context, in *account.ListOrgsByUserRequest, opts ...grpc.CallOption) (*account.ListOrgsByUserResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListOrgsByUser", varargs...)
	ret0, _ := ret[0].(*account.ListOrgsByUserResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListOrgsByUser indicates an expected call of ListOrgsByUser.
func (mr *MockApiCliMockRecorder) ListOrgsByUser(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListOrgsByUser", reflect.TypeOf((*MockApiCli)(nil).ListOrgsByUser), varargs...)
}

// ListProjects mocks base method.
func (m *MockApiCli) ListProjects(ctx context.Context, in *account.ProjectFilter, opts ...grpc.CallOption) (*account.ListProjectsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListProjects", varargs...)
	ret0, _ := ret[0].(*account.ListProjectsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListProjects indicates an expected call of ListProjects.
func (mr *MockApiCliMockRecorder) ListProjects(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProjects", reflect.TypeOf((*MockApiCli)(nil).ListProjects), varargs...)
}

// ListProjectsByOrgs mocks base method.
func (m *MockApiCli) ListProjectsByOrgs(ctx context.Context, in *account.ListProjectsByOrgsRequest, opts ...grpc.CallOption) (*account.ListProjectsByOrgsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListProjectsByOrgs", varargs...)
	ret0, _ := ret[0].(*account.ListProjectsByOrgsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListProjectsByOrgs indicates an expected call of ListProjectsByOrgs.
func (mr *MockApiCliMockRecorder) ListProjectsByOrgs(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProjectsByOrgs", reflect.TypeOf((*MockApiCli)(nil).ListProjectsByOrgs), varargs...)
}

// ListProjectsByOrgsInUser mocks base method.
func (m *MockApiCli) ListProjectsByOrgsInUser(ctx context.Context, in *account.ListProjectsByOrgsInUserRequest, opts ...grpc.CallOption) (*account.ListProjectsByOrgsInUserResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListProjectsByOrgsInUser", varargs...)
	ret0, _ := ret[0].(*account.ListProjectsByOrgsInUserResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListProjectsByOrgsInUser indicates an expected call of ListProjectsByOrgsInUser.
func (mr *MockApiCliMockRecorder) ListProjectsByOrgsInUser(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProjectsByOrgsInUser", reflect.TypeOf((*MockApiCli)(nil).ListProjectsByOrgsInUser), varargs...)
}

// ListTrials mocks base method.
func (m *MockApiCli) ListTrials(ctx context.Context, in *account.TrialFilter, opts ...grpc.CallOption) (*account.ListTrialsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTrials", varargs...)
	ret0, _ := ret[0].(*account.ListTrialsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTrials indicates an expected call of ListTrials.
func (mr *MockApiCliMockRecorder) ListTrials(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrials", reflect.TypeOf((*MockApiCli)(nil).ListTrials), varargs...)
}

// ListUsers mocks base method.
func (m *MockApiCli) ListUsers(ctx context.Context, in *account.UserFilter, opts ...grpc.CallOption) (*account.ListUsersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListUsers", varargs...)
	ret0, _ := ret[0].(*account.ListUsersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListUsers indicates an expected call of ListUsers.
func (mr *MockApiCliMockRecorder) ListUsers(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUsers", reflect.TypeOf((*MockApiCli)(nil).ListUsers), varargs...)
}

// ListUsersByFilter mocks base method.
func (m *MockApiCli) ListUsersByFilter(ctx context.Context, in *account.ListUsersByFilterRequest, opts ...grpc.CallOption) (*account.ListUsersByFilterResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListUsersByFilter", varargs...)
	ret0, _ := ret[0].(*account.ListUsersByFilterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListUsersByFilter indicates an expected call of ListUsersByFilter.
func (mr *MockApiCliMockRecorder) ListUsersByFilter(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUsersByFilter", reflect.TypeOf((*MockApiCli)(nil).ListUsersByFilter), varargs...)
}

// QueryEmailUniqueID mocks base method.
func (m *MockApiCli) QueryEmailUniqueID(ctx context.Context, in *account.QueryEmailUniqueIDReq, opts ...grpc.CallOption) (*account.QueryEmailUniqueIDResp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "QueryEmailUniqueID", varargs...)
	ret0, _ := ret[0].(*account.QueryEmailUniqueIDResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryEmailUniqueID indicates an expected call of QueryEmailUniqueID.
func (mr *MockApiCliMockRecorder) QueryEmailUniqueID(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryEmailUniqueID", reflect.TypeOf((*MockApiCli)(nil).QueryEmailUniqueID), varargs...)
}

// RecoverApiKeyPermission mocks base method.
func (m *MockApiCli) RecoverApiKeyPermission(ctx context.Context, in *account.RecoverApiKeyPermissionReq, opts ...grpc.CallOption) (*account.RecoverApiKeyPermissionRsp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RecoverApiKeyPermission", varargs...)
	ret0, _ := ret[0].(*account.RecoverApiKeyPermissionRsp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RecoverApiKeyPermission indicates an expected call of RecoverApiKeyPermission.
func (mr *MockApiCliMockRecorder) RecoverApiKeyPermission(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecoverApiKeyPermission", reflect.TypeOf((*MockApiCli)(nil).RecoverApiKeyPermission), varargs...)
}

// RecoverResourceRefAllApiKeyPermission mocks base method.
func (m *MockApiCli) RecoverResourceRefAllApiKeyPermission(ctx context.Context, in *account.RecoverResourceRefAllApiKeyPermissionReq, opts ...grpc.CallOption) (*account.RecoverResourceRefAllApiKeyPermissionRsp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RecoverResourceRefAllApiKeyPermission", varargs...)
	ret0, _ := ret[0].(*account.RecoverResourceRefAllApiKeyPermissionRsp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RecoverResourceRefAllApiKeyPermission indicates an expected call of RecoverResourceRefAllApiKeyPermission.
func (mr *MockApiCliMockRecorder) RecoverResourceRefAllApiKeyPermission(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecoverResourceRefAllApiKeyPermission", reflect.TypeOf((*MockApiCli)(nil).RecoverResourceRefAllApiKeyPermission), varargs...)
}

// SaveAuthorizationData mocks base method.
func (m *MockApiCli) SaveAuthorizationData(ctx context.Context, in *account.SaveAuthorizationDataReq, opts ...grpc.CallOption) (*account.SaveAuthorizationDataResp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SaveAuthorizationData", varargs...)
	ret0, _ := ret[0].(*account.SaveAuthorizationDataResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SaveAuthorizationData indicates an expected call of SaveAuthorizationData.
func (mr *MockApiCliMockRecorder) SaveAuthorizationData(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveAuthorizationData", reflect.TypeOf((*MockApiCli)(nil).SaveAuthorizationData), varargs...)
}

// SendEmail mocks base method.
func (m *MockApiCli) SendEmail(ctx context.Context, in *account.SendEmailReq, opts ...grpc.CallOption) (*account.SendEmailResp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SendEmail", varargs...)
	ret0, _ := ret[0].(*account.SendEmailResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendEmail indicates an expected call of SendEmail.
func (mr *MockApiCliMockRecorder) SendEmail(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendEmail", reflect.TypeOf((*MockApiCli)(nil).SendEmail), varargs...)
}

// SendEmailByLabels mocks base method.
func (m *MockApiCli) SendEmailByLabels(ctx context.Context, in *account.SendEmailByLabelsReq, opts ...grpc.CallOption) (*account.SendEmailByLabelsResp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SendEmailByLabels", varargs...)
	ret0, _ := ret[0].(*account.SendEmailByLabelsResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendEmailByLabels indicates an expected call of SendEmailByLabels.
func (mr *MockApiCliMockRecorder) SendEmailByLabels(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendEmailByLabels", reflect.TypeOf((*MockApiCli)(nil).SendEmailByLabels), varargs...)
}

// TestClusterDbUser mocks base method.
func (m *MockApiCli) TestClusterDbUser(ctx context.Context, in *account.TestClusterDbUserReq, opts ...grpc.CallOption) (*account.TestClusterDbUserRsp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TestClusterDbUser", varargs...)
	ret0, _ := ret[0].(*account.TestClusterDbUserRsp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TestClusterDbUser indicates an expected call of TestClusterDbUser.
func (mr *MockApiCliMockRecorder) TestClusterDbUser(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestClusterDbUser", reflect.TypeOf((*MockApiCli)(nil).TestClusterDbUser), varargs...)
}

// UpdateApiKey mocks base method.
func (m *MockApiCli) UpdateApiKey(ctx context.Context, in *account.UpdateApiKeyReq, opts ...grpc.CallOption) (*account.UpdateApiKeyRsp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateApiKey", varargs...)
	ret0, _ := ret[0].(*account.UpdateApiKeyRsp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateApiKey indicates an expected call of UpdateApiKey.
func (mr *MockApiCliMockRecorder) UpdateApiKey(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateApiKey", reflect.TypeOf((*MockApiCli)(nil).UpdateApiKey), varargs...)
}

// UpdateOrg mocks base method.
func (m *MockApiCli) UpdateOrg(ctx context.Context, in *account.UpdateOrgRequest, opts ...grpc.CallOption) (*account.UpdateOrgResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateOrg", varargs...)
	ret0, _ := ret[0].(*account.UpdateOrgResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateOrg indicates an expected call of UpdateOrg.
func (mr *MockApiCliMockRecorder) UpdateOrg(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOrg", reflect.TypeOf((*MockApiCli)(nil).UpdateOrg), varargs...)
}

// ValidateToken mocks base method.
func (m *MockApiCli) ValidateToken(ctx context.Context, in *account.ValidateTokenRequest, opts ...grpc.CallOption) (*account.ValidateTokenResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ValidateToken", varargs...)
	ret0, _ := ret[0].(*account.ValidateTokenResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidateToken indicates an expected call of ValidateToken.
func (mr *MockApiCliMockRecorder) ValidateToken(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateToken", reflect.TypeOf((*MockApiCli)(nil).ValidateToken), varargs...)
}

// VerifyUserOrgAndProjects mocks base method.
func (m *MockApiCli) VerifyUserOrgAndProjects(ctx context.Context, in *account.VerifyUserOrgAndProjectsReq, opts ...grpc.CallOption) (*account.VerifyUserOrgAndProjectsResp, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "VerifyUserOrgAndProjects", varargs...)
	ret0, _ := ret[0].(*account.VerifyUserOrgAndProjectsResp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VerifyUserOrgAndProjects indicates an expected call of VerifyUserOrgAndProjects.
func (mr *MockApiCliMockRecorder) VerifyUserOrgAndProjects(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyUserOrgAndProjects", reflect.TypeOf((*MockApiCli)(nil).VerifyUserOrgAndProjects), varargs...)
}