// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/coder/coder/v2/coderd/database (interfaces: Store)
//
// Generated by this command:
//
//	mockgen -destination ./dbmock.go -package dbmock github.com/coder/coder/v2/coderd/database Store
//

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

import (
	context "context"
	json "encoding/json"
	reflect "reflect"
	time "time"

	database "github.com/coder/coder/v2/coderd/database"
	rbac "github.com/coder/coder/v2/coderd/rbac"
	uuid "github.com/google/uuid"
	gomock "go.uber.org/mock/gomock"
)

// MockStore is a mock of Store interface.
type MockStore struct {
	ctrl     *gomock.Controller
	recorder *MockStoreMockRecorder
	isgomock struct{}
}

// MockStoreMockRecorder is the mock recorder for MockStore.
type MockStoreMockRecorder struct {
	mock *MockStore
}

// NewMockStore creates a new mock instance.
func NewMockStore(ctrl *gomock.Controller) *MockStore {
	mock := &MockStore{ctrl: ctrl}
	mock.recorder = &MockStoreMockRecorder{mock}
	return mock
}

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

// AcquireChats mocks base method.
func (m *MockStore) AcquireChats(ctx context.Context, arg database.AcquireChatsParams) ([]database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcquireChats", ctx, arg)
	ret0, _ := ret[0].([]database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AcquireChats indicates an expected call of AcquireChats.
func (mr *MockStoreMockRecorder) AcquireChats(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcquireChats", reflect.TypeOf((*MockStore)(nil).AcquireChats), ctx, arg)
}

// AcquireLock mocks base method.
func (m *MockStore) AcquireLock(ctx context.Context, pgAdvisoryXactLock int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcquireLock", ctx, pgAdvisoryXactLock)
	ret0, _ := ret[0].(error)
	return ret0
}

// AcquireLock indicates an expected call of AcquireLock.
func (mr *MockStoreMockRecorder) AcquireLock(ctx, pgAdvisoryXactLock any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcquireLock", reflect.TypeOf((*MockStore)(nil).AcquireLock), ctx, pgAdvisoryXactLock)
}

// AcquireNotificationMessages mocks base method.
func (m *MockStore) AcquireNotificationMessages(ctx context.Context, arg database.AcquireNotificationMessagesParams) ([]database.AcquireNotificationMessagesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcquireNotificationMessages", ctx, arg)
	ret0, _ := ret[0].([]database.AcquireNotificationMessagesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AcquireNotificationMessages indicates an expected call of AcquireNotificationMessages.
func (mr *MockStoreMockRecorder) AcquireNotificationMessages(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcquireNotificationMessages", reflect.TypeOf((*MockStore)(nil).AcquireNotificationMessages), ctx, arg)
}

// AcquireProvisionerJob mocks base method.
func (m *MockStore) AcquireProvisionerJob(ctx context.Context, arg database.AcquireProvisionerJobParams) (database.ProvisionerJob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcquireProvisionerJob", ctx, arg)
	ret0, _ := ret[0].(database.ProvisionerJob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AcquireProvisionerJob indicates an expected call of AcquireProvisionerJob.
func (mr *MockStoreMockRecorder) AcquireProvisionerJob(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcquireProvisionerJob", reflect.TypeOf((*MockStore)(nil).AcquireProvisionerJob), ctx, arg)
}

// AcquireStaleChatDiffStatuses mocks base method.
func (m *MockStore) AcquireStaleChatDiffStatuses(ctx context.Context, limitVal int32) ([]database.AcquireStaleChatDiffStatusesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AcquireStaleChatDiffStatuses", ctx, limitVal)
	ret0, _ := ret[0].([]database.AcquireStaleChatDiffStatusesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AcquireStaleChatDiffStatuses indicates an expected call of AcquireStaleChatDiffStatuses.
func (mr *MockStoreMockRecorder) AcquireStaleChatDiffStatuses(ctx, limitVal any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcquireStaleChatDiffStatuses", reflect.TypeOf((*MockStore)(nil).AcquireStaleChatDiffStatuses), ctx, limitVal)
}

// ActivityBumpWorkspace mocks base method.
func (m *MockStore) ActivityBumpWorkspace(ctx context.Context, arg database.ActivityBumpWorkspaceParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ActivityBumpWorkspace", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// ActivityBumpWorkspace indicates an expected call of ActivityBumpWorkspace.
func (mr *MockStoreMockRecorder) ActivityBumpWorkspace(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivityBumpWorkspace", reflect.TypeOf((*MockStore)(nil).ActivityBumpWorkspace), ctx, arg)
}

// AllUserIDs mocks base method.
func (m *MockStore) AllUserIDs(ctx context.Context, includeSystem bool) ([]uuid.UUID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllUserIDs", ctx, includeSystem)
	ret0, _ := ret[0].([]uuid.UUID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AllUserIDs indicates an expected call of AllUserIDs.
func (mr *MockStoreMockRecorder) AllUserIDs(ctx, includeSystem any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllUserIDs", reflect.TypeOf((*MockStore)(nil).AllUserIDs), ctx, includeSystem)
}

// ArchiveChatByID mocks base method.
func (m *MockStore) ArchiveChatByID(ctx context.Context, id uuid.UUID) ([]database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ArchiveChatByID", ctx, id)
	ret0, _ := ret[0].([]database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ArchiveUnusedTemplateVersions mocks base method.
func (m *MockStore) ArchiveUnusedTemplateVersions(ctx context.Context, arg database.ArchiveUnusedTemplateVersionsParams) ([]uuid.UUID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ArchiveUnusedTemplateVersions", ctx, arg)
	ret0, _ := ret[0].([]uuid.UUID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ArchiveUnusedTemplateVersions indicates an expected call of ArchiveUnusedTemplateVersions.
func (mr *MockStoreMockRecorder) ArchiveUnusedTemplateVersions(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ArchiveUnusedTemplateVersions", reflect.TypeOf((*MockStore)(nil).ArchiveUnusedTemplateVersions), ctx, arg)
}

// AutoArchiveInactiveChats mocks base method.
func (m *MockStore) AutoArchiveInactiveChats(ctx context.Context, arg database.AutoArchiveInactiveChatsParams) ([]database.AutoArchiveInactiveChatsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AutoArchiveInactiveChats", ctx, arg)
	ret0, _ := ret[0].([]database.AutoArchiveInactiveChatsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AutoArchiveInactiveChats indicates an expected call of AutoArchiveInactiveChats.
func (mr *MockStoreMockRecorder) AutoArchiveInactiveChats(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AutoArchiveInactiveChats", reflect.TypeOf((*MockStore)(nil).AutoArchiveInactiveChats), ctx, arg)
}

// BackoffChatDiffStatus mocks base method.
func (m *MockStore) BackoffChatDiffStatus(ctx context.Context, arg database.BackoffChatDiffStatusParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BackoffChatDiffStatus", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// BackoffChatDiffStatus indicates an expected call of BackoffChatDiffStatus.
func (mr *MockStoreMockRecorder) BackoffChatDiffStatus(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BackoffChatDiffStatus", reflect.TypeOf((*MockStore)(nil).BackoffChatDiffStatus), ctx, arg)
}

// BatchUpdateWorkspaceAgentMetadata mocks base method.
func (m *MockStore) BatchUpdateWorkspaceAgentMetadata(ctx context.Context, arg database.BatchUpdateWorkspaceAgentMetadataParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchUpdateWorkspaceAgentMetadata", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchUpdateWorkspaceAgentMetadata indicates an expected call of BatchUpdateWorkspaceAgentMetadata.
func (mr *MockStoreMockRecorder) BatchUpdateWorkspaceAgentMetadata(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchUpdateWorkspaceAgentMetadata", reflect.TypeOf((*MockStore)(nil).BatchUpdateWorkspaceAgentMetadata), ctx, arg)
}

// BatchUpdateWorkspaceLastUsedAt mocks base method.
func (m *MockStore) BatchUpdateWorkspaceLastUsedAt(ctx context.Context, arg database.BatchUpdateWorkspaceLastUsedAtParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchUpdateWorkspaceLastUsedAt", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchUpdateWorkspaceLastUsedAt indicates an expected call of BatchUpdateWorkspaceLastUsedAt.
func (mr *MockStoreMockRecorder) BatchUpdateWorkspaceLastUsedAt(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchUpdateWorkspaceLastUsedAt", reflect.TypeOf((*MockStore)(nil).BatchUpdateWorkspaceLastUsedAt), ctx, arg)
}

// BatchUpdateWorkspaceNextStartAt mocks base method.
func (m *MockStore) BatchUpdateWorkspaceNextStartAt(ctx context.Context, arg database.BatchUpdateWorkspaceNextStartAtParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchUpdateWorkspaceNextStartAt", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchUpdateWorkspaceNextStartAt indicates an expected call of BatchUpdateWorkspaceNextStartAt.
func (mr *MockStoreMockRecorder) BatchUpdateWorkspaceNextStartAt(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchUpdateWorkspaceNextStartAt", reflect.TypeOf((*MockStore)(nil).BatchUpdateWorkspaceNextStartAt), ctx, arg)
}

// BatchUpsertConnectionLogs mocks base method.
func (m *MockStore) BatchUpsertConnectionLogs(ctx context.Context, arg database.BatchUpsertConnectionLogsParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchUpsertConnectionLogs", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchUpsertConnectionLogs indicates an expected call of BatchUpsertConnectionLogs.
func (mr *MockStoreMockRecorder) BatchUpsertConnectionLogs(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchUpsertConnectionLogs", reflect.TypeOf((*MockStore)(nil).BatchUpsertConnectionLogs), ctx, arg)
}

// BulkMarkNotificationMessagesFailed mocks base method.
func (m *MockStore) BulkMarkNotificationMessagesFailed(ctx context.Context, arg database.BulkMarkNotificationMessagesFailedParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BulkMarkNotificationMessagesFailed", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BulkMarkNotificationMessagesFailed indicates an expected call of BulkMarkNotificationMessagesFailed.
func (mr *MockStoreMockRecorder) BulkMarkNotificationMessagesFailed(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BulkMarkNotificationMessagesFailed", reflect.TypeOf((*MockStore)(nil).BulkMarkNotificationMessagesFailed), ctx, arg)
}

// BulkMarkNotificationMessagesSent mocks base method.
func (m *MockStore) BulkMarkNotificationMessagesSent(ctx context.Context, arg database.BulkMarkNotificationMessagesSentParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BulkMarkNotificationMessagesSent", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BulkMarkNotificationMessagesSent indicates an expected call of BulkMarkNotificationMessagesSent.
func (mr *MockStoreMockRecorder) BulkMarkNotificationMessagesSent(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BulkMarkNotificationMessagesSent", reflect.TypeOf((*MockStore)(nil).BulkMarkNotificationMessagesSent), ctx, arg)
}

// CalculateAIBridgeInterceptionsTelemetrySummary mocks base method.
func (m *MockStore) CalculateAIBridgeInterceptionsTelemetrySummary(ctx context.Context, arg database.CalculateAIBridgeInterceptionsTelemetrySummaryParams) (database.CalculateAIBridgeInterceptionsTelemetrySummaryRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalculateAIBridgeInterceptionsTelemetrySummary", ctx, arg)
	ret0, _ := ret[0].(database.CalculateAIBridgeInterceptionsTelemetrySummaryRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CalculateAIBridgeInterceptionsTelemetrySummary indicates an expected call of CalculateAIBridgeInterceptionsTelemetrySummary.
func (mr *MockStoreMockRecorder) CalculateAIBridgeInterceptionsTelemetrySummary(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CalculateAIBridgeInterceptionsTelemetrySummary", reflect.TypeOf((*MockStore)(nil).CalculateAIBridgeInterceptionsTelemetrySummary), ctx, arg)
}

// ClaimPrebuiltWorkspace mocks base method.
func (m *MockStore) ClaimPrebuiltWorkspace(ctx context.Context, arg database.ClaimPrebuiltWorkspaceParams) (database.ClaimPrebuiltWorkspaceRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClaimPrebuiltWorkspace", ctx, arg)
	ret0, _ := ret[0].(database.ClaimPrebuiltWorkspaceRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ClaimPrebuiltWorkspace indicates an expected call of ClaimPrebuiltWorkspace.
func (mr *MockStoreMockRecorder) ClaimPrebuiltWorkspace(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClaimPrebuiltWorkspace", reflect.TypeOf((*MockStore)(nil).ClaimPrebuiltWorkspace), ctx, arg)
}

// CleanTailnetCoordinators mocks base method.
func (m *MockStore) CleanTailnetCoordinators(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CleanTailnetCoordinators", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// CleanTailnetLostPeers mocks base method.
func (m *MockStore) CleanTailnetLostPeers(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CleanTailnetLostPeers", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// CleanTailnetTunnels mocks base method.
func (m *MockStore) CleanTailnetTunnels(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CleanTailnetTunnels", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// CleanupDeletedMCPServerIDsFromChats mocks base method.
func (m *MockStore) CleanupDeletedMCPServerIDsFromChats(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CleanupDeletedMCPServerIDsFromChats", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ClearChatMessageProviderResponseIDsByChatID mocks base method.
func (m *MockStore) ClearChatMessageProviderResponseIDsByChatID(ctx context.Context, chatID uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClearChatMessageProviderResponseIDsByChatID", ctx, chatID)
	ret0, _ := ret[0].(error)
	return ret0
}

// ClearChatMessageProviderResponseIDsByChatID indicates an expected call of ClearChatMessageProviderResponseIDsByChatID.
func (mr *MockStoreMockRecorder) ClearChatMessageProviderResponseIDsByChatID(ctx, chatID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearChatMessageProviderResponseIDsByChatID", reflect.TypeOf((*MockStore)(nil).ClearChatMessageProviderResponseIDsByChatID), ctx, chatID)
}

// CountAIBridgeInterceptions mocks base method.
func (m *MockStore) CountAIBridgeInterceptions(ctx context.Context, arg database.CountAIBridgeInterceptionsParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountAIBridgeInterceptions", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountAIBridgeInterceptions indicates an expected call of CountAIBridgeInterceptions.
func (mr *MockStoreMockRecorder) CountAIBridgeInterceptions(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountAIBridgeInterceptions", reflect.TypeOf((*MockStore)(nil).CountAIBridgeInterceptions), ctx, arg)
}

// CountAIBridgeSessions mocks base method.
func (m *MockStore) CountAIBridgeSessions(ctx context.Context, arg database.CountAIBridgeSessionsParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountAIBridgeSessions", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountAIBridgeSessions indicates an expected call of CountAIBridgeSessions.
func (mr *MockStoreMockRecorder) CountAIBridgeSessions(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountAIBridgeSessions", reflect.TypeOf((*MockStore)(nil).CountAIBridgeSessions), ctx, arg)
}

// CountAuditLogs mocks base method.
func (m *MockStore) CountAuditLogs(ctx context.Context, arg database.CountAuditLogsParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountAuditLogs", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountAuditLogs indicates an expected call of CountAuditLogs.
func (mr *MockStoreMockRecorder) CountAuditLogs(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountAuditLogs", reflect.TypeOf((*MockStore)(nil).CountAuditLogs), ctx, arg)
}

// CountAuthorizedAIBridgeInterceptions mocks base method.
func (m *MockStore) CountAuthorizedAIBridgeInterceptions(ctx context.Context, arg database.CountAIBridgeInterceptionsParams, prepared rbac.PreparedAuthorized) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountAuthorizedAIBridgeInterceptions", ctx, arg, prepared)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountAuthorizedAIBridgeInterceptions indicates an expected call of CountAuthorizedAIBridgeInterceptions.
func (mr *MockStoreMockRecorder) CountAuthorizedAIBridgeInterceptions(ctx, arg, prepared any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountAuthorizedAIBridgeInterceptions", reflect.TypeOf((*MockStore)(nil).CountAuthorizedAIBridgeInterceptions), ctx, arg, prepared)
}

// CountAuthorizedAIBridgeSessions mocks base method.
func (m *MockStore) CountAuthorizedAIBridgeSessions(ctx context.Context, arg database.CountAIBridgeSessionsParams, prepared rbac.PreparedAuthorized) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountAuthorizedAIBridgeSessions", ctx, arg, prepared)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountAuthorizedAIBridgeSessions indicates an expected call of CountAuthorizedAIBridgeSessions.
func (mr *MockStoreMockRecorder) CountAuthorizedAIBridgeSessions(ctx, arg, prepared any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountAuthorizedAIBridgeSessions", reflect.TypeOf((*MockStore)(nil).CountAuthorizedAIBridgeSessions), ctx, arg, prepared)
}

// CountAuthorizedAuditLogs mocks base method.
func (m *MockStore) CountAuthorizedAuditLogs(ctx context.Context, arg database.CountAuditLogsParams, prepared rbac.PreparedAuthorized) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountAuthorizedAuditLogs", ctx, arg, prepared)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountAuthorizedAuditLogs indicates an expected call of CountAuthorizedAuditLogs.
func (mr *MockStoreMockRecorder) CountAuthorizedAuditLogs(ctx, arg, prepared any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountAuthorizedAuditLogs", reflect.TypeOf((*MockStore)(nil).CountAuthorizedAuditLogs), ctx, arg, prepared)
}

// CountAuthorizedConnectionLogs mocks base method.
func (m *MockStore) CountAuthorizedConnectionLogs(ctx context.Context, arg database.CountConnectionLogsParams, prepared rbac.PreparedAuthorized) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountAuthorizedConnectionLogs", ctx, arg, prepared)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountAuthorizedConnectionLogs indicates an expected call of CountAuthorizedConnectionLogs.
func (mr *MockStoreMockRecorder) CountAuthorizedConnectionLogs(ctx, arg, prepared any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountAuthorizedConnectionLogs", reflect.TypeOf((*MockStore)(nil).CountAuthorizedConnectionLogs), ctx, arg, prepared)
}

// CountConnectionLogs mocks base method.
func (m *MockStore) CountConnectionLogs(ctx context.Context, arg database.CountConnectionLogsParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountConnectionLogs", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountConnectionLogs indicates an expected call of CountConnectionLogs.
func (mr *MockStoreMockRecorder) CountConnectionLogs(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountConnectionLogs", reflect.TypeOf((*MockStore)(nil).CountConnectionLogs), ctx, arg)
}

// CountEnabledModelsWithoutPricing mocks base method.
func (m *MockStore) CountEnabledModelsWithoutPricing(ctx context.Context) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountEnabledModelsWithoutPricing", ctx)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CountInProgressPrebuilds mocks base method.
func (m *MockStore) CountInProgressPrebuilds(ctx context.Context) ([]database.CountInProgressPrebuildsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountInProgressPrebuilds", ctx)
	ret0, _ := ret[0].([]database.CountInProgressPrebuildsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CountPendingNonActivePrebuilds mocks base method.
func (m *MockStore) CountPendingNonActivePrebuilds(ctx context.Context) ([]database.CountPendingNonActivePrebuildsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountPendingNonActivePrebuilds", ctx)
	ret0, _ := ret[0].([]database.CountPendingNonActivePrebuildsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CountUnreadInboxNotificationsByUserID mocks base method.
func (m *MockStore) CountUnreadInboxNotificationsByUserID(ctx context.Context, userID uuid.UUID) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CountUnreadInboxNotificationsByUserID", ctx, userID)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateUserSecret mocks base method.
func (m *MockStore) CreateUserSecret(ctx context.Context, arg database.CreateUserSecretParams) (database.UserSecret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateUserSecret", ctx, arg)
	ret0, _ := ret[0].(database.UserSecret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateUserSecret indicates an expected call of CreateUserSecret.
func (mr *MockStoreMockRecorder) CreateUserSecret(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUserSecret", reflect.TypeOf((*MockStore)(nil).CreateUserSecret), ctx, arg)
}

// CustomRoles mocks base method.
func (m *MockStore) CustomRoles(ctx context.Context, arg database.CustomRolesParams) ([]database.CustomRole, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CustomRoles", ctx, arg)
	ret0, _ := ret[0].([]database.CustomRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CustomRoles indicates an expected call of CustomRoles.
func (mr *MockStoreMockRecorder) CustomRoles(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CustomRoles", reflect.TypeOf((*MockStore)(nil).CustomRoles), ctx, arg)
}

// DeleteAIProviderByID mocks base method.
func (m *MockStore) DeleteAIProviderByID(ctx context.Context, id uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAIProviderByID", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteAIProviderKey mocks base method.
func (m *MockStore) DeleteAIProviderKey(ctx context.Context, id uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAIProviderKey", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteAPIKeyByID mocks base method.
func (m *MockStore) DeleteAPIKeyByID(ctx context.Context, id string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAPIKeyByID", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteAPIKeysByUserID mocks base method.
func (m *MockStore) DeleteAPIKeysByUserID(ctx context.Context, userID uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAPIKeysByUserID", ctx, userID)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteAllChatQueuedMessages mocks base method.
func (m *MockStore) DeleteAllChatQueuedMessages(ctx context.Context, chatID uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAllChatQueuedMessages", ctx, chatID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteAllChatQueuedMessages indicates an expected call of DeleteAllChatQueuedMessages.
func (mr *MockStoreMockRecorder) DeleteAllChatQueuedMessages(ctx, chatID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllChatQueuedMessages", reflect.TypeOf((*MockStore)(nil).DeleteAllChatQueuedMessages), ctx, chatID)
}

// DeleteAllTailnetTunnels mocks base method.
func (m *MockStore) DeleteAllTailnetTunnels(ctx context.Context, arg database.DeleteAllTailnetTunnelsParams) ([]database.DeleteAllTailnetTunnelsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAllTailnetTunnels", ctx, arg)
	ret0, _ := ret[0].([]database.DeleteAllTailnetTunnelsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteAllTailnetTunnels indicates an expected call of DeleteAllTailnetTunnels.
func (mr *MockStoreMockRecorder) DeleteAllTailnetTunnels(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllTailnetTunnels", reflect.TypeOf((*MockStore)(nil).DeleteAllTailnetTunnels), ctx, arg)
}

// DeleteAllWebpushSubscriptions mocks base method.
func (m *MockStore) DeleteAllWebpushSubscriptions(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAllWebpushSubscriptions", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteApplicationConnectAPIKeysByUserID mocks base method.
func (m *MockStore) DeleteApplicationConnectAPIKeysByUserID(ctx context.Context, userID uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteApplicationConnectAPIKeysByUserID", ctx, userID)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteChatDebugDataAfterMessageID mocks base method.
func (m *MockStore) DeleteChatDebugDataAfterMessageID(ctx context.Context, arg database.DeleteChatDebugDataAfterMessageIDParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteChatDebugDataAfterMessageID", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteChatDebugDataAfterMessageID indicates an expected call of DeleteChatDebugDataAfterMessageID.
func (mr *MockStoreMockRecorder) DeleteChatDebugDataAfterMessageID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChatDebugDataAfterMessageID", reflect.TypeOf((*MockStore)(nil).DeleteChatDebugDataAfterMessageID), ctx, arg)
}

// DeleteChatDebugDataByChatID mocks base method.
func (m *MockStore) DeleteChatDebugDataByChatID(ctx context.Context, arg database.DeleteChatDebugDataByChatIDParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteChatDebugDataByChatID", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteChatDebugDataByChatID indicates an expected call of DeleteChatDebugDataByChatID.
func (mr *MockStoreMockRecorder) DeleteChatDebugDataByChatID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChatDebugDataByChatID", reflect.TypeOf((*MockStore)(nil).DeleteChatDebugDataByChatID), ctx, arg)
}

// DeleteChatModelConfigByID mocks base method.
func (m *MockStore) DeleteChatModelConfigByID(ctx context.Context, id uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteChatModelConfigByID", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteChatModelConfigsByAIProviderID mocks base method.
func (m *MockStore) DeleteChatModelConfigsByAIProviderID(ctx context.Context, aiProviderID uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteChatModelConfigsByAIProviderID", ctx, aiProviderID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteChatModelConfigsByAIProviderID indicates an expected call of DeleteChatModelConfigsByAIProviderID.
func (mr *MockStoreMockRecorder) DeleteChatModelConfigsByAIProviderID(ctx, aiProviderID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChatModelConfigsByAIProviderID", reflect.TypeOf((*MockStore)(nil).DeleteChatModelConfigsByAIProviderID), ctx, aiProviderID)
}

// DeleteChatModelConfigsByProvider mocks base method.
func (m *MockStore) DeleteChatModelConfigsByProvider(ctx context.Context, provider string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteChatModelConfigsByProvider", ctx, provider)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteChatModelConfigsByProvider indicates an expected call of DeleteChatModelConfigsByProvider.
func (mr *MockStoreMockRecorder) DeleteChatModelConfigsByProvider(ctx, provider any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChatModelConfigsByProvider", reflect.TypeOf((*MockStore)(nil).DeleteChatModelConfigsByProvider), ctx, provider)
}

// DeleteChatQueuedMessage mocks base method.
func (m *MockStore) DeleteChatQueuedMessage(ctx context.Context, arg database.DeleteChatQueuedMessageParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteChatQueuedMessage", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteChatQueuedMessage indicates an expected call of DeleteChatQueuedMessage.
func (mr *MockStoreMockRecorder) DeleteChatQueuedMessage(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChatQueuedMessage", reflect.TypeOf((*MockStore)(nil).DeleteChatQueuedMessage), ctx, arg)
}

// DeleteChatUsageLimitGroupOverride mocks base method.
func (m *MockStore) DeleteChatUsageLimitGroupOverride(ctx context.Context, groupID uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteChatUsageLimitGroupOverride", ctx, groupID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteChatUsageLimitGroupOverride indicates an expected call of DeleteChatUsageLimitGroupOverride.
func (mr *MockStoreMockRecorder) DeleteChatUsageLimitGroupOverride(ctx, groupID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteChatUsageLimitGroupOverride", reflect.TypeOf((*MockStore)(nil).DeleteChatUsageLimitGroupOverride), ctx, groupID)
}

// DeleteChatUsageLimitUserOverride mocks base method.
func (m *MockStore) DeleteChatUsageLimitUserOverride(ctx context.Context, userID uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteChatUsageLimitUserOverride", ctx, userID)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteCryptoKey mocks base method.
func (m *MockStore) DeleteCryptoKey(ctx context.Context, arg database.DeleteCryptoKeyParams) (database.CryptoKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCryptoKey", ctx, arg)
	ret0, _ := ret[0].(database.CryptoKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteCryptoKey indicates an expected call of DeleteCryptoKey.
func (mr *MockStoreMockRecorder) DeleteCryptoKey(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCryptoKey", reflect.TypeOf((*MockStore)(nil).DeleteCryptoKey), ctx, arg)
}

// DeleteCustomRole mocks base method.
func (m *MockStore) DeleteCustomRole(ctx context.Context, arg database.DeleteCustomRoleParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCustomRole", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCustomRole indicates an expected call of DeleteCustomRole.
func (mr *MockStoreMockRecorder) DeleteCustomRole(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomRole", reflect.TypeOf((*MockStore)(nil).DeleteCustomRole), ctx, arg)
}

// DeleteExpiredAPIKeys mocks base method.
func (m *MockStore) DeleteExpiredAPIKeys(ctx context.Context, arg database.DeleteExpiredAPIKeysParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteExpiredAPIKeys", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteExpiredAPIKeys indicates an expected call of DeleteExpiredAPIKeys.
func (mr *MockStoreMockRecorder) DeleteExpiredAPIKeys(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteExpiredAPIKeys", reflect.TypeOf((*MockStore)(nil).DeleteExpiredAPIKeys), ctx, arg)
}

// DeleteExternalAuthLink mocks base method.
func (m *MockStore) DeleteExternalAuthLink(ctx context.Context, arg database.DeleteExternalAuthLinkParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteExternalAuthLink", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteExternalAuthLink indicates an expected call of DeleteExternalAuthLink.
func (mr *MockStoreMockRecorder) DeleteExternalAuthLink(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteExternalAuthLink", reflect.TypeOf((*MockStore)(nil).DeleteExternalAuthLink), ctx, arg)
}

// DeleteGroupAIBudget mocks base method.
func (m *MockStore) DeleteGroupAIBudget(ctx context.Context, groupID uuid.UUID) (database.GroupAiBudget, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteGroupAIBudget", ctx, groupID)
	ret0, _ := ret[0].(database.GroupAiBudget)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteGroupAIBudget indicates an expected call of DeleteGroupAIBudget.
func (mr *MockStoreMockRecorder) DeleteGroupAIBudget(ctx, groupID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGroupAIBudget", reflect.TypeOf((*MockStore)(nil).DeleteGroupAIBudget), ctx, groupID)
}

// DeleteGroupByID mocks base method.
func (m *MockStore) DeleteGroupByID(ctx context.Context, id uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteGroupByID", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteGroupMemberFromGroup mocks base method.
func (m *MockStore) DeleteGroupMemberFromGroup(ctx context.Context, arg database.DeleteGroupMemberFromGroupParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteGroupMemberFromGroup", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteGroupMemberFromGroup indicates an expected call of DeleteGroupMemberFromGroup.
func (mr *MockStoreMockRecorder) DeleteGroupMemberFromGroup(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGroupMemberFromGroup", reflect.TypeOf((*MockStore)(nil).DeleteGroupMemberFromGroup), ctx, arg)
}

// DeleteLicense mocks base method.
func (m *MockStore) DeleteLicense(ctx context.Context, id int32) (int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteLicense", ctx, id)
	ret0, _ := ret[0].(int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteMCPServerConfigByID mocks base method.
func (m *MockStore) DeleteMCPServerConfigByID(ctx context.Context, id uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMCPServerConfigByID", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteMCPServerUserToken mocks base method.
func (m *MockStore) DeleteMCPServerUserToken(ctx context.Context, arg database.DeleteMCPServerUserTokenParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMCPServerUserToken", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteMCPServerUserToken indicates an expected call of DeleteMCPServerUserToken.
func (mr *MockStoreMockRecorder) DeleteMCPServerUserToken(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMCPServerUserToken", reflect.TypeOf((*MockStore)(nil).DeleteMCPServerUserToken), ctx, arg)
}

// DeleteOAuth2ProviderAppByClientID mocks base method.
func (m *MockStore) DeleteOAuth2ProviderAppByClientID(ctx context.Context, id uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOAuth2ProviderAppByClientID", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteOAuth2ProviderAppByID mocks base method.
func (m *MockStore) DeleteOAuth2ProviderAppByID(ctx context.Context, id uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOAuth2ProviderAppByID", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteOAuth2ProviderAppCodeByID mocks base method.
func (m *MockStore) DeleteOAuth2ProviderAppCodeByID(ctx context.Context, id uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOAuth2ProviderAppCodeByID", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteOAuth2ProviderAppCodesByAppAndUserID mocks base method.
func (m *MockStore) DeleteOAuth2ProviderAppCodesByAppAndUserID(ctx context.Context, arg database.DeleteOAuth2ProviderAppCodesByAppAndUserIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOAuth2ProviderAppCodesByAppAndUserID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteOAuth2ProviderAppCodesByAppAndUserID indicates an expected call of DeleteOAuth2ProviderAppCodesByAppAndUserID.
func (mr *MockStoreMockRecorder) DeleteOAuth2ProviderAppCodesByAppAndUserID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOAuth2ProviderAppCodesByAppAndUserID", reflect.TypeOf((*MockStore)(nil).DeleteOAuth2ProviderAppCodesByAppAndUserID), ctx, arg)
}

// DeleteOAuth2ProviderAppSecretByID mocks base method.
func (m *MockStore) DeleteOAuth2ProviderAppSecretByID(ctx context.Context, id uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOAuth2ProviderAppSecretByID", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteOAuth2ProviderAppTokensByAppAndUserID mocks base method.
func (m *MockStore) DeleteOAuth2ProviderAppTokensByAppAndUserID(ctx context.Context, arg database.DeleteOAuth2ProviderAppTokensByAppAndUserIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOAuth2ProviderAppTokensByAppAndUserID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteOAuth2ProviderAppTokensByAppAndUserID indicates an expected call of DeleteOAuth2ProviderAppTokensByAppAndUserID.
func (mr *MockStoreMockRecorder) DeleteOAuth2ProviderAppTokensByAppAndUserID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOAuth2ProviderAppTokensByAppAndUserID", reflect.TypeOf((*MockStore)(nil).DeleteOAuth2ProviderAppTokensByAppAndUserID), ctx, arg)
}

// DeleteOldAIBridgeRecords mocks base method.
func (m *MockStore) DeleteOldAIBridgeRecords(ctx context.Context, beforeTime time.Time) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOldAIBridgeRecords", ctx, beforeTime)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteOldAIBridgeRecords indicates an expected call of DeleteOldAIBridgeRecords.
func (mr *MockStoreMockRecorder) DeleteOldAIBridgeRecords(ctx, beforeTime any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldAIBridgeRecords", reflect.TypeOf((*MockStore)(nil).DeleteOldAIBridgeRecords), ctx, beforeTime)
}

// DeleteOldAuditLogConnectionEvents mocks base method.
func (m *MockStore) DeleteOldAuditLogConnectionEvents(ctx context.Context, arg database.DeleteOldAuditLogConnectionEventsParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOldAuditLogConnectionEvents", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteOldAuditLogConnectionEvents indicates an expected call of DeleteOldAuditLogConnectionEvents.
func (mr *MockStoreMockRecorder) DeleteOldAuditLogConnectionEvents(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldAuditLogConnectionEvents", reflect.TypeOf((*MockStore)(nil).DeleteOldAuditLogConnectionEvents), ctx, arg)
}

// DeleteOldAuditLogs mocks base method.
func (m *MockStore) DeleteOldAuditLogs(ctx context.Context, arg database.DeleteOldAuditLogsParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOldAuditLogs", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteOldAuditLogs indicates an expected call of DeleteOldAuditLogs.
func (mr *MockStoreMockRecorder) DeleteOldAuditLogs(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldAuditLogs", reflect.TypeOf((*MockStore)(nil).DeleteOldAuditLogs), ctx, arg)
}

// DeleteOldBoundaryLogs mocks base method.
func (m *MockStore) DeleteOldBoundaryLogs(ctx context.Context, arg database.DeleteOldBoundaryLogsParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOldBoundaryLogs", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteOldBoundaryLogs indicates an expected call of DeleteOldBoundaryLogs.
func (mr *MockStoreMockRecorder) DeleteOldBoundaryLogs(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldBoundaryLogs", reflect.TypeOf((*MockStore)(nil).DeleteOldBoundaryLogs), ctx, arg)
}

// DeleteOldChatDebugRuns mocks base method.
func (m *MockStore) DeleteOldChatDebugRuns(ctx context.Context, arg database.DeleteOldChatDebugRunsParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOldChatDebugRuns", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteOldChatDebugRuns indicates an expected call of DeleteOldChatDebugRuns.
func (mr *MockStoreMockRecorder) DeleteOldChatDebugRuns(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldChatDebugRuns", reflect.TypeOf((*MockStore)(nil).DeleteOldChatDebugRuns), ctx, arg)
}

// DeleteOldChatFiles mocks base method.
func (m *MockStore) DeleteOldChatFiles(ctx context.Context, arg database.DeleteOldChatFilesParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOldChatFiles", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteOldChatFiles indicates an expected call of DeleteOldChatFiles.
func (mr *MockStoreMockRecorder) DeleteOldChatFiles(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldChatFiles", reflect.TypeOf((*MockStore)(nil).DeleteOldChatFiles), ctx, arg)
}

// DeleteOldChats mocks base method.
func (m *MockStore) DeleteOldChats(ctx context.Context, arg database.DeleteOldChatsParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOldChats", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteOldChats indicates an expected call of DeleteOldChats.
func (mr *MockStoreMockRecorder) DeleteOldChats(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldChats", reflect.TypeOf((*MockStore)(nil).DeleteOldChats), ctx, arg)
}

// DeleteOldConnectionLogs mocks base method.
func (m *MockStore) DeleteOldConnectionLogs(ctx context.Context, arg database.DeleteOldConnectionLogsParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOldConnectionLogs", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteOldConnectionLogs indicates an expected call of DeleteOldConnectionLogs.
func (mr *MockStoreMockRecorder) DeleteOldConnectionLogs(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldConnectionLogs", reflect.TypeOf((*MockStore)(nil).DeleteOldConnectionLogs), ctx, arg)
}

// DeleteOldNotificationMessages mocks base method.
func (m *MockStore) DeleteOldNotificationMessages(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOldNotificationMessages", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteOldProvisionerDaemons mocks base method.
func (m *MockStore) DeleteOldProvisionerDaemons(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOldProvisionerDaemons", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteOldTelemetryLocks mocks base method.
func (m *MockStore) DeleteOldTelemetryLocks(ctx context.Context, periodEndingAtBefore time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOldTelemetryLocks", ctx, periodEndingAtBefore)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteOldTelemetryLocks indicates an expected call of DeleteOldTelemetryLocks.
func (mr *MockStoreMockRecorder) DeleteOldTelemetryLocks(ctx, periodEndingAtBefore any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldTelemetryLocks", reflect.TypeOf((*MockStore)(nil).DeleteOldTelemetryLocks), ctx, periodEndingAtBefore)
}

// DeleteOldWorkspaceAgentLogs mocks base method.
func (m *MockStore) DeleteOldWorkspaceAgentLogs(ctx context.Context, threshold time.Time) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOldWorkspaceAgentLogs", ctx, threshold)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteOldWorkspaceAgentLogs indicates an expected call of DeleteOldWorkspaceAgentLogs.
func (mr *MockStoreMockRecorder) DeleteOldWorkspaceAgentLogs(ctx, threshold any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldWorkspaceAgentLogs", reflect.TypeOf((*MockStore)(nil).DeleteOldWorkspaceAgentLogs), ctx, threshold)
}

// DeleteOldWorkspaceAgentStats mocks base method.
func (m *MockStore) DeleteOldWorkspaceAgentStats(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOldWorkspaceAgentStats", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteOrganizationMember mocks base method.
func (m *MockStore) DeleteOrganizationMember(ctx context.Context, arg database.DeleteOrganizationMemberParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteOrganizationMember", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteOrganizationMember indicates an expected call of DeleteOrganizationMember.
func (mr *MockStoreMockRecorder) DeleteOrganizationMember(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOrganizationMember", reflect.TypeOf((*MockStore)(nil).DeleteOrganizationMember), ctx, arg)
}

// DeleteProvisionerKey mocks base method.
func (m *MockStore) DeleteProvisionerKey(ctx context.Context, id uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteProvisionerKey", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteReplicasUpdatedBefore mocks base method.
func (m *MockStore) DeleteReplicasUpdatedBefore(ctx context.Context, updatedAt time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteReplicasUpdatedBefore", ctx, updatedAt)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteReplicasUpdatedBefore indicates an expected call of DeleteReplicasUpdatedBefore.
func (mr *MockStoreMockRecorder) DeleteReplicasUpdatedBefore(ctx, updatedAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReplicasUpdatedBefore", reflect.TypeOf((*MockStore)(nil).DeleteReplicasUpdatedBefore), ctx, updatedAt)
}

// DeleteRuntimeConfig mocks base method.
func (m *MockStore) DeleteRuntimeConfig(ctx context.Context, key string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRuntimeConfig", ctx, key)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteRuntimeConfig indicates an expected call of DeleteRuntimeConfig.
func (mr *MockStoreMockRecorder) DeleteRuntimeConfig(ctx, key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRuntimeConfig", reflect.TypeOf((*MockStore)(nil).DeleteRuntimeConfig), ctx, key)
}

// DeleteTailnetPeer mocks base method.
func (m *MockStore) DeleteTailnetPeer(ctx context.Context, arg database.DeleteTailnetPeerParams) (database.DeleteTailnetPeerRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTailnetPeer", ctx, arg)
	ret0, _ := ret[0].(database.DeleteTailnetPeerRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTailnetPeer indicates an expected call of DeleteTailnetPeer.
func (mr *MockStoreMockRecorder) DeleteTailnetPeer(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTailnetPeer", reflect.TypeOf((*MockStore)(nil).DeleteTailnetPeer), ctx, arg)
}

// DeleteTailnetTunnel mocks base method.
func (m *MockStore) DeleteTailnetTunnel(ctx context.Context, arg database.DeleteTailnetTunnelParams) (database.DeleteTailnetTunnelRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTailnetTunnel", ctx, arg)
	ret0, _ := ret[0].(database.DeleteTailnetTunnelRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTailnetTunnel indicates an expected call of DeleteTailnetTunnel.
func (mr *MockStoreMockRecorder) DeleteTailnetTunnel(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTailnetTunnel", reflect.TypeOf((*MockStore)(nil).DeleteTailnetTunnel), ctx, arg)
}

// DeleteTask mocks base method.
func (m *MockStore) DeleteTask(ctx context.Context, arg database.DeleteTaskParams) (uuid.UUID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTask", ctx, arg)
	ret0, _ := ret[0].(uuid.UUID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTask indicates an expected call of DeleteTask.
func (mr *MockStoreMockRecorder) DeleteTask(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTask", reflect.TypeOf((*MockStore)(nil).DeleteTask), ctx, arg)
}

// DeleteUserAIProviderKey mocks base method.
func (m *MockStore) DeleteUserAIProviderKey(ctx context.Context, arg database.DeleteUserAIProviderKeyParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUserAIProviderKey", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteUserAIProviderKey indicates an expected call of DeleteUserAIProviderKey.
func (mr *MockStoreMockRecorder) DeleteUserAIProviderKey(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserAIProviderKey", reflect.TypeOf((*MockStore)(nil).DeleteUserAIProviderKey), ctx, arg)
}

// DeleteUserAIProviderKeysByProviderID mocks base method.
func (m *MockStore) DeleteUserAIProviderKeysByProviderID(ctx context.Context, aiProviderID uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUserAIProviderKeysByProviderID", ctx, aiProviderID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteUserAIProviderKeysByProviderID indicates an expected call of DeleteUserAIProviderKeysByProviderID.
func (mr *MockStoreMockRecorder) DeleteUserAIProviderKeysByProviderID(ctx, aiProviderID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserAIProviderKeysByProviderID", reflect.TypeOf((*MockStore)(nil).DeleteUserAIProviderKeysByProviderID), ctx, aiProviderID)
}

// DeleteUserChatCompactionThreshold mocks base method.
func (m *MockStore) DeleteUserChatCompactionThreshold(ctx context.Context, arg database.DeleteUserChatCompactionThresholdParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUserChatCompactionThreshold", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteUserChatCompactionThreshold indicates an expected call of DeleteUserChatCompactionThreshold.
func (mr *MockStoreMockRecorder) DeleteUserChatCompactionThreshold(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserChatCompactionThreshold", reflect.TypeOf((*MockStore)(nil).DeleteUserChatCompactionThreshold), ctx, arg)
}

// DeleteUserSecretByUserIDAndName mocks base method.
func (m *MockStore) DeleteUserSecretByUserIDAndName(ctx context.Context, arg database.DeleteUserSecretByUserIDAndNameParams) (database.UserSecret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUserSecretByUserIDAndName", ctx, arg)
	ret0, _ := ret[0].(database.UserSecret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteUserSecretByUserIDAndName indicates an expected call of DeleteUserSecretByUserIDAndName.
func (mr *MockStoreMockRecorder) DeleteUserSecretByUserIDAndName(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserSecretByUserIDAndName", reflect.TypeOf((*MockStore)(nil).DeleteUserSecretByUserIDAndName), ctx, arg)
}

// DeleteUserSkillByUserIDAndName mocks base method.
func (m *MockStore) DeleteUserSkillByUserIDAndName(ctx context.Context, arg database.DeleteUserSkillByUserIDAndNameParams) (database.UserSkill, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUserSkillByUserIDAndName", ctx, arg)
	ret0, _ := ret[0].(database.UserSkill)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteUserSkillByUserIDAndName indicates an expected call of DeleteUserSkillByUserIDAndName.
func (mr *MockStoreMockRecorder) DeleteUserSkillByUserIDAndName(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserSkillByUserIDAndName", reflect.TypeOf((*MockStore)(nil).DeleteUserSkillByUserIDAndName), ctx, arg)
}

// DeleteWebpushSubscriptionByUserIDAndEndpoint mocks base method.
func (m *MockStore) DeleteWebpushSubscriptionByUserIDAndEndpoint(ctx context.Context, arg database.DeleteWebpushSubscriptionByUserIDAndEndpointParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWebpushSubscriptionByUserIDAndEndpoint", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteWebpushSubscriptionByUserIDAndEndpoint indicates an expected call of DeleteWebpushSubscriptionByUserIDAndEndpoint.
func (mr *MockStoreMockRecorder) DeleteWebpushSubscriptionByUserIDAndEndpoint(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWebpushSubscriptionByUserIDAndEndpoint", reflect.TypeOf((*MockStore)(nil).DeleteWebpushSubscriptionByUserIDAndEndpoint), ctx, arg)
}

// DeleteWebpushSubscriptions mocks base method.
func (m *MockStore) DeleteWebpushSubscriptions(ctx context.Context, ids []uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWebpushSubscriptions", ctx, ids)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteWorkspaceACLByID mocks base method.
func (m *MockStore) DeleteWorkspaceACLByID(ctx context.Context, id uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkspaceACLByID", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DeleteWorkspaceACLsByOrganization mocks base method.
func (m *MockStore) DeleteWorkspaceACLsByOrganization(ctx context.Context, arg database.DeleteWorkspaceACLsByOrganizationParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkspaceACLsByOrganization", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteWorkspaceACLsByOrganization indicates an expected call of DeleteWorkspaceACLsByOrganization.
func (mr *MockStoreMockRecorder) DeleteWorkspaceACLsByOrganization(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkspaceACLsByOrganization", reflect.TypeOf((*MockStore)(nil).DeleteWorkspaceACLsByOrganization), ctx, arg)
}

// DeleteWorkspaceAgentPortShare mocks base method.
func (m *MockStore) DeleteWorkspaceAgentPortShare(ctx context.Context, arg database.DeleteWorkspaceAgentPortShareParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkspaceAgentPortShare", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteWorkspaceAgentPortShare indicates an expected call of DeleteWorkspaceAgentPortShare.
func (mr *MockStoreMockRecorder) DeleteWorkspaceAgentPortShare(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkspaceAgentPortShare", reflect.TypeOf((*MockStore)(nil).DeleteWorkspaceAgentPortShare), ctx, arg)
}

// DeleteWorkspaceAgentPortSharesByTemplate mocks base method.
func (m *MockStore) DeleteWorkspaceAgentPortSharesByTemplate(ctx context.Context, templateID uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkspaceAgentPortSharesByTemplate", ctx, templateID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteWorkspaceAgentPortSharesByTemplate indicates an expected call of DeleteWorkspaceAgentPortSharesByTemplate.
func (mr *MockStoreMockRecorder) DeleteWorkspaceAgentPortSharesByTemplate(ctx, templateID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkspaceAgentPortSharesByTemplate", reflect.TypeOf((*MockStore)(nil).DeleteWorkspaceAgentPortSharesByTemplate), ctx, templateID)
}

// DeleteWorkspaceSubAgentByID mocks base method.
func (m *MockStore) DeleteWorkspaceSubAgentByID(ctx context.Context, id uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkspaceSubAgentByID", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DisableForeignKeysAndTriggers mocks base method.
func (m *MockStore) DisableForeignKeysAndTriggers(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableForeignKeysAndTriggers", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// EnqueueNotificationMessage mocks base method.
func (m *MockStore) EnqueueNotificationMessage(ctx context.Context, arg database.EnqueueNotificationMessageParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnqueueNotificationMessage", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// EnqueueNotificationMessage indicates an expected call of EnqueueNotificationMessage.
func (mr *MockStoreMockRecorder) EnqueueNotificationMessage(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnqueueNotificationMessage", reflect.TypeOf((*MockStore)(nil).EnqueueNotificationMessage), ctx, arg)
}

// ExpirePrebuildsAPIKeys mocks base method.
func (m *MockStore) ExpirePrebuildsAPIKeys(ctx context.Context, now time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExpirePrebuildsAPIKeys", ctx, now)
	ret0, _ := ret[0].(error)
	return ret0
}

// ExpirePrebuildsAPIKeys indicates an expected call of ExpirePrebuildsAPIKeys.
func (mr *MockStoreMockRecorder) ExpirePrebuildsAPIKeys(ctx, now any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpirePrebuildsAPIKeys", reflect.TypeOf((*MockStore)(nil).ExpirePrebuildsAPIKeys), ctx, now)
}

// FavoriteWorkspace mocks base method.
func (m *MockStore) FavoriteWorkspace(ctx context.Context, id uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FavoriteWorkspace", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// FetchMemoryResourceMonitorsByAgentID mocks base method.
func (m *MockStore) FetchMemoryResourceMonitorsByAgentID(ctx context.Context, agentID uuid.UUID) (database.WorkspaceAgentMemoryResourceMonitor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchMemoryResourceMonitorsByAgentID", ctx, agentID)
	ret0, _ := ret[0].(database.WorkspaceAgentMemoryResourceMonitor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchMemoryResourceMonitorsByAgentID indicates an expected call of FetchMemoryResourceMonitorsByAgentID.
func (mr *MockStoreMockRecorder) FetchMemoryResourceMonitorsByAgentID(ctx, agentID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMemoryResourceMonitorsByAgentID", reflect.TypeOf((*MockStore)(nil).FetchMemoryResourceMonitorsByAgentID), ctx, agentID)
}

// FetchMemoryResourceMonitorsUpdatedAfter mocks base method.
func (m *MockStore) FetchMemoryResourceMonitorsUpdatedAfter(ctx context.Context, updatedAt time.Time) ([]database.WorkspaceAgentMemoryResourceMonitor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchMemoryResourceMonitorsUpdatedAfter", ctx, updatedAt)
	ret0, _ := ret[0].([]database.WorkspaceAgentMemoryResourceMonitor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchMemoryResourceMonitorsUpdatedAfter indicates an expected call of FetchMemoryResourceMonitorsUpdatedAfter.
func (mr *MockStoreMockRecorder) FetchMemoryResourceMonitorsUpdatedAfter(ctx, updatedAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMemoryResourceMonitorsUpdatedAfter", reflect.TypeOf((*MockStore)(nil).FetchMemoryResourceMonitorsUpdatedAfter), ctx, updatedAt)
}

// FetchNewMessageMetadata mocks base method.
func (m *MockStore) FetchNewMessageMetadata(ctx context.Context, arg database.FetchNewMessageMetadataParams) (database.FetchNewMessageMetadataRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchNewMessageMetadata", ctx, arg)
	ret0, _ := ret[0].(database.FetchNewMessageMetadataRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchNewMessageMetadata indicates an expected call of FetchNewMessageMetadata.
func (mr *MockStoreMockRecorder) FetchNewMessageMetadata(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchNewMessageMetadata", reflect.TypeOf((*MockStore)(nil).FetchNewMessageMetadata), ctx, arg)
}

// FetchVolumesResourceMonitorsByAgentID mocks base method.
func (m *MockStore) FetchVolumesResourceMonitorsByAgentID(ctx context.Context, agentID uuid.UUID) ([]database.WorkspaceAgentVolumeResourceMonitor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchVolumesResourceMonitorsByAgentID", ctx, agentID)
	ret0, _ := ret[0].([]database.WorkspaceAgentVolumeResourceMonitor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchVolumesResourceMonitorsByAgentID indicates an expected call of FetchVolumesResourceMonitorsByAgentID.
func (mr *MockStoreMockRecorder) FetchVolumesResourceMonitorsByAgentID(ctx, agentID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchVolumesResourceMonitorsByAgentID", reflect.TypeOf((*MockStore)(nil).FetchVolumesResourceMonitorsByAgentID), ctx, agentID)
}

// FetchVolumesResourceMonitorsUpdatedAfter mocks base method.
func (m *MockStore) FetchVolumesResourceMonitorsUpdatedAfter(ctx context.Context, updatedAt time.Time) ([]database.WorkspaceAgentVolumeResourceMonitor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchVolumesResourceMonitorsUpdatedAfter", ctx, updatedAt)
	ret0, _ := ret[0].([]database.WorkspaceAgentVolumeResourceMonitor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchVolumesResourceMonitorsUpdatedAfter indicates an expected call of FetchVolumesResourceMonitorsUpdatedAfter.
func (mr *MockStoreMockRecorder) FetchVolumesResourceMonitorsUpdatedAfter(ctx, updatedAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchVolumesResourceMonitorsUpdatedAfter", reflect.TypeOf((*MockStore)(nil).FetchVolumesResourceMonitorsUpdatedAfter), ctx, updatedAt)
}

// FinalizeStaleChatDebugRows mocks base method.
func (m *MockStore) FinalizeStaleChatDebugRows(ctx context.Context, arg database.FinalizeStaleChatDebugRowsParams) (database.FinalizeStaleChatDebugRowsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FinalizeStaleChatDebugRows", ctx, arg)
	ret0, _ := ret[0].(database.FinalizeStaleChatDebugRowsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FinalizeStaleChatDebugRows indicates an expected call of FinalizeStaleChatDebugRows.
func (mr *MockStoreMockRecorder) FinalizeStaleChatDebugRows(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizeStaleChatDebugRows", reflect.TypeOf((*MockStore)(nil).FinalizeStaleChatDebugRows), ctx, arg)
}

// FindMatchingPresetID mocks base method.
func (m *MockStore) FindMatchingPresetID(ctx context.Context, arg database.FindMatchingPresetIDParams) (uuid.UUID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindMatchingPresetID", ctx, arg)
	ret0, _ := ret[0].(uuid.UUID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindMatchingPresetID indicates an expected call of FindMatchingPresetID.
func (mr *MockStoreMockRecorder) FindMatchingPresetID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindMatchingPresetID", reflect.TypeOf((*MockStore)(nil).FindMatchingPresetID), ctx, arg)
}

// GetAIBridgeInterceptionByID mocks base method.
func (m *MockStore) GetAIBridgeInterceptionByID(ctx context.Context, id uuid.UUID) (database.AIBridgeInterception, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAIBridgeInterceptionByID", ctx, id)
	ret0, _ := ret[0].(database.AIBridgeInterception)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAIBridgeInterceptionLineageByToolCallID mocks base method.
func (m *MockStore) GetAIBridgeInterceptionLineageByToolCallID(ctx context.Context, toolCallID string) (database.GetAIBridgeInterceptionLineageByToolCallIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAIBridgeInterceptionLineageByToolCallID", ctx, toolCallID)
	ret0, _ := ret[0].(database.GetAIBridgeInterceptionLineageByToolCallIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAIBridgeInterceptionLineageByToolCallID indicates an expected call of GetAIBridgeInterceptionLineageByToolCallID.
func (mr *MockStoreMockRecorder) GetAIBridgeInterceptionLineageByToolCallID(ctx, toolCallID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAIBridgeInterceptionLineageByToolCallID", reflect.TypeOf((*MockStore)(nil).GetAIBridgeInterceptionLineageByToolCallID), ctx, toolCallID)
}

// GetAIBridgeInterceptions mocks base method.
func (m *MockStore) GetAIBridgeInterceptions(ctx context.Context) ([]database.AIBridgeInterception, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAIBridgeInterceptions", ctx)
	ret0, _ := ret[0].([]database.AIBridgeInterception)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAIBridgeTokenUsagesByInterceptionID mocks base method.
func (m *MockStore) GetAIBridgeTokenUsagesByInterceptionID(ctx context.Context, interceptionID uuid.UUID) ([]database.AIBridgeTokenUsage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAIBridgeTokenUsagesByInterceptionID", ctx, interceptionID)
	ret0, _ := ret[0].([]database.AIBridgeTokenUsage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAIBridgeTokenUsagesByInterceptionID indicates an expected call of GetAIBridgeTokenUsagesByInterceptionID.
func (mr *MockStoreMockRecorder) GetAIBridgeTokenUsagesByInterceptionID(ctx, interceptionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAIBridgeTokenUsagesByInterceptionID", reflect.TypeOf((*MockStore)(nil).GetAIBridgeTokenUsagesByInterceptionID), ctx, interceptionID)
}

// GetAIBridgeToolUsagesByInterceptionID mocks base method.
func (m *MockStore) GetAIBridgeToolUsagesByInterceptionID(ctx context.Context, interceptionID uuid.UUID) ([]database.AIBridgeToolUsage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAIBridgeToolUsagesByInterceptionID", ctx, interceptionID)
	ret0, _ := ret[0].([]database.AIBridgeToolUsage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAIBridgeToolUsagesByInterceptionID indicates an expected call of GetAIBridgeToolUsagesByInterceptionID.
func (mr *MockStoreMockRecorder) GetAIBridgeToolUsagesByInterceptionID(ctx, interceptionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAIBridgeToolUsagesByInterceptionID", reflect.TypeOf((*MockStore)(nil).GetAIBridgeToolUsagesByInterceptionID), ctx, interceptionID)
}

// GetAIBridgeUserPromptsByInterceptionID mocks base method.
func (m *MockStore) GetAIBridgeUserPromptsByInterceptionID(ctx context.Context, interceptionID uuid.UUID) ([]database.AIBridgeUserPrompt, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAIBridgeUserPromptsByInterceptionID", ctx, interceptionID)
	ret0, _ := ret[0].([]database.AIBridgeUserPrompt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAIBridgeUserPromptsByInterceptionID indicates an expected call of GetAIBridgeUserPromptsByInterceptionID.
func (mr *MockStoreMockRecorder) GetAIBridgeUserPromptsByInterceptionID(ctx, interceptionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAIBridgeUserPromptsByInterceptionID", reflect.TypeOf((*MockStore)(nil).GetAIBridgeUserPromptsByInterceptionID), ctx, interceptionID)
}

// GetAIModelPriceByProviderModel mocks base method.
func (m *MockStore) GetAIModelPriceByProviderModel(ctx context.Context, arg database.GetAIModelPriceByProviderModelParams) (database.AiModelPrice, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAIModelPriceByProviderModel", ctx, arg)
	ret0, _ := ret[0].(database.AiModelPrice)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAIModelPriceByProviderModel indicates an expected call of GetAIModelPriceByProviderModel.
func (mr *MockStoreMockRecorder) GetAIModelPriceByProviderModel(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAIModelPriceByProviderModel", reflect.TypeOf((*MockStore)(nil).GetAIModelPriceByProviderModel), ctx, arg)
}

// GetAIProviderByID mocks base method.
func (m *MockStore) GetAIProviderByID(ctx context.Context, id uuid.UUID) (database.AIProvider, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAIProviderByID", ctx, id)
	ret0, _ := ret[0].(database.AIProvider)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAIProviderByIDForReferenceLock mocks base method.
func (m *MockStore) GetAIProviderByIDForReferenceLock(ctx context.Context, id uuid.UUID) (database.AIProvider, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAIProviderByIDForReferenceLock", ctx, id)
	ret0, _ := ret[0].(database.AIProvider)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAIProviderByName mocks base method.
func (m *MockStore) GetAIProviderByName(ctx context.Context, name string) (database.AIProvider, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAIProviderByName", ctx, name)
	ret0, _ := ret[0].(database.AIProvider)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAIProviderByName indicates an expected call of GetAIProviderByName.
func (mr *MockStoreMockRecorder) GetAIProviderByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAIProviderByName", reflect.TypeOf((*MockStore)(nil).GetAIProviderByName), ctx, name)
}

// GetAIProviderKeyByID mocks base method.
func (m *MockStore) GetAIProviderKeyByID(ctx context.Context, id uuid.UUID) (database.AIProviderKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAIProviderKeyByID", ctx, id)
	ret0, _ := ret[0].(database.AIProviderKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAIProviderKeyPresence mocks base method.
func (m *MockStore) GetAIProviderKeyPresence(ctx context.Context, providerIds []uuid.UUID) ([]uuid.UUID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAIProviderKeyPresence", ctx, providerIds)
	ret0, _ := ret[0].([]uuid.UUID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAIProviderKeyPresence indicates an expected call of GetAIProviderKeyPresence.
func (mr *MockStoreMockRecorder) GetAIProviderKeyPresence(ctx, providerIds any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAIProviderKeyPresence", reflect.TypeOf((*MockStore)(nil).GetAIProviderKeyPresence), ctx, providerIds)
}

// GetAIProviderKeys mocks base method.
func (m *MockStore) GetAIProviderKeys(ctx context.Context, includeDeleted bool) ([]database.AIProviderKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAIProviderKeys", ctx, includeDeleted)
	ret0, _ := ret[0].([]database.AIProviderKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAIProviderKeys indicates an expected call of GetAIProviderKeys.
func (mr *MockStoreMockRecorder) GetAIProviderKeys(ctx, includeDeleted any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAIProviderKeys", reflect.TypeOf((*MockStore)(nil).GetAIProviderKeys), ctx, includeDeleted)
}

// GetAIProviderKeysByProviderID mocks base method.
func (m *MockStore) GetAIProviderKeysByProviderID(ctx context.Context, providerID uuid.UUID) ([]database.AIProviderKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAIProviderKeysByProviderID", ctx, providerID)
	ret0, _ := ret[0].([]database.AIProviderKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAIProviderKeysByProviderID indicates an expected call of GetAIProviderKeysByProviderID.
func (mr *MockStoreMockRecorder) GetAIProviderKeysByProviderID(ctx, providerID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAIProviderKeysByProviderID", reflect.TypeOf((*MockStore)(nil).GetAIProviderKeysByProviderID), ctx, providerID)
}

// GetAIProviderKeysByProviderIDs mocks base method.
func (m *MockStore) GetAIProviderKeysByProviderIDs(ctx context.Context, providerIds []uuid.UUID) ([]database.AIProviderKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAIProviderKeysByProviderIDs", ctx, providerIds)
	ret0, _ := ret[0].([]database.AIProviderKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAIProviderKeysByProviderIDs indicates an expected call of GetAIProviderKeysByProviderIDs.
func (mr *MockStoreMockRecorder) GetAIProviderKeysByProviderIDs(ctx, providerIds any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAIProviderKeysByProviderIDs", reflect.TypeOf((*MockStore)(nil).GetAIProviderKeysByProviderIDs), ctx, providerIds)
}

// GetAIProviders mocks base method.
func (m *MockStore) GetAIProviders(ctx context.Context, arg database.GetAIProvidersParams) ([]database.AIProvider, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAIProviders", ctx, arg)
	ret0, _ := ret[0].([]database.AIProvider)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAIProviders indicates an expected call of GetAIProviders.
func (mr *MockStoreMockRecorder) GetAIProviders(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAIProviders", reflect.TypeOf((*MockStore)(nil).GetAIProviders), ctx, arg)
}

// GetAPIKeyByID mocks base method.
func (m *MockStore) GetAPIKeyByID(ctx context.Context, id string) (database.APIKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAPIKeyByID", ctx, id)
	ret0, _ := ret[0].(database.APIKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAPIKeyByName mocks base method.
func (m *MockStore) GetAPIKeyByName(ctx context.Context, arg database.GetAPIKeyByNameParams) (database.APIKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAPIKeyByName", ctx, arg)
	ret0, _ := ret[0].(database.APIKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAPIKeyByName indicates an expected call of GetAPIKeyByName.
func (mr *MockStoreMockRecorder) GetAPIKeyByName(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAPIKeyByName", reflect.TypeOf((*MockStore)(nil).GetAPIKeyByName), ctx, arg)
}

// GetAPIKeysByLoginType mocks base method.
func (m *MockStore) GetAPIKeysByLoginType(ctx context.Context, arg database.GetAPIKeysByLoginTypeParams) ([]database.APIKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAPIKeysByLoginType", ctx, arg)
	ret0, _ := ret[0].([]database.APIKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAPIKeysByLoginType indicates an expected call of GetAPIKeysByLoginType.
func (mr *MockStoreMockRecorder) GetAPIKeysByLoginType(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAPIKeysByLoginType", reflect.TypeOf((*MockStore)(nil).GetAPIKeysByLoginType), ctx, arg)
}

// GetAPIKeysByUserID mocks base method.
func (m *MockStore) GetAPIKeysByUserID(ctx context.Context, arg database.GetAPIKeysByUserIDParams) ([]database.APIKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAPIKeysByUserID", ctx, arg)
	ret0, _ := ret[0].([]database.APIKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAPIKeysByUserID indicates an expected call of GetAPIKeysByUserID.
func (mr *MockStoreMockRecorder) GetAPIKeysByUserID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAPIKeysByUserID", reflect.TypeOf((*MockStore)(nil).GetAPIKeysByUserID), ctx, arg)
}

// GetAPIKeysLastUsedAfter mocks base method.
func (m *MockStore) GetAPIKeysLastUsedAfter(ctx context.Context, lastUsed time.Time) ([]database.APIKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAPIKeysLastUsedAfter", ctx, lastUsed)
	ret0, _ := ret[0].([]database.APIKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAPIKeysLastUsedAfter indicates an expected call of GetAPIKeysLastUsedAfter.
func (mr *MockStoreMockRecorder) GetAPIKeysLastUsedAfter(ctx, lastUsed any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAPIKeysLastUsedAfter", reflect.TypeOf((*MockStore)(nil).GetAPIKeysLastUsedAfter), ctx, lastUsed)
}

// GetActiveAISeatCount mocks base method.
func (m *MockStore) GetActiveAISeatCount(ctx context.Context) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetActiveAISeatCount", ctx)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetActiveChatsByAgentID mocks base method.
func (m *MockStore) GetActiveChatsByAgentID(ctx context.Context, agentID uuid.UUID) ([]database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetActiveChatsByAgentID", ctx, agentID)
	ret0, _ := ret[0].([]database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetActiveChatsByAgentID indicates an expected call of GetActiveChatsByAgentID.
func (mr *MockStoreMockRecorder) GetActiveChatsByAgentID(ctx, agentID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActiveChatsByAgentID", reflect.TypeOf((*MockStore)(nil).GetActiveChatsByAgentID), ctx, agentID)
}

// GetActivePresetPrebuildSchedules mocks base method.
func (m *MockStore) GetActivePresetPrebuildSchedules(ctx context.Context) ([]database.TemplateVersionPresetPrebuildSchedule, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetActivePresetPrebuildSchedules", ctx)
	ret0, _ := ret[0].([]database.TemplateVersionPresetPrebuildSchedule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetActiveUserCount mocks base method.
func (m *MockStore) GetActiveUserCount(ctx context.Context, includeSystem bool) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetActiveUserCount", ctx, includeSystem)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetActiveUserCount indicates an expected call of GetActiveUserCount.
func (mr *MockStoreMockRecorder) GetActiveUserCount(ctx, includeSystem any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActiveUserCount", reflect.TypeOf((*MockStore)(nil).GetActiveUserCount), ctx, includeSystem)
}

// GetActiveWorkspaceBuildsByTemplateID mocks base method.
func (m *MockStore) GetActiveWorkspaceBuildsByTemplateID(ctx context.Context, templateID uuid.UUID) ([]database.WorkspaceBuild, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetActiveWorkspaceBuildsByTemplateID", ctx, templateID)
	ret0, _ := ret[0].([]database.WorkspaceBuild)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetActiveWorkspaceBuildsByTemplateID indicates an expected call of GetActiveWorkspaceBuildsByTemplateID.
func (mr *MockStoreMockRecorder) GetActiveWorkspaceBuildsByTemplateID(ctx, templateID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActiveWorkspaceBuildsByTemplateID", reflect.TypeOf((*MockStore)(nil).GetActiveWorkspaceBuildsByTemplateID), ctx, templateID)
}

// GetAllTailnetCoordinators mocks base method.
func (m *MockStore) GetAllTailnetCoordinators(ctx context.Context) ([]database.TailnetCoordinator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllTailnetCoordinators", ctx)
	ret0, _ := ret[0].([]database.TailnetCoordinator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAllTailnetPeers mocks base method.
func (m *MockStore) GetAllTailnetPeers(ctx context.Context) ([]database.TailnetPeer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllTailnetPeers", ctx)
	ret0, _ := ret[0].([]database.TailnetPeer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAllTailnetTunnels mocks base method.
func (m *MockStore) GetAllTailnetTunnels(ctx context.Context) ([]database.TailnetTunnel, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllTailnetTunnels", ctx)
	ret0, _ := ret[0].([]database.TailnetTunnel)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAndResetBoundaryUsageSummary mocks base method.
func (m *MockStore) GetAndResetBoundaryUsageSummary(ctx context.Context, maxStalenessMs int64) (database.GetAndResetBoundaryUsageSummaryRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAndResetBoundaryUsageSummary", ctx, maxStalenessMs)
	ret0, _ := ret[0].(database.GetAndResetBoundaryUsageSummaryRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAndResetBoundaryUsageSummary indicates an expected call of GetAndResetBoundaryUsageSummary.
func (mr *MockStoreMockRecorder) GetAndResetBoundaryUsageSummary(ctx, maxStalenessMs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAndResetBoundaryUsageSummary", reflect.TypeOf((*MockStore)(nil).GetAndResetBoundaryUsageSummary), ctx, maxStalenessMs)
}

// GetAnnouncementBanners mocks base method.
func (m *MockStore) GetAnnouncementBanners(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAnnouncementBanners", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetApplicationName mocks base method.
func (m *MockStore) GetApplicationName(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetApplicationName", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAuditLogsOffset mocks base method.
func (m *MockStore) GetAuditLogsOffset(ctx context.Context, arg database.GetAuditLogsOffsetParams) ([]database.GetAuditLogsOffsetRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAuditLogsOffset", ctx, arg)
	ret0, _ := ret[0].([]database.GetAuditLogsOffsetRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAuditLogsOffset indicates an expected call of GetAuditLogsOffset.
func (mr *MockStoreMockRecorder) GetAuditLogsOffset(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuditLogsOffset", reflect.TypeOf((*MockStore)(nil).GetAuditLogsOffset), ctx, arg)
}

// GetAuthenticatedWorkspaceAgentAndBuildByAuthToken mocks base method.
func (m *MockStore) GetAuthenticatedWorkspaceAgentAndBuildByAuthToken(ctx context.Context, authToken uuid.UUID) (database.GetAuthenticatedWorkspaceAgentAndBuildByAuthTokenRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAuthenticatedWorkspaceAgentAndBuildByAuthToken", ctx, authToken)
	ret0, _ := ret[0].(database.GetAuthenticatedWorkspaceAgentAndBuildByAuthTokenRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAuthenticatedWorkspaceAgentAndBuildByAuthToken indicates an expected call of GetAuthenticatedWorkspaceAgentAndBuildByAuthToken.
func (mr *MockStoreMockRecorder) GetAuthenticatedWorkspaceAgentAndBuildByAuthToken(ctx, authToken any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthenticatedWorkspaceAgentAndBuildByAuthToken", reflect.TypeOf((*MockStore)(nil).GetAuthenticatedWorkspaceAgentAndBuildByAuthToken), ctx, authToken)
}

// GetAuthorizationUserRoles mocks base method.
func (m *MockStore) GetAuthorizationUserRoles(ctx context.Context, userID uuid.UUID) (database.GetAuthorizationUserRolesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAuthorizationUserRoles", ctx, userID)
	ret0, _ := ret[0].(database.GetAuthorizationUserRolesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAuthorizedAuditLogsOffset mocks base method.
func (m *MockStore) GetAuthorizedAuditLogsOffset(ctx context.Context, arg database.GetAuditLogsOffsetParams, prepared rbac.PreparedAuthorized) ([]database.GetAuditLogsOffsetRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAuthorizedAuditLogsOffset", ctx, arg, prepared)
	ret0, _ := ret[0].([]database.GetAuditLogsOffsetRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAuthorizedAuditLogsOffset indicates an expected call of GetAuthorizedAuditLogsOffset.
func (mr *MockStoreMockRecorder) GetAuthorizedAuditLogsOffset(ctx, arg, prepared any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthorizedAuditLogsOffset", reflect.TypeOf((*MockStore)(nil).GetAuthorizedAuditLogsOffset), ctx, arg, prepared)
}

// GetAuthorizedChats mocks base method.
func (m *MockStore) GetAuthorizedChats(ctx context.Context, arg database.GetChatsParams, prepared rbac.PreparedAuthorized) ([]database.GetChatsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAuthorizedChats", ctx, arg, prepared)
	ret0, _ := ret[0].([]database.GetChatsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAuthorizedChats indicates an expected call of GetAuthorizedChats.
func (mr *MockStoreMockRecorder) GetAuthorizedChats(ctx, arg, prepared any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthorizedChats", reflect.TypeOf((*MockStore)(nil).GetAuthorizedChats), ctx, arg, prepared)
}

// GetAuthorizedChatsByChatFileID mocks base method.
func (m *MockStore) GetAuthorizedChatsByChatFileID(ctx context.Context, fileID uuid.UUID, prepared rbac.PreparedAuthorized) ([]database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAuthorizedChatsByChatFileID", ctx, fileID, prepared)
	ret0, _ := ret[0].([]database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAuthorizedChatsByChatFileID indicates an expected call of GetAuthorizedChatsByChatFileID.
func (mr *MockStoreMockRecorder) GetAuthorizedChatsByChatFileID(ctx, fileID, prepared any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthorizedChatsByChatFileID", reflect.TypeOf((*MockStore)(nil).GetAuthorizedChatsByChatFileID), ctx, fileID, prepared)
}

// GetAuthorizedConnectionLogsOffset mocks base method.
func (m *MockStore) GetAuthorizedConnectionLogsOffset(ctx context.Context, arg database.GetConnectionLogsOffsetParams, prepared rbac.PreparedAuthorized) ([]database.GetConnectionLogsOffsetRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAuthorizedConnectionLogsOffset", ctx, arg, prepared)
	ret0, _ := ret[0].([]database.GetConnectionLogsOffsetRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAuthorizedConnectionLogsOffset indicates an expected call of GetAuthorizedConnectionLogsOffset.
func (mr *MockStoreMockRecorder) GetAuthorizedConnectionLogsOffset(ctx, arg, prepared any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthorizedConnectionLogsOffset", reflect.TypeOf((*MockStore)(nil).GetAuthorizedConnectionLogsOffset), ctx, arg, prepared)
}

// GetAuthorizedTemplates mocks base method.
func (m *MockStore) GetAuthorizedTemplates(ctx context.Context, arg database.GetTemplatesWithFilterParams, prepared rbac.PreparedAuthorized) ([]database.Template, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAuthorizedTemplates", ctx, arg, prepared)
	ret0, _ := ret[0].([]database.Template)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAuthorizedTemplates indicates an expected call of GetAuthorizedTemplates.
func (mr *MockStoreMockRecorder) GetAuthorizedTemplates(ctx, arg, prepared any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthorizedTemplates", reflect.TypeOf((*MockStore)(nil).GetAuthorizedTemplates), ctx, arg, prepared)
}

// GetAuthorizedUsers mocks base method.
func (m *MockStore) GetAuthorizedUsers(ctx context.Context, arg database.GetUsersParams, prepared rbac.PreparedAuthorized) ([]database.GetUsersRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAuthorizedUsers", ctx, arg, prepared)
	ret0, _ := ret[0].([]database.GetUsersRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAuthorizedUsers indicates an expected call of GetAuthorizedUsers.
func (mr *MockStoreMockRecorder) GetAuthorizedUsers(ctx, arg, prepared any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthorizedUsers", reflect.TypeOf((*MockStore)(nil).GetAuthorizedUsers), ctx, arg, prepared)
}

// GetAuthorizedWorkspaces mocks base method.
func (m *MockStore) GetAuthorizedWorkspaces(ctx context.Context, arg database.GetWorkspacesParams, prepared rbac.PreparedAuthorized) ([]database.GetWorkspacesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAuthorizedWorkspaces", ctx, arg, prepared)
	ret0, _ := ret[0].([]database.GetWorkspacesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAuthorizedWorkspaces indicates an expected call of GetAuthorizedWorkspaces.
func (mr *MockStoreMockRecorder) GetAuthorizedWorkspaces(ctx, arg, prepared any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthorizedWorkspaces", reflect.TypeOf((*MockStore)(nil).GetAuthorizedWorkspaces), ctx, arg, prepared)
}

// GetAuthorizedWorkspacesAndAgentsByOwnerID mocks base method.
func (m *MockStore) GetAuthorizedWorkspacesAndAgentsByOwnerID(ctx context.Context, ownerID uuid.UUID, prepared rbac.PreparedAuthorized) ([]database.GetWorkspacesAndAgentsByOwnerIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAuthorizedWorkspacesAndAgentsByOwnerID", ctx, ownerID, prepared)
	ret0, _ := ret[0].([]database.GetWorkspacesAndAgentsByOwnerIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAuthorizedWorkspacesAndAgentsByOwnerID indicates an expected call of GetAuthorizedWorkspacesAndAgentsByOwnerID.
func (mr *MockStoreMockRecorder) GetAuthorizedWorkspacesAndAgentsByOwnerID(ctx, ownerID, prepared any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthorizedWorkspacesAndAgentsByOwnerID", reflect.TypeOf((*MockStore)(nil).GetAuthorizedWorkspacesAndAgentsByOwnerID), ctx, ownerID, prepared)
}

// GetBoundaryLogByID mocks base method.
func (m *MockStore) GetBoundaryLogByID(ctx context.Context, id uuid.UUID) (database.BoundaryLog, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBoundaryLogByID", ctx, id)
	ret0, _ := ret[0].(database.BoundaryLog)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBoundarySessionByID mocks base method.
func (m *MockStore) GetBoundarySessionByID(ctx context.Context, id uuid.UUID) (database.BoundarySession, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBoundarySessionByID", ctx, id)
	ret0, _ := ret[0].(database.BoundarySession)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatACLByID mocks base method.
func (m *MockStore) GetChatACLByID(ctx context.Context, id uuid.UUID) (database.GetChatACLByIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatACLByID", ctx, id)
	ret0, _ := ret[0].(database.GetChatACLByIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatAdvisorConfig mocks base method.
func (m *MockStore) GetChatAdvisorConfig(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatAdvisorConfig", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatAutoArchiveDays mocks base method.
func (m *MockStore) GetChatAutoArchiveDays(ctx context.Context, defaultAutoArchiveDays int32) (int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatAutoArchiveDays", ctx, defaultAutoArchiveDays)
	ret0, _ := ret[0].(int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatAutoArchiveDays indicates an expected call of GetChatAutoArchiveDays.
func (mr *MockStoreMockRecorder) GetChatAutoArchiveDays(ctx, defaultAutoArchiveDays any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatAutoArchiveDays", reflect.TypeOf((*MockStore)(nil).GetChatAutoArchiveDays), ctx, defaultAutoArchiveDays)
}

// GetChatByID mocks base method.
func (m *MockStore) GetChatByID(ctx context.Context, id uuid.UUID) (database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatByID", ctx, id)
	ret0, _ := ret[0].(database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatByIDForUpdate mocks base method.
func (m *MockStore) GetChatByIDForUpdate(ctx context.Context, id uuid.UUID) (database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatByIDForUpdate", ctx, id)
	ret0, _ := ret[0].(database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatComputerUseProvider mocks base method.
func (m *MockStore) GetChatComputerUseProvider(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatComputerUseProvider", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatCostPerChat mocks base method.
func (m *MockStore) GetChatCostPerChat(ctx context.Context, arg database.GetChatCostPerChatParams) ([]database.GetChatCostPerChatRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatCostPerChat", ctx, arg)
	ret0, _ := ret[0].([]database.GetChatCostPerChatRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatCostPerChat indicates an expected call of GetChatCostPerChat.
func (mr *MockStoreMockRecorder) GetChatCostPerChat(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatCostPerChat", reflect.TypeOf((*MockStore)(nil).GetChatCostPerChat), ctx, arg)
}

// GetChatCostPerModel mocks base method.
func (m *MockStore) GetChatCostPerModel(ctx context.Context, arg database.GetChatCostPerModelParams) ([]database.GetChatCostPerModelRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatCostPerModel", ctx, arg)
	ret0, _ := ret[0].([]database.GetChatCostPerModelRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatCostPerModel indicates an expected call of GetChatCostPerModel.
func (mr *MockStoreMockRecorder) GetChatCostPerModel(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatCostPerModel", reflect.TypeOf((*MockStore)(nil).GetChatCostPerModel), ctx, arg)
}

// GetChatCostPerUser mocks base method.
func (m *MockStore) GetChatCostPerUser(ctx context.Context, arg database.GetChatCostPerUserParams) ([]database.GetChatCostPerUserRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatCostPerUser", ctx, arg)
	ret0, _ := ret[0].([]database.GetChatCostPerUserRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatCostPerUser indicates an expected call of GetChatCostPerUser.
func (mr *MockStoreMockRecorder) GetChatCostPerUser(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatCostPerUser", reflect.TypeOf((*MockStore)(nil).GetChatCostPerUser), ctx, arg)
}

// GetChatCostSummary mocks base method.
func (m *MockStore) GetChatCostSummary(ctx context.Context, arg database.GetChatCostSummaryParams) (database.GetChatCostSummaryRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatCostSummary", ctx, arg)
	ret0, _ := ret[0].(database.GetChatCostSummaryRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatCostSummary indicates an expected call of GetChatCostSummary.
func (mr *MockStoreMockRecorder) GetChatCostSummary(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatCostSummary", reflect.TypeOf((*MockStore)(nil).GetChatCostSummary), ctx, arg)
}

// GetChatDebugLoggingAllowUsers mocks base method.
func (m *MockStore) GetChatDebugLoggingAllowUsers(ctx context.Context) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatDebugLoggingAllowUsers", ctx)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatDebugRetentionDays mocks base method.
func (m *MockStore) GetChatDebugRetentionDays(ctx context.Context, defaultDebugRetentionDays int32) (int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatDebugRetentionDays", ctx, defaultDebugRetentionDays)
	ret0, _ := ret[0].(int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatDebugRetentionDays indicates an expected call of GetChatDebugRetentionDays.
func (mr *MockStoreMockRecorder) GetChatDebugRetentionDays(ctx, defaultDebugRetentionDays any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatDebugRetentionDays", reflect.TypeOf((*MockStore)(nil).GetChatDebugRetentionDays), ctx, defaultDebugRetentionDays)
}

// GetChatDebugRunByID mocks base method.
func (m *MockStore) GetChatDebugRunByID(ctx context.Context, id uuid.UUID) (database.ChatDebugRun, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatDebugRunByID", ctx, id)
	ret0, _ := ret[0].(database.ChatDebugRun)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatDebugRunsByChatID mocks base method.
func (m *MockStore) GetChatDebugRunsByChatID(ctx context.Context, arg database.GetChatDebugRunsByChatIDParams) ([]database.ChatDebugRun, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatDebugRunsByChatID", ctx, arg)
	ret0, _ := ret[0].([]database.ChatDebugRun)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatDebugRunsByChatID indicates an expected call of GetChatDebugRunsByChatID.
func (mr *MockStoreMockRecorder) GetChatDebugRunsByChatID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatDebugRunsByChatID", reflect.TypeOf((*MockStore)(nil).GetChatDebugRunsByChatID), ctx, arg)
}

// GetChatDebugStepsByRunID mocks base method.
func (m *MockStore) GetChatDebugStepsByRunID(ctx context.Context, runID uuid.UUID) ([]database.ChatDebugStep, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatDebugStepsByRunID", ctx, runID)
	ret0, _ := ret[0].([]database.ChatDebugStep)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatDebugStepsByRunID indicates an expected call of GetChatDebugStepsByRunID.
func (mr *MockStoreMockRecorder) GetChatDebugStepsByRunID(ctx, runID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatDebugStepsByRunID", reflect.TypeOf((*MockStore)(nil).GetChatDebugStepsByRunID), ctx, runID)
}

// GetChatDesktopEnabled mocks base method.
func (m *MockStore) GetChatDesktopEnabled(ctx context.Context) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatDesktopEnabled", ctx)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatDiffStatusByChatID mocks base method.
func (m *MockStore) GetChatDiffStatusByChatID(ctx context.Context, chatID uuid.UUID) (database.ChatDiffStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatDiffStatusByChatID", ctx, chatID)
	ret0, _ := ret[0].(database.ChatDiffStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatDiffStatusByChatID indicates an expected call of GetChatDiffStatusByChatID.
func (mr *MockStoreMockRecorder) GetChatDiffStatusByChatID(ctx, chatID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatDiffStatusByChatID", reflect.TypeOf((*MockStore)(nil).GetChatDiffStatusByChatID), ctx, chatID)
}

// GetChatDiffStatusSummary mocks base method.
func (m *MockStore) GetChatDiffStatusSummary(ctx context.Context) (database.GetChatDiffStatusSummaryRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatDiffStatusSummary", ctx)
	ret0, _ := ret[0].(database.GetChatDiffStatusSummaryRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatDiffStatusesByChatIDs mocks base method.
func (m *MockStore) GetChatDiffStatusesByChatIDs(ctx context.Context, chatIds []uuid.UUID) ([]database.ChatDiffStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatDiffStatusesByChatIDs", ctx, chatIds)
	ret0, _ := ret[0].([]database.ChatDiffStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatDiffStatusesByChatIDs indicates an expected call of GetChatDiffStatusesByChatIDs.
func (mr *MockStoreMockRecorder) GetChatDiffStatusesByChatIDs(ctx, chatIds any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatDiffStatusesByChatIDs", reflect.TypeOf((*MockStore)(nil).GetChatDiffStatusesByChatIDs), ctx, chatIds)
}

// GetChatExploreModelOverride mocks base method.
func (m *MockStore) GetChatExploreModelOverride(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatExploreModelOverride", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatFileByID mocks base method.
func (m *MockStore) GetChatFileByID(ctx context.Context, id uuid.UUID) (database.ChatFile, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatFileByID", ctx, id)
	ret0, _ := ret[0].(database.ChatFile)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatFileMetadataByChatID mocks base method.
func (m *MockStore) GetChatFileMetadataByChatID(ctx context.Context, chatID uuid.UUID) ([]database.GetChatFileMetadataByChatIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatFileMetadataByChatID", ctx, chatID)
	ret0, _ := ret[0].([]database.GetChatFileMetadataByChatIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatFileMetadataByChatID indicates an expected call of GetChatFileMetadataByChatID.
func (mr *MockStoreMockRecorder) GetChatFileMetadataByChatID(ctx, chatID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatFileMetadataByChatID", reflect.TypeOf((*MockStore)(nil).GetChatFileMetadataByChatID), ctx, chatID)
}

// GetChatFilesByIDs mocks base method.
func (m *MockStore) GetChatFilesByIDs(ctx context.Context, ids []uuid.UUID) ([]database.ChatFile, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatFilesByIDs", ctx, ids)
	ret0, _ := ret[0].([]database.ChatFile)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatGeneralModelOverride mocks base method.
func (m *MockStore) GetChatGeneralModelOverride(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatGeneralModelOverride", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatIncludeDefaultSystemPrompt mocks base method.
func (m *MockStore) GetChatIncludeDefaultSystemPrompt(ctx context.Context) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatIncludeDefaultSystemPrompt", ctx)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatMessageByID mocks base method.
func (m *MockStore) GetChatMessageByID(ctx context.Context, id int64) (database.ChatMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatMessageByID", ctx, id)
	ret0, _ := ret[0].(database.ChatMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatMessageSummariesPerChat mocks base method.
func (m *MockStore) GetChatMessageSummariesPerChat(ctx context.Context, createdAfter time.Time) ([]database.GetChatMessageSummariesPerChatRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatMessageSummariesPerChat", ctx, createdAfter)
	ret0, _ := ret[0].([]database.GetChatMessageSummariesPerChatRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatMessageSummariesPerChat indicates an expected call of GetChatMessageSummariesPerChat.
func (mr *MockStoreMockRecorder) GetChatMessageSummariesPerChat(ctx, createdAfter any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatMessageSummariesPerChat", reflect.TypeOf((*MockStore)(nil).GetChatMessageSummariesPerChat), ctx, createdAfter)
}

// GetChatMessagesByChatID mocks base method.
func (m *MockStore) GetChatMessagesByChatID(ctx context.Context, arg database.GetChatMessagesByChatIDParams) ([]database.ChatMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatMessagesByChatID", ctx, arg)
	ret0, _ := ret[0].([]database.ChatMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatMessagesByChatID indicates an expected call of GetChatMessagesByChatID.
func (mr *MockStoreMockRecorder) GetChatMessagesByChatID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatMessagesByChatID", reflect.TypeOf((*MockStore)(nil).GetChatMessagesByChatID), ctx, arg)
}

// GetChatMessagesByChatIDAscPaginated mocks base method.
func (m *MockStore) GetChatMessagesByChatIDAscPaginated(ctx context.Context, arg database.GetChatMessagesByChatIDAscPaginatedParams) ([]database.ChatMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatMessagesByChatIDAscPaginated", ctx, arg)
	ret0, _ := ret[0].([]database.ChatMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatMessagesByChatIDAscPaginated indicates an expected call of GetChatMessagesByChatIDAscPaginated.
func (mr *MockStoreMockRecorder) GetChatMessagesByChatIDAscPaginated(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatMessagesByChatIDAscPaginated", reflect.TypeOf((*MockStore)(nil).GetChatMessagesByChatIDAscPaginated), ctx, arg)
}

// GetChatMessagesByChatIDDescPaginated mocks base method.
func (m *MockStore) GetChatMessagesByChatIDDescPaginated(ctx context.Context, arg database.GetChatMessagesByChatIDDescPaginatedParams) ([]database.ChatMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatMessagesByChatIDDescPaginated", ctx, arg)
	ret0, _ := ret[0].([]database.ChatMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatMessagesByChatIDDescPaginated indicates an expected call of GetChatMessagesByChatIDDescPaginated.
func (mr *MockStoreMockRecorder) GetChatMessagesByChatIDDescPaginated(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatMessagesByChatIDDescPaginated", reflect.TypeOf((*MockStore)(nil).GetChatMessagesByChatIDDescPaginated), ctx, arg)
}

// GetChatMessagesForPromptByChatID mocks base method.
func (m *MockStore) GetChatMessagesForPromptByChatID(ctx context.Context, chatID uuid.UUID) ([]database.ChatMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatMessagesForPromptByChatID", ctx, chatID)
	ret0, _ := ret[0].([]database.ChatMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatMessagesForPromptByChatID indicates an expected call of GetChatMessagesForPromptByChatID.
func (mr *MockStoreMockRecorder) GetChatMessagesForPromptByChatID(ctx, chatID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatMessagesForPromptByChatID", reflect.TypeOf((*MockStore)(nil).GetChatMessagesForPromptByChatID), ctx, chatID)
}

// GetChatModelConfigByID mocks base method.
func (m *MockStore) GetChatModelConfigByID(ctx context.Context, id uuid.UUID) (database.ChatModelConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatModelConfigByID", ctx, id)
	ret0, _ := ret[0].(database.ChatModelConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatModelConfigs mocks base method.
func (m *MockStore) GetChatModelConfigs(ctx context.Context) ([]database.ChatModelConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatModelConfigs", ctx)
	ret0, _ := ret[0].([]database.ChatModelConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatModelConfigsForTelemetry mocks base method.
func (m *MockStore) GetChatModelConfigsForTelemetry(ctx context.Context) ([]database.GetChatModelConfigsForTelemetryRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatModelConfigsForTelemetry", ctx)
	ret0, _ := ret[0].([]database.GetChatModelConfigsForTelemetryRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatPersonalModelOverridesEnabled mocks base method.
func (m *MockStore) GetChatPersonalModelOverridesEnabled(ctx context.Context) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatPersonalModelOverridesEnabled", ctx)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatPlanModeInstructions mocks base method.
func (m *MockStore) GetChatPlanModeInstructions(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatPlanModeInstructions", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatQueuedMessages mocks base method.
func (m *MockStore) GetChatQueuedMessages(ctx context.Context, chatID uuid.UUID) ([]database.ChatQueuedMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatQueuedMessages", ctx, chatID)
	ret0, _ := ret[0].([]database.ChatQueuedMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatQueuedMessages indicates an expected call of GetChatQueuedMessages.
func (mr *MockStoreMockRecorder) GetChatQueuedMessages(ctx, chatID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatQueuedMessages", reflect.TypeOf((*MockStore)(nil).GetChatQueuedMessages), ctx, chatID)
}

// GetChatRetentionDays mocks base method.
func (m *MockStore) GetChatRetentionDays(ctx context.Context) (int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatRetentionDays", ctx)
	ret0, _ := ret[0].(int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatSystemPrompt mocks base method.
func (m *MockStore) GetChatSystemPrompt(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatSystemPrompt", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatSystemPromptConfig mocks base method.
func (m *MockStore) GetChatSystemPromptConfig(ctx context.Context) (database.GetChatSystemPromptConfigRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatSystemPromptConfig", ctx)
	ret0, _ := ret[0].(database.GetChatSystemPromptConfigRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatTemplateAllowlist mocks base method.
func (m *MockStore) GetChatTemplateAllowlist(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatTemplateAllowlist", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatTitleGenerationModelOverride mocks base method.
func (m *MockStore) GetChatTitleGenerationModelOverride(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatTitleGenerationModelOverride", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatUsageLimitConfig mocks base method.
func (m *MockStore) GetChatUsageLimitConfig(ctx context.Context) (database.ChatUsageLimitConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatUsageLimitConfig", ctx)
	ret0, _ := ret[0].(database.ChatUsageLimitConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatUsageLimitGroupOverride mocks base method.
func (m *MockStore) GetChatUsageLimitGroupOverride(ctx context.Context, groupID uuid.UUID) (database.GetChatUsageLimitGroupOverrideRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatUsageLimitGroupOverride", ctx, groupID)
	ret0, _ := ret[0].(database.GetChatUsageLimitGroupOverrideRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatUsageLimitGroupOverride indicates an expected call of GetChatUsageLimitGroupOverride.
func (mr *MockStoreMockRecorder) GetChatUsageLimitGroupOverride(ctx, groupID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatUsageLimitGroupOverride", reflect.TypeOf((*MockStore)(nil).GetChatUsageLimitGroupOverride), ctx, groupID)
}

// GetChatUsageLimitUserOverride mocks base method.
func (m *MockStore) GetChatUsageLimitUserOverride(ctx context.Context, userID uuid.UUID) (database.GetChatUsageLimitUserOverrideRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatUsageLimitUserOverride", ctx, userID)
	ret0, _ := ret[0].(database.GetChatUsageLimitUserOverrideRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatUserPromptsByChatID mocks base method.
func (m *MockStore) GetChatUserPromptsByChatID(ctx context.Context, arg database.GetChatUserPromptsByChatIDParams) ([]database.GetChatUserPromptsByChatIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatUserPromptsByChatID", ctx, arg)
	ret0, _ := ret[0].([]database.GetChatUserPromptsByChatIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatUserPromptsByChatID indicates an expected call of GetChatUserPromptsByChatID.
func (mr *MockStoreMockRecorder) GetChatUserPromptsByChatID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatUserPromptsByChatID", reflect.TypeOf((*MockStore)(nil).GetChatUserPromptsByChatID), ctx, arg)
}

// GetChatWorkspaceTTL mocks base method.
func (m *MockStore) GetChatWorkspaceTTL(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatWorkspaceTTL", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChats mocks base method.
func (m *MockStore) GetChats(ctx context.Context, arg database.GetChatsParams) ([]database.GetChatsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChats", ctx, arg)
	ret0, _ := ret[0].([]database.GetChatsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChats indicates an expected call of GetChats.
func (mr *MockStoreMockRecorder) GetChats(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChats", reflect.TypeOf((*MockStore)(nil).GetChats), ctx, arg)
}

// GetChatsByChatFileID mocks base method.
func (m *MockStore) GetChatsByChatFileID(ctx context.Context, fileID uuid.UUID) ([]database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatsByChatFileID", ctx, fileID)
	ret0, _ := ret[0].([]database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatsByChatFileID indicates an expected call of GetChatsByChatFileID.
func (mr *MockStoreMockRecorder) GetChatsByChatFileID(ctx, fileID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatsByChatFileID", reflect.TypeOf((*MockStore)(nil).GetChatsByChatFileID), ctx, fileID)
}

// GetChatsByWorkspaceIDs mocks base method.
func (m *MockStore) GetChatsByWorkspaceIDs(ctx context.Context, ids []uuid.UUID) ([]database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatsByWorkspaceIDs", ctx, ids)
	ret0, _ := ret[0].([]database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetChatsUpdatedAfter mocks base method.
func (m *MockStore) GetChatsUpdatedAfter(ctx context.Context, updatedAfter time.Time) ([]database.GetChatsUpdatedAfterRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChatsUpdatedAfter", ctx, updatedAfter)
	ret0, _ := ret[0].([]database.GetChatsUpdatedAfterRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChatsUpdatedAfter indicates an expected call of GetChatsUpdatedAfter.
func (mr *MockStoreMockRecorder) GetChatsUpdatedAfter(ctx, updatedAfter any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChatsUpdatedAfter", reflect.TypeOf((*MockStore)(nil).GetChatsUpdatedAfter), ctx, updatedAfter)
}

// GetChildChatsByParentIDs mocks base method.
func (m *MockStore) GetChildChatsByParentIDs(ctx context.Context, arg database.GetChildChatsByParentIDsParams) ([]database.GetChildChatsByParentIDsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChildChatsByParentIDs", ctx, arg)
	ret0, _ := ret[0].([]database.GetChildChatsByParentIDsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetChildChatsByParentIDs indicates an expected call of GetChildChatsByParentIDs.
func (mr *MockStoreMockRecorder) GetChildChatsByParentIDs(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChildChatsByParentIDs", reflect.TypeOf((*MockStore)(nil).GetChildChatsByParentIDs), ctx, arg)
}

// GetConnectionLogsOffset mocks base method.
func (m *MockStore) GetConnectionLogsOffset(ctx context.Context, arg database.GetConnectionLogsOffsetParams) ([]database.GetConnectionLogsOffsetRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConnectionLogsOffset", ctx, arg)
	ret0, _ := ret[0].([]database.GetConnectionLogsOffsetRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetConnectionLogsOffset indicates an expected call of GetConnectionLogsOffset.
func (mr *MockStoreMockRecorder) GetConnectionLogsOffset(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConnectionLogsOffset", reflect.TypeOf((*MockStore)(nil).GetConnectionLogsOffset), ctx, arg)
}

// GetCryptoKeyByFeatureAndSequence mocks base method.
func (m *MockStore) GetCryptoKeyByFeatureAndSequence(ctx context.Context, arg database.GetCryptoKeyByFeatureAndSequenceParams) (database.CryptoKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCryptoKeyByFeatureAndSequence", ctx, arg)
	ret0, _ := ret[0].(database.CryptoKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCryptoKeyByFeatureAndSequence indicates an expected call of GetCryptoKeyByFeatureAndSequence.
func (mr *MockStoreMockRecorder) GetCryptoKeyByFeatureAndSequence(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCryptoKeyByFeatureAndSequence", reflect.TypeOf((*MockStore)(nil).GetCryptoKeyByFeatureAndSequence), ctx, arg)
}

// GetCryptoKeys mocks base method.
func (m *MockStore) GetCryptoKeys(ctx context.Context) ([]database.CryptoKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCryptoKeys", ctx)
	ret0, _ := ret[0].([]database.CryptoKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetCryptoKeysByFeature mocks base method.
func (m *MockStore) GetCryptoKeysByFeature(ctx context.Context, feature database.CryptoKeyFeature) ([]database.CryptoKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCryptoKeysByFeature", ctx, feature)
	ret0, _ := ret[0].([]database.CryptoKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCryptoKeysByFeature indicates an expected call of GetCryptoKeysByFeature.
func (mr *MockStoreMockRecorder) GetCryptoKeysByFeature(ctx, feature any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCryptoKeysByFeature", reflect.TypeOf((*MockStore)(nil).GetCryptoKeysByFeature), ctx, feature)
}

// GetDBCryptKeys mocks base method.
func (m *MockStore) GetDBCryptKeys(ctx context.Context) ([]database.DBCryptKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDBCryptKeys", ctx)
	ret0, _ := ret[0].([]database.DBCryptKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDERPMeshKey mocks base method.
func (m *MockStore) GetDERPMeshKey(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDERPMeshKey", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDefaultChatModelConfig mocks base method.
func (m *MockStore) GetDefaultChatModelConfig(ctx context.Context) (database.ChatModelConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefaultChatModelConfig", ctx)
	ret0, _ := ret[0].(database.ChatModelConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDefaultOrganization mocks base method.
func (m *MockStore) GetDefaultOrganization(ctx context.Context) (database.Organization, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefaultOrganization", ctx)
	ret0, _ := ret[0].(database.Organization)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDefaultProxyConfig mocks base method.
func (m *MockStore) GetDefaultProxyConfig(ctx context.Context) (database.GetDefaultProxyConfigRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDefaultProxyConfig", ctx)
	ret0, _ := ret[0].(database.GetDefaultProxyConfigRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDeploymentID mocks base method.
func (m *MockStore) GetDeploymentID(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeploymentID", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDeploymentWorkspaceAgentStats mocks base method.
func (m *MockStore) GetDeploymentWorkspaceAgentStats(ctx context.Context, createdAt time.Time) (database.GetDeploymentWorkspaceAgentStatsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeploymentWorkspaceAgentStats", ctx, createdAt)
	ret0, _ := ret[0].(database.GetDeploymentWorkspaceAgentStatsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDeploymentWorkspaceAgentStats indicates an expected call of GetDeploymentWorkspaceAgentStats.
func (mr *MockStoreMockRecorder) GetDeploymentWorkspaceAgentStats(ctx, createdAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeploymentWorkspaceAgentStats", reflect.TypeOf((*MockStore)(nil).GetDeploymentWorkspaceAgentStats), ctx, createdAt)
}

// GetDeploymentWorkspaceAgentUsageStats mocks base method.
func (m *MockStore) GetDeploymentWorkspaceAgentUsageStats(ctx context.Context, createdAt time.Time) (database.GetDeploymentWorkspaceAgentUsageStatsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeploymentWorkspaceAgentUsageStats", ctx, createdAt)
	ret0, _ := ret[0].(database.GetDeploymentWorkspaceAgentUsageStatsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDeploymentWorkspaceAgentUsageStats indicates an expected call of GetDeploymentWorkspaceAgentUsageStats.
func (mr *MockStoreMockRecorder) GetDeploymentWorkspaceAgentUsageStats(ctx, createdAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeploymentWorkspaceAgentUsageStats", reflect.TypeOf((*MockStore)(nil).GetDeploymentWorkspaceAgentUsageStats), ctx, createdAt)
}

// GetDeploymentWorkspaceStats mocks base method.
func (m *MockStore) GetDeploymentWorkspaceStats(ctx context.Context) (database.GetDeploymentWorkspaceStatsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeploymentWorkspaceStats", ctx)
	ret0, _ := ret[0].(database.GetDeploymentWorkspaceStatsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetEligibleProvisionerDaemonsByProvisionerJobIDs mocks base method.
func (m *MockStore) GetEligibleProvisionerDaemonsByProvisionerJobIDs(ctx context.Context, provisionerJobIds []uuid.UUID) ([]database.GetEligibleProvisionerDaemonsByProvisionerJobIDsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEligibleProvisionerDaemonsByProvisionerJobIDs", ctx, provisionerJobIds)
	ret0, _ := ret[0].([]database.GetEligibleProvisionerDaemonsByProvisionerJobIDsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetEligibleProvisionerDaemonsByProvisionerJobIDs indicates an expected call of GetEligibleProvisionerDaemonsByProvisionerJobIDs.
func (mr *MockStoreMockRecorder) GetEligibleProvisionerDaemonsByProvisionerJobIDs(ctx, provisionerJobIds any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEligibleProvisionerDaemonsByProvisionerJobIDs", reflect.TypeOf((*MockStore)(nil).GetEligibleProvisionerDaemonsByProvisionerJobIDs), ctx, provisionerJobIds)
}

// GetEnabledChatModelConfigByID mocks base method.
func (m *MockStore) GetEnabledChatModelConfigByID(ctx context.Context, id uuid.UUID) (database.ChatModelConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEnabledChatModelConfigByID", ctx, id)
	ret0, _ := ret[0].(database.ChatModelConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetEnabledChatModelConfigs mocks base method.
func (m *MockStore) GetEnabledChatModelConfigs(ctx context.Context) ([]database.ChatModelConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEnabledChatModelConfigs", ctx)
	ret0, _ := ret[0].([]database.ChatModelConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetEnabledMCPServerConfigs mocks base method.
func (m *MockStore) GetEnabledMCPServerConfigs(ctx context.Context) ([]database.MCPServerConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEnabledMCPServerConfigs", ctx)
	ret0, _ := ret[0].([]database.MCPServerConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetExternalAuthLink mocks base method.
func (m *MockStore) GetExternalAuthLink(ctx context.Context, arg database.GetExternalAuthLinkParams) (database.ExternalAuthLink, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExternalAuthLink", ctx, arg)
	ret0, _ := ret[0].(database.ExternalAuthLink)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetExternalAuthLink indicates an expected call of GetExternalAuthLink.
func (mr *MockStoreMockRecorder) GetExternalAuthLink(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExternalAuthLink", reflect.TypeOf((*MockStore)(nil).GetExternalAuthLink), ctx, arg)
}

// GetExternalAuthLinksByUserID mocks base method.
func (m *MockStore) GetExternalAuthLinksByUserID(ctx context.Context, userID uuid.UUID) ([]database.ExternalAuthLink, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExternalAuthLinksByUserID", ctx, userID)
	ret0, _ := ret[0].([]database.ExternalAuthLink)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetFailedWorkspaceBuildsByTemplateID mocks base method.
func (m *MockStore) GetFailedWorkspaceBuildsByTemplateID(ctx context.Context, arg database.GetFailedWorkspaceBuildsByTemplateIDParams) ([]database.GetFailedWorkspaceBuildsByTemplateIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFailedWorkspaceBuildsByTemplateID", ctx, arg)
	ret0, _ := ret[0].([]database.GetFailedWorkspaceBuildsByTemplateIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFailedWorkspaceBuildsByTemplateID indicates an expected call of GetFailedWorkspaceBuildsByTemplateID.
func (mr *MockStoreMockRecorder) GetFailedWorkspaceBuildsByTemplateID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFailedWorkspaceBuildsByTemplateID", reflect.TypeOf((*MockStore)(nil).GetFailedWorkspaceBuildsByTemplateID), ctx, arg)
}

// GetFileByHashAndCreator mocks base method.
func (m *MockStore) GetFileByHashAndCreator(ctx context.Context, arg database.GetFileByHashAndCreatorParams) (database.File, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFileByHashAndCreator", ctx, arg)
	ret0, _ := ret[0].(database.File)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFileByHashAndCreator indicates an expected call of GetFileByHashAndCreator.
func (mr *MockStoreMockRecorder) GetFileByHashAndCreator(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFileByHashAndCreator", reflect.TypeOf((*MockStore)(nil).GetFileByHashAndCreator), ctx, arg)
}

// GetFileByID mocks base method.
func (m *MockStore) GetFileByID(ctx context.Context, id uuid.UUID) (database.File, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFileByID", ctx, id)
	ret0, _ := ret[0].(database.File)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetFileTemplates mocks base method.
func (m *MockStore) GetFileTemplates(ctx context.Context, fileID uuid.UUID) ([]database.GetFileTemplatesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFileTemplates", ctx, fileID)
	ret0, _ := ret[0].([]database.GetFileTemplatesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFileTemplates indicates an expected call of GetFileTemplates.
func (mr *MockStoreMockRecorder) GetFileTemplates(ctx, fileID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFileTemplates", reflect.TypeOf((*MockStore)(nil).GetFileTemplates), ctx, fileID)
}

// GetFilteredInboxNotificationsByUserID mocks base method.
func (m *MockStore) GetFilteredInboxNotificationsByUserID(ctx context.Context, arg database.GetFilteredInboxNotificationsByUserIDParams) ([]database.InboxNotification, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFilteredInboxNotificationsByUserID", ctx, arg)
	ret0, _ := ret[0].([]database.InboxNotification)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFilteredInboxNotificationsByUserID indicates an expected call of GetFilteredInboxNotificationsByUserID.
func (mr *MockStoreMockRecorder) GetFilteredInboxNotificationsByUserID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFilteredInboxNotificationsByUserID", reflect.TypeOf((*MockStore)(nil).GetFilteredInboxNotificationsByUserID), ctx, arg)
}

// GetForcedMCPServerConfigs mocks base method.
func (m *MockStore) GetForcedMCPServerConfigs(ctx context.Context) ([]database.MCPServerConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetForcedMCPServerConfigs", ctx)
	ret0, _ := ret[0].([]database.MCPServerConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetGitSSHKey mocks base method.
func (m *MockStore) GetGitSSHKey(ctx context.Context, userID uuid.UUID) (database.GitSSHKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGitSSHKey", ctx, userID)
	ret0, _ := ret[0].(database.GitSSHKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetGroupAIBudget mocks base method.
func (m *MockStore) GetGroupAIBudget(ctx context.Context, groupID uuid.UUID) (database.GroupAiBudget, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupAIBudget", ctx, groupID)
	ret0, _ := ret[0].(database.GroupAiBudget)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGroupAIBudget indicates an expected call of GetGroupAIBudget.
func (mr *MockStoreMockRecorder) GetGroupAIBudget(ctx, groupID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupAIBudget", reflect.TypeOf((*MockStore)(nil).GetGroupAIBudget), ctx, groupID)
}

// GetGroupByID mocks base method.
func (m *MockStore) GetGroupByID(ctx context.Context, id uuid.UUID) (database.Group, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupByID", ctx, id)
	ret0, _ := ret[0].(database.Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetGroupByOrgAndName mocks base method.
func (m *MockStore) GetGroupByOrgAndName(ctx context.Context, arg database.GetGroupByOrgAndNameParams) (database.Group, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupByOrgAndName", ctx, arg)
	ret0, _ := ret[0].(database.Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGroupByOrgAndName indicates an expected call of GetGroupByOrgAndName.
func (mr *MockStoreMockRecorder) GetGroupByOrgAndName(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupByOrgAndName", reflect.TypeOf((*MockStore)(nil).GetGroupByOrgAndName), ctx, arg)
}

// GetGroupMembers mocks base method.
func (m *MockStore) GetGroupMembers(ctx context.Context, includeSystem bool) ([]database.GroupMember, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupMembers", ctx, includeSystem)
	ret0, _ := ret[0].([]database.GroupMember)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGroupMembers indicates an expected call of GetGroupMembers.
func (mr *MockStoreMockRecorder) GetGroupMembers(ctx, includeSystem any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupMembers", reflect.TypeOf((*MockStore)(nil).GetGroupMembers), ctx, includeSystem)
}

// GetGroupMembersByGroupID mocks base method.
func (m *MockStore) GetGroupMembersByGroupID(ctx context.Context, arg database.GetGroupMembersByGroupIDParams) ([]database.GroupMember, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupMembersByGroupID", ctx, arg)
	ret0, _ := ret[0].([]database.GroupMember)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGroupMembersByGroupID indicates an expected call of GetGroupMembersByGroupID.
func (mr *MockStoreMockRecorder) GetGroupMembersByGroupID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupMembersByGroupID", reflect.TypeOf((*MockStore)(nil).GetGroupMembersByGroupID), ctx, arg)
}

// GetGroupMembersByGroupIDPaginated mocks base method.
func (m *MockStore) GetGroupMembersByGroupIDPaginated(ctx context.Context, arg database.GetGroupMembersByGroupIDPaginatedParams) ([]database.GetGroupMembersByGroupIDPaginatedRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupMembersByGroupIDPaginated", ctx, arg)
	ret0, _ := ret[0].([]database.GetGroupMembersByGroupIDPaginatedRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGroupMembersByGroupIDPaginated indicates an expected call of GetGroupMembersByGroupIDPaginated.
func (mr *MockStoreMockRecorder) GetGroupMembersByGroupIDPaginated(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupMembersByGroupIDPaginated", reflect.TypeOf((*MockStore)(nil).GetGroupMembersByGroupIDPaginated), ctx, arg)
}

// GetGroupMembersCountByGroupID mocks base method.
func (m *MockStore) GetGroupMembersCountByGroupID(ctx context.Context, arg database.GetGroupMembersCountByGroupIDParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupMembersCountByGroupID", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGroupMembersCountByGroupID indicates an expected call of GetGroupMembersCountByGroupID.
func (mr *MockStoreMockRecorder) GetGroupMembersCountByGroupID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupMembersCountByGroupID", reflect.TypeOf((*MockStore)(nil).GetGroupMembersCountByGroupID), ctx, arg)
}

// GetGroupMembersCountByGroupIDs mocks base method.
func (m *MockStore) GetGroupMembersCountByGroupIDs(ctx context.Context, arg database.GetGroupMembersCountByGroupIDsParams) ([]database.GetGroupMembersCountByGroupIDsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupMembersCountByGroupIDs", ctx, arg)
	ret0, _ := ret[0].([]database.GetGroupMembersCountByGroupIDsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGroupMembersCountByGroupIDs indicates an expected call of GetGroupMembersCountByGroupIDs.
func (mr *MockStoreMockRecorder) GetGroupMembersCountByGroupIDs(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupMembersCountByGroupIDs", reflect.TypeOf((*MockStore)(nil).GetGroupMembersCountByGroupIDs), ctx, arg)
}

// GetGroups mocks base method.
func (m *MockStore) GetGroups(ctx context.Context, arg database.GetGroupsParams) ([]database.GetGroupsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroups", ctx, arg)
	ret0, _ := ret[0].([]database.GetGroupsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGroups indicates an expected call of GetGroups.
func (mr *MockStoreMockRecorder) GetGroups(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroups", reflect.TypeOf((*MockStore)(nil).GetGroups), ctx, arg)
}

// GetHealthSettings mocks base method.
func (m *MockStore) GetHealthSettings(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHealthSettings", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetInboxNotificationByID mocks base method.
func (m *MockStore) GetInboxNotificationByID(ctx context.Context, id uuid.UUID) (database.InboxNotification, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInboxNotificationByID", ctx, id)
	ret0, _ := ret[0].(database.InboxNotification)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetInboxNotificationsByUserID mocks base method.
func (m *MockStore) GetInboxNotificationsByUserID(ctx context.Context, arg database.GetInboxNotificationsByUserIDParams) ([]database.InboxNotification, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInboxNotificationsByUserID", ctx, arg)
	ret0, _ := ret[0].([]database.InboxNotification)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInboxNotificationsByUserID indicates an expected call of GetInboxNotificationsByUserID.
func (mr *MockStoreMockRecorder) GetInboxNotificationsByUserID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInboxNotificationsByUserID", reflect.TypeOf((*MockStore)(nil).GetInboxNotificationsByUserID), ctx, arg)
}

// GetLastChatMessageByRole mocks base method.
func (m *MockStore) GetLastChatMessageByRole(ctx context.Context, arg database.GetLastChatMessageByRoleParams) (database.ChatMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLastChatMessageByRole", ctx, arg)
	ret0, _ := ret[0].(database.ChatMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLastChatMessageByRole indicates an expected call of GetLastChatMessageByRole.
func (mr *MockStoreMockRecorder) GetLastChatMessageByRole(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastChatMessageByRole", reflect.TypeOf((*MockStore)(nil).GetLastChatMessageByRole), ctx, arg)
}

// GetLastUpdateCheck mocks base method.
func (m *MockStore) GetLastUpdateCheck(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLastUpdateCheck", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetLatestCryptoKeyByFeature mocks base method.
func (m *MockStore) GetLatestCryptoKeyByFeature(ctx context.Context, feature database.CryptoKeyFeature) (database.CryptoKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestCryptoKeyByFeature", ctx, feature)
	ret0, _ := ret[0].(database.CryptoKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLatestCryptoKeyByFeature indicates an expected call of GetLatestCryptoKeyByFeature.
func (mr *MockStoreMockRecorder) GetLatestCryptoKeyByFeature(ctx, feature any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestCryptoKeyByFeature", reflect.TypeOf((*MockStore)(nil).GetLatestCryptoKeyByFeature), ctx, feature)
}

// GetLatestWorkspaceAppStatusByAppID mocks base method.
func (m *MockStore) GetLatestWorkspaceAppStatusByAppID(ctx context.Context, appID uuid.UUID) (database.WorkspaceAppStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestWorkspaceAppStatusByAppID", ctx, appID)
	ret0, _ := ret[0].(database.WorkspaceAppStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLatestWorkspaceAppStatusByAppID indicates an expected call of GetLatestWorkspaceAppStatusByAppID.
func (mr *MockStoreMockRecorder) GetLatestWorkspaceAppStatusByAppID(ctx, appID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestWorkspaceAppStatusByAppID", reflect.TypeOf((*MockStore)(nil).GetLatestWorkspaceAppStatusByAppID), ctx, appID)
}

// GetLatestWorkspaceAppStatusesByWorkspaceIDs mocks base method.
func (m *MockStore) GetLatestWorkspaceAppStatusesByWorkspaceIDs(ctx context.Context, ids []uuid.UUID) ([]database.WorkspaceAppStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestWorkspaceAppStatusesByWorkspaceIDs", ctx, ids)
	ret0, _ := ret[0].([]database.WorkspaceAppStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetLatestWorkspaceBuildByWorkspaceID mocks base method.
func (m *MockStore) GetLatestWorkspaceBuildByWorkspaceID(ctx context.Context, workspaceID uuid.UUID) (database.WorkspaceBuild, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestWorkspaceBuildByWorkspaceID", ctx, workspaceID)
	ret0, _ := ret[0].(database.WorkspaceBuild)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLatestWorkspaceBuildByWorkspaceID indicates an expected call of GetLatestWorkspaceBuildByWorkspaceID.
func (mr *MockStoreMockRecorder) GetLatestWorkspaceBuildByWorkspaceID(ctx, workspaceID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestWorkspaceBuildByWorkspaceID", reflect.TypeOf((*MockStore)(nil).GetLatestWorkspaceBuildByWorkspaceID), ctx, workspaceID)
}

// GetLatestWorkspaceBuildWithStatusByWorkspaceID mocks base method.
func (m *MockStore) GetLatestWorkspaceBuildWithStatusByWorkspaceID(ctx context.Context, workspaceID uuid.UUID) (database.GetLatestWorkspaceBuildWithStatusByWorkspaceIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestWorkspaceBuildWithStatusByWorkspaceID", ctx, workspaceID)
	ret0, _ := ret[0].(database.GetLatestWorkspaceBuildWithStatusByWorkspaceIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLatestWorkspaceBuildWithStatusByWorkspaceID indicates an expected call of GetLatestWorkspaceBuildWithStatusByWorkspaceID.
func (mr *MockStoreMockRecorder) GetLatestWorkspaceBuildWithStatusByWorkspaceID(ctx, workspaceID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestWorkspaceBuildWithStatusByWorkspaceID", reflect.TypeOf((*MockStore)(nil).GetLatestWorkspaceBuildWithStatusByWorkspaceID), ctx, workspaceID)
}

// GetLatestWorkspaceBuildsByWorkspaceIDs mocks base method.
func (m *MockStore) GetLatestWorkspaceBuildsByWorkspaceIDs(ctx context.Context, ids []uuid.UUID) ([]database.WorkspaceBuild, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestWorkspaceBuildsByWorkspaceIDs", ctx, ids)
	ret0, _ := ret[0].([]database.WorkspaceBuild)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetLicenseByID mocks base method.
func (m *MockStore) GetLicenseByID(ctx context.Context, id int32) (database.License, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLicenseByID", ctx, id)
	ret0, _ := ret[0].(database.License)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetLicenses mocks base method.
func (m *MockStore) GetLicenses(ctx context.Context) ([]database.License, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLicenses", ctx)
	ret0, _ := ret[0].([]database.License)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetLogoURL mocks base method.
func (m *MockStore) GetLogoURL(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogoURL", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetMCPServerConfigByID mocks base method.
func (m *MockStore) GetMCPServerConfigByID(ctx context.Context, id uuid.UUID) (database.MCPServerConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMCPServerConfigByID", ctx, id)
	ret0, _ := ret[0].(database.MCPServerConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetMCPServerConfigBySlug mocks base method.
func (m *MockStore) GetMCPServerConfigBySlug(ctx context.Context, slug string) (database.MCPServerConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMCPServerConfigBySlug", ctx, slug)
	ret0, _ := ret[0].(database.MCPServerConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMCPServerConfigBySlug indicates an expected call of GetMCPServerConfigBySlug.
func (mr *MockStoreMockRecorder) GetMCPServerConfigBySlug(ctx, slug any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMCPServerConfigBySlug", reflect.TypeOf((*MockStore)(nil).GetMCPServerConfigBySlug), ctx, slug)
}

// GetMCPServerConfigs mocks base method.
func (m *MockStore) GetMCPServerConfigs(ctx context.Context) ([]database.MCPServerConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMCPServerConfigs", ctx)
	ret0, _ := ret[0].([]database.MCPServerConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetMCPServerConfigsByIDs mocks base method.
func (m *MockStore) GetMCPServerConfigsByIDs(ctx context.Context, ids []uuid.UUID) ([]database.MCPServerConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMCPServerConfigsByIDs", ctx, ids)
	ret0, _ := ret[0].([]database.MCPServerConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetMCPServerUserToken mocks base method.
func (m *MockStore) GetMCPServerUserToken(ctx context.Context, arg database.GetMCPServerUserTokenParams) (database.MCPServerUserToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMCPServerUserToken", ctx, arg)
	ret0, _ := ret[0].(database.MCPServerUserToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMCPServerUserToken indicates an expected call of GetMCPServerUserToken.
func (mr *MockStoreMockRecorder) GetMCPServerUserToken(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMCPServerUserToken", reflect.TypeOf((*MockStore)(nil).GetMCPServerUserToken), ctx, arg)
}

// GetMCPServerUserTokensByUserID mocks base method.
func (m *MockStore) GetMCPServerUserTokensByUserID(ctx context.Context, userID uuid.UUID) ([]database.MCPServerUserToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMCPServerUserTokensByUserID", ctx, userID)
	ret0, _ := ret[0].([]database.MCPServerUserToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNotificationMessagesByStatus mocks base method.
func (m *MockStore) GetNotificationMessagesByStatus(ctx context.Context, arg database.GetNotificationMessagesByStatusParams) ([]database.NotificationMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNotificationMessagesByStatus", ctx, arg)
	ret0, _ := ret[0].([]database.NotificationMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNotificationMessagesByStatus indicates an expected call of GetNotificationMessagesByStatus.
func (mr *MockStoreMockRecorder) GetNotificationMessagesByStatus(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNotificationMessagesByStatus", reflect.TypeOf((*MockStore)(nil).GetNotificationMessagesByStatus), ctx, arg)
}

// GetNotificationReportGeneratorLogByTemplate mocks base method.
func (m *MockStore) GetNotificationReportGeneratorLogByTemplate(ctx context.Context, templateID uuid.UUID) (database.NotificationReportGeneratorLog, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNotificationReportGeneratorLogByTemplate", ctx, templateID)
	ret0, _ := ret[0].(database.NotificationReportGeneratorLog)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNotificationReportGeneratorLogByTemplate indicates an expected call of GetNotificationReportGeneratorLogByTemplate.
func (mr *MockStoreMockRecorder) GetNotificationReportGeneratorLogByTemplate(ctx, templateID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNotificationReportGeneratorLogByTemplate", reflect.TypeOf((*MockStore)(nil).GetNotificationReportGeneratorLogByTemplate), ctx, templateID)
}

// GetNotificationTemplateByID mocks base method.
func (m *MockStore) GetNotificationTemplateByID(ctx context.Context, id uuid.UUID) (database.NotificationTemplate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNotificationTemplateByID", ctx, id)
	ret0, _ := ret[0].(database.NotificationTemplate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNotificationTemplatesByKind mocks base method.
func (m *MockStore) GetNotificationTemplatesByKind(ctx context.Context, kind database.NotificationTemplateKind) ([]database.NotificationTemplate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNotificationTemplatesByKind", ctx, kind)
	ret0, _ := ret[0].([]database.NotificationTemplate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNotificationTemplatesByKind indicates an expected call of GetNotificationTemplatesByKind.
func (mr *MockStoreMockRecorder) GetNotificationTemplatesByKind(ctx, kind any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNotificationTemplatesByKind", reflect.TypeOf((*MockStore)(nil).GetNotificationTemplatesByKind), ctx, kind)
}

// GetNotificationsSettings mocks base method.
func (m *MockStore) GetNotificationsSettings(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNotificationsSettings", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetOAuth2GithubDefaultEligible mocks base method.
func (m *MockStore) GetOAuth2GithubDefaultEligible(ctx context.Context) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOAuth2GithubDefaultEligible", ctx)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetOAuth2ProviderAppByClientID mocks base method.
func (m *MockStore) GetOAuth2ProviderAppByClientID(ctx context.Context, id uuid.UUID) (database.OAuth2ProviderApp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOAuth2ProviderAppByClientID", ctx, id)
	ret0, _ := ret[0].(database.OAuth2ProviderApp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetOAuth2ProviderAppByID mocks base method.
func (m *MockStore) GetOAuth2ProviderAppByID(ctx context.Context, id uuid.UUID) (database.OAuth2ProviderApp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOAuth2ProviderAppByID", ctx, id)
	ret0, _ := ret[0].(database.OAuth2ProviderApp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetOAuth2ProviderAppCodeByID mocks base method.
func (m *MockStore) GetOAuth2ProviderAppCodeByID(ctx context.Context, id uuid.UUID) (database.OAuth2ProviderAppCode, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOAuth2ProviderAppCodeByID", ctx, id)
	ret0, _ := ret[0].(database.OAuth2ProviderAppCode)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetOAuth2ProviderAppCodeByPrefix mocks base method.
func (m *MockStore) GetOAuth2ProviderAppCodeByPrefix(ctx context.Context, secretPrefix []byte) (database.OAuth2ProviderAppCode, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOAuth2ProviderAppCodeByPrefix", ctx, secretPrefix)
	ret0, _ := ret[0].(database.OAuth2ProviderAppCode)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOAuth2ProviderAppCodeByPrefix indicates an expected call of GetOAuth2ProviderAppCodeByPrefix.
func (mr *MockStoreMockRecorder) GetOAuth2ProviderAppCodeByPrefix(ctx, secretPrefix any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOAuth2ProviderAppCodeByPrefix", reflect.TypeOf((*MockStore)(nil).GetOAuth2ProviderAppCodeByPrefix), ctx, secretPrefix)
}

// GetOAuth2ProviderAppSecretByID mocks base method.
func (m *MockStore) GetOAuth2ProviderAppSecretByID(ctx context.Context, id uuid.UUID) (database.OAuth2ProviderAppSecret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOAuth2ProviderAppSecretByID", ctx, id)
	ret0, _ := ret[0].(database.OAuth2ProviderAppSecret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetOAuth2ProviderAppSecretByPrefix mocks base method.
func (m *MockStore) GetOAuth2ProviderAppSecretByPrefix(ctx context.Context, secretPrefix []byte) (database.OAuth2ProviderAppSecret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOAuth2ProviderAppSecretByPrefix", ctx, secretPrefix)
	ret0, _ := ret[0].(database.OAuth2ProviderAppSecret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOAuth2ProviderAppSecretByPrefix indicates an expected call of GetOAuth2ProviderAppSecretByPrefix.
func (mr *MockStoreMockRecorder) GetOAuth2ProviderAppSecretByPrefix(ctx, secretPrefix any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOAuth2ProviderAppSecretByPrefix", reflect.TypeOf((*MockStore)(nil).GetOAuth2ProviderAppSecretByPrefix), ctx, secretPrefix)
}

// GetOAuth2ProviderAppSecretsByAppID mocks base method.
func (m *MockStore) GetOAuth2ProviderAppSecretsByAppID(ctx context.Context, appID uuid.UUID) ([]database.OAuth2ProviderAppSecret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOAuth2ProviderAppSecretsByAppID", ctx, appID)
	ret0, _ := ret[0].([]database.OAuth2ProviderAppSecret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOAuth2ProviderAppSecretsByAppID indicates an expected call of GetOAuth2ProviderAppSecretsByAppID.
func (mr *MockStoreMockRecorder) GetOAuth2ProviderAppSecretsByAppID(ctx, appID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOAuth2ProviderAppSecretsByAppID", reflect.TypeOf((*MockStore)(nil).GetOAuth2ProviderAppSecretsByAppID), ctx, appID)
}

// GetOAuth2ProviderAppTokenByAPIKeyID mocks base method.
func (m *MockStore) GetOAuth2ProviderAppTokenByAPIKeyID(ctx context.Context, apiKeyID string) (database.OAuth2ProviderAppToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOAuth2ProviderAppTokenByAPIKeyID", ctx, apiKeyID)
	ret0, _ := ret[0].(database.OAuth2ProviderAppToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOAuth2ProviderAppTokenByAPIKeyID indicates an expected call of GetOAuth2ProviderAppTokenByAPIKeyID.
func (mr *MockStoreMockRecorder) GetOAuth2ProviderAppTokenByAPIKeyID(ctx, apiKeyID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOAuth2ProviderAppTokenByAPIKeyID", reflect.TypeOf((*MockStore)(nil).GetOAuth2ProviderAppTokenByAPIKeyID), ctx, apiKeyID)
}

// GetOAuth2ProviderAppTokenByPrefix mocks base method.
func (m *MockStore) GetOAuth2ProviderAppTokenByPrefix(ctx context.Context, hashPrefix []byte) (database.OAuth2ProviderAppToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOAuth2ProviderAppTokenByPrefix", ctx, hashPrefix)
	ret0, _ := ret[0].(database.OAuth2ProviderAppToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOAuth2ProviderAppTokenByPrefix indicates an expected call of GetOAuth2ProviderAppTokenByPrefix.
func (mr *MockStoreMockRecorder) GetOAuth2ProviderAppTokenByPrefix(ctx, hashPrefix any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOAuth2ProviderAppTokenByPrefix", reflect.TypeOf((*MockStore)(nil).GetOAuth2ProviderAppTokenByPrefix), ctx, hashPrefix)
}

// GetOAuth2ProviderApps mocks base method.
func (m *MockStore) GetOAuth2ProviderApps(ctx context.Context) ([]database.OAuth2ProviderApp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOAuth2ProviderApps", ctx)
	ret0, _ := ret[0].([]database.OAuth2ProviderApp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetOAuth2ProviderAppsByUserID mocks base method.
func (m *MockStore) GetOAuth2ProviderAppsByUserID(ctx context.Context, userID uuid.UUID) ([]database.GetOAuth2ProviderAppsByUserIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOAuth2ProviderAppsByUserID", ctx, userID)
	ret0, _ := ret[0].([]database.GetOAuth2ProviderAppsByUserIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetOrganizationByID mocks base method.
func (m *MockStore) GetOrganizationByID(ctx context.Context, id uuid.UUID) (database.Organization, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrganizationByID", ctx, id)
	ret0, _ := ret[0].(database.Organization)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetOrganizationByName mocks base method.
func (m *MockStore) GetOrganizationByName(ctx context.Context, arg database.GetOrganizationByNameParams) (database.Organization, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrganizationByName", ctx, arg)
	ret0, _ := ret[0].(database.Organization)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrganizationByName indicates an expected call of GetOrganizationByName.
func (mr *MockStoreMockRecorder) GetOrganizationByName(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationByName", reflect.TypeOf((*MockStore)(nil).GetOrganizationByName), ctx, arg)
}

// GetOrganizationIDsByMemberIDs mocks base method.
func (m *MockStore) GetOrganizationIDsByMemberIDs(ctx context.Context, ids []uuid.UUID) ([]database.GetOrganizationIDsByMemberIDsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrganizationIDsByMemberIDs", ctx, ids)
	ret0, _ := ret[0].([]database.GetOrganizationIDsByMemberIDsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetOrganizationResourceCountByID mocks base method.
func (m *MockStore) GetOrganizationResourceCountByID(ctx context.Context, organizationID uuid.UUID) (database.GetOrganizationResourceCountByIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrganizationResourceCountByID", ctx, organizationID)
	ret0, _ := ret[0].(database.GetOrganizationResourceCountByIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrganizationResourceCountByID indicates an expected call of GetOrganizationResourceCountByID.
func (mr *MockStoreMockRecorder) GetOrganizationResourceCountByID(ctx, organizationID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationResourceCountByID", reflect.TypeOf((*MockStore)(nil).GetOrganizationResourceCountByID), ctx, organizationID)
}

// GetOrganizations mocks base method.
func (m *MockStore) GetOrganizations(ctx context.Context, arg database.GetOrganizationsParams) ([]database.Organization, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrganizations", ctx, arg)
	ret0, _ := ret[0].([]database.Organization)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrganizations indicates an expected call of GetOrganizations.
func (mr *MockStoreMockRecorder) GetOrganizations(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizations", reflect.TypeOf((*MockStore)(nil).GetOrganizations), ctx, arg)
}

// GetOrganizationsByUserID mocks base method.
func (m *MockStore) GetOrganizationsByUserID(ctx context.Context, arg database.GetOrganizationsByUserIDParams) ([]database.Organization, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrganizationsByUserID", ctx, arg)
	ret0, _ := ret[0].([]database.Organization)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrganizationsByUserID indicates an expected call of GetOrganizationsByUserID.
func (mr *MockStoreMockRecorder) GetOrganizationsByUserID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationsByUserID", reflect.TypeOf((*MockStore)(nil).GetOrganizationsByUserID), ctx, arg)
}

// GetOrganizationsWithPrebuildStatus mocks base method.
func (m *MockStore) GetOrganizationsWithPrebuildStatus(ctx context.Context, arg database.GetOrganizationsWithPrebuildStatusParams) ([]database.GetOrganizationsWithPrebuildStatusRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrganizationsWithPrebuildStatus", ctx, arg)
	ret0, _ := ret[0].([]database.GetOrganizationsWithPrebuildStatusRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOrganizationsWithPrebuildStatus indicates an expected call of GetOrganizationsWithPrebuildStatus.
func (mr *MockStoreMockRecorder) GetOrganizationsWithPrebuildStatus(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationsWithPrebuildStatus", reflect.TypeOf((*MockStore)(nil).GetOrganizationsWithPrebuildStatus), ctx, arg)
}

// GetPRInsightsPerModel mocks base method.
func (m *MockStore) GetPRInsightsPerModel(ctx context.Context, arg database.GetPRInsightsPerModelParams) ([]database.GetPRInsightsPerModelRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPRInsightsPerModel", ctx, arg)
	ret0, _ := ret[0].([]database.GetPRInsightsPerModelRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPRInsightsPerModel indicates an expected call of GetPRInsightsPerModel.
func (mr *MockStoreMockRecorder) GetPRInsightsPerModel(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPRInsightsPerModel", reflect.TypeOf((*MockStore)(nil).GetPRInsightsPerModel), ctx, arg)
}

// GetPRInsightsPullRequests mocks base method.
func (m *MockStore) GetPRInsightsPullRequests(ctx context.Context, arg database.GetPRInsightsPullRequestsParams) ([]database.GetPRInsightsPullRequestsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPRInsightsPullRequests", ctx, arg)
	ret0, _ := ret[0].([]database.GetPRInsightsPullRequestsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPRInsightsPullRequests indicates an expected call of GetPRInsightsPullRequests.
func (mr *MockStoreMockRecorder) GetPRInsightsPullRequests(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPRInsightsPullRequests", reflect.TypeOf((*MockStore)(nil).GetPRInsightsPullRequests), ctx, arg)
}

// GetPRInsightsSummary mocks base method.
func (m *MockStore) GetPRInsightsSummary(ctx context.Context, arg database.GetPRInsightsSummaryParams) (database.GetPRInsightsSummaryRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPRInsightsSummary", ctx, arg)
	ret0, _ := ret[0].(database.GetPRInsightsSummaryRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPRInsightsSummary indicates an expected call of GetPRInsightsSummary.
func (mr *MockStoreMockRecorder) GetPRInsightsSummary(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPRInsightsSummary", reflect.TypeOf((*MockStore)(nil).GetPRInsightsSummary), ctx, arg)
}

// GetPRInsightsTimeSeries mocks base method.
func (m *MockStore) GetPRInsightsTimeSeries(ctx context.Context, arg database.GetPRInsightsTimeSeriesParams) ([]database.GetPRInsightsTimeSeriesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPRInsightsTimeSeries", ctx, arg)
	ret0, _ := ret[0].([]database.GetPRInsightsTimeSeriesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPRInsightsTimeSeries indicates an expected call of GetPRInsightsTimeSeries.
func (mr *MockStoreMockRecorder) GetPRInsightsTimeSeries(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPRInsightsTimeSeries", reflect.TypeOf((*MockStore)(nil).GetPRInsightsTimeSeries), ctx, arg)
}

// GetParameterSchemasByJobID mocks base method.
func (m *MockStore) GetParameterSchemasByJobID(ctx context.Context, jobID uuid.UUID) ([]database.ParameterSchema, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetParameterSchemasByJobID", ctx, jobID)
	ret0, _ := ret[0].([]database.ParameterSchema)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetParameterSchemasByJobID indicates an expected call of GetParameterSchemasByJobID.
func (mr *MockStoreMockRecorder) GetParameterSchemasByJobID(ctx, jobID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetParameterSchemasByJobID", reflect.TypeOf((*MockStore)(nil).GetParameterSchemasByJobID), ctx, jobID)
}

// GetPrebuildMetrics mocks base method.
func (m *MockStore) GetPrebuildMetrics(ctx context.Context) ([]database.GetPrebuildMetricsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPrebuildMetrics", ctx)
	ret0, _ := ret[0].([]database.GetPrebuildMetricsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPrebuildsSettings mocks base method.
func (m *MockStore) GetPrebuildsSettings(ctx context.Context) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPrebuildsSettings", ctx)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPresetByID mocks base method.
func (m *MockStore) GetPresetByID(ctx context.Context, presetID uuid.UUID) (database.GetPresetByIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPresetByID", ctx, presetID)
	ret0, _ := ret[0].(database.GetPresetByIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPresetByID indicates an expected call of GetPresetByID.
func (mr *MockStoreMockRecorder) GetPresetByID(ctx, presetID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPresetByID", reflect.TypeOf((*MockStore)(nil).GetPresetByID), ctx, presetID)
}

// GetPresetByWorkspaceBuildID mocks base method.
func (m *MockStore) GetPresetByWorkspaceBuildID(ctx context.Context, workspaceBuildID uuid.UUID) (database.TemplateVersionPreset, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPresetByWorkspaceBuildID", ctx, workspaceBuildID)
	ret0, _ := ret[0].(database.TemplateVersionPreset)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPresetByWorkspaceBuildID indicates an expected call of GetPresetByWorkspaceBuildID.
func (mr *MockStoreMockRecorder) GetPresetByWorkspaceBuildID(ctx, workspaceBuildID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPresetByWorkspaceBuildID", reflect.TypeOf((*MockStore)(nil).GetPresetByWorkspaceBuildID), ctx, workspaceBuildID)
}

// GetPresetParametersByPresetID mocks base method.
func (m *MockStore) GetPresetParametersByPresetID(ctx context.Context, presetID uuid.UUID) ([]database.TemplateVersionPresetParameter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPresetParametersByPresetID", ctx, presetID)
	ret0, _ := ret[0].([]database.TemplateVersionPresetParameter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPresetParametersByPresetID indicates an expected call of GetPresetParametersByPresetID.
func (mr *MockStoreMockRecorder) GetPresetParametersByPresetID(ctx, presetID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPresetParametersByPresetID", reflect.TypeOf((*MockStore)(nil).GetPresetParametersByPresetID), ctx, presetID)
}

// GetPresetParametersByTemplateVersionID mocks base method.
func (m *MockStore) GetPresetParametersByTemplateVersionID(ctx context.Context, templateVersionID uuid.UUID) ([]database.TemplateVersionPresetParameter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPresetParametersByTemplateVersionID", ctx, templateVersionID)
	ret0, _ := ret[0].([]database.TemplateVersionPresetParameter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPresetParametersByTemplateVersionID indicates an expected call of GetPresetParametersByTemplateVersionID.
func (mr *MockStoreMockRecorder) GetPresetParametersByTemplateVersionID(ctx, templateVersionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPresetParametersByTemplateVersionID", reflect.TypeOf((*MockStore)(nil).GetPresetParametersByTemplateVersionID), ctx, templateVersionID)
}

// GetPresetsAtFailureLimit mocks base method.
func (m *MockStore) GetPresetsAtFailureLimit(ctx context.Context, hardLimit int64) ([]database.GetPresetsAtFailureLimitRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPresetsAtFailureLimit", ctx, hardLimit)
	ret0, _ := ret[0].([]database.GetPresetsAtFailureLimitRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPresetsAtFailureLimit indicates an expected call of GetPresetsAtFailureLimit.
func (mr *MockStoreMockRecorder) GetPresetsAtFailureLimit(ctx, hardLimit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPresetsAtFailureLimit", reflect.TypeOf((*MockStore)(nil).GetPresetsAtFailureLimit), ctx, hardLimit)
}

// GetPresetsBackoff mocks base method.
func (m *MockStore) GetPresetsBackoff(ctx context.Context, lookback time.Time) ([]database.GetPresetsBackoffRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPresetsBackoff", ctx, lookback)
	ret0, _ := ret[0].([]database.GetPresetsBackoffRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPresetsBackoff indicates an expected call of GetPresetsBackoff.
func (mr *MockStoreMockRecorder) GetPresetsBackoff(ctx, lookback any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPresetsBackoff", reflect.TypeOf((*MockStore)(nil).GetPresetsBackoff), ctx, lookback)
}

// GetPresetsByTemplateVersionID mocks base method.
func (m *MockStore) GetPresetsByTemplateVersionID(ctx context.Context, templateVersionID uuid.UUID) ([]database.TemplateVersionPreset, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPresetsByTemplateVersionID", ctx, templateVersionID)
	ret0, _ := ret[0].([]database.TemplateVersionPreset)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPresetsByTemplateVersionID indicates an expected call of GetPresetsByTemplateVersionID.
func (mr *MockStoreMockRecorder) GetPresetsByTemplateVersionID(ctx, templateVersionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPresetsByTemplateVersionID", reflect.TypeOf((*MockStore)(nil).GetPresetsByTemplateVersionID), ctx, templateVersionID)
}

// GetPreviousTemplateVersion mocks base method.
func (m *MockStore) GetPreviousTemplateVersion(ctx context.Context, arg database.GetPreviousTemplateVersionParams) (database.TemplateVersion, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPreviousTemplateVersion", ctx, arg)
	ret0, _ := ret[0].(database.TemplateVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPreviousTemplateVersion indicates an expected call of GetPreviousTemplateVersion.
func (mr *MockStoreMockRecorder) GetPreviousTemplateVersion(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPreviousTemplateVersion", reflect.TypeOf((*MockStore)(nil).GetPreviousTemplateVersion), ctx, arg)
}

// GetProvisionerDaemons mocks base method.
func (m *MockStore) GetProvisionerDaemons(ctx context.Context) ([]database.ProvisionerDaemon, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProvisionerDaemons", ctx)
	ret0, _ := ret[0].([]database.ProvisionerDaemon)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetProvisionerDaemonsByOrganization mocks base method.
func (m *MockStore) GetProvisionerDaemonsByOrganization(ctx context.Context, arg database.GetProvisionerDaemonsByOrganizationParams) ([]database.ProvisionerDaemon, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProvisionerDaemonsByOrganization", ctx, arg)
	ret0, _ := ret[0].([]database.ProvisionerDaemon)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProvisionerDaemonsByOrganization indicates an expected call of GetProvisionerDaemonsByOrganization.
func (mr *MockStoreMockRecorder) GetProvisionerDaemonsByOrganization(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProvisionerDaemonsByOrganization", reflect.TypeOf((*MockStore)(nil).GetProvisionerDaemonsByOrganization), ctx, arg)
}

// GetProvisionerDaemonsWithStatusByOrganization mocks base method.
func (m *MockStore) GetProvisionerDaemonsWithStatusByOrganization(ctx context.Context, arg database.GetProvisionerDaemonsWithStatusByOrganizationParams) ([]database.GetProvisionerDaemonsWithStatusByOrganizationRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProvisionerDaemonsWithStatusByOrganization", ctx, arg)
	ret0, _ := ret[0].([]database.GetProvisionerDaemonsWithStatusByOrganizationRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProvisionerDaemonsWithStatusByOrganization indicates an expected call of GetProvisionerDaemonsWithStatusByOrganization.
func (mr *MockStoreMockRecorder) GetProvisionerDaemonsWithStatusByOrganization(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProvisionerDaemonsWithStatusByOrganization", reflect.TypeOf((*MockStore)(nil).GetProvisionerDaemonsWithStatusByOrganization), ctx, arg)
}

// GetProvisionerJobByID mocks base method.
func (m *MockStore) GetProvisionerJobByID(ctx context.Context, id uuid.UUID) (database.ProvisionerJob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProvisionerJobByID", ctx, id)
	ret0, _ := ret[0].(database.ProvisionerJob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetProvisionerJobByIDForUpdate mocks base method.
func (m *MockStore) GetProvisionerJobByIDForUpdate(ctx context.Context, id uuid.UUID) (database.ProvisionerJob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProvisionerJobByIDForUpdate", ctx, id)
	ret0, _ := ret[0].(database.ProvisionerJob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetProvisionerJobByIDWithLock mocks base method.
func (m *MockStore) GetProvisionerJobByIDWithLock(ctx context.Context, id uuid.UUID) (database.ProvisionerJob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProvisionerJobByIDWithLock", ctx, id)
	ret0, _ := ret[0].(database.ProvisionerJob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetProvisionerJobTimingsByJobID mocks base method.
func (m *MockStore) GetProvisionerJobTimingsByJobID(ctx context.Context, jobID uuid.UUID) ([]database.ProvisionerJobTiming, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProvisionerJobTimingsByJobID", ctx, jobID)
	ret0, _ := ret[0].([]database.ProvisionerJobTiming)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProvisionerJobTimingsByJobID indicates an expected call of GetProvisionerJobTimingsByJobID.
func (mr *MockStoreMockRecorder) GetProvisionerJobTimingsByJobID(ctx, jobID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProvisionerJobTimingsByJobID", reflect.TypeOf((*MockStore)(nil).GetProvisionerJobTimingsByJobID), ctx, jobID)
}

// GetProvisionerJobsByIDsWithQueuePosition mocks base method.
func (m *MockStore) GetProvisionerJobsByIDsWithQueuePosition(ctx context.Context, arg database.GetProvisionerJobsByIDsWithQueuePositionParams) ([]database.GetProvisionerJobsByIDsWithQueuePositionRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProvisionerJobsByIDsWithQueuePosition", ctx, arg)
	ret0, _ := ret[0].([]database.GetProvisionerJobsByIDsWithQueuePositionRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProvisionerJobsByIDsWithQueuePosition indicates an expected call of GetProvisionerJobsByIDsWithQueuePosition.
func (mr *MockStoreMockRecorder) GetProvisionerJobsByIDsWithQueuePosition(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProvisionerJobsByIDsWithQueuePosition", reflect.TypeOf((*MockStore)(nil).GetProvisionerJobsByIDsWithQueuePosition), ctx, arg)
}

// GetProvisionerJobsByOrganizationAndStatusWithQueuePositionAndProvisioner mocks base method.
func (m *MockStore) GetProvisionerJobsByOrganizationAndStatusWithQueuePositionAndProvisioner(ctx context.Context, arg database.GetProvisionerJobsByOrganizationAndStatusWithQueuePositionAndProvisionerParams) ([]database.GetProvisionerJobsByOrganizationAndStatusWithQueuePositionAndProvisionerRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProvisionerJobsByOrganizationAndStatusWithQueuePositionAndProvisioner", ctx, arg)
	ret0, _ := ret[0].([]database.GetProvisionerJobsByOrganizationAndStatusWithQueuePositionAndProvisionerRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProvisionerJobsByOrganizationAndStatusWithQueuePositionAndProvisioner indicates an expected call of GetProvisionerJobsByOrganizationAndStatusWithQueuePositionAndProvisioner.
func (mr *MockStoreMockRecorder) GetProvisionerJobsByOrganizationAndStatusWithQueuePositionAndProvisioner(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProvisionerJobsByOrganizationAndStatusWithQueuePositionAndProvisioner", reflect.TypeOf((*MockStore)(nil).GetProvisionerJobsByOrganizationAndStatusWithQueuePositionAndProvisioner), ctx, arg)
}

// GetProvisionerJobsCreatedAfter mocks base method.
func (m *MockStore) GetProvisionerJobsCreatedAfter(ctx context.Context, createdAt time.Time) ([]database.ProvisionerJob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProvisionerJobsCreatedAfter", ctx, createdAt)
	ret0, _ := ret[0].([]database.ProvisionerJob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProvisionerJobsCreatedAfter indicates an expected call of GetProvisionerJobsCreatedAfter.
func (mr *MockStoreMockRecorder) GetProvisionerJobsCreatedAfter(ctx, createdAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProvisionerJobsCreatedAfter", reflect.TypeOf((*MockStore)(nil).GetProvisionerJobsCreatedAfter), ctx, createdAt)
}

// GetProvisionerJobsToBeReaped mocks base method.
func (m *MockStore) GetProvisionerJobsToBeReaped(ctx context.Context, arg database.GetProvisionerJobsToBeReapedParams) ([]database.ProvisionerJob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProvisionerJobsToBeReaped", ctx, arg)
	ret0, _ := ret[0].([]database.ProvisionerJob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProvisionerJobsToBeReaped indicates an expected call of GetProvisionerJobsToBeReaped.
func (mr *MockStoreMockRecorder) GetProvisionerJobsToBeReaped(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProvisionerJobsToBeReaped", reflect.TypeOf((*MockStore)(nil).GetProvisionerJobsToBeReaped), ctx, arg)
}

// GetProvisionerKeyByHashedSecret mocks base method.
func (m *MockStore) GetProvisionerKeyByHashedSecret(ctx context.Context, hashedSecret []byte) (database.ProvisionerKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProvisionerKeyByHashedSecret", ctx, hashedSecret)
	ret0, _ := ret[0].(database.ProvisionerKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProvisionerKeyByHashedSecret indicates an expected call of GetProvisionerKeyByHashedSecret.
func (mr *MockStoreMockRecorder) GetProvisionerKeyByHashedSecret(ctx, hashedSecret any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProvisionerKeyByHashedSecret", reflect.TypeOf((*MockStore)(nil).GetProvisionerKeyByHashedSecret), ctx, hashedSecret)
}

// GetProvisionerKeyByID mocks base method.
func (m *MockStore) GetProvisionerKeyByID(ctx context.Context, id uuid.UUID) (database.ProvisionerKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProvisionerKeyByID", ctx, id)
	ret0, _ := ret[0].(database.ProvisionerKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetProvisionerKeyByName mocks base method.
func (m *MockStore) GetProvisionerKeyByName(ctx context.Context, arg database.GetProvisionerKeyByNameParams) (database.ProvisionerKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProvisionerKeyByName", ctx, arg)
	ret0, _ := ret[0].(database.ProvisionerKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProvisionerKeyByName indicates an expected call of GetProvisionerKeyByName.
func (mr *MockStoreMockRecorder) GetProvisionerKeyByName(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProvisionerKeyByName", reflect.TypeOf((*MockStore)(nil).GetProvisionerKeyByName), ctx, arg)
}

// GetProvisionerLogsAfterID mocks base method.
func (m *MockStore) GetProvisionerLogsAfterID(ctx context.Context, arg database.GetProvisionerLogsAfterIDParams) ([]database.ProvisionerJobLog, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProvisionerLogsAfterID", ctx, arg)
	ret0, _ := ret[0].([]database.ProvisionerJobLog)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProvisionerLogsAfterID indicates an expected call of GetProvisionerLogsAfterID.
func (mr *MockStoreMockRecorder) GetProvisionerLogsAfterID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProvisionerLogsAfterID", reflect.TypeOf((*MockStore)(nil).GetProvisionerLogsAfterID), ctx, arg)
}

// GetQuotaAllowanceForUser mocks base method.
func (m *MockStore) GetQuotaAllowanceForUser(ctx context.Context, arg database.GetQuotaAllowanceForUserParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQuotaAllowanceForUser", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetQuotaAllowanceForUser indicates an expected call of GetQuotaAllowanceForUser.
func (mr *MockStoreMockRecorder) GetQuotaAllowanceForUser(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQuotaAllowanceForUser", reflect.TypeOf((*MockStore)(nil).GetQuotaAllowanceForUser), ctx, arg)
}

// GetQuotaConsumedForUser mocks base method.
func (m *MockStore) GetQuotaConsumedForUser(ctx context.Context, arg database.GetQuotaConsumedForUserParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQuotaConsumedForUser", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetQuotaConsumedForUser indicates an expected call of GetQuotaConsumedForUser.
func (mr *MockStoreMockRecorder) GetQuotaConsumedForUser(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQuotaConsumedForUser", reflect.TypeOf((*MockStore)(nil).GetQuotaConsumedForUser), ctx, arg)
}

// GetRegularWorkspaceCreateMetrics mocks base method.
func (m *MockStore) GetRegularWorkspaceCreateMetrics(ctx context.Context) ([]database.GetRegularWorkspaceCreateMetricsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRegularWorkspaceCreateMetrics", ctx)
	ret0, _ := ret[0].([]database.GetRegularWorkspaceCreateMetricsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetReplicaByID mocks base method.
func (m *MockStore) GetReplicaByID(ctx context.Context, id uuid.UUID) (database.Replica, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReplicaByID", ctx, id)
	ret0, _ := ret[0].(database.Replica)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetReplicasUpdatedAfter mocks base method.
func (m *MockStore) GetReplicasUpdatedAfter(ctx context.Context, updatedAt time.Time) ([]database.Replica, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReplicasUpdatedAfter", ctx, updatedAt)
	ret0, _ := ret[0].([]database.Replica)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReplicasUpdatedAfter indicates an expected call of GetReplicasUpdatedAfter.
func (mr *MockStoreMockRecorder) GetReplicasUpdatedAfter(ctx, updatedAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReplicasUpdatedAfter", reflect.TypeOf((*MockStore)(nil).GetReplicasUpdatedAfter), ctx, updatedAt)
}

// GetRunningPrebuiltWorkspaces mocks base method.
func (m *MockStore) GetRunningPrebuiltWorkspaces(ctx context.Context) ([]database.GetRunningPrebuiltWorkspacesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRunningPrebuiltWorkspaces", ctx)
	ret0, _ := ret[0].([]database.GetRunningPrebuiltWorkspacesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetRuntimeConfig mocks base method.
func (m *MockStore) GetRuntimeConfig(ctx context.Context, key string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRuntimeConfig", ctx, key)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRuntimeConfig indicates an expected call of GetRuntimeConfig.
func (mr *MockStoreMockRecorder) GetRuntimeConfig(ctx, key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRuntimeConfig", reflect.TypeOf((*MockStore)(nil).GetRuntimeConfig), ctx, key)
}

// GetStaleChats mocks base method.
func (m *MockStore) GetStaleChats(ctx context.Context, staleThreshold time.Time) ([]database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStaleChats", ctx, staleThreshold)
	ret0, _ := ret[0].([]database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStaleChats indicates an expected call of GetStaleChats.
func (mr *MockStoreMockRecorder) GetStaleChats(ctx, staleThreshold any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStaleChats", reflect.TypeOf((*MockStore)(nil).GetStaleChats), ctx, staleThreshold)
}

// GetTailnetPeers mocks base method.
func (m *MockStore) GetTailnetPeers(ctx context.Context, id uuid.UUID) ([]database.TailnetPeer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTailnetPeers", ctx, id)
	ret0, _ := ret[0].([]database.TailnetPeer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTailnetTunnelPeerBindingsBatch mocks base method.
func (m *MockStore) GetTailnetTunnelPeerBindingsBatch(ctx context.Context, ids []uuid.UUID) ([]database.GetTailnetTunnelPeerBindingsBatchRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTailnetTunnelPeerBindingsBatch", ctx, ids)
	ret0, _ := ret[0].([]database.GetTailnetTunnelPeerBindingsBatchRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTailnetTunnelPeerIDsBatch mocks base method.
func (m *MockStore) GetTailnetTunnelPeerIDsBatch(ctx context.Context, ids []uuid.UUID) ([]database.GetTailnetTunnelPeerIDsBatchRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTailnetTunnelPeerIDsBatch", ctx, ids)
	ret0, _ := ret[0].([]database.GetTailnetTunnelPeerIDsBatchRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTaskByID mocks base method.
func (m *MockStore) GetTaskByID(ctx context.Context, id uuid.UUID) (database.Task, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTaskByID", ctx, id)
	ret0, _ := ret[0].(database.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTaskByOwnerIDAndName mocks base method.
func (m *MockStore) GetTaskByOwnerIDAndName(ctx context.Context, arg database.GetTaskByOwnerIDAndNameParams) (database.Task, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTaskByOwnerIDAndName", ctx, arg)
	ret0, _ := ret[0].(database.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTaskByOwnerIDAndName indicates an expected call of GetTaskByOwnerIDAndName.
func (mr *MockStoreMockRecorder) GetTaskByOwnerIDAndName(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskByOwnerIDAndName", reflect.TypeOf((*MockStore)(nil).GetTaskByOwnerIDAndName), ctx, arg)
}

// GetTaskByWorkspaceID mocks base method.
func (m *MockStore) GetTaskByWorkspaceID(ctx context.Context, workspaceID uuid.UUID) (database.Task, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTaskByWorkspaceID", ctx, workspaceID)
	ret0, _ := ret[0].(database.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTaskByWorkspaceID indicates an expected call of GetTaskByWorkspaceID.
func (mr *MockStoreMockRecorder) GetTaskByWorkspaceID(ctx, workspaceID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskByWorkspaceID", reflect.TypeOf((*MockStore)(nil).GetTaskByWorkspaceID), ctx, workspaceID)
}

// GetTaskSnapshot mocks base method.
func (m *MockStore) GetTaskSnapshot(ctx context.Context, taskID uuid.UUID) (database.TaskSnapshot, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTaskSnapshot", ctx, taskID)
	ret0, _ := ret[0].(database.TaskSnapshot)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTaskSnapshot indicates an expected call of GetTaskSnapshot.
func (mr *MockStoreMockRecorder) GetTaskSnapshot(ctx, taskID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskSnapshot", reflect.TypeOf((*MockStore)(nil).GetTaskSnapshot), ctx, taskID)
}

// GetTelemetryItem mocks base method.
func (m *MockStore) GetTelemetryItem(ctx context.Context, key string) (database.TelemetryItem, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTelemetryItem", ctx, key)
	ret0, _ := ret[0].(database.TelemetryItem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTelemetryItem indicates an expected call of GetTelemetryItem.
func (mr *MockStoreMockRecorder) GetTelemetryItem(ctx, key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTelemetryItem", reflect.TypeOf((*MockStore)(nil).GetTelemetryItem), ctx, key)
}

// GetTelemetryItems mocks base method.
func (m *MockStore) GetTelemetryItems(ctx context.Context) ([]database.TelemetryItem, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTelemetryItems", ctx)
	ret0, _ := ret[0].([]database.TelemetryItem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTelemetryTaskEvents mocks base method.
func (m *MockStore) GetTelemetryTaskEvents(ctx context.Context, arg database.GetTelemetryTaskEventsParams) ([]database.GetTelemetryTaskEventsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTelemetryTaskEvents", ctx, arg)
	ret0, _ := ret[0].([]database.GetTelemetryTaskEventsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTelemetryTaskEvents indicates an expected call of GetTelemetryTaskEvents.
func (mr *MockStoreMockRecorder) GetTelemetryTaskEvents(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTelemetryTaskEvents", reflect.TypeOf((*MockStore)(nil).GetTelemetryTaskEvents), ctx, arg)
}

// GetTemplateAppInsights mocks base method.
func (m *MockStore) GetTemplateAppInsights(ctx context.Context, arg database.GetTemplateAppInsightsParams) ([]database.GetTemplateAppInsightsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateAppInsights", ctx, arg)
	ret0, _ := ret[0].([]database.GetTemplateAppInsightsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplateAppInsights indicates an expected call of GetTemplateAppInsights.
func (mr *MockStoreMockRecorder) GetTemplateAppInsights(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateAppInsights", reflect.TypeOf((*MockStore)(nil).GetTemplateAppInsights), ctx, arg)
}

// GetTemplateAppInsightsByTemplate mocks base method.
func (m *MockStore) GetTemplateAppInsightsByTemplate(ctx context.Context, arg database.GetTemplateAppInsightsByTemplateParams) ([]database.GetTemplateAppInsightsByTemplateRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateAppInsightsByTemplate", ctx, arg)
	ret0, _ := ret[0].([]database.GetTemplateAppInsightsByTemplateRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplateAppInsightsByTemplate indicates an expected call of GetTemplateAppInsightsByTemplate.
func (mr *MockStoreMockRecorder) GetTemplateAppInsightsByTemplate(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateAppInsightsByTemplate", reflect.TypeOf((*MockStore)(nil).GetTemplateAppInsightsByTemplate), ctx, arg)
}

// GetTemplateAverageBuildTime mocks base method.
func (m *MockStore) GetTemplateAverageBuildTime(ctx context.Context, templateID uuid.NullUUID) (database.GetTemplateAverageBuildTimeRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateAverageBuildTime", ctx, templateID)
	ret0, _ := ret[0].(database.GetTemplateAverageBuildTimeRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplateAverageBuildTime indicates an expected call of GetTemplateAverageBuildTime.
func (mr *MockStoreMockRecorder) GetTemplateAverageBuildTime(ctx, templateID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateAverageBuildTime", reflect.TypeOf((*MockStore)(nil).GetTemplateAverageBuildTime), ctx, templateID)
}

// GetTemplateByID mocks base method.
func (m *MockStore) GetTemplateByID(ctx context.Context, id uuid.UUID) (database.Template, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateByID", ctx, id)
	ret0, _ := ret[0].(database.Template)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTemplateByOrganizationAndName mocks base method.
func (m *MockStore) GetTemplateByOrganizationAndName(ctx context.Context, arg database.GetTemplateByOrganizationAndNameParams) (database.Template, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateByOrganizationAndName", ctx, arg)
	ret0, _ := ret[0].(database.Template)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplateByOrganizationAndName indicates an expected call of GetTemplateByOrganizationAndName.
func (mr *MockStoreMockRecorder) GetTemplateByOrganizationAndName(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateByOrganizationAndName", reflect.TypeOf((*MockStore)(nil).GetTemplateByOrganizationAndName), ctx, arg)
}

// GetTemplateGroupRoles mocks base method.
func (m *MockStore) GetTemplateGroupRoles(ctx context.Context, id uuid.UUID) ([]database.TemplateGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateGroupRoles", ctx, id)
	ret0, _ := ret[0].([]database.TemplateGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTemplateInsights mocks base method.
func (m *MockStore) GetTemplateInsights(ctx context.Context, arg database.GetTemplateInsightsParams) (database.GetTemplateInsightsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateInsights", ctx, arg)
	ret0, _ := ret[0].(database.GetTemplateInsightsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplateInsights indicates an expected call of GetTemplateInsights.
func (mr *MockStoreMockRecorder) GetTemplateInsights(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateInsights", reflect.TypeOf((*MockStore)(nil).GetTemplateInsights), ctx, arg)
}

// GetTemplateInsightsByInterval mocks base method.
func (m *MockStore) GetTemplateInsightsByInterval(ctx context.Context, arg database.GetTemplateInsightsByIntervalParams) ([]database.GetTemplateInsightsByIntervalRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateInsightsByInterval", ctx, arg)
	ret0, _ := ret[0].([]database.GetTemplateInsightsByIntervalRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplateInsightsByInterval indicates an expected call of GetTemplateInsightsByInterval.
func (mr *MockStoreMockRecorder) GetTemplateInsightsByInterval(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateInsightsByInterval", reflect.TypeOf((*MockStore)(nil).GetTemplateInsightsByInterval), ctx, arg)
}

// GetTemplateInsightsByTemplate mocks base method.
func (m *MockStore) GetTemplateInsightsByTemplate(ctx context.Context, arg database.GetTemplateInsightsByTemplateParams) ([]database.GetTemplateInsightsByTemplateRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateInsightsByTemplate", ctx, arg)
	ret0, _ := ret[0].([]database.GetTemplateInsightsByTemplateRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplateInsightsByTemplate indicates an expected call of GetTemplateInsightsByTemplate.
func (mr *MockStoreMockRecorder) GetTemplateInsightsByTemplate(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateInsightsByTemplate", reflect.TypeOf((*MockStore)(nil).GetTemplateInsightsByTemplate), ctx, arg)
}

// GetTemplateParameterInsights mocks base method.
func (m *MockStore) GetTemplateParameterInsights(ctx context.Context, arg database.GetTemplateParameterInsightsParams) ([]database.GetTemplateParameterInsightsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateParameterInsights", ctx, arg)
	ret0, _ := ret[0].([]database.GetTemplateParameterInsightsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplateParameterInsights indicates an expected call of GetTemplateParameterInsights.
func (mr *MockStoreMockRecorder) GetTemplateParameterInsights(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateParameterInsights", reflect.TypeOf((*MockStore)(nil).GetTemplateParameterInsights), ctx, arg)
}

// GetTemplatePresetsWithPrebuilds mocks base method.
func (m *MockStore) GetTemplatePresetsWithPrebuilds(ctx context.Context, templateID uuid.NullUUID) ([]database.GetTemplatePresetsWithPrebuildsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplatePresetsWithPrebuilds", ctx, templateID)
	ret0, _ := ret[0].([]database.GetTemplatePresetsWithPrebuildsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplatePresetsWithPrebuilds indicates an expected call of GetTemplatePresetsWithPrebuilds.
func (mr *MockStoreMockRecorder) GetTemplatePresetsWithPrebuilds(ctx, templateID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplatePresetsWithPrebuilds", reflect.TypeOf((*MockStore)(nil).GetTemplatePresetsWithPrebuilds), ctx, templateID)
}

// GetTemplateUsageStats mocks base method.
func (m *MockStore) GetTemplateUsageStats(ctx context.Context, arg database.GetTemplateUsageStatsParams) ([]database.TemplateUsageStat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateUsageStats", ctx, arg)
	ret0, _ := ret[0].([]database.TemplateUsageStat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplateUsageStats indicates an expected call of GetTemplateUsageStats.
func (mr *MockStoreMockRecorder) GetTemplateUsageStats(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateUsageStats", reflect.TypeOf((*MockStore)(nil).GetTemplateUsageStats), ctx, arg)
}

// GetTemplateUserRoles mocks base method.
func (m *MockStore) GetTemplateUserRoles(ctx context.Context, id uuid.UUID) ([]database.TemplateUser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateUserRoles", ctx, id)
	ret0, _ := ret[0].([]database.TemplateUser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTemplateVersionByID mocks base method.
func (m *MockStore) GetTemplateVersionByID(ctx context.Context, id uuid.UUID) (database.TemplateVersion, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateVersionByID", ctx, id)
	ret0, _ := ret[0].(database.TemplateVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTemplateVersionByJobID mocks base method.
func (m *MockStore) GetTemplateVersionByJobID(ctx context.Context, jobID uuid.UUID) (database.TemplateVersion, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateVersionByJobID", ctx, jobID)
	ret0, _ := ret[0].(database.TemplateVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplateVersionByJobID indicates an expected call of GetTemplateVersionByJobID.
func (mr *MockStoreMockRecorder) GetTemplateVersionByJobID(ctx, jobID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateVersionByJobID", reflect.TypeOf((*MockStore)(nil).GetTemplateVersionByJobID), ctx, jobID)
}

// GetTemplateVersionByTemplateIDAndName mocks base method.
func (m *MockStore) GetTemplateVersionByTemplateIDAndName(ctx context.Context, arg database.GetTemplateVersionByTemplateIDAndNameParams) (database.TemplateVersion, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateVersionByTemplateIDAndName", ctx, arg)
	ret0, _ := ret[0].(database.TemplateVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplateVersionByTemplateIDAndName indicates an expected call of GetTemplateVersionByTemplateIDAndName.
func (mr *MockStoreMockRecorder) GetTemplateVersionByTemplateIDAndName(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateVersionByTemplateIDAndName", reflect.TypeOf((*MockStore)(nil).GetTemplateVersionByTemplateIDAndName), ctx, arg)
}

// GetTemplateVersionParameters mocks base method.
func (m *MockStore) GetTemplateVersionParameters(ctx context.Context, templateVersionID uuid.UUID) ([]database.TemplateVersionParameter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateVersionParameters", ctx, templateVersionID)
	ret0, _ := ret[0].([]database.TemplateVersionParameter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplateVersionParameters indicates an expected call of GetTemplateVersionParameters.
func (mr *MockStoreMockRecorder) GetTemplateVersionParameters(ctx, templateVersionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateVersionParameters", reflect.TypeOf((*MockStore)(nil).GetTemplateVersionParameters), ctx, templateVersionID)
}

// GetTemplateVersionTerraformValues mocks base method.
func (m *MockStore) GetTemplateVersionTerraformValues(ctx context.Context, templateVersionID uuid.UUID) (database.TemplateVersionTerraformValue, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateVersionTerraformValues", ctx, templateVersionID)
	ret0, _ := ret[0].(database.TemplateVersionTerraformValue)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplateVersionTerraformValues indicates an expected call of GetTemplateVersionTerraformValues.
func (mr *MockStoreMockRecorder) GetTemplateVersionTerraformValues(ctx, templateVersionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateVersionTerraformValues", reflect.TypeOf((*MockStore)(nil).GetTemplateVersionTerraformValues), ctx, templateVersionID)
}

// GetTemplateVersionVariables mocks base method.
func (m *MockStore) GetTemplateVersionVariables(ctx context.Context, templateVersionID uuid.UUID) ([]database.TemplateVersionVariable, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateVersionVariables", ctx, templateVersionID)
	ret0, _ := ret[0].([]database.TemplateVersionVariable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplateVersionVariables indicates an expected call of GetTemplateVersionVariables.
func (mr *MockStoreMockRecorder) GetTemplateVersionVariables(ctx, templateVersionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateVersionVariables", reflect.TypeOf((*MockStore)(nil).GetTemplateVersionVariables), ctx, templateVersionID)
}

// GetTemplateVersionWorkspaceTags mocks base method.
func (m *MockStore) GetTemplateVersionWorkspaceTags(ctx context.Context, templateVersionID uuid.UUID) ([]database.TemplateVersionWorkspaceTag, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateVersionWorkspaceTags", ctx, templateVersionID)
	ret0, _ := ret[0].([]database.TemplateVersionWorkspaceTag)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplateVersionWorkspaceTags indicates an expected call of GetTemplateVersionWorkspaceTags.
func (mr *MockStoreMockRecorder) GetTemplateVersionWorkspaceTags(ctx, templateVersionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateVersionWorkspaceTags", reflect.TypeOf((*MockStore)(nil).GetTemplateVersionWorkspaceTags), ctx, templateVersionID)
}

// GetTemplateVersionsByIDs mocks base method.
func (m *MockStore) GetTemplateVersionsByIDs(ctx context.Context, ids []uuid.UUID) ([]database.TemplateVersion, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateVersionsByIDs", ctx, ids)
	ret0, _ := ret[0].([]database.TemplateVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTemplateVersionsByTemplateID mocks base method.
func (m *MockStore) GetTemplateVersionsByTemplateID(ctx context.Context, arg database.GetTemplateVersionsByTemplateIDParams) ([]database.TemplateVersion, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateVersionsByTemplateID", ctx, arg)
	ret0, _ := ret[0].([]database.TemplateVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplateVersionsByTemplateID indicates an expected call of GetTemplateVersionsByTemplateID.
func (mr *MockStoreMockRecorder) GetTemplateVersionsByTemplateID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateVersionsByTemplateID", reflect.TypeOf((*MockStore)(nil).GetTemplateVersionsByTemplateID), ctx, arg)
}

// GetTemplateVersionsCreatedAfter mocks base method.
func (m *MockStore) GetTemplateVersionsCreatedAfter(ctx context.Context, createdAt time.Time) ([]database.TemplateVersion, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplateVersionsCreatedAfter", ctx, createdAt)
	ret0, _ := ret[0].([]database.TemplateVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplateVersionsCreatedAfter indicates an expected call of GetTemplateVersionsCreatedAfter.
func (mr *MockStoreMockRecorder) GetTemplateVersionsCreatedAfter(ctx, createdAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplateVersionsCreatedAfter", reflect.TypeOf((*MockStore)(nil).GetTemplateVersionsCreatedAfter), ctx, createdAt)
}

// GetTemplates mocks base method.
func (m *MockStore) GetTemplates(ctx context.Context) ([]database.Template, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplates", ctx)
	ret0, _ := ret[0].([]database.Template)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTemplatesWithFilter mocks base method.
func (m *MockStore) GetTemplatesWithFilter(ctx context.Context, arg database.GetTemplatesWithFilterParams) ([]database.Template, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTemplatesWithFilter", ctx, arg)
	ret0, _ := ret[0].([]database.Template)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTemplatesWithFilter indicates an expected call of GetTemplatesWithFilter.
func (mr *MockStoreMockRecorder) GetTemplatesWithFilter(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTemplatesWithFilter", reflect.TypeOf((*MockStore)(nil).GetTemplatesWithFilter), ctx, arg)
}

// GetTotalUsageDCManagedAgentsV1 mocks base method.
func (m *MockStore) GetTotalUsageDCManagedAgentsV1(ctx context.Context, arg database.GetTotalUsageDCManagedAgentsV1Params) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTotalUsageDCManagedAgentsV1", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTotalUsageDCManagedAgentsV1 indicates an expected call of GetTotalUsageDCManagedAgentsV1.
func (mr *MockStoreMockRecorder) GetTotalUsageDCManagedAgentsV1(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTotalUsageDCManagedAgentsV1", reflect.TypeOf((*MockStore)(nil).GetTotalUsageDCManagedAgentsV1), ctx, arg)
}

// GetUnexpiredLicenses mocks base method.
func (m *MockStore) GetUnexpiredLicenses(ctx context.Context) ([]database.License, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUnexpiredLicenses", ctx)
	ret0, _ := ret[0].([]database.License)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserAIProviderKeyByProviderID mocks base method.
func (m *MockStore) GetUserAIProviderKeyByProviderID(ctx context.Context, arg database.GetUserAIProviderKeyByProviderIDParams) (database.UserAiProviderKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserAIProviderKeyByProviderID", ctx, arg)
	ret0, _ := ret[0].(database.UserAiProviderKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserAIProviderKeyByProviderID indicates an expected call of GetUserAIProviderKeyByProviderID.
func (mr *MockStoreMockRecorder) GetUserAIProviderKeyByProviderID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserAIProviderKeyByProviderID", reflect.TypeOf((*MockStore)(nil).GetUserAIProviderKeyByProviderID), ctx, arg)
}

// GetUserAIProviderKeys mocks base method.
func (m *MockStore) GetUserAIProviderKeys(ctx context.Context) ([]database.UserAiProviderKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserAIProviderKeys", ctx)
	ret0, _ := ret[0].([]database.UserAiProviderKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserAIProviderKeysByUserID mocks base method.
func (m *MockStore) GetUserAIProviderKeysByUserID(ctx context.Context, userID uuid.UUID) ([]database.UserAiProviderKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserAIProviderKeysByUserID", ctx, userID)
	ret0, _ := ret[0].([]database.UserAiProviderKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserAISeatStates mocks base method.
func (m *MockStore) GetUserAISeatStates(ctx context.Context, userIds []uuid.UUID) ([]uuid.UUID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserAISeatStates", ctx, userIds)
	ret0, _ := ret[0].([]uuid.UUID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserAISeatStates indicates an expected call of GetUserAISeatStates.
func (mr *MockStoreMockRecorder) GetUserAISeatStates(ctx, userIds any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserAISeatStates", reflect.TypeOf((*MockStore)(nil).GetUserAISeatStates), ctx, userIds)
}

// GetUserActivityInsights mocks base method.
func (m *MockStore) GetUserActivityInsights(ctx context.Context, arg database.GetUserActivityInsightsParams) ([]database.GetUserActivityInsightsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserActivityInsights", ctx, arg)
	ret0, _ := ret[0].([]database.GetUserActivityInsightsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserActivityInsights indicates an expected call of GetUserActivityInsights.
func (mr *MockStoreMockRecorder) GetUserActivityInsights(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserActivityInsights", reflect.TypeOf((*MockStore)(nil).GetUserActivityInsights), ctx, arg)
}

// GetUserAgentChatSendShortcut mocks base method.
func (m *MockStore) GetUserAgentChatSendShortcut(ctx context.Context, userID uuid.UUID) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserAgentChatSendShortcut", ctx, userID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserAppearanceSettings mocks base method.
func (m *MockStore) GetUserAppearanceSettings(ctx context.Context, userID uuid.UUID) (database.GetUserAppearanceSettingsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserAppearanceSettings", ctx, userID)
	ret0, _ := ret[0].(database.GetUserAppearanceSettingsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserByEmailOrUsername mocks base method.
func (m *MockStore) GetUserByEmailOrUsername(ctx context.Context, arg database.GetUserByEmailOrUsernameParams) (database.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserByEmailOrUsername", ctx, arg)
	ret0, _ := ret[0].(database.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserByEmailOrUsername indicates an expected call of GetUserByEmailOrUsername.
func (mr *MockStoreMockRecorder) GetUserByEmailOrUsername(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByEmailOrUsername", reflect.TypeOf((*MockStore)(nil).GetUserByEmailOrUsername), ctx, arg)
}

// GetUserByID mocks base method.
func (m *MockStore) GetUserByID(ctx context.Context, id uuid.UUID) (database.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserByID", ctx, id)
	ret0, _ := ret[0].(database.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserChatCompactionThreshold mocks base method.
func (m *MockStore) GetUserChatCompactionThreshold(ctx context.Context, arg database.GetUserChatCompactionThresholdParams) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserChatCompactionThreshold", ctx, arg)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserChatCompactionThreshold indicates an expected call of GetUserChatCompactionThreshold.
func (mr *MockStoreMockRecorder) GetUserChatCompactionThreshold(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserChatCompactionThreshold", reflect.TypeOf((*MockStore)(nil).GetUserChatCompactionThreshold), ctx, arg)
}

// GetUserChatCustomPrompt mocks base method.
func (m *MockStore) GetUserChatCustomPrompt(ctx context.Context, userID uuid.UUID) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserChatCustomPrompt", ctx, userID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserChatDebugLoggingEnabled mocks base method.
func (m *MockStore) GetUserChatDebugLoggingEnabled(ctx context.Context, userID uuid.UUID) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserChatDebugLoggingEnabled", ctx, userID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserChatPersonalModelOverride mocks base method.
func (m *MockStore) GetUserChatPersonalModelOverride(ctx context.Context, arg database.GetUserChatPersonalModelOverrideParams) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserChatPersonalModelOverride", ctx, arg)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserChatPersonalModelOverride indicates an expected call of GetUserChatPersonalModelOverride.
func (mr *MockStoreMockRecorder) GetUserChatPersonalModelOverride(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserChatPersonalModelOverride", reflect.TypeOf((*MockStore)(nil).GetUserChatPersonalModelOverride), ctx, arg)
}

// GetUserChatSpendInPeriod mocks base method.
func (m *MockStore) GetUserChatSpendInPeriod(ctx context.Context, arg database.GetUserChatSpendInPeriodParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserChatSpendInPeriod", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserChatSpendInPeriod indicates an expected call of GetUserChatSpendInPeriod.
func (mr *MockStoreMockRecorder) GetUserChatSpendInPeriod(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserChatSpendInPeriod", reflect.TypeOf((*MockStore)(nil).GetUserChatSpendInPeriod), ctx, arg)
}

// GetUserCodeDiffDisplayMode mocks base method.
func (m *MockStore) GetUserCodeDiffDisplayMode(ctx context.Context, userID uuid.UUID) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserCodeDiffDisplayMode", ctx, userID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserCount mocks base method.
func (m *MockStore) GetUserCount(ctx context.Context, includeSystem bool) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserCount", ctx, includeSystem)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserCount indicates an expected call of GetUserCount.
func (mr *MockStoreMockRecorder) GetUserCount(ctx, includeSystem any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserCount", reflect.TypeOf((*MockStore)(nil).GetUserCount), ctx, includeSystem)
}

// GetUserGroupSpendLimit mocks base method.
func (m *MockStore) GetUserGroupSpendLimit(ctx context.Context, arg database.GetUserGroupSpendLimitParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserGroupSpendLimit", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserGroupSpendLimit indicates an expected call of GetUserGroupSpendLimit.
func (mr *MockStoreMockRecorder) GetUserGroupSpendLimit(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserGroupSpendLimit", reflect.TypeOf((*MockStore)(nil).GetUserGroupSpendLimit), ctx, arg)
}

// GetUserLatencyInsights mocks base method.
func (m *MockStore) GetUserLatencyInsights(ctx context.Context, arg database.GetUserLatencyInsightsParams) ([]database.GetUserLatencyInsightsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserLatencyInsights", ctx, arg)
	ret0, _ := ret[0].([]database.GetUserLatencyInsightsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserLatencyInsights indicates an expected call of GetUserLatencyInsights.
func (mr *MockStoreMockRecorder) GetUserLatencyInsights(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserLatencyInsights", reflect.TypeOf((*MockStore)(nil).GetUserLatencyInsights), ctx, arg)
}

// GetUserLinkByLinkedID mocks base method.
func (m *MockStore) GetUserLinkByLinkedID(ctx context.Context, linkedID string) (database.UserLink, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserLinkByLinkedID", ctx, linkedID)
	ret0, _ := ret[0].(database.UserLink)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserLinkByLinkedID indicates an expected call of GetUserLinkByLinkedID.
func (mr *MockStoreMockRecorder) GetUserLinkByLinkedID(ctx, linkedID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserLinkByLinkedID", reflect.TypeOf((*MockStore)(nil).GetUserLinkByLinkedID), ctx, linkedID)
}

// GetUserLinkByUserIDLoginType mocks base method.
func (m *MockStore) GetUserLinkByUserIDLoginType(ctx context.Context, arg database.GetUserLinkByUserIDLoginTypeParams) (database.UserLink, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserLinkByUserIDLoginType", ctx, arg)
	ret0, _ := ret[0].(database.UserLink)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserLinkByUserIDLoginType indicates an expected call of GetUserLinkByUserIDLoginType.
func (mr *MockStoreMockRecorder) GetUserLinkByUserIDLoginType(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserLinkByUserIDLoginType", reflect.TypeOf((*MockStore)(nil).GetUserLinkByUserIDLoginType), ctx, arg)
}

// GetUserLinksByUserID mocks base method.
func (m *MockStore) GetUserLinksByUserID(ctx context.Context, userID uuid.UUID) ([]database.UserLink, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserLinksByUserID", ctx, userID)
	ret0, _ := ret[0].([]database.UserLink)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserNotificationPreferences mocks base method.
func (m *MockStore) GetUserNotificationPreferences(ctx context.Context, userID uuid.UUID) ([]database.NotificationPreference, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserNotificationPreferences", ctx, userID)
	ret0, _ := ret[0].([]database.NotificationPreference)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserSecretByID mocks base method.
func (m *MockStore) GetUserSecretByID(ctx context.Context, id uuid.UUID) (database.UserSecret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserSecretByID", ctx, id)
	ret0, _ := ret[0].(database.UserSecret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserSecretByUserIDAndName mocks base method.
func (m *MockStore) GetUserSecretByUserIDAndName(ctx context.Context, arg database.GetUserSecretByUserIDAndNameParams) (database.UserSecret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserSecretByUserIDAndName", ctx, arg)
	ret0, _ := ret[0].(database.UserSecret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserSecretByUserIDAndName indicates an expected call of GetUserSecretByUserIDAndName.
func (mr *MockStoreMockRecorder) GetUserSecretByUserIDAndName(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserSecretByUserIDAndName", reflect.TypeOf((*MockStore)(nil).GetUserSecretByUserIDAndName), ctx, arg)
}

// GetUserSecretsTelemetrySummary mocks base method.
func (m *MockStore) GetUserSecretsTelemetrySummary(ctx context.Context) (database.GetUserSecretsTelemetrySummaryRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserSecretsTelemetrySummary", ctx)
	ret0, _ := ret[0].(database.GetUserSecretsTelemetrySummaryRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserShellToolDisplayMode mocks base method.
func (m *MockStore) GetUserShellToolDisplayMode(ctx context.Context, userID uuid.UUID) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserShellToolDisplayMode", ctx, userID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserSkillByUserIDAndName mocks base method.
func (m *MockStore) GetUserSkillByUserIDAndName(ctx context.Context, arg database.GetUserSkillByUserIDAndNameParams) (database.UserSkill, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserSkillByUserIDAndName", ctx, arg)
	ret0, _ := ret[0].(database.UserSkill)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserSkillByUserIDAndName indicates an expected call of GetUserSkillByUserIDAndName.
func (mr *MockStoreMockRecorder) GetUserSkillByUserIDAndName(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserSkillByUserIDAndName", reflect.TypeOf((*MockStore)(nil).GetUserSkillByUserIDAndName), ctx, arg)
}

// GetUserStatusCounts mocks base method.
func (m *MockStore) GetUserStatusCounts(ctx context.Context, arg database.GetUserStatusCountsParams) ([]database.GetUserStatusCountsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserStatusCounts", ctx, arg)
	ret0, _ := ret[0].([]database.GetUserStatusCountsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserStatusCounts indicates an expected call of GetUserStatusCounts.
func (mr *MockStoreMockRecorder) GetUserStatusCounts(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserStatusCounts", reflect.TypeOf((*MockStore)(nil).GetUserStatusCounts), ctx, arg)
}

// GetUserTaskNotificationAlertDismissed mocks base method.
func (m *MockStore) GetUserTaskNotificationAlertDismissed(ctx context.Context, userID uuid.UUID) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserTaskNotificationAlertDismissed", ctx, userID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserThinkingDisplayMode mocks base method.
func (m *MockStore) GetUserThinkingDisplayMode(ctx context.Context, userID uuid.UUID) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserThinkingDisplayMode", ctx, userID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserWorkspaceBuildParameters mocks base method.
func (m *MockStore) GetUserWorkspaceBuildParameters(ctx context.Context, arg database.GetUserWorkspaceBuildParametersParams) ([]database.GetUserWorkspaceBuildParametersRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserWorkspaceBuildParameters", ctx, arg)
	ret0, _ := ret[0].([]database.GetUserWorkspaceBuildParametersRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserWorkspaceBuildParameters indicates an expected call of GetUserWorkspaceBuildParameters.
func (mr *MockStoreMockRecorder) GetUserWorkspaceBuildParameters(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserWorkspaceBuildParameters", reflect.TypeOf((*MockStore)(nil).GetUserWorkspaceBuildParameters), ctx, arg)
}

// GetUsers mocks base method.
func (m *MockStore) GetUsers(ctx context.Context, arg database.GetUsersParams) ([]database.GetUsersRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUsers", ctx, arg)
	ret0, _ := ret[0].([]database.GetUsersRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUsers indicates an expected call of GetUsers.
func (mr *MockStoreMockRecorder) GetUsers(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUsers", reflect.TypeOf((*MockStore)(nil).GetUsers), ctx, arg)
}

// GetUsersByIDs mocks base method.
func (m *MockStore) GetUsersByIDs(ctx context.Context, ids []uuid.UUID) ([]database.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUsersByIDs", ctx, ids)
	ret0, _ := ret[0].([]database.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWebpushSubscriptionsByUserID mocks base method.
func (m *MockStore) GetWebpushSubscriptionsByUserID(ctx context.Context, userID uuid.UUID) ([]database.WebpushSubscription, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWebpushSubscriptionsByUserID", ctx, userID)
	ret0, _ := ret[0].([]database.WebpushSubscription)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWebpushVAPIDKeys mocks base method.
func (m *MockStore) GetWebpushVAPIDKeys(ctx context.Context) (database.GetWebpushVAPIDKeysRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWebpushVAPIDKeys", ctx)
	ret0, _ := ret[0].(database.GetWebpushVAPIDKeysRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkspaceACLByID mocks base method.
func (m *MockStore) GetWorkspaceACLByID(ctx context.Context, id uuid.UUID) (database.GetWorkspaceACLByIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceACLByID", ctx, id)
	ret0, _ := ret[0].(database.GetWorkspaceACLByIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkspaceAgentAndWorkspaceByID mocks base method.
func (m *MockStore) GetWorkspaceAgentAndWorkspaceByID(ctx context.Context, id uuid.UUID) (database.GetWorkspaceAgentAndWorkspaceByIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentAndWorkspaceByID", ctx, id)
	ret0, _ := ret[0].(database.GetWorkspaceAgentAndWorkspaceByIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkspaceAgentByID mocks base method.
func (m *MockStore) GetWorkspaceAgentByID(ctx context.Context, id uuid.UUID) (database.WorkspaceAgent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentByID", ctx, id)
	ret0, _ := ret[0].(database.WorkspaceAgent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkspaceAgentDevcontainersByAgentID mocks base method.
func (m *MockStore) GetWorkspaceAgentDevcontainersByAgentID(ctx context.Context, workspaceAgentID uuid.UUID) ([]database.WorkspaceAgentDevcontainer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentDevcontainersByAgentID", ctx, workspaceAgentID)
	ret0, _ := ret[0].([]database.WorkspaceAgentDevcontainer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceAgentDevcontainersByAgentID indicates an expected call of GetWorkspaceAgentDevcontainersByAgentID.
func (mr *MockStoreMockRecorder) GetWorkspaceAgentDevcontainersByAgentID(ctx, workspaceAgentID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceAgentDevcontainersByAgentID", reflect.TypeOf((*MockStore)(nil).GetWorkspaceAgentDevcontainersByAgentID), ctx, workspaceAgentID)
}

// GetWorkspaceAgentLifecycleStateByID mocks base method.
func (m *MockStore) GetWorkspaceAgentLifecycleStateByID(ctx context.Context, id uuid.UUID) (database.GetWorkspaceAgentLifecycleStateByIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentLifecycleStateByID", ctx, id)
	ret0, _ := ret[0].(database.GetWorkspaceAgentLifecycleStateByIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkspaceAgentLogSourcesByAgentIDs mocks base method.
func (m *MockStore) GetWorkspaceAgentLogSourcesByAgentIDs(ctx context.Context, ids []uuid.UUID) ([]database.WorkspaceAgentLogSource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentLogSourcesByAgentIDs", ctx, ids)
	ret0, _ := ret[0].([]database.WorkspaceAgentLogSource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkspaceAgentLogsAfter mocks base method.
func (m *MockStore) GetWorkspaceAgentLogsAfter(ctx context.Context, arg database.GetWorkspaceAgentLogsAfterParams) ([]database.WorkspaceAgentLog, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentLogsAfter", ctx, arg)
	ret0, _ := ret[0].([]database.WorkspaceAgentLog)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceAgentLogsAfter indicates an expected call of GetWorkspaceAgentLogsAfter.
func (mr *MockStoreMockRecorder) GetWorkspaceAgentLogsAfter(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceAgentLogsAfter", reflect.TypeOf((*MockStore)(nil).GetWorkspaceAgentLogsAfter), ctx, arg)
}

// GetWorkspaceAgentMetadata mocks base method.
func (m *MockStore) GetWorkspaceAgentMetadata(ctx context.Context, arg database.GetWorkspaceAgentMetadataParams) ([]database.WorkspaceAgentMetadatum, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentMetadata", ctx, arg)
	ret0, _ := ret[0].([]database.WorkspaceAgentMetadatum)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceAgentMetadata indicates an expected call of GetWorkspaceAgentMetadata.
func (mr *MockStoreMockRecorder) GetWorkspaceAgentMetadata(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceAgentMetadata", reflect.TypeOf((*MockStore)(nil).GetWorkspaceAgentMetadata), ctx, arg)
}

// GetWorkspaceAgentPortShare mocks base method.
func (m *MockStore) GetWorkspaceAgentPortShare(ctx context.Context, arg database.GetWorkspaceAgentPortShareParams) (database.WorkspaceAgentPortShare, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentPortShare", ctx, arg)
	ret0, _ := ret[0].(database.WorkspaceAgentPortShare)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceAgentPortShare indicates an expected call of GetWorkspaceAgentPortShare.
func (mr *MockStoreMockRecorder) GetWorkspaceAgentPortShare(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceAgentPortShare", reflect.TypeOf((*MockStore)(nil).GetWorkspaceAgentPortShare), ctx, arg)
}

// GetWorkspaceAgentScriptTimingsByBuildID mocks base method.
func (m *MockStore) GetWorkspaceAgentScriptTimingsByBuildID(ctx context.Context, id uuid.UUID) ([]database.GetWorkspaceAgentScriptTimingsByBuildIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentScriptTimingsByBuildID", ctx, id)
	ret0, _ := ret[0].([]database.GetWorkspaceAgentScriptTimingsByBuildIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkspaceAgentScriptsByAgentIDs mocks base method.
func (m *MockStore) GetWorkspaceAgentScriptsByAgentIDs(ctx context.Context, ids []uuid.UUID) ([]database.GetWorkspaceAgentScriptsByAgentIDsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentScriptsByAgentIDs", ctx, ids)
	ret0, _ := ret[0].([]database.GetWorkspaceAgentScriptsByAgentIDsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkspaceAgentStats mocks base method.
func (m *MockStore) GetWorkspaceAgentStats(ctx context.Context, createdAt time.Time) ([]database.GetWorkspaceAgentStatsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentStats", ctx, createdAt)
	ret0, _ := ret[0].([]database.GetWorkspaceAgentStatsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceAgentStats indicates an expected call of GetWorkspaceAgentStats.
func (mr *MockStoreMockRecorder) GetWorkspaceAgentStats(ctx, createdAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceAgentStats", reflect.TypeOf((*MockStore)(nil).GetWorkspaceAgentStats), ctx, createdAt)
}

// GetWorkspaceAgentStatsAndLabels mocks base method.
func (m *MockStore) GetWorkspaceAgentStatsAndLabels(ctx context.Context, createdAt time.Time) ([]database.GetWorkspaceAgentStatsAndLabelsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentStatsAndLabels", ctx, createdAt)
	ret0, _ := ret[0].([]database.GetWorkspaceAgentStatsAndLabelsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceAgentStatsAndLabels indicates an expected call of GetWorkspaceAgentStatsAndLabels.
func (mr *MockStoreMockRecorder) GetWorkspaceAgentStatsAndLabels(ctx, createdAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceAgentStatsAndLabels", reflect.TypeOf((*MockStore)(nil).GetWorkspaceAgentStatsAndLabels), ctx, createdAt)
}

// GetWorkspaceAgentUsageStats mocks base method.
func (m *MockStore) GetWorkspaceAgentUsageStats(ctx context.Context, createdAt time.Time) ([]database.GetWorkspaceAgentUsageStatsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentUsageStats", ctx, createdAt)
	ret0, _ := ret[0].([]database.GetWorkspaceAgentUsageStatsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceAgentUsageStats indicates an expected call of GetWorkspaceAgentUsageStats.
func (mr *MockStoreMockRecorder) GetWorkspaceAgentUsageStats(ctx, createdAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceAgentUsageStats", reflect.TypeOf((*MockStore)(nil).GetWorkspaceAgentUsageStats), ctx, createdAt)
}

// GetWorkspaceAgentUsageStatsAndLabels mocks base method.
func (m *MockStore) GetWorkspaceAgentUsageStatsAndLabels(ctx context.Context, createdAt time.Time) ([]database.GetWorkspaceAgentUsageStatsAndLabelsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentUsageStatsAndLabels", ctx, createdAt)
	ret0, _ := ret[0].([]database.GetWorkspaceAgentUsageStatsAndLabelsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceAgentUsageStatsAndLabels indicates an expected call of GetWorkspaceAgentUsageStatsAndLabels.
func (mr *MockStoreMockRecorder) GetWorkspaceAgentUsageStatsAndLabels(ctx, createdAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceAgentUsageStatsAndLabels", reflect.TypeOf((*MockStore)(nil).GetWorkspaceAgentUsageStatsAndLabels), ctx, createdAt)
}

// GetWorkspaceAgentsByInstanceID mocks base method.
func (m *MockStore) GetWorkspaceAgentsByInstanceID(ctx context.Context, authInstanceID string) ([]database.WorkspaceAgent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentsByInstanceID", ctx, authInstanceID)
	ret0, _ := ret[0].([]database.WorkspaceAgent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceAgentsByInstanceID indicates an expected call of GetWorkspaceAgentsByInstanceID.
func (mr *MockStoreMockRecorder) GetWorkspaceAgentsByInstanceID(ctx, authInstanceID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceAgentsByInstanceID", reflect.TypeOf((*MockStore)(nil).GetWorkspaceAgentsByInstanceID), ctx, authInstanceID)
}

// GetWorkspaceAgentsByParentID mocks base method.
func (m *MockStore) GetWorkspaceAgentsByParentID(ctx context.Context, parentID uuid.UUID) ([]database.WorkspaceAgent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentsByParentID", ctx, parentID)
	ret0, _ := ret[0].([]database.WorkspaceAgent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceAgentsByParentID indicates an expected call of GetWorkspaceAgentsByParentID.
func (mr *MockStoreMockRecorder) GetWorkspaceAgentsByParentID(ctx, parentID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceAgentsByParentID", reflect.TypeOf((*MockStore)(nil).GetWorkspaceAgentsByParentID), ctx, parentID)
}

// GetWorkspaceAgentsByResourceIDs mocks base method.
func (m *MockStore) GetWorkspaceAgentsByResourceIDs(ctx context.Context, ids []uuid.UUID) ([]database.WorkspaceAgent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentsByResourceIDs", ctx, ids)
	ret0, _ := ret[0].([]database.WorkspaceAgent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkspaceAgentsByWorkspaceAndBuildNumber mocks base method.
func (m *MockStore) GetWorkspaceAgentsByWorkspaceAndBuildNumber(ctx context.Context, arg database.GetWorkspaceAgentsByWorkspaceAndBuildNumberParams) ([]database.WorkspaceAgent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentsByWorkspaceAndBuildNumber", ctx, arg)
	ret0, _ := ret[0].([]database.WorkspaceAgent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceAgentsByWorkspaceAndBuildNumber indicates an expected call of GetWorkspaceAgentsByWorkspaceAndBuildNumber.
func (mr *MockStoreMockRecorder) GetWorkspaceAgentsByWorkspaceAndBuildNumber(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceAgentsByWorkspaceAndBuildNumber", reflect.TypeOf((*MockStore)(nil).GetWorkspaceAgentsByWorkspaceAndBuildNumber), ctx, arg)
}

// GetWorkspaceAgentsCreatedAfter mocks base method.
func (m *MockStore) GetWorkspaceAgentsCreatedAfter(ctx context.Context, createdAt time.Time) ([]database.WorkspaceAgent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentsCreatedAfter", ctx, createdAt)
	ret0, _ := ret[0].([]database.WorkspaceAgent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceAgentsCreatedAfter indicates an expected call of GetWorkspaceAgentsCreatedAfter.
func (mr *MockStoreMockRecorder) GetWorkspaceAgentsCreatedAfter(ctx, createdAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceAgentsCreatedAfter", reflect.TypeOf((*MockStore)(nil).GetWorkspaceAgentsCreatedAfter), ctx, createdAt)
}

// GetWorkspaceAgentsForMetrics mocks base method.
func (m *MockStore) GetWorkspaceAgentsForMetrics(ctx context.Context) ([]database.GetWorkspaceAgentsForMetricsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentsForMetrics", ctx)
	ret0, _ := ret[0].([]database.GetWorkspaceAgentsForMetricsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkspaceAgentsInLatestBuildByWorkspaceID mocks base method.
func (m *MockStore) GetWorkspaceAgentsInLatestBuildByWorkspaceID(ctx context.Context, workspaceID uuid.UUID) ([]database.WorkspaceAgent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAgentsInLatestBuildByWorkspaceID", ctx, workspaceID)
	ret0, _ := ret[0].([]database.WorkspaceAgent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceAgentsInLatestBuildByWorkspaceID indicates an expected call of GetWorkspaceAgentsInLatestBuildByWorkspaceID.
func (mr *MockStoreMockRecorder) GetWorkspaceAgentsInLatestBuildByWorkspaceID(ctx, workspaceID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceAgentsInLatestBuildByWorkspaceID", reflect.TypeOf((*MockStore)(nil).GetWorkspaceAgentsInLatestBuildByWorkspaceID), ctx, workspaceID)
}

// GetWorkspaceAppByAgentIDAndSlug mocks base method.
func (m *MockStore) GetWorkspaceAppByAgentIDAndSlug(ctx context.Context, arg database.GetWorkspaceAppByAgentIDAndSlugParams) (database.WorkspaceApp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAppByAgentIDAndSlug", ctx, arg)
	ret0, _ := ret[0].(database.WorkspaceApp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceAppByAgentIDAndSlug indicates an expected call of GetWorkspaceAppByAgentIDAndSlug.
func (mr *MockStoreMockRecorder) GetWorkspaceAppByAgentIDAndSlug(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceAppByAgentIDAndSlug", reflect.TypeOf((*MockStore)(nil).GetWorkspaceAppByAgentIDAndSlug), ctx, arg)
}

// GetWorkspaceAppStatusesByAppIDs mocks base method.
func (m *MockStore) GetWorkspaceAppStatusesByAppIDs(ctx context.Context, ids []uuid.UUID) ([]database.WorkspaceAppStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAppStatusesByAppIDs", ctx, ids)
	ret0, _ := ret[0].([]database.WorkspaceAppStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkspaceAppsByAgentID mocks base method.
func (m *MockStore) GetWorkspaceAppsByAgentID(ctx context.Context, agentID uuid.UUID) ([]database.WorkspaceApp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAppsByAgentID", ctx, agentID)
	ret0, _ := ret[0].([]database.WorkspaceApp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceAppsByAgentID indicates an expected call of GetWorkspaceAppsByAgentID.
func (mr *MockStoreMockRecorder) GetWorkspaceAppsByAgentID(ctx, agentID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceAppsByAgentID", reflect.TypeOf((*MockStore)(nil).GetWorkspaceAppsByAgentID), ctx, agentID)
}

// GetWorkspaceAppsByAgentIDs mocks base method.
func (m *MockStore) GetWorkspaceAppsByAgentIDs(ctx context.Context, ids []uuid.UUID) ([]database.WorkspaceApp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAppsByAgentIDs", ctx, ids)
	ret0, _ := ret[0].([]database.WorkspaceApp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkspaceAppsCreatedAfter mocks base method.
func (m *MockStore) GetWorkspaceAppsCreatedAfter(ctx context.Context, createdAt time.Time) ([]database.WorkspaceApp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceAppsCreatedAfter", ctx, createdAt)
	ret0, _ := ret[0].([]database.WorkspaceApp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceAppsCreatedAfter indicates an expected call of GetWorkspaceAppsCreatedAfter.
func (mr *MockStoreMockRecorder) GetWorkspaceAppsCreatedAfter(ctx, createdAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceAppsCreatedAfter", reflect.TypeOf((*MockStore)(nil).GetWorkspaceAppsCreatedAfter), ctx, createdAt)
}

// GetWorkspaceBuildAgentsByInstanceID mocks base method.
func (m *MockStore) GetWorkspaceBuildAgentsByInstanceID(ctx context.Context, authInstanceID string) ([]database.GetWorkspaceBuildAgentsByInstanceIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceBuildAgentsByInstanceID", ctx, authInstanceID)
	ret0, _ := ret[0].([]database.GetWorkspaceBuildAgentsByInstanceIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceBuildAgentsByInstanceID indicates an expected call of GetWorkspaceBuildAgentsByInstanceID.
func (mr *MockStoreMockRecorder) GetWorkspaceBuildAgentsByInstanceID(ctx, authInstanceID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceBuildAgentsByInstanceID", reflect.TypeOf((*MockStore)(nil).GetWorkspaceBuildAgentsByInstanceID), ctx, authInstanceID)
}

// GetWorkspaceBuildByID mocks base method.
func (m *MockStore) GetWorkspaceBuildByID(ctx context.Context, id uuid.UUID) (database.WorkspaceBuild, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceBuildByID", ctx, id)
	ret0, _ := ret[0].(database.WorkspaceBuild)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkspaceBuildByJobID mocks base method.
func (m *MockStore) GetWorkspaceBuildByJobID(ctx context.Context, jobID uuid.UUID) (database.WorkspaceBuild, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceBuildByJobID", ctx, jobID)
	ret0, _ := ret[0].(database.WorkspaceBuild)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceBuildByJobID indicates an expected call of GetWorkspaceBuildByJobID.
func (mr *MockStoreMockRecorder) GetWorkspaceBuildByJobID(ctx, jobID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceBuildByJobID", reflect.TypeOf((*MockStore)(nil).GetWorkspaceBuildByJobID), ctx, jobID)
}

// GetWorkspaceBuildByWorkspaceIDAndBuildNumber mocks base method.
func (m *MockStore) GetWorkspaceBuildByWorkspaceIDAndBuildNumber(ctx context.Context, arg database.GetWorkspaceBuildByWorkspaceIDAndBuildNumberParams) (database.WorkspaceBuild, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceBuildByWorkspaceIDAndBuildNumber", ctx, arg)
	ret0, _ := ret[0].(database.WorkspaceBuild)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceBuildByWorkspaceIDAndBuildNumber indicates an expected call of GetWorkspaceBuildByWorkspaceIDAndBuildNumber.
func (mr *MockStoreMockRecorder) GetWorkspaceBuildByWorkspaceIDAndBuildNumber(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceBuildByWorkspaceIDAndBuildNumber", reflect.TypeOf((*MockStore)(nil).GetWorkspaceBuildByWorkspaceIDAndBuildNumber), ctx, arg)
}

// GetWorkspaceBuildMetricsByResourceID mocks base method.
func (m *MockStore) GetWorkspaceBuildMetricsByResourceID(ctx context.Context, id uuid.UUID) (database.GetWorkspaceBuildMetricsByResourceIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceBuildMetricsByResourceID", ctx, id)
	ret0, _ := ret[0].(database.GetWorkspaceBuildMetricsByResourceIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkspaceBuildParameters mocks base method.
func (m *MockStore) GetWorkspaceBuildParameters(ctx context.Context, workspaceBuildID uuid.UUID) ([]database.WorkspaceBuildParameter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceBuildParameters", ctx, workspaceBuildID)
	ret0, _ := ret[0].([]database.WorkspaceBuildParameter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceBuildParameters indicates an expected call of GetWorkspaceBuildParameters.
func (mr *MockStoreMockRecorder) GetWorkspaceBuildParameters(ctx, workspaceBuildID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceBuildParameters", reflect.TypeOf((*MockStore)(nil).GetWorkspaceBuildParameters), ctx, workspaceBuildID)
}

// GetWorkspaceBuildProvisionerStateByID mocks base method.
func (m *MockStore) GetWorkspaceBuildProvisionerStateByID(ctx context.Context, workspaceBuildID uuid.UUID) (database.GetWorkspaceBuildProvisionerStateByIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceBuildProvisionerStateByID", ctx, workspaceBuildID)
	ret0, _ := ret[0].(database.GetWorkspaceBuildProvisionerStateByIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceBuildProvisionerStateByID indicates an expected call of GetWorkspaceBuildProvisionerStateByID.
func (mr *MockStoreMockRecorder) GetWorkspaceBuildProvisionerStateByID(ctx, workspaceBuildID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceBuildProvisionerStateByID", reflect.TypeOf((*MockStore)(nil).GetWorkspaceBuildProvisionerStateByID), ctx, workspaceBuildID)
}

// GetWorkspaceBuildStatsByTemplates mocks base method.
func (m *MockStore) GetWorkspaceBuildStatsByTemplates(ctx context.Context, since time.Time) ([]database.GetWorkspaceBuildStatsByTemplatesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceBuildStatsByTemplates", ctx, since)
	ret0, _ := ret[0].([]database.GetWorkspaceBuildStatsByTemplatesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceBuildStatsByTemplates indicates an expected call of GetWorkspaceBuildStatsByTemplates.
func (mr *MockStoreMockRecorder) GetWorkspaceBuildStatsByTemplates(ctx, since any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceBuildStatsByTemplates", reflect.TypeOf((*MockStore)(nil).GetWorkspaceBuildStatsByTemplates), ctx, since)
}

// GetWorkspaceBuildsByWorkspaceID mocks base method.
func (m *MockStore) GetWorkspaceBuildsByWorkspaceID(ctx context.Context, arg database.GetWorkspaceBuildsByWorkspaceIDParams) ([]database.WorkspaceBuild, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceBuildsByWorkspaceID", ctx, arg)
	ret0, _ := ret[0].([]database.WorkspaceBuild)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceBuildsByWorkspaceID indicates an expected call of GetWorkspaceBuildsByWorkspaceID.
func (mr *MockStoreMockRecorder) GetWorkspaceBuildsByWorkspaceID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceBuildsByWorkspaceID", reflect.TypeOf((*MockStore)(nil).GetWorkspaceBuildsByWorkspaceID), ctx, arg)
}

// GetWorkspaceBuildsCreatedAfter mocks base method.
func (m *MockStore) GetWorkspaceBuildsCreatedAfter(ctx context.Context, createdAt time.Time) ([]database.WorkspaceBuild, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceBuildsCreatedAfter", ctx, createdAt)
	ret0, _ := ret[0].([]database.WorkspaceBuild)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceBuildsCreatedAfter indicates an expected call of GetWorkspaceBuildsCreatedAfter.
func (mr *MockStoreMockRecorder) GetWorkspaceBuildsCreatedAfter(ctx, createdAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceBuildsCreatedAfter", reflect.TypeOf((*MockStore)(nil).GetWorkspaceBuildsCreatedAfter), ctx, createdAt)
}

// GetWorkspaceByAgentID mocks base method.
func (m *MockStore) GetWorkspaceByAgentID(ctx context.Context, agentID uuid.UUID) (database.Workspace, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceByAgentID", ctx, agentID)
	ret0, _ := ret[0].(database.Workspace)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceByAgentID indicates an expected call of GetWorkspaceByAgentID.
func (mr *MockStoreMockRecorder) GetWorkspaceByAgentID(ctx, agentID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceByAgentID", reflect.TypeOf((*MockStore)(nil).GetWorkspaceByAgentID), ctx, agentID)
}

// GetWorkspaceByID mocks base method.
func (m *MockStore) GetWorkspaceByID(ctx context.Context, id uuid.UUID) (database.Workspace, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceByID", ctx, id)
	ret0, _ := ret[0].(database.Workspace)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkspaceByOwnerIDAndName mocks base method.
func (m *MockStore) GetWorkspaceByOwnerIDAndName(ctx context.Context, arg database.GetWorkspaceByOwnerIDAndNameParams) (database.Workspace, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceByOwnerIDAndName", ctx, arg)
	ret0, _ := ret[0].(database.Workspace)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceByOwnerIDAndName indicates an expected call of GetWorkspaceByOwnerIDAndName.
func (mr *MockStoreMockRecorder) GetWorkspaceByOwnerIDAndName(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceByOwnerIDAndName", reflect.TypeOf((*MockStore)(nil).GetWorkspaceByOwnerIDAndName), ctx, arg)
}

// GetWorkspaceByResourceID mocks base method.
func (m *MockStore) GetWorkspaceByResourceID(ctx context.Context, resourceID uuid.UUID) (database.Workspace, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceByResourceID", ctx, resourceID)
	ret0, _ := ret[0].(database.Workspace)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceByResourceID indicates an expected call of GetWorkspaceByResourceID.
func (mr *MockStoreMockRecorder) GetWorkspaceByResourceID(ctx, resourceID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceByResourceID", reflect.TypeOf((*MockStore)(nil).GetWorkspaceByResourceID), ctx, resourceID)
}

// GetWorkspaceByWorkspaceAppID mocks base method.
func (m *MockStore) GetWorkspaceByWorkspaceAppID(ctx context.Context, workspaceAppID uuid.UUID) (database.Workspace, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceByWorkspaceAppID", ctx, workspaceAppID)
	ret0, _ := ret[0].(database.Workspace)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceByWorkspaceAppID indicates an expected call of GetWorkspaceByWorkspaceAppID.
func (mr *MockStoreMockRecorder) GetWorkspaceByWorkspaceAppID(ctx, workspaceAppID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceByWorkspaceAppID", reflect.TypeOf((*MockStore)(nil).GetWorkspaceByWorkspaceAppID), ctx, workspaceAppID)
}

// GetWorkspaceModulesByJobID mocks base method.
func (m *MockStore) GetWorkspaceModulesByJobID(ctx context.Context, jobID uuid.UUID) ([]database.WorkspaceModule, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceModulesByJobID", ctx, jobID)
	ret0, _ := ret[0].([]database.WorkspaceModule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceModulesByJobID indicates an expected call of GetWorkspaceModulesByJobID.
func (mr *MockStoreMockRecorder) GetWorkspaceModulesByJobID(ctx, jobID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceModulesByJobID", reflect.TypeOf((*MockStore)(nil).GetWorkspaceModulesByJobID), ctx, jobID)
}

// GetWorkspaceModulesCreatedAfter mocks base method.
func (m *MockStore) GetWorkspaceModulesCreatedAfter(ctx context.Context, createdAt time.Time) ([]database.WorkspaceModule, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceModulesCreatedAfter", ctx, createdAt)
	ret0, _ := ret[0].([]database.WorkspaceModule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceModulesCreatedAfter indicates an expected call of GetWorkspaceModulesCreatedAfter.
func (mr *MockStoreMockRecorder) GetWorkspaceModulesCreatedAfter(ctx, createdAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceModulesCreatedAfter", reflect.TypeOf((*MockStore)(nil).GetWorkspaceModulesCreatedAfter), ctx, createdAt)
}

// GetWorkspaceProxies mocks base method.
func (m *MockStore) GetWorkspaceProxies(ctx context.Context) ([]database.WorkspaceProxy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceProxies", ctx)
	ret0, _ := ret[0].([]database.WorkspaceProxy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkspaceProxyByHostname mocks base method.
func (m *MockStore) GetWorkspaceProxyByHostname(ctx context.Context, arg database.GetWorkspaceProxyByHostnameParams) (database.WorkspaceProxy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceProxyByHostname", ctx, arg)
	ret0, _ := ret[0].(database.WorkspaceProxy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceProxyByHostname indicates an expected call of GetWorkspaceProxyByHostname.
func (mr *MockStoreMockRecorder) GetWorkspaceProxyByHostname(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceProxyByHostname", reflect.TypeOf((*MockStore)(nil).GetWorkspaceProxyByHostname), ctx, arg)
}

// GetWorkspaceProxyByID mocks base method.
func (m *MockStore) GetWorkspaceProxyByID(ctx context.Context, id uuid.UUID) (database.WorkspaceProxy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceProxyByID", ctx, id)
	ret0, _ := ret[0].(database.WorkspaceProxy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkspaceProxyByName mocks base method.
func (m *MockStore) GetWorkspaceProxyByName(ctx context.Context, name string) (database.WorkspaceProxy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceProxyByName", ctx, name)
	ret0, _ := ret[0].(database.WorkspaceProxy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceProxyByName indicates an expected call of GetWorkspaceProxyByName.
func (mr *MockStoreMockRecorder) GetWorkspaceProxyByName(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceProxyByName", reflect.TypeOf((*MockStore)(nil).GetWorkspaceProxyByName), ctx, name)
}

// GetWorkspaceResourceByID mocks base method.
func (m *MockStore) GetWorkspaceResourceByID(ctx context.Context, id uuid.UUID) (database.WorkspaceResource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceResourceByID", ctx, id)
	ret0, _ := ret[0].(database.WorkspaceResource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkspaceResourceMetadataByResourceIDs mocks base method.
func (m *MockStore) GetWorkspaceResourceMetadataByResourceIDs(ctx context.Context, ids []uuid.UUID) ([]database.WorkspaceResourceMetadatum, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceResourceMetadataByResourceIDs", ctx, ids)
	ret0, _ := ret[0].([]database.WorkspaceResourceMetadatum)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkspaceResourceMetadataCreatedAfter mocks base method.
func (m *MockStore) GetWorkspaceResourceMetadataCreatedAfter(ctx context.Context, createdAt time.Time) ([]database.WorkspaceResourceMetadatum, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceResourceMetadataCreatedAfter", ctx, createdAt)
	ret0, _ := ret[0].([]database.WorkspaceResourceMetadatum)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceResourceMetadataCreatedAfter indicates an expected call of GetWorkspaceResourceMetadataCreatedAfter.
func (mr *MockStoreMockRecorder) GetWorkspaceResourceMetadataCreatedAfter(ctx, createdAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceResourceMetadataCreatedAfter", reflect.TypeOf((*MockStore)(nil).GetWorkspaceResourceMetadataCreatedAfter), ctx, createdAt)
}

// GetWorkspaceResourcesByJobID mocks base method.
func (m *MockStore) GetWorkspaceResourcesByJobID(ctx context.Context, jobID uuid.UUID) ([]database.WorkspaceResource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceResourcesByJobID", ctx, jobID)
	ret0, _ := ret[0].([]database.WorkspaceResource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceResourcesByJobID indicates an expected call of GetWorkspaceResourcesByJobID.
func (mr *MockStoreMockRecorder) GetWorkspaceResourcesByJobID(ctx, jobID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceResourcesByJobID", reflect.TypeOf((*MockStore)(nil).GetWorkspaceResourcesByJobID), ctx, jobID)
}

// GetWorkspaceResourcesByJobIDs mocks base method.
func (m *MockStore) GetWorkspaceResourcesByJobIDs(ctx context.Context, ids []uuid.UUID) ([]database.WorkspaceResource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceResourcesByJobIDs", ctx, ids)
	ret0, _ := ret[0].([]database.WorkspaceResource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkspaceResourcesCreatedAfter mocks base method.
func (m *MockStore) GetWorkspaceResourcesCreatedAfter(ctx context.Context, createdAt time.Time) ([]database.WorkspaceResource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceResourcesCreatedAfter", ctx, createdAt)
	ret0, _ := ret[0].([]database.WorkspaceResource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceResourcesCreatedAfter indicates an expected call of GetWorkspaceResourcesCreatedAfter.
func (mr *MockStoreMockRecorder) GetWorkspaceResourcesCreatedAfter(ctx, createdAt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceResourcesCreatedAfter", reflect.TypeOf((*MockStore)(nil).GetWorkspaceResourcesCreatedAfter), ctx, createdAt)
}

// GetWorkspaceUniqueOwnerCountByTemplateIDs mocks base method.
func (m *MockStore) GetWorkspaceUniqueOwnerCountByTemplateIDs(ctx context.Context, templateIds []uuid.UUID) ([]database.GetWorkspaceUniqueOwnerCountByTemplateIDsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaceUniqueOwnerCountByTemplateIDs", ctx, templateIds)
	ret0, _ := ret[0].([]database.GetWorkspaceUniqueOwnerCountByTemplateIDsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaceUniqueOwnerCountByTemplateIDs indicates an expected call of GetWorkspaceUniqueOwnerCountByTemplateIDs.
func (mr *MockStoreMockRecorder) GetWorkspaceUniqueOwnerCountByTemplateIDs(ctx, templateIds any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceUniqueOwnerCountByTemplateIDs", reflect.TypeOf((*MockStore)(nil).GetWorkspaceUniqueOwnerCountByTemplateIDs), ctx, templateIds)
}

// GetWorkspaces mocks base method.
func (m *MockStore) GetWorkspaces(ctx context.Context, arg database.GetWorkspacesParams) ([]database.GetWorkspacesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspaces", ctx, arg)
	ret0, _ := ret[0].([]database.GetWorkspacesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspaces indicates an expected call of GetWorkspaces.
func (mr *MockStoreMockRecorder) GetWorkspaces(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaces", reflect.TypeOf((*MockStore)(nil).GetWorkspaces), ctx, arg)
}

// GetWorkspacesAndAgentsByOwnerID mocks base method.
func (m *MockStore) GetWorkspacesAndAgentsByOwnerID(ctx context.Context, ownerID uuid.UUID) ([]database.GetWorkspacesAndAgentsByOwnerIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspacesAndAgentsByOwnerID", ctx, ownerID)
	ret0, _ := ret[0].([]database.GetWorkspacesAndAgentsByOwnerIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspacesAndAgentsByOwnerID indicates an expected call of GetWorkspacesAndAgentsByOwnerID.
func (mr *MockStoreMockRecorder) GetWorkspacesAndAgentsByOwnerID(ctx, ownerID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspacesAndAgentsByOwnerID", reflect.TypeOf((*MockStore)(nil).GetWorkspacesAndAgentsByOwnerID), ctx, ownerID)
}

// GetWorkspacesByTemplateID mocks base method.
func (m *MockStore) GetWorkspacesByTemplateID(ctx context.Context, templateID uuid.UUID) ([]database.WorkspaceTable, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspacesByTemplateID", ctx, templateID)
	ret0, _ := ret[0].([]database.WorkspaceTable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspacesByTemplateID indicates an expected call of GetWorkspacesByTemplateID.
func (mr *MockStoreMockRecorder) GetWorkspacesByTemplateID(ctx, templateID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspacesByTemplateID", reflect.TypeOf((*MockStore)(nil).GetWorkspacesByTemplateID), ctx, templateID)
}

// GetWorkspacesEligibleForTransition mocks base method.
func (m *MockStore) GetWorkspacesEligibleForTransition(ctx context.Context, now time.Time) ([]database.GetWorkspacesEligibleForTransitionRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspacesEligibleForTransition", ctx, now)
	ret0, _ := ret[0].([]database.GetWorkspacesEligibleForTransitionRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkspacesEligibleForTransition indicates an expected call of GetWorkspacesEligibleForTransition.
func (mr *MockStoreMockRecorder) GetWorkspacesEligibleForTransition(ctx, now any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspacesEligibleForTransition", reflect.TypeOf((*MockStore)(nil).GetWorkspacesEligibleForTransition), ctx, now)
}

// GetWorkspacesForWorkspaceMetrics mocks base method.
func (m *MockStore) GetWorkspacesForWorkspaceMetrics(ctx context.Context) ([]database.GetWorkspacesForWorkspaceMetricsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkspacesForWorkspaceMetrics", ctx)
	ret0, _ := ret[0].([]database.GetWorkspacesForWorkspaceMetricsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// InTx mocks base method.
func (m *MockStore) InTx(arg0 func(database.Store) error, arg1 *database.TxOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InTx", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// InTx indicates an expected call of InTx.
func (mr *MockStoreMockRecorder) InTx(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InTx", reflect.TypeOf((*MockStore)(nil).InTx), arg0, arg1)
}

// InsertAIBridgeInterception mocks base method.
func (m *MockStore) InsertAIBridgeInterception(ctx context.Context, arg database.InsertAIBridgeInterceptionParams) (database.AIBridgeInterception, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertAIBridgeInterception", ctx, arg)
	ret0, _ := ret[0].(database.AIBridgeInterception)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertAIBridgeInterception indicates an expected call of InsertAIBridgeInterception.
func (mr *MockStoreMockRecorder) InsertAIBridgeInterception(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertAIBridgeInterception", reflect.TypeOf((*MockStore)(nil).InsertAIBridgeInterception), ctx, arg)
}

// InsertAIBridgeModelThought mocks base method.
func (m *MockStore) InsertAIBridgeModelThought(ctx context.Context, arg database.InsertAIBridgeModelThoughtParams) (database.AIBridgeModelThought, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertAIBridgeModelThought", ctx, arg)
	ret0, _ := ret[0].(database.AIBridgeModelThought)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertAIBridgeModelThought indicates an expected call of InsertAIBridgeModelThought.
func (mr *MockStoreMockRecorder) InsertAIBridgeModelThought(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertAIBridgeModelThought", reflect.TypeOf((*MockStore)(nil).InsertAIBridgeModelThought), ctx, arg)
}

// InsertAIBridgeTokenUsage mocks base method.
func (m *MockStore) InsertAIBridgeTokenUsage(ctx context.Context, arg database.InsertAIBridgeTokenUsageParams) (database.AIBridgeTokenUsage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertAIBridgeTokenUsage", ctx, arg)
	ret0, _ := ret[0].(database.AIBridgeTokenUsage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertAIBridgeTokenUsage indicates an expected call of InsertAIBridgeTokenUsage.
func (mr *MockStoreMockRecorder) InsertAIBridgeTokenUsage(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertAIBridgeTokenUsage", reflect.TypeOf((*MockStore)(nil).InsertAIBridgeTokenUsage), ctx, arg)
}

// InsertAIBridgeToolUsage mocks base method.
func (m *MockStore) InsertAIBridgeToolUsage(ctx context.Context, arg database.InsertAIBridgeToolUsageParams) (database.AIBridgeToolUsage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertAIBridgeToolUsage", ctx, arg)
	ret0, _ := ret[0].(database.AIBridgeToolUsage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertAIBridgeToolUsage indicates an expected call of InsertAIBridgeToolUsage.
func (mr *MockStoreMockRecorder) InsertAIBridgeToolUsage(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertAIBridgeToolUsage", reflect.TypeOf((*MockStore)(nil).InsertAIBridgeToolUsage), ctx, arg)
}

// InsertAIBridgeUserPrompt mocks base method.
func (m *MockStore) InsertAIBridgeUserPrompt(ctx context.Context, arg database.InsertAIBridgeUserPromptParams) (database.AIBridgeUserPrompt, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertAIBridgeUserPrompt", ctx, arg)
	ret0, _ := ret[0].(database.AIBridgeUserPrompt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertAIBridgeUserPrompt indicates an expected call of InsertAIBridgeUserPrompt.
func (mr *MockStoreMockRecorder) InsertAIBridgeUserPrompt(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertAIBridgeUserPrompt", reflect.TypeOf((*MockStore)(nil).InsertAIBridgeUserPrompt), ctx, arg)
}

// InsertAIProvider mocks base method.
func (m *MockStore) InsertAIProvider(ctx context.Context, arg database.InsertAIProviderParams) (database.AIProvider, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertAIProvider", ctx, arg)
	ret0, _ := ret[0].(database.AIProvider)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertAIProvider indicates an expected call of InsertAIProvider.
func (mr *MockStoreMockRecorder) InsertAIProvider(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertAIProvider", reflect.TypeOf((*MockStore)(nil).InsertAIProvider), ctx, arg)
}

// InsertAIProviderKey mocks base method.
func (m *MockStore) InsertAIProviderKey(ctx context.Context, arg database.InsertAIProviderKeyParams) (database.AIProviderKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertAIProviderKey", ctx, arg)
	ret0, _ := ret[0].(database.AIProviderKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertAIProviderKey indicates an expected call of InsertAIProviderKey.
func (mr *MockStoreMockRecorder) InsertAIProviderKey(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertAIProviderKey", reflect.TypeOf((*MockStore)(nil).InsertAIProviderKey), ctx, arg)
}

// InsertAPIKey mocks base method.
func (m *MockStore) InsertAPIKey(ctx context.Context, arg database.InsertAPIKeyParams) (database.APIKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertAPIKey", ctx, arg)
	ret0, _ := ret[0].(database.APIKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertAPIKey indicates an expected call of InsertAPIKey.
func (mr *MockStoreMockRecorder) InsertAPIKey(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertAPIKey", reflect.TypeOf((*MockStore)(nil).InsertAPIKey), ctx, arg)
}

// InsertAllUsersGroup mocks base method.
func (m *MockStore) InsertAllUsersGroup(ctx context.Context, organizationID uuid.UUID) (database.Group, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertAllUsersGroup", ctx, organizationID)
	ret0, _ := ret[0].(database.Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertAllUsersGroup indicates an expected call of InsertAllUsersGroup.
func (mr *MockStoreMockRecorder) InsertAllUsersGroup(ctx, organizationID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertAllUsersGroup", reflect.TypeOf((*MockStore)(nil).InsertAllUsersGroup), ctx, organizationID)
}

// InsertAuditLog mocks base method.
func (m *MockStore) InsertAuditLog(ctx context.Context, arg database.InsertAuditLogParams) (database.AuditLog, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertAuditLog", ctx, arg)
	ret0, _ := ret[0].(database.AuditLog)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertAuditLog indicates an expected call of InsertAuditLog.
func (mr *MockStoreMockRecorder) InsertAuditLog(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertAuditLog", reflect.TypeOf((*MockStore)(nil).InsertAuditLog), ctx, arg)
}

// InsertBoundaryLog mocks base method.
func (m *MockStore) InsertBoundaryLog(ctx context.Context, arg database.InsertBoundaryLogParams) (database.BoundaryLog, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertBoundaryLog", ctx, arg)
	ret0, _ := ret[0].(database.BoundaryLog)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertBoundaryLog indicates an expected call of InsertBoundaryLog.
func (mr *MockStoreMockRecorder) InsertBoundaryLog(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertBoundaryLog", reflect.TypeOf((*MockStore)(nil).InsertBoundaryLog), ctx, arg)
}

// InsertBoundarySession mocks base method.
func (m *MockStore) InsertBoundarySession(ctx context.Context, arg database.InsertBoundarySessionParams) (database.BoundarySession, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertBoundarySession", ctx, arg)
	ret0, _ := ret[0].(database.BoundarySession)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertBoundarySession indicates an expected call of InsertBoundarySession.
func (mr *MockStoreMockRecorder) InsertBoundarySession(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertBoundarySession", reflect.TypeOf((*MockStore)(nil).InsertBoundarySession), ctx, arg)
}

// InsertChat mocks base method.
func (m *MockStore) InsertChat(ctx context.Context, arg database.InsertChatParams) (database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertChat", ctx, arg)
	ret0, _ := ret[0].(database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertChat indicates an expected call of InsertChat.
func (mr *MockStoreMockRecorder) InsertChat(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertChat", reflect.TypeOf((*MockStore)(nil).InsertChat), ctx, arg)
}

// InsertChatDebugRun mocks base method.
func (m *MockStore) InsertChatDebugRun(ctx context.Context, arg database.InsertChatDebugRunParams) (database.ChatDebugRun, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertChatDebugRun", ctx, arg)
	ret0, _ := ret[0].(database.ChatDebugRun)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertChatDebugRun indicates an expected call of InsertChatDebugRun.
func (mr *MockStoreMockRecorder) InsertChatDebugRun(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertChatDebugRun", reflect.TypeOf((*MockStore)(nil).InsertChatDebugRun), ctx, arg)
}

// InsertChatDebugStep mocks base method.
func (m *MockStore) InsertChatDebugStep(ctx context.Context, arg database.InsertChatDebugStepParams) (database.ChatDebugStep, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertChatDebugStep", ctx, arg)
	ret0, _ := ret[0].(database.ChatDebugStep)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertChatDebugStep indicates an expected call of InsertChatDebugStep.
func (mr *MockStoreMockRecorder) InsertChatDebugStep(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertChatDebugStep", reflect.TypeOf((*MockStore)(nil).InsertChatDebugStep), ctx, arg)
}

// InsertChatFile mocks base method.
func (m *MockStore) InsertChatFile(ctx context.Context, arg database.InsertChatFileParams) (database.InsertChatFileRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertChatFile", ctx, arg)
	ret0, _ := ret[0].(database.InsertChatFileRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertChatFile indicates an expected call of InsertChatFile.
func (mr *MockStoreMockRecorder) InsertChatFile(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertChatFile", reflect.TypeOf((*MockStore)(nil).InsertChatFile), ctx, arg)
}

// InsertChatMessages mocks base method.
func (m *MockStore) InsertChatMessages(ctx context.Context, arg database.InsertChatMessagesParams) ([]database.ChatMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertChatMessages", ctx, arg)
	ret0, _ := ret[0].([]database.ChatMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertChatMessages indicates an expected call of InsertChatMessages.
func (mr *MockStoreMockRecorder) InsertChatMessages(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertChatMessages", reflect.TypeOf((*MockStore)(nil).InsertChatMessages), ctx, arg)
}

// InsertChatModelConfig mocks base method.
func (m *MockStore) InsertChatModelConfig(ctx context.Context, arg database.InsertChatModelConfigParams) (database.ChatModelConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertChatModelConfig", ctx, arg)
	ret0, _ := ret[0].(database.ChatModelConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertChatModelConfig indicates an expected call of InsertChatModelConfig.
func (mr *MockStoreMockRecorder) InsertChatModelConfig(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertChatModelConfig", reflect.TypeOf((*MockStore)(nil).InsertChatModelConfig), ctx, arg)
}

// InsertChatQueuedMessage mocks base method.
func (m *MockStore) InsertChatQueuedMessage(ctx context.Context, arg database.InsertChatQueuedMessageParams) (database.ChatQueuedMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertChatQueuedMessage", ctx, arg)
	ret0, _ := ret[0].(database.ChatQueuedMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertChatQueuedMessage indicates an expected call of InsertChatQueuedMessage.
func (mr *MockStoreMockRecorder) InsertChatQueuedMessage(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertChatQueuedMessage", reflect.TypeOf((*MockStore)(nil).InsertChatQueuedMessage), ctx, arg)
}

// InsertCryptoKey mocks base method.
func (m *MockStore) InsertCryptoKey(ctx context.Context, arg database.InsertCryptoKeyParams) (database.CryptoKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertCryptoKey", ctx, arg)
	ret0, _ := ret[0].(database.CryptoKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertCryptoKey indicates an expected call of InsertCryptoKey.
func (mr *MockStoreMockRecorder) InsertCryptoKey(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertCryptoKey", reflect.TypeOf((*MockStore)(nil).InsertCryptoKey), ctx, arg)
}

// InsertCustomRole mocks base method.
func (m *MockStore) InsertCustomRole(ctx context.Context, arg database.InsertCustomRoleParams) (database.CustomRole, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertCustomRole", ctx, arg)
	ret0, _ := ret[0].(database.CustomRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertCustomRole indicates an expected call of InsertCustomRole.
func (mr *MockStoreMockRecorder) InsertCustomRole(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertCustomRole", reflect.TypeOf((*MockStore)(nil).InsertCustomRole), ctx, arg)
}

// InsertDBCryptKey mocks base method.
func (m *MockStore) InsertDBCryptKey(ctx context.Context, arg database.InsertDBCryptKeyParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertDBCryptKey", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertDBCryptKey indicates an expected call of InsertDBCryptKey.
func (mr *MockStoreMockRecorder) InsertDBCryptKey(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertDBCryptKey", reflect.TypeOf((*MockStore)(nil).InsertDBCryptKey), ctx, arg)
}

// InsertDERPMeshKey mocks base method.
func (m *MockStore) InsertDERPMeshKey(ctx context.Context, value string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertDERPMeshKey", ctx, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertDERPMeshKey indicates an expected call of InsertDERPMeshKey.
func (mr *MockStoreMockRecorder) InsertDERPMeshKey(ctx, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertDERPMeshKey", reflect.TypeOf((*MockStore)(nil).InsertDERPMeshKey), ctx, value)
}

// InsertDeploymentID mocks base method.
func (m *MockStore) InsertDeploymentID(ctx context.Context, value string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertDeploymentID", ctx, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertDeploymentID indicates an expected call of InsertDeploymentID.
func (mr *MockStoreMockRecorder) InsertDeploymentID(ctx, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertDeploymentID", reflect.TypeOf((*MockStore)(nil).InsertDeploymentID), ctx, value)
}

// InsertExternalAuthLink mocks base method.
func (m *MockStore) InsertExternalAuthLink(ctx context.Context, arg database.InsertExternalAuthLinkParams) (database.ExternalAuthLink, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertExternalAuthLink", ctx, arg)
	ret0, _ := ret[0].(database.ExternalAuthLink)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertExternalAuthLink indicates an expected call of InsertExternalAuthLink.
func (mr *MockStoreMockRecorder) InsertExternalAuthLink(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertExternalAuthLink", reflect.TypeOf((*MockStore)(nil).InsertExternalAuthLink), ctx, arg)
}

// InsertFile mocks base method.
func (m *MockStore) InsertFile(ctx context.Context, arg database.InsertFileParams) (database.File, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertFile", ctx, arg)
	ret0, _ := ret[0].(database.File)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertFile indicates an expected call of InsertFile.
func (mr *MockStoreMockRecorder) InsertFile(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertFile", reflect.TypeOf((*MockStore)(nil).InsertFile), ctx, arg)
}

// InsertGitSSHKey mocks base method.
func (m *MockStore) InsertGitSSHKey(ctx context.Context, arg database.InsertGitSSHKeyParams) (database.GitSSHKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertGitSSHKey", ctx, arg)
	ret0, _ := ret[0].(database.GitSSHKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertGitSSHKey indicates an expected call of InsertGitSSHKey.
func (mr *MockStoreMockRecorder) InsertGitSSHKey(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertGitSSHKey", reflect.TypeOf((*MockStore)(nil).InsertGitSSHKey), ctx, arg)
}

// InsertGroup mocks base method.
func (m *MockStore) InsertGroup(ctx context.Context, arg database.InsertGroupParams) (database.Group, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertGroup", ctx, arg)
	ret0, _ := ret[0].(database.Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertGroup indicates an expected call of InsertGroup.
func (mr *MockStoreMockRecorder) InsertGroup(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertGroup", reflect.TypeOf((*MockStore)(nil).InsertGroup), ctx, arg)
}

// InsertGroupMember mocks base method.
func (m *MockStore) InsertGroupMember(ctx context.Context, arg database.InsertGroupMemberParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertGroupMember", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertGroupMember indicates an expected call of InsertGroupMember.
func (mr *MockStoreMockRecorder) InsertGroupMember(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertGroupMember", reflect.TypeOf((*MockStore)(nil).InsertGroupMember), ctx, arg)
}

// InsertInboxNotification mocks base method.
func (m *MockStore) InsertInboxNotification(ctx context.Context, arg database.InsertInboxNotificationParams) (database.InboxNotification, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertInboxNotification", ctx, arg)
	ret0, _ := ret[0].(database.InboxNotification)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertInboxNotification indicates an expected call of InsertInboxNotification.
func (mr *MockStoreMockRecorder) InsertInboxNotification(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertInboxNotification", reflect.TypeOf((*MockStore)(nil).InsertInboxNotification), ctx, arg)
}

// InsertLicense mocks base method.
func (m *MockStore) InsertLicense(ctx context.Context, arg database.InsertLicenseParams) (database.License, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertLicense", ctx, arg)
	ret0, _ := ret[0].(database.License)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertLicense indicates an expected call of InsertLicense.
func (mr *MockStoreMockRecorder) InsertLicense(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertLicense", reflect.TypeOf((*MockStore)(nil).InsertLicense), ctx, arg)
}

// InsertMCPServerConfig mocks base method.
func (m *MockStore) InsertMCPServerConfig(ctx context.Context, arg database.InsertMCPServerConfigParams) (database.MCPServerConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertMCPServerConfig", ctx, arg)
	ret0, _ := ret[0].(database.MCPServerConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertMCPServerConfig indicates an expected call of InsertMCPServerConfig.
func (mr *MockStoreMockRecorder) InsertMCPServerConfig(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertMCPServerConfig", reflect.TypeOf((*MockStore)(nil).InsertMCPServerConfig), ctx, arg)
}

// InsertMemoryResourceMonitor mocks base method.
func (m *MockStore) InsertMemoryResourceMonitor(ctx context.Context, arg database.InsertMemoryResourceMonitorParams) (database.WorkspaceAgentMemoryResourceMonitor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertMemoryResourceMonitor", ctx, arg)
	ret0, _ := ret[0].(database.WorkspaceAgentMemoryResourceMonitor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertMemoryResourceMonitor indicates an expected call of InsertMemoryResourceMonitor.
func (mr *MockStoreMockRecorder) InsertMemoryResourceMonitor(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertMemoryResourceMonitor", reflect.TypeOf((*MockStore)(nil).InsertMemoryResourceMonitor), ctx, arg)
}

// InsertMissingGroups mocks base method.
func (m *MockStore) InsertMissingGroups(ctx context.Context, arg database.InsertMissingGroupsParams) ([]database.Group, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertMissingGroups", ctx, arg)
	ret0, _ := ret[0].([]database.Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertMissingGroups indicates an expected call of InsertMissingGroups.
func (mr *MockStoreMockRecorder) InsertMissingGroups(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertMissingGroups", reflect.TypeOf((*MockStore)(nil).InsertMissingGroups), ctx, arg)
}

// InsertOAuth2ProviderApp mocks base method.
func (m *MockStore) InsertOAuth2ProviderApp(ctx context.Context, arg database.InsertOAuth2ProviderAppParams) (database.OAuth2ProviderApp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOAuth2ProviderApp", ctx, arg)
	ret0, _ := ret[0].(database.OAuth2ProviderApp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertOAuth2ProviderApp indicates an expected call of InsertOAuth2ProviderApp.
func (mr *MockStoreMockRecorder) InsertOAuth2ProviderApp(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertOAuth2ProviderApp", reflect.TypeOf((*MockStore)(nil).InsertOAuth2ProviderApp), ctx, arg)
}

// InsertOAuth2ProviderAppCode mocks base method.
func (m *MockStore) InsertOAuth2ProviderAppCode(ctx context.Context, arg database.InsertOAuth2ProviderAppCodeParams) (database.OAuth2ProviderAppCode, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOAuth2ProviderAppCode", ctx, arg)
	ret0, _ := ret[0].(database.OAuth2ProviderAppCode)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertOAuth2ProviderAppCode indicates an expected call of InsertOAuth2ProviderAppCode.
func (mr *MockStoreMockRecorder) InsertOAuth2ProviderAppCode(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertOAuth2ProviderAppCode", reflect.TypeOf((*MockStore)(nil).InsertOAuth2ProviderAppCode), ctx, arg)
}

// InsertOAuth2ProviderAppSecret mocks base method.
func (m *MockStore) InsertOAuth2ProviderAppSecret(ctx context.Context, arg database.InsertOAuth2ProviderAppSecretParams) (database.OAuth2ProviderAppSecret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOAuth2ProviderAppSecret", ctx, arg)
	ret0, _ := ret[0].(database.OAuth2ProviderAppSecret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertOAuth2ProviderAppSecret indicates an expected call of InsertOAuth2ProviderAppSecret.
func (mr *MockStoreMockRecorder) InsertOAuth2ProviderAppSecret(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertOAuth2ProviderAppSecret", reflect.TypeOf((*MockStore)(nil).InsertOAuth2ProviderAppSecret), ctx, arg)
}

// InsertOAuth2ProviderAppToken mocks base method.
func (m *MockStore) InsertOAuth2ProviderAppToken(ctx context.Context, arg database.InsertOAuth2ProviderAppTokenParams) (database.OAuth2ProviderAppToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOAuth2ProviderAppToken", ctx, arg)
	ret0, _ := ret[0].(database.OAuth2ProviderAppToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertOAuth2ProviderAppToken indicates an expected call of InsertOAuth2ProviderAppToken.
func (mr *MockStoreMockRecorder) InsertOAuth2ProviderAppToken(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertOAuth2ProviderAppToken", reflect.TypeOf((*MockStore)(nil).InsertOAuth2ProviderAppToken), ctx, arg)
}

// InsertOrganization mocks base method.
func (m *MockStore) InsertOrganization(ctx context.Context, arg database.InsertOrganizationParams) (database.Organization, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOrganization", ctx, arg)
	ret0, _ := ret[0].(database.Organization)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertOrganization indicates an expected call of InsertOrganization.
func (mr *MockStoreMockRecorder) InsertOrganization(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertOrganization", reflect.TypeOf((*MockStore)(nil).InsertOrganization), ctx, arg)
}

// InsertOrganizationMember mocks base method.
func (m *MockStore) InsertOrganizationMember(ctx context.Context, arg database.InsertOrganizationMemberParams) (database.OrganizationMember, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertOrganizationMember", ctx, arg)
	ret0, _ := ret[0].(database.OrganizationMember)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertOrganizationMember indicates an expected call of InsertOrganizationMember.
func (mr *MockStoreMockRecorder) InsertOrganizationMember(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertOrganizationMember", reflect.TypeOf((*MockStore)(nil).InsertOrganizationMember), ctx, arg)
}

// InsertPreset mocks base method.
func (m *MockStore) InsertPreset(ctx context.Context, arg database.InsertPresetParams) (database.TemplateVersionPreset, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertPreset", ctx, arg)
	ret0, _ := ret[0].(database.TemplateVersionPreset)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertPreset indicates an expected call of InsertPreset.
func (mr *MockStoreMockRecorder) InsertPreset(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertPreset", reflect.TypeOf((*MockStore)(nil).InsertPreset), ctx, arg)
}

// InsertPresetParameters mocks base method.
func (m *MockStore) InsertPresetParameters(ctx context.Context, arg database.InsertPresetParametersParams) ([]database.TemplateVersionPresetParameter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertPresetParameters", ctx, arg)
	ret0, _ := ret[0].([]database.TemplateVersionPresetParameter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertPresetParameters indicates an expected call of InsertPresetParameters.
func (mr *MockStoreMockRecorder) InsertPresetParameters(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertPresetParameters", reflect.TypeOf((*MockStore)(nil).InsertPresetParameters), ctx, arg)
}

// InsertPresetPrebuildSchedule mocks base method.
func (m *MockStore) InsertPresetPrebuildSchedule(ctx context.Context, arg database.InsertPresetPrebuildScheduleParams) (database.TemplateVersionPresetPrebuildSchedule, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertPresetPrebuildSchedule", ctx, arg)
	ret0, _ := ret[0].(database.TemplateVersionPresetPrebuildSchedule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertPresetPrebuildSchedule indicates an expected call of InsertPresetPrebuildSchedule.
func (mr *MockStoreMockRecorder) InsertPresetPrebuildSchedule(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertPresetPrebuildSchedule", reflect.TypeOf((*MockStore)(nil).InsertPresetPrebuildSchedule), ctx, arg)
}

// InsertProvisionerJob mocks base method.
func (m *MockStore) InsertProvisionerJob(ctx context.Context, arg database.InsertProvisionerJobParams) (database.ProvisionerJob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertProvisionerJob", ctx, arg)
	ret0, _ := ret[0].(database.ProvisionerJob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertProvisionerJob indicates an expected call of InsertProvisionerJob.
func (mr *MockStoreMockRecorder) InsertProvisionerJob(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertProvisionerJob", reflect.TypeOf((*MockStore)(nil).InsertProvisionerJob), ctx, arg)
}

// InsertProvisionerJobLogs mocks base method.
func (m *MockStore) InsertProvisionerJobLogs(ctx context.Context, arg database.InsertProvisionerJobLogsParams) ([]database.ProvisionerJobLog, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertProvisionerJobLogs", ctx, arg)
	ret0, _ := ret[0].([]database.ProvisionerJobLog)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertProvisionerJobLogs indicates an expected call of InsertProvisionerJobLogs.
func (mr *MockStoreMockRecorder) InsertProvisionerJobLogs(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertProvisionerJobLogs", reflect.TypeOf((*MockStore)(nil).InsertProvisionerJobLogs), ctx, arg)
}

// InsertProvisionerJobTimings mocks base method.
func (m *MockStore) InsertProvisionerJobTimings(ctx context.Context, arg database.InsertProvisionerJobTimingsParams) ([]database.ProvisionerJobTiming, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertProvisionerJobTimings", ctx, arg)
	ret0, _ := ret[0].([]database.ProvisionerJobTiming)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertProvisionerJobTimings indicates an expected call of InsertProvisionerJobTimings.
func (mr *MockStoreMockRecorder) InsertProvisionerJobTimings(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertProvisionerJobTimings", reflect.TypeOf((*MockStore)(nil).InsertProvisionerJobTimings), ctx, arg)
}

// InsertProvisionerKey mocks base method.
func (m *MockStore) InsertProvisionerKey(ctx context.Context, arg database.InsertProvisionerKeyParams) (database.ProvisionerKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertProvisionerKey", ctx, arg)
	ret0, _ := ret[0].(database.ProvisionerKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertProvisionerKey indicates an expected call of InsertProvisionerKey.
func (mr *MockStoreMockRecorder) InsertProvisionerKey(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertProvisionerKey", reflect.TypeOf((*MockStore)(nil).InsertProvisionerKey), ctx, arg)
}

// InsertReplica mocks base method.
func (m *MockStore) InsertReplica(ctx context.Context, arg database.InsertReplicaParams) (database.Replica, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertReplica", ctx, arg)
	ret0, _ := ret[0].(database.Replica)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertReplica indicates an expected call of InsertReplica.
func (mr *MockStoreMockRecorder) InsertReplica(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertReplica", reflect.TypeOf((*MockStore)(nil).InsertReplica), ctx, arg)
}

// InsertTask mocks base method.
func (m *MockStore) InsertTask(ctx context.Context, arg database.InsertTaskParams) (database.TaskTable, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertTask", ctx, arg)
	ret0, _ := ret[0].(database.TaskTable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertTask indicates an expected call of InsertTask.
func (mr *MockStoreMockRecorder) InsertTask(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertTask", reflect.TypeOf((*MockStore)(nil).InsertTask), ctx, arg)
}

// InsertTelemetryItemIfNotExists mocks base method.
func (m *MockStore) InsertTelemetryItemIfNotExists(ctx context.Context, arg database.InsertTelemetryItemIfNotExistsParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertTelemetryItemIfNotExists", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertTelemetryItemIfNotExists indicates an expected call of InsertTelemetryItemIfNotExists.
func (mr *MockStoreMockRecorder) InsertTelemetryItemIfNotExists(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertTelemetryItemIfNotExists", reflect.TypeOf((*MockStore)(nil).InsertTelemetryItemIfNotExists), ctx, arg)
}

// InsertTelemetryLock mocks base method.
func (m *MockStore) InsertTelemetryLock(ctx context.Context, arg database.InsertTelemetryLockParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertTelemetryLock", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertTelemetryLock indicates an expected call of InsertTelemetryLock.
func (mr *MockStoreMockRecorder) InsertTelemetryLock(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertTelemetryLock", reflect.TypeOf((*MockStore)(nil).InsertTelemetryLock), ctx, arg)
}

// InsertTemplate mocks base method.
func (m *MockStore) InsertTemplate(ctx context.Context, arg database.InsertTemplateParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertTemplate", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertTemplate indicates an expected call of InsertTemplate.
func (mr *MockStoreMockRecorder) InsertTemplate(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertTemplate", reflect.TypeOf((*MockStore)(nil).InsertTemplate), ctx, arg)
}

// InsertTemplateVersion mocks base method.
func (m *MockStore) InsertTemplateVersion(ctx context.Context, arg database.InsertTemplateVersionParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertTemplateVersion", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertTemplateVersion indicates an expected call of InsertTemplateVersion.
func (mr *MockStoreMockRecorder) InsertTemplateVersion(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertTemplateVersion", reflect.TypeOf((*MockStore)(nil).InsertTemplateVersion), ctx, arg)
}

// InsertTemplateVersionParameter mocks base method.
func (m *MockStore) InsertTemplateVersionParameter(ctx context.Context, arg database.InsertTemplateVersionParameterParams) (database.TemplateVersionParameter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertTemplateVersionParameter", ctx, arg)
	ret0, _ := ret[0].(database.TemplateVersionParameter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertTemplateVersionParameter indicates an expected call of InsertTemplateVersionParameter.
func (mr *MockStoreMockRecorder) InsertTemplateVersionParameter(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertTemplateVersionParameter", reflect.TypeOf((*MockStore)(nil).InsertTemplateVersionParameter), ctx, arg)
}

// InsertTemplateVersionTerraformValuesByJobID mocks base method.
func (m *MockStore) InsertTemplateVersionTerraformValuesByJobID(ctx context.Context, arg database.InsertTemplateVersionTerraformValuesByJobIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertTemplateVersionTerraformValuesByJobID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertTemplateVersionTerraformValuesByJobID indicates an expected call of InsertTemplateVersionTerraformValuesByJobID.
func (mr *MockStoreMockRecorder) InsertTemplateVersionTerraformValuesByJobID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertTemplateVersionTerraformValuesByJobID", reflect.TypeOf((*MockStore)(nil).InsertTemplateVersionTerraformValuesByJobID), ctx, arg)
}

// InsertTemplateVersionVariable mocks base method.
func (m *MockStore) InsertTemplateVersionVariable(ctx context.Context, arg database.InsertTemplateVersionVariableParams) (database.TemplateVersionVariable, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertTemplateVersionVariable", ctx, arg)
	ret0, _ := ret[0].(database.TemplateVersionVariable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertTemplateVersionVariable indicates an expected call of InsertTemplateVersionVariable.
func (mr *MockStoreMockRecorder) InsertTemplateVersionVariable(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertTemplateVersionVariable", reflect.TypeOf((*MockStore)(nil).InsertTemplateVersionVariable), ctx, arg)
}

// InsertTemplateVersionWorkspaceTag mocks base method.
func (m *MockStore) InsertTemplateVersionWorkspaceTag(ctx context.Context, arg database.InsertTemplateVersionWorkspaceTagParams) (database.TemplateVersionWorkspaceTag, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertTemplateVersionWorkspaceTag", ctx, arg)
	ret0, _ := ret[0].(database.TemplateVersionWorkspaceTag)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertTemplateVersionWorkspaceTag indicates an expected call of InsertTemplateVersionWorkspaceTag.
func (mr *MockStoreMockRecorder) InsertTemplateVersionWorkspaceTag(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertTemplateVersionWorkspaceTag", reflect.TypeOf((*MockStore)(nil).InsertTemplateVersionWorkspaceTag), ctx, arg)
}

// InsertUsageEvent mocks base method.
func (m *MockStore) InsertUsageEvent(ctx context.Context, arg database.InsertUsageEventParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertUsageEvent", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertUsageEvent indicates an expected call of InsertUsageEvent.
func (mr *MockStoreMockRecorder) InsertUsageEvent(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertUsageEvent", reflect.TypeOf((*MockStore)(nil).InsertUsageEvent), ctx, arg)
}

// InsertUser mocks base method.
func (m *MockStore) InsertUser(ctx context.Context, arg database.InsertUserParams) (database.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertUser", ctx, arg)
	ret0, _ := ret[0].(database.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertUser indicates an expected call of InsertUser.
func (mr *MockStoreMockRecorder) InsertUser(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertUser", reflect.TypeOf((*MockStore)(nil).InsertUser), ctx, arg)
}

// InsertUserGroupsByID mocks base method.
func (m *MockStore) InsertUserGroupsByID(ctx context.Context, arg database.InsertUserGroupsByIDParams) ([]uuid.UUID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertUserGroupsByID", ctx, arg)
	ret0, _ := ret[0].([]uuid.UUID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertUserGroupsByID indicates an expected call of InsertUserGroupsByID.
func (mr *MockStoreMockRecorder) InsertUserGroupsByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertUserGroupsByID", reflect.TypeOf((*MockStore)(nil).InsertUserGroupsByID), ctx, arg)
}

// InsertUserLink mocks base method.
func (m *MockStore) InsertUserLink(ctx context.Context, arg database.InsertUserLinkParams) (database.UserLink, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertUserLink", ctx, arg)
	ret0, _ := ret[0].(database.UserLink)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertUserLink indicates an expected call of InsertUserLink.
func (mr *MockStoreMockRecorder) InsertUserLink(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertUserLink", reflect.TypeOf((*MockStore)(nil).InsertUserLink), ctx, arg)
}

// InsertUserSkill mocks base method.
func (m *MockStore) InsertUserSkill(ctx context.Context, arg database.InsertUserSkillParams) (database.UserSkill, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertUserSkill", ctx, arg)
	ret0, _ := ret[0].(database.UserSkill)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertUserSkill indicates an expected call of InsertUserSkill.
func (mr *MockStoreMockRecorder) InsertUserSkill(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertUserSkill", reflect.TypeOf((*MockStore)(nil).InsertUserSkill), ctx, arg)
}

// InsertVolumeResourceMonitor mocks base method.
func (m *MockStore) InsertVolumeResourceMonitor(ctx context.Context, arg database.InsertVolumeResourceMonitorParams) (database.WorkspaceAgentVolumeResourceMonitor, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertVolumeResourceMonitor", ctx, arg)
	ret0, _ := ret[0].(database.WorkspaceAgentVolumeResourceMonitor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertVolumeResourceMonitor indicates an expected call of InsertVolumeResourceMonitor.
func (mr *MockStoreMockRecorder) InsertVolumeResourceMonitor(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertVolumeResourceMonitor", reflect.TypeOf((*MockStore)(nil).InsertVolumeResourceMonitor), ctx, arg)
}

// InsertWebpushSubscription mocks base method.
func (m *MockStore) InsertWebpushSubscription(ctx context.Context, arg database.InsertWebpushSubscriptionParams) (database.WebpushSubscription, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWebpushSubscription", ctx, arg)
	ret0, _ := ret[0].(database.WebpushSubscription)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertWebpushSubscription indicates an expected call of InsertWebpushSubscription.
func (mr *MockStoreMockRecorder) InsertWebpushSubscription(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWebpushSubscription", reflect.TypeOf((*MockStore)(nil).InsertWebpushSubscription), ctx, arg)
}

// InsertWorkspace mocks base method.
func (m *MockStore) InsertWorkspace(ctx context.Context, arg database.InsertWorkspaceParams) (database.WorkspaceTable, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWorkspace", ctx, arg)
	ret0, _ := ret[0].(database.WorkspaceTable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertWorkspace indicates an expected call of InsertWorkspace.
func (mr *MockStoreMockRecorder) InsertWorkspace(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkspace", reflect.TypeOf((*MockStore)(nil).InsertWorkspace), ctx, arg)
}

// InsertWorkspaceAgent mocks base method.
func (m *MockStore) InsertWorkspaceAgent(ctx context.Context, arg database.InsertWorkspaceAgentParams) (database.WorkspaceAgent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWorkspaceAgent", ctx, arg)
	ret0, _ := ret[0].(database.WorkspaceAgent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertWorkspaceAgent indicates an expected call of InsertWorkspaceAgent.
func (mr *MockStoreMockRecorder) InsertWorkspaceAgent(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkspaceAgent", reflect.TypeOf((*MockStore)(nil).InsertWorkspaceAgent), ctx, arg)
}

// InsertWorkspaceAgentDevcontainers mocks base method.
func (m *MockStore) InsertWorkspaceAgentDevcontainers(ctx context.Context, arg database.InsertWorkspaceAgentDevcontainersParams) ([]database.WorkspaceAgentDevcontainer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWorkspaceAgentDevcontainers", ctx, arg)
	ret0, _ := ret[0].([]database.WorkspaceAgentDevcontainer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertWorkspaceAgentDevcontainers indicates an expected call of InsertWorkspaceAgentDevcontainers.
func (mr *MockStoreMockRecorder) InsertWorkspaceAgentDevcontainers(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkspaceAgentDevcontainers", reflect.TypeOf((*MockStore)(nil).InsertWorkspaceAgentDevcontainers), ctx, arg)
}

// InsertWorkspaceAgentLogSources mocks base method.
func (m *MockStore) InsertWorkspaceAgentLogSources(ctx context.Context, arg database.InsertWorkspaceAgentLogSourcesParams) ([]database.WorkspaceAgentLogSource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWorkspaceAgentLogSources", ctx, arg)
	ret0, _ := ret[0].([]database.WorkspaceAgentLogSource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertWorkspaceAgentLogSources indicates an expected call of InsertWorkspaceAgentLogSources.
func (mr *MockStoreMockRecorder) InsertWorkspaceAgentLogSources(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkspaceAgentLogSources", reflect.TypeOf((*MockStore)(nil).InsertWorkspaceAgentLogSources), ctx, arg)
}

// InsertWorkspaceAgentLogs mocks base method.
func (m *MockStore) InsertWorkspaceAgentLogs(ctx context.Context, arg database.InsertWorkspaceAgentLogsParams) ([]database.WorkspaceAgentLog, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWorkspaceAgentLogs", ctx, arg)
	ret0, _ := ret[0].([]database.WorkspaceAgentLog)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertWorkspaceAgentLogs indicates an expected call of InsertWorkspaceAgentLogs.
func (mr *MockStoreMockRecorder) InsertWorkspaceAgentLogs(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkspaceAgentLogs", reflect.TypeOf((*MockStore)(nil).InsertWorkspaceAgentLogs), ctx, arg)
}

// InsertWorkspaceAgentMetadata mocks base method.
func (m *MockStore) InsertWorkspaceAgentMetadata(ctx context.Context, arg database.InsertWorkspaceAgentMetadataParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWorkspaceAgentMetadata", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertWorkspaceAgentMetadata indicates an expected call of InsertWorkspaceAgentMetadata.
func (mr *MockStoreMockRecorder) InsertWorkspaceAgentMetadata(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkspaceAgentMetadata", reflect.TypeOf((*MockStore)(nil).InsertWorkspaceAgentMetadata), ctx, arg)
}

// InsertWorkspaceAgentScriptTimings mocks base method.
func (m *MockStore) InsertWorkspaceAgentScriptTimings(ctx context.Context, arg database.InsertWorkspaceAgentScriptTimingsParams) (database.WorkspaceAgentScriptTiming, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWorkspaceAgentScriptTimings", ctx, arg)
	ret0, _ := ret[0].(database.WorkspaceAgentScriptTiming)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertWorkspaceAgentScriptTimings indicates an expected call of InsertWorkspaceAgentScriptTimings.
func (mr *MockStoreMockRecorder) InsertWorkspaceAgentScriptTimings(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkspaceAgentScriptTimings", reflect.TypeOf((*MockStore)(nil).InsertWorkspaceAgentScriptTimings), ctx, arg)
}

// InsertWorkspaceAgentScripts mocks base method.
func (m *MockStore) InsertWorkspaceAgentScripts(ctx context.Context, arg database.InsertWorkspaceAgentScriptsParams) ([]database.WorkspaceAgentScript, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWorkspaceAgentScripts", ctx, arg)
	ret0, _ := ret[0].([]database.WorkspaceAgentScript)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertWorkspaceAgentScripts indicates an expected call of InsertWorkspaceAgentScripts.
func (mr *MockStoreMockRecorder) InsertWorkspaceAgentScripts(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkspaceAgentScripts", reflect.TypeOf((*MockStore)(nil).InsertWorkspaceAgentScripts), ctx, arg)
}

// InsertWorkspaceAgentStats mocks base method.
func (m *MockStore) InsertWorkspaceAgentStats(ctx context.Context, arg database.InsertWorkspaceAgentStatsParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWorkspaceAgentStats", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertWorkspaceAgentStats indicates an expected call of InsertWorkspaceAgentStats.
func (mr *MockStoreMockRecorder) InsertWorkspaceAgentStats(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkspaceAgentStats", reflect.TypeOf((*MockStore)(nil).InsertWorkspaceAgentStats), ctx, arg)
}

// InsertWorkspaceAppStats mocks base method.
func (m *MockStore) InsertWorkspaceAppStats(ctx context.Context, arg database.InsertWorkspaceAppStatsParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWorkspaceAppStats", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertWorkspaceAppStats indicates an expected call of InsertWorkspaceAppStats.
func (mr *MockStoreMockRecorder) InsertWorkspaceAppStats(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkspaceAppStats", reflect.TypeOf((*MockStore)(nil).InsertWorkspaceAppStats), ctx, arg)
}

// InsertWorkspaceAppStatus mocks base method.
func (m *MockStore) InsertWorkspaceAppStatus(ctx context.Context, arg database.InsertWorkspaceAppStatusParams) (database.WorkspaceAppStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWorkspaceAppStatus", ctx, arg)
	ret0, _ := ret[0].(database.WorkspaceAppStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertWorkspaceAppStatus indicates an expected call of InsertWorkspaceAppStatus.
func (mr *MockStoreMockRecorder) InsertWorkspaceAppStatus(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkspaceAppStatus", reflect.TypeOf((*MockStore)(nil).InsertWorkspaceAppStatus), ctx, arg)
}

// InsertWorkspaceBuild mocks base method.
func (m *MockStore) InsertWorkspaceBuild(ctx context.Context, arg database.InsertWorkspaceBuildParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWorkspaceBuild", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertWorkspaceBuild indicates an expected call of InsertWorkspaceBuild.
func (mr *MockStoreMockRecorder) InsertWorkspaceBuild(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkspaceBuild", reflect.TypeOf((*MockStore)(nil).InsertWorkspaceBuild), ctx, arg)
}

// InsertWorkspaceBuildParameters mocks base method.
func (m *MockStore) InsertWorkspaceBuildParameters(ctx context.Context, arg database.InsertWorkspaceBuildParametersParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWorkspaceBuildParameters", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertWorkspaceBuildParameters indicates an expected call of InsertWorkspaceBuildParameters.
func (mr *MockStoreMockRecorder) InsertWorkspaceBuildParameters(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkspaceBuildParameters", reflect.TypeOf((*MockStore)(nil).InsertWorkspaceBuildParameters), ctx, arg)
}

// InsertWorkspaceModule mocks base method.
func (m *MockStore) InsertWorkspaceModule(ctx context.Context, arg database.InsertWorkspaceModuleParams) (database.WorkspaceModule, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWorkspaceModule", ctx, arg)
	ret0, _ := ret[0].(database.WorkspaceModule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertWorkspaceModule indicates an expected call of InsertWorkspaceModule.
func (mr *MockStoreMockRecorder) InsertWorkspaceModule(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkspaceModule", reflect.TypeOf((*MockStore)(nil).InsertWorkspaceModule), ctx, arg)
}

// InsertWorkspaceProxy mocks base method.
func (m *MockStore) InsertWorkspaceProxy(ctx context.Context, arg database.InsertWorkspaceProxyParams) (database.WorkspaceProxy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWorkspaceProxy", ctx, arg)
	ret0, _ := ret[0].(database.WorkspaceProxy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertWorkspaceProxy indicates an expected call of InsertWorkspaceProxy.
func (mr *MockStoreMockRecorder) InsertWorkspaceProxy(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkspaceProxy", reflect.TypeOf((*MockStore)(nil).InsertWorkspaceProxy), ctx, arg)
}

// InsertWorkspaceResource mocks base method.
func (m *MockStore) InsertWorkspaceResource(ctx context.Context, arg database.InsertWorkspaceResourceParams) (database.WorkspaceResource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWorkspaceResource", ctx, arg)
	ret0, _ := ret[0].(database.WorkspaceResource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertWorkspaceResource indicates an expected call of InsertWorkspaceResource.
func (mr *MockStoreMockRecorder) InsertWorkspaceResource(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkspaceResource", reflect.TypeOf((*MockStore)(nil).InsertWorkspaceResource), ctx, arg)
}

// InsertWorkspaceResourceMetadata mocks base method.
func (m *MockStore) InsertWorkspaceResourceMetadata(ctx context.Context, arg database.InsertWorkspaceResourceMetadataParams) ([]database.WorkspaceResourceMetadatum, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWorkspaceResourceMetadata", ctx, arg)
	ret0, _ := ret[0].([]database.WorkspaceResourceMetadatum)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertWorkspaceResourceMetadata indicates an expected call of InsertWorkspaceResourceMetadata.
func (mr *MockStoreMockRecorder) InsertWorkspaceResourceMetadata(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkspaceResourceMetadata", reflect.TypeOf((*MockStore)(nil).InsertWorkspaceResourceMetadata), ctx, arg)
}

// LinkChatFiles mocks base method.
func (m *MockStore) LinkChatFiles(ctx context.Context, arg database.LinkChatFilesParams) (int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LinkChatFiles", ctx, arg)
	ret0, _ := ret[0].(int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LinkChatFiles indicates an expected call of LinkChatFiles.
func (mr *MockStoreMockRecorder) LinkChatFiles(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LinkChatFiles", reflect.TypeOf((*MockStore)(nil).LinkChatFiles), ctx, arg)
}

// ListAIBridgeClients mocks base method.
func (m *MockStore) ListAIBridgeClients(ctx context.Context, arg database.ListAIBridgeClientsParams) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAIBridgeClients", ctx, arg)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAIBridgeClients indicates an expected call of ListAIBridgeClients.
func (mr *MockStoreMockRecorder) ListAIBridgeClients(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAIBridgeClients", reflect.TypeOf((*MockStore)(nil).ListAIBridgeClients), ctx, arg)
}

// ListAIBridgeInterceptions mocks base method.
func (m *MockStore) ListAIBridgeInterceptions(ctx context.Context, arg database.ListAIBridgeInterceptionsParams) ([]database.ListAIBridgeInterceptionsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAIBridgeInterceptions", ctx, arg)
	ret0, _ := ret[0].([]database.ListAIBridgeInterceptionsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAIBridgeInterceptions indicates an expected call of ListAIBridgeInterceptions.
func (mr *MockStoreMockRecorder) ListAIBridgeInterceptions(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAIBridgeInterceptions", reflect.TypeOf((*MockStore)(nil).ListAIBridgeInterceptions), ctx, arg)
}

// ListAIBridgeInterceptionsTelemetrySummaries mocks base method.
func (m *MockStore) ListAIBridgeInterceptionsTelemetrySummaries(ctx context.Context, arg database.ListAIBridgeInterceptionsTelemetrySummariesParams) ([]database.ListAIBridgeInterceptionsTelemetrySummariesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAIBridgeInterceptionsTelemetrySummaries", ctx, arg)
	ret0, _ := ret[0].([]database.ListAIBridgeInterceptionsTelemetrySummariesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAIBridgeInterceptionsTelemetrySummaries indicates an expected call of ListAIBridgeInterceptionsTelemetrySummaries.
func (mr *MockStoreMockRecorder) ListAIBridgeInterceptionsTelemetrySummaries(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAIBridgeInterceptionsTelemetrySummaries", reflect.TypeOf((*MockStore)(nil).ListAIBridgeInterceptionsTelemetrySummaries), ctx, arg)
}

// ListAIBridgeModelThoughtsByInterceptionIDs mocks base method.
func (m *MockStore) ListAIBridgeModelThoughtsByInterceptionIDs(ctx context.Context, interceptionIds []uuid.UUID) ([]database.AIBridgeModelThought, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAIBridgeModelThoughtsByInterceptionIDs", ctx, interceptionIds)
	ret0, _ := ret[0].([]database.AIBridgeModelThought)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAIBridgeModelThoughtsByInterceptionIDs indicates an expected call of ListAIBridgeModelThoughtsByInterceptionIDs.
func (mr *MockStoreMockRecorder) ListAIBridgeModelThoughtsByInterceptionIDs(ctx, interceptionIds any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAIBridgeModelThoughtsByInterceptionIDs", reflect.TypeOf((*MockStore)(nil).ListAIBridgeModelThoughtsByInterceptionIDs), ctx, interceptionIds)
}

// ListAIBridgeModels mocks base method.
func (m *MockStore) ListAIBridgeModels(ctx context.Context, arg database.ListAIBridgeModelsParams) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAIBridgeModels", ctx, arg)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAIBridgeModels indicates an expected call of ListAIBridgeModels.
func (mr *MockStoreMockRecorder) ListAIBridgeModels(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAIBridgeModels", reflect.TypeOf((*MockStore)(nil).ListAIBridgeModels), ctx, arg)
}

// ListAIBridgeSessionThreads mocks base method.
func (m *MockStore) ListAIBridgeSessionThreads(ctx context.Context, arg database.ListAIBridgeSessionThreadsParams) ([]database.ListAIBridgeSessionThreadsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAIBridgeSessionThreads", ctx, arg)
	ret0, _ := ret[0].([]database.ListAIBridgeSessionThreadsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAIBridgeSessionThreads indicates an expected call of ListAIBridgeSessionThreads.
func (mr *MockStoreMockRecorder) ListAIBridgeSessionThreads(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAIBridgeSessionThreads", reflect.TypeOf((*MockStore)(nil).ListAIBridgeSessionThreads), ctx, arg)
}

// ListAIBridgeSessions mocks base method.
func (m *MockStore) ListAIBridgeSessions(ctx context.Context, arg database.ListAIBridgeSessionsParams) ([]database.ListAIBridgeSessionsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAIBridgeSessions", ctx, arg)
	ret0, _ := ret[0].([]database.ListAIBridgeSessionsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAIBridgeSessions indicates an expected call of ListAIBridgeSessions.
func (mr *MockStoreMockRecorder) ListAIBridgeSessions(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAIBridgeSessions", reflect.TypeOf((*MockStore)(nil).ListAIBridgeSessions), ctx, arg)
}

// ListAIBridgeTokenUsagesByInterceptionIDs mocks base method.
func (m *MockStore) ListAIBridgeTokenUsagesByInterceptionIDs(ctx context.Context, interceptionIds []uuid.UUID) ([]database.AIBridgeTokenUsage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAIBridgeTokenUsagesByInterceptionIDs", ctx, interceptionIds)
	ret0, _ := ret[0].([]database.AIBridgeTokenUsage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAIBridgeTokenUsagesByInterceptionIDs indicates an expected call of ListAIBridgeTokenUsagesByInterceptionIDs.
func (mr *MockStoreMockRecorder) ListAIBridgeTokenUsagesByInterceptionIDs(ctx, interceptionIds any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAIBridgeTokenUsagesByInterceptionIDs", reflect.TypeOf((*MockStore)(nil).ListAIBridgeTokenUsagesByInterceptionIDs), ctx, interceptionIds)
}

// ListAIBridgeToolUsagesByInterceptionIDs mocks base method.
func (m *MockStore) ListAIBridgeToolUsagesByInterceptionIDs(ctx context.Context, interceptionIds []uuid.UUID) ([]database.AIBridgeToolUsage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAIBridgeToolUsagesByInterceptionIDs", ctx, interceptionIds)
	ret0, _ := ret[0].([]database.AIBridgeToolUsage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAIBridgeToolUsagesByInterceptionIDs indicates an expected call of ListAIBridgeToolUsagesByInterceptionIDs.
func (mr *MockStoreMockRecorder) ListAIBridgeToolUsagesByInterceptionIDs(ctx, interceptionIds any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAIBridgeToolUsagesByInterceptionIDs", reflect.TypeOf((*MockStore)(nil).ListAIBridgeToolUsagesByInterceptionIDs), ctx, interceptionIds)
}

// ListAIBridgeUserPromptsByInterceptionIDs mocks base method.
func (m *MockStore) ListAIBridgeUserPromptsByInterceptionIDs(ctx context.Context, interceptionIds []uuid.UUID) ([]database.AIBridgeUserPrompt, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAIBridgeUserPromptsByInterceptionIDs", ctx, interceptionIds)
	ret0, _ := ret[0].([]database.AIBridgeUserPrompt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAIBridgeUserPromptsByInterceptionIDs indicates an expected call of ListAIBridgeUserPromptsByInterceptionIDs.
func (mr *MockStoreMockRecorder) ListAIBridgeUserPromptsByInterceptionIDs(ctx, interceptionIds any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAIBridgeUserPromptsByInterceptionIDs", reflect.TypeOf((*MockStore)(nil).ListAIBridgeUserPromptsByInterceptionIDs), ctx, interceptionIds)
}

// ListAuthorizedAIBridgeClients mocks base method.
func (m *MockStore) ListAuthorizedAIBridgeClients(ctx context.Context, arg database.ListAIBridgeClientsParams, prepared rbac.PreparedAuthorized) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAuthorizedAIBridgeClients", ctx, arg, prepared)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAuthorizedAIBridgeClients indicates an expected call of ListAuthorizedAIBridgeClients.
func (mr *MockStoreMockRecorder) ListAuthorizedAIBridgeClients(ctx, arg, prepared any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAuthorizedAIBridgeClients", reflect.TypeOf((*MockStore)(nil).ListAuthorizedAIBridgeClients), ctx, arg, prepared)
}

// ListAuthorizedAIBridgeInterceptions mocks base method.
func (m *MockStore) ListAuthorizedAIBridgeInterceptions(ctx context.Context, arg database.ListAIBridgeInterceptionsParams, prepared rbac.PreparedAuthorized) ([]database.ListAIBridgeInterceptionsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAuthorizedAIBridgeInterceptions", ctx, arg, prepared)
	ret0, _ := ret[0].([]database.ListAIBridgeInterceptionsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAuthorizedAIBridgeInterceptions indicates an expected call of ListAuthorizedAIBridgeInterceptions.
func (mr *MockStoreMockRecorder) ListAuthorizedAIBridgeInterceptions(ctx, arg, prepared any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAuthorizedAIBridgeInterceptions", reflect.TypeOf((*MockStore)(nil).ListAuthorizedAIBridgeInterceptions), ctx, arg, prepared)
}

// ListAuthorizedAIBridgeModels mocks base method.
func (m *MockStore) ListAuthorizedAIBridgeModels(ctx context.Context, arg database.ListAIBridgeModelsParams, prepared rbac.PreparedAuthorized) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAuthorizedAIBridgeModels", ctx, arg, prepared)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAuthorizedAIBridgeModels indicates an expected call of ListAuthorizedAIBridgeModels.
func (mr *MockStoreMockRecorder) ListAuthorizedAIBridgeModels(ctx, arg, prepared any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAuthorizedAIBridgeModels", reflect.TypeOf((*MockStore)(nil).ListAuthorizedAIBridgeModels), ctx, arg, prepared)
}

// ListAuthorizedAIBridgeSessionThreads mocks base method.
func (m *MockStore) ListAuthorizedAIBridgeSessionThreads(ctx context.Context, arg database.ListAIBridgeSessionThreadsParams, prepared rbac.PreparedAuthorized) ([]database.ListAIBridgeSessionThreadsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAuthorizedAIBridgeSessionThreads", ctx, arg, prepared)
	ret0, _ := ret[0].([]database.ListAIBridgeSessionThreadsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAuthorizedAIBridgeSessionThreads indicates an expected call of ListAuthorizedAIBridgeSessionThreads.
func (mr *MockStoreMockRecorder) ListAuthorizedAIBridgeSessionThreads(ctx, arg, prepared any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAuthorizedAIBridgeSessionThreads", reflect.TypeOf((*MockStore)(nil).ListAuthorizedAIBridgeSessionThreads), ctx, arg, prepared)
}

// ListAuthorizedAIBridgeSessions mocks base method.
func (m *MockStore) ListAuthorizedAIBridgeSessions(ctx context.Context, arg database.ListAIBridgeSessionsParams, prepared rbac.PreparedAuthorized) ([]database.ListAIBridgeSessionsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAuthorizedAIBridgeSessions", ctx, arg, prepared)
	ret0, _ := ret[0].([]database.ListAIBridgeSessionsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAuthorizedAIBridgeSessions indicates an expected call of ListAuthorizedAIBridgeSessions.
func (mr *MockStoreMockRecorder) ListAuthorizedAIBridgeSessions(ctx, arg, prepared any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAuthorizedAIBridgeSessions", reflect.TypeOf((*MockStore)(nil).ListAuthorizedAIBridgeSessions), ctx, arg, prepared)
}

// ListBoundaryLogsBySessionID mocks base method.
func (m *MockStore) ListBoundaryLogsBySessionID(ctx context.Context, arg database.ListBoundaryLogsBySessionIDParams) ([]database.BoundaryLog, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBoundaryLogsBySessionID", ctx, arg)
	ret0, _ := ret[0].([]database.BoundaryLog)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListBoundaryLogsBySessionID indicates an expected call of ListBoundaryLogsBySessionID.
func (mr *MockStoreMockRecorder) ListBoundaryLogsBySessionID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBoundaryLogsBySessionID", reflect.TypeOf((*MockStore)(nil).ListBoundaryLogsBySessionID), ctx, arg)
}

// ListChatUsageLimitGroupOverrides mocks base method.
func (m *MockStore) ListChatUsageLimitGroupOverrides(ctx context.Context) ([]database.ListChatUsageLimitGroupOverridesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListChatUsageLimitGroupOverrides", ctx)
	ret0, _ := ret[0].([]database.ListChatUsageLimitGroupOverridesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListChatUsageLimitOverrides mocks base method.
func (m *MockStore) ListChatUsageLimitOverrides(ctx context.Context) ([]database.ListChatUsageLimitOverridesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListChatUsageLimitOverrides", ctx)
	ret0, _ := ret[0].([]database.ListChatUsageLimitOverridesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListProvisionerKeysByOrganization mocks base method.
func (m *MockStore) ListProvisionerKeysByOrganization(ctx context.Context, organizationID uuid.UUID) ([]database.ProvisionerKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProvisionerKeysByOrganization", ctx, organizationID)
	ret0, _ := ret[0].([]database.ProvisionerKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListProvisionerKeysByOrganization indicates an expected call of ListProvisionerKeysByOrganization.
func (mr *MockStoreMockRecorder) ListProvisionerKeysByOrganization(ctx, organizationID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProvisionerKeysByOrganization", reflect.TypeOf((*MockStore)(nil).ListProvisionerKeysByOrganization), ctx, organizationID)
}

// ListProvisionerKeysByOrganizationExcludeReserved mocks base method.
func (m *MockStore) ListProvisionerKeysByOrganizationExcludeReserved(ctx context.Context, organizationID uuid.UUID) ([]database.ProvisionerKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProvisionerKeysByOrganizationExcludeReserved", ctx, organizationID)
	ret0, _ := ret[0].([]database.ProvisionerKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListProvisionerKeysByOrganizationExcludeReserved indicates an expected call of ListProvisionerKeysByOrganizationExcludeReserved.
func (mr *MockStoreMockRecorder) ListProvisionerKeysByOrganizationExcludeReserved(ctx, organizationID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProvisionerKeysByOrganizationExcludeReserved", reflect.TypeOf((*MockStore)(nil).ListProvisionerKeysByOrganizationExcludeReserved), ctx, organizationID)
}

// ListTasks mocks base method.
func (m *MockStore) ListTasks(ctx context.Context, arg database.ListTasksParams) ([]database.Task, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTasks", ctx, arg)
	ret0, _ := ret[0].([]database.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTasks indicates an expected call of ListTasks.
func (mr *MockStoreMockRecorder) ListTasks(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTasks", reflect.TypeOf((*MockStore)(nil).ListTasks), ctx, arg)
}

// ListUserChatCompactionThresholds mocks base method.
func (m *MockStore) ListUserChatCompactionThresholds(ctx context.Context, userID uuid.UUID) ([]database.UserConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUserChatCompactionThresholds", ctx, userID)
	ret0, _ := ret[0].([]database.UserConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListUserChatPersonalModelOverrides mocks base method.
func (m *MockStore) ListUserChatPersonalModelOverrides(ctx context.Context, userID uuid.UUID) ([]database.ListUserChatPersonalModelOverridesRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUserChatPersonalModelOverrides", ctx, userID)
	ret0, _ := ret[0].([]database.ListUserChatPersonalModelOverridesRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListUserSecrets mocks base method.
func (m *MockStore) ListUserSecrets(ctx context.Context, userID uuid.UUID) ([]database.ListUserSecretsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUserSecrets", ctx, userID)
	ret0, _ := ret[0].([]database.ListUserSecretsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListUserSecretsWithValues mocks base method.
func (m *MockStore) ListUserSecretsWithValues(ctx context.Context, userID uuid.UUID) ([]database.UserSecret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUserSecretsWithValues", ctx, userID)
	ret0, _ := ret[0].([]database.UserSecret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListUserSkillMetadataByUserID mocks base method.
func (m *MockStore) ListUserSkillMetadataByUserID(ctx context.Context, userID uuid.UUID) ([]database.ListUserSkillMetadataByUserIDRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUserSkillMetadataByUserID", ctx, userID)
	ret0, _ := ret[0].([]database.ListUserSkillMetadataByUserIDRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListWorkspaceAgentPortShares mocks base method.
func (m *MockStore) ListWorkspaceAgentPortShares(ctx context.Context, workspaceID uuid.UUID) ([]database.WorkspaceAgentPortShare, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListWorkspaceAgentPortShares", ctx, workspaceID)
	ret0, _ := ret[0].([]database.WorkspaceAgentPortShare)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListWorkspaceAgentPortShares indicates an expected call of ListWorkspaceAgentPortShares.
func (mr *MockStoreMockRecorder) ListWorkspaceAgentPortShares(ctx, workspaceID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListWorkspaceAgentPortShares", reflect.TypeOf((*MockStore)(nil).ListWorkspaceAgentPortShares), ctx, workspaceID)
}

// MarkAllInboxNotificationsAsRead mocks base method.
func (m *MockStore) MarkAllInboxNotificationsAsRead(ctx context.Context, arg database.MarkAllInboxNotificationsAsReadParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarkAllInboxNotificationsAsRead", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// MarkAllInboxNotificationsAsRead indicates an expected call of MarkAllInboxNotificationsAsRead.
func (mr *MockStoreMockRecorder) MarkAllInboxNotificationsAsRead(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkAllInboxNotificationsAsRead", reflect.TypeOf((*MockStore)(nil).MarkAllInboxNotificationsAsRead), ctx, arg)
}

// OIDCClaimFieldValues mocks base method.
func (m *MockStore) OIDCClaimFieldValues(ctx context.Context, arg database.OIDCClaimFieldValuesParams) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OIDCClaimFieldValues", ctx, arg)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OIDCClaimFieldValues indicates an expected call of OIDCClaimFieldValues.
func (mr *MockStoreMockRecorder) OIDCClaimFieldValues(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OIDCClaimFieldValues", reflect.TypeOf((*MockStore)(nil).OIDCClaimFieldValues), ctx, arg)
}

// OIDCClaimFields mocks base method.
func (m *MockStore) OIDCClaimFields(ctx context.Context, organizationID uuid.UUID) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OIDCClaimFields", ctx, organizationID)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OIDCClaimFields indicates an expected call of OIDCClaimFields.
func (mr *MockStoreMockRecorder) OIDCClaimFields(ctx, organizationID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OIDCClaimFields", reflect.TypeOf((*MockStore)(nil).OIDCClaimFields), ctx, organizationID)
}

// OrganizationMembers mocks base method.
func (m *MockStore) OrganizationMembers(ctx context.Context, arg database.OrganizationMembersParams) ([]database.OrganizationMembersRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OrganizationMembers", ctx, arg)
	ret0, _ := ret[0].([]database.OrganizationMembersRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OrganizationMembers indicates an expected call of OrganizationMembers.
func (mr *MockStoreMockRecorder) OrganizationMembers(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationMembers", reflect.TypeOf((*MockStore)(nil).OrganizationMembers), ctx, arg)
}

// PGLocks mocks base method.
func (m *MockStore) PGLocks(ctx context.Context) (database.PGLocks, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PGLocks", ctx)
	ret0, _ := ret[0].(database.PGLocks)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PaginatedOrganizationMembers mocks base method.
func (m *MockStore) PaginatedOrganizationMembers(ctx context.Context, arg database.PaginatedOrganizationMembersParams) ([]database.PaginatedOrganizationMembersRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaginatedOrganizationMembers", ctx, arg)
	ret0, _ := ret[0].([]database.PaginatedOrganizationMembersRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PaginatedOrganizationMembers indicates an expected call of PaginatedOrganizationMembers.
func (mr *MockStoreMockRecorder) PaginatedOrganizationMembers(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaginatedOrganizationMembers", reflect.TypeOf((*MockStore)(nil).PaginatedOrganizationMembers), ctx, arg)
}

// PinChatByID mocks base method.
func (m *MockStore) PinChatByID(ctx context.Context, id uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PinChatByID", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// Ping mocks base method.
func (m *MockStore) Ping(ctx context.Context) (time.Duration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Ping", ctx)
	ret0, _ := ret[0].(time.Duration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PopNextQueuedMessage mocks base method.
func (m *MockStore) PopNextQueuedMessage(ctx context.Context, chatID uuid.UUID) (database.ChatQueuedMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PopNextQueuedMessage", ctx, chatID)
	ret0, _ := ret[0].(database.ChatQueuedMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PopNextQueuedMessage indicates an expected call of PopNextQueuedMessage.
func (mr *MockStoreMockRecorder) PopNextQueuedMessage(ctx, chatID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PopNextQueuedMessage", reflect.TypeOf((*MockStore)(nil).PopNextQueuedMessage), ctx, chatID)
}

// ReduceWorkspaceAgentShareLevelToAuthenticatedByTemplate mocks base method.
func (m *MockStore) ReduceWorkspaceAgentShareLevelToAuthenticatedByTemplate(ctx context.Context, templateID uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReduceWorkspaceAgentShareLevelToAuthenticatedByTemplate", ctx, templateID)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReduceWorkspaceAgentShareLevelToAuthenticatedByTemplate indicates an expected call of ReduceWorkspaceAgentShareLevelToAuthenticatedByTemplate.
func (mr *MockStoreMockRecorder) ReduceWorkspaceAgentShareLevelToAuthenticatedByTemplate(ctx, templateID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReduceWorkspaceAgentShareLevelToAuthenticatedByTemplate", reflect.TypeOf((*MockStore)(nil).ReduceWorkspaceAgentShareLevelToAuthenticatedByTemplate), ctx, templateID)
}

// RegisterWorkspaceProxy mocks base method.
func (m *MockStore) RegisterWorkspaceProxy(ctx context.Context, arg database.RegisterWorkspaceProxyParams) (database.WorkspaceProxy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterWorkspaceProxy", ctx, arg)
	ret0, _ := ret[0].(database.WorkspaceProxy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RegisterWorkspaceProxy indicates an expected call of RegisterWorkspaceProxy.
func (mr *MockStoreMockRecorder) RegisterWorkspaceProxy(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterWorkspaceProxy", reflect.TypeOf((*MockStore)(nil).RegisterWorkspaceProxy), ctx, arg)
}

// RemoveUserFromGroups mocks base method.
func (m *MockStore) RemoveUserFromGroups(ctx context.Context, arg database.RemoveUserFromGroupsParams) ([]uuid.UUID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveUserFromGroups", ctx, arg)
	ret0, _ := ret[0].([]uuid.UUID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveUserFromGroups indicates an expected call of RemoveUserFromGroups.
func (mr *MockStoreMockRecorder) RemoveUserFromGroups(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveUserFromGroups", reflect.TypeOf((*MockStore)(nil).RemoveUserFromGroups), ctx, arg)
}

// ReorderChatQueuedMessageToFront mocks base method.
func (m *MockStore) ReorderChatQueuedMessageToFront(ctx context.Context, arg database.ReorderChatQueuedMessageToFrontParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReorderChatQueuedMessageToFront", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReorderChatQueuedMessageToFront indicates an expected call of ReorderChatQueuedMessageToFront.
func (mr *MockStoreMockRecorder) ReorderChatQueuedMessageToFront(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReorderChatQueuedMessageToFront", reflect.TypeOf((*MockStore)(nil).ReorderChatQueuedMessageToFront), ctx, arg)
}

// ResolveUserChatSpendLimit mocks base method.
func (m *MockStore) ResolveUserChatSpendLimit(ctx context.Context, arg database.ResolveUserChatSpendLimitParams) (database.ResolveUserChatSpendLimitRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResolveUserChatSpendLimit", ctx, arg)
	ret0, _ := ret[0].(database.ResolveUserChatSpendLimitRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResolveUserChatSpendLimit indicates an expected call of ResolveUserChatSpendLimit.
func (mr *MockStoreMockRecorder) ResolveUserChatSpendLimit(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveUserChatSpendLimit", reflect.TypeOf((*MockStore)(nil).ResolveUserChatSpendLimit), ctx, arg)
}

// RevokeDBCryptKey mocks base method.
func (m *MockStore) RevokeDBCryptKey(ctx context.Context, activeKeyDigest string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RevokeDBCryptKey", ctx, activeKeyDigest)
	ret0, _ := ret[0].(error)
	return ret0
}

// RevokeDBCryptKey indicates an expected call of RevokeDBCryptKey.
func (mr *MockStoreMockRecorder) RevokeDBCryptKey(ctx, activeKeyDigest any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeDBCryptKey", reflect.TypeOf((*MockStore)(nil).RevokeDBCryptKey), ctx, activeKeyDigest)
}

// SelectUsageEventsForPublishing mocks base method.
func (m *MockStore) SelectUsageEventsForPublishing(ctx context.Context, now time.Time) ([]database.UsageEvent, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectUsageEventsForPublishing", ctx, now)
	ret0, _ := ret[0].([]database.UsageEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectUsageEventsForPublishing indicates an expected call of SelectUsageEventsForPublishing.
func (mr *MockStoreMockRecorder) SelectUsageEventsForPublishing(ctx, now any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectUsageEventsForPublishing", reflect.TypeOf((*MockStore)(nil).SelectUsageEventsForPublishing), ctx, now)
}

// SoftDeleteChatMessageByID mocks base method.
func (m *MockStore) SoftDeleteChatMessageByID(ctx context.Context, id int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SoftDeleteChatMessageByID", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SoftDeleteChatMessagesAfterID mocks base method.
func (m *MockStore) SoftDeleteChatMessagesAfterID(ctx context.Context, arg database.SoftDeleteChatMessagesAfterIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SoftDeleteChatMessagesAfterID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// SoftDeleteChatMessagesAfterID indicates an expected call of SoftDeleteChatMessagesAfterID.
func (mr *MockStoreMockRecorder) SoftDeleteChatMessagesAfterID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SoftDeleteChatMessagesAfterID", reflect.TypeOf((*MockStore)(nil).SoftDeleteChatMessagesAfterID), ctx, arg)
}

// SoftDeleteContextFileMessages mocks base method.
func (m *MockStore) SoftDeleteContextFileMessages(ctx context.Context, chatID uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SoftDeleteContextFileMessages", ctx, chatID)
	ret0, _ := ret[0].(error)
	return ret0
}

// SoftDeleteContextFileMessages indicates an expected call of SoftDeleteContextFileMessages.
func (mr *MockStoreMockRecorder) SoftDeleteContextFileMessages(ctx, chatID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SoftDeleteContextFileMessages", reflect.TypeOf((*MockStore)(nil).SoftDeleteContextFileMessages), ctx, chatID)
}

// SoftDeletePriorWorkspaceAgents mocks base method.
func (m *MockStore) SoftDeletePriorWorkspaceAgents(ctx context.Context, arg database.SoftDeletePriorWorkspaceAgentsParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SoftDeletePriorWorkspaceAgents", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// SoftDeletePriorWorkspaceAgents indicates an expected call of SoftDeletePriorWorkspaceAgents.
func (mr *MockStoreMockRecorder) SoftDeletePriorWorkspaceAgents(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SoftDeletePriorWorkspaceAgents", reflect.TypeOf((*MockStore)(nil).SoftDeletePriorWorkspaceAgents), ctx, arg)
}

// SoftDeleteWorkspaceAgentsByWorkspaceID mocks base method.
func (m *MockStore) SoftDeleteWorkspaceAgentsByWorkspaceID(ctx context.Context, workspaceID uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SoftDeleteWorkspaceAgentsByWorkspaceID", ctx, workspaceID)
	ret0, _ := ret[0].(error)
	return ret0
}

// SoftDeleteWorkspaceAgentsByWorkspaceID indicates an expected call of SoftDeleteWorkspaceAgentsByWorkspaceID.
func (mr *MockStoreMockRecorder) SoftDeleteWorkspaceAgentsByWorkspaceID(ctx, workspaceID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SoftDeleteWorkspaceAgentsByWorkspaceID", reflect.TypeOf((*MockStore)(nil).SoftDeleteWorkspaceAgentsByWorkspaceID), ctx, workspaceID)
}

// TouchChatDebugRunUpdatedAt mocks base method.
func (m *MockStore) TouchChatDebugRunUpdatedAt(ctx context.Context, arg database.TouchChatDebugRunUpdatedAtParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TouchChatDebugRunUpdatedAt", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// TouchChatDebugRunUpdatedAt indicates an expected call of TouchChatDebugRunUpdatedAt.
func (mr *MockStoreMockRecorder) TouchChatDebugRunUpdatedAt(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TouchChatDebugRunUpdatedAt", reflect.TypeOf((*MockStore)(nil).TouchChatDebugRunUpdatedAt), ctx, arg)
}

// TouchChatDebugStepAndRun mocks base method.
func (m *MockStore) TouchChatDebugStepAndRun(ctx context.Context, arg database.TouchChatDebugStepAndRunParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TouchChatDebugStepAndRun", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// TouchChatDebugStepAndRun indicates an expected call of TouchChatDebugStepAndRun.
func (mr *MockStoreMockRecorder) TouchChatDebugStepAndRun(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TouchChatDebugStepAndRun", reflect.TypeOf((*MockStore)(nil).TouchChatDebugStepAndRun), ctx, arg)
}

// TryAcquireLock mocks base method.
func (m *MockStore) TryAcquireLock(ctx context.Context, pgTryAdvisoryXactLock int64) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TryAcquireLock", ctx, pgTryAdvisoryXactLock)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TryAcquireLock indicates an expected call of TryAcquireLock.
func (mr *MockStoreMockRecorder) TryAcquireLock(ctx, pgTryAdvisoryXactLock any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryAcquireLock", reflect.TypeOf((*MockStore)(nil).TryAcquireLock), ctx, pgTryAdvisoryXactLock)
}

// UnarchiveChatByID mocks base method.
func (m *MockStore) UnarchiveChatByID(ctx context.Context, id uuid.UUID) ([]database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnarchiveChatByID", ctx, id)
	ret0, _ := ret[0].([]database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UnarchiveTemplateVersion mocks base method.
func (m *MockStore) UnarchiveTemplateVersion(ctx context.Context, arg database.UnarchiveTemplateVersionParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnarchiveTemplateVersion", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UnarchiveTemplateVersion indicates an expected call of UnarchiveTemplateVersion.
func (mr *MockStoreMockRecorder) UnarchiveTemplateVersion(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnarchiveTemplateVersion", reflect.TypeOf((*MockStore)(nil).UnarchiveTemplateVersion), ctx, arg)
}

// UnfavoriteWorkspace mocks base method.
func (m *MockStore) UnfavoriteWorkspace(ctx context.Context, id uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnfavoriteWorkspace", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UnpinChatByID mocks base method.
func (m *MockStore) UnpinChatByID(ctx context.Context, id uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnpinChatByID", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UnsetDefaultChatModelConfigs mocks base method.
func (m *MockStore) UnsetDefaultChatModelConfigs(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnsetDefaultChatModelConfigs", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UpdateAIBridgeInterceptionEnded mocks base method.
func (m *MockStore) UpdateAIBridgeInterceptionEnded(ctx context.Context, arg database.UpdateAIBridgeInterceptionEndedParams) (database.AIBridgeInterception, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAIBridgeInterceptionEnded", ctx, arg)
	ret0, _ := ret[0].(database.AIBridgeInterception)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateAIBridgeInterceptionEnded indicates an expected call of UpdateAIBridgeInterceptionEnded.
func (mr *MockStoreMockRecorder) UpdateAIBridgeInterceptionEnded(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAIBridgeInterceptionEnded", reflect.TypeOf((*MockStore)(nil).UpdateAIBridgeInterceptionEnded), ctx, arg)
}

// UpdateAIProvider mocks base method.
func (m *MockStore) UpdateAIProvider(ctx context.Context, arg database.UpdateAIProviderParams) (database.AIProvider, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAIProvider", ctx, arg)
	ret0, _ := ret[0].(database.AIProvider)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateAIProvider indicates an expected call of UpdateAIProvider.
func (mr *MockStoreMockRecorder) UpdateAIProvider(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAIProvider", reflect.TypeOf((*MockStore)(nil).UpdateAIProvider), ctx, arg)
}

// UpdateAPIKeyByID mocks base method.
func (m *MockStore) UpdateAPIKeyByID(ctx context.Context, arg database.UpdateAPIKeyByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAPIKeyByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateAPIKeyByID indicates an expected call of UpdateAPIKeyByID.
func (mr *MockStoreMockRecorder) UpdateAPIKeyByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAPIKeyByID", reflect.TypeOf((*MockStore)(nil).UpdateAPIKeyByID), ctx, arg)
}

// UpdateChatACLByID mocks base method.
func (m *MockStore) UpdateChatACLByID(ctx context.Context, arg database.UpdateChatACLByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatACLByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateChatACLByID indicates an expected call of UpdateChatACLByID.
func (mr *MockStoreMockRecorder) UpdateChatACLByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatACLByID", reflect.TypeOf((*MockStore)(nil).UpdateChatACLByID), ctx, arg)
}

// UpdateChatBuildAgentBinding mocks base method.
func (m *MockStore) UpdateChatBuildAgentBinding(ctx context.Context, arg database.UpdateChatBuildAgentBindingParams) (database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatBuildAgentBinding", ctx, arg)
	ret0, _ := ret[0].(database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateChatBuildAgentBinding indicates an expected call of UpdateChatBuildAgentBinding.
func (mr *MockStoreMockRecorder) UpdateChatBuildAgentBinding(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatBuildAgentBinding", reflect.TypeOf((*MockStore)(nil).UpdateChatBuildAgentBinding), ctx, arg)
}

// UpdateChatByID mocks base method.
func (m *MockStore) UpdateChatByID(ctx context.Context, arg database.UpdateChatByIDParams) (database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatByID", ctx, arg)
	ret0, _ := ret[0].(database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateChatByID indicates an expected call of UpdateChatByID.
func (mr *MockStoreMockRecorder) UpdateChatByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatByID", reflect.TypeOf((*MockStore)(nil).UpdateChatByID), ctx, arg)
}

// UpdateChatDebugRun mocks base method.
func (m *MockStore) UpdateChatDebugRun(ctx context.Context, arg database.UpdateChatDebugRunParams) (database.ChatDebugRun, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatDebugRun", ctx, arg)
	ret0, _ := ret[0].(database.ChatDebugRun)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateChatDebugRun indicates an expected call of UpdateChatDebugRun.
func (mr *MockStoreMockRecorder) UpdateChatDebugRun(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatDebugRun", reflect.TypeOf((*MockStore)(nil).UpdateChatDebugRun), ctx, arg)
}

// UpdateChatDebugStep mocks base method.
func (m *MockStore) UpdateChatDebugStep(ctx context.Context, arg database.UpdateChatDebugStepParams) (database.ChatDebugStep, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatDebugStep", ctx, arg)
	ret0, _ := ret[0].(database.ChatDebugStep)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateChatDebugStep indicates an expected call of UpdateChatDebugStep.
func (mr *MockStoreMockRecorder) UpdateChatDebugStep(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatDebugStep", reflect.TypeOf((*MockStore)(nil).UpdateChatDebugStep), ctx, arg)
}

// UpdateChatHeartbeats mocks base method.
func (m *MockStore) UpdateChatHeartbeats(ctx context.Context, arg database.UpdateChatHeartbeatsParams) ([]uuid.UUID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatHeartbeats", ctx, arg)
	ret0, _ := ret[0].([]uuid.UUID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateChatHeartbeats indicates an expected call of UpdateChatHeartbeats.
func (mr *MockStoreMockRecorder) UpdateChatHeartbeats(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatHeartbeats", reflect.TypeOf((*MockStore)(nil).UpdateChatHeartbeats), ctx, arg)
}

// UpdateChatLabelsByID mocks base method.
func (m *MockStore) UpdateChatLabelsByID(ctx context.Context, arg database.UpdateChatLabelsByIDParams) (database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatLabelsByID", ctx, arg)
	ret0, _ := ret[0].(database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateChatLabelsByID indicates an expected call of UpdateChatLabelsByID.
func (mr *MockStoreMockRecorder) UpdateChatLabelsByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatLabelsByID", reflect.TypeOf((*MockStore)(nil).UpdateChatLabelsByID), ctx, arg)
}

// UpdateChatLastInjectedContext mocks base method.
func (m *MockStore) UpdateChatLastInjectedContext(ctx context.Context, arg database.UpdateChatLastInjectedContextParams) (database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatLastInjectedContext", ctx, arg)
	ret0, _ := ret[0].(database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateChatLastInjectedContext indicates an expected call of UpdateChatLastInjectedContext.
func (mr *MockStoreMockRecorder) UpdateChatLastInjectedContext(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatLastInjectedContext", reflect.TypeOf((*MockStore)(nil).UpdateChatLastInjectedContext), ctx, arg)
}

// UpdateChatLastModelConfigByID mocks base method.
func (m *MockStore) UpdateChatLastModelConfigByID(ctx context.Context, arg database.UpdateChatLastModelConfigByIDParams) (database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatLastModelConfigByID", ctx, arg)
	ret0, _ := ret[0].(database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateChatLastModelConfigByID indicates an expected call of UpdateChatLastModelConfigByID.
func (mr *MockStoreMockRecorder) UpdateChatLastModelConfigByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatLastModelConfigByID", reflect.TypeOf((*MockStore)(nil).UpdateChatLastModelConfigByID), ctx, arg)
}

// UpdateChatLastReadMessageID mocks base method.
func (m *MockStore) UpdateChatLastReadMessageID(ctx context.Context, arg database.UpdateChatLastReadMessageIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatLastReadMessageID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateChatLastReadMessageID indicates an expected call of UpdateChatLastReadMessageID.
func (mr *MockStoreMockRecorder) UpdateChatLastReadMessageID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatLastReadMessageID", reflect.TypeOf((*MockStore)(nil).UpdateChatLastReadMessageID), ctx, arg)
}

// UpdateChatLastTurnSummary mocks base method.
func (m *MockStore) UpdateChatLastTurnSummary(ctx context.Context, arg database.UpdateChatLastTurnSummaryParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatLastTurnSummary", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateChatLastTurnSummary indicates an expected call of UpdateChatLastTurnSummary.
func (mr *MockStoreMockRecorder) UpdateChatLastTurnSummary(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatLastTurnSummary", reflect.TypeOf((*MockStore)(nil).UpdateChatLastTurnSummary), ctx, arg)
}

// UpdateChatMCPServerIDs mocks base method.
func (m *MockStore) UpdateChatMCPServerIDs(ctx context.Context, arg database.UpdateChatMCPServerIDsParams) (database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatMCPServerIDs", ctx, arg)
	ret0, _ := ret[0].(database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateChatMCPServerIDs indicates an expected call of UpdateChatMCPServerIDs.
func (mr *MockStoreMockRecorder) UpdateChatMCPServerIDs(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatMCPServerIDs", reflect.TypeOf((*MockStore)(nil).UpdateChatMCPServerIDs), ctx, arg)
}

// UpdateChatMessageByID mocks base method.
func (m *MockStore) UpdateChatMessageByID(ctx context.Context, arg database.UpdateChatMessageByIDParams) (database.ChatMessage, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatMessageByID", ctx, arg)
	ret0, _ := ret[0].(database.ChatMessage)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateChatMessageByID indicates an expected call of UpdateChatMessageByID.
func (mr *MockStoreMockRecorder) UpdateChatMessageByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatMessageByID", reflect.TypeOf((*MockStore)(nil).UpdateChatMessageByID), ctx, arg)
}

// UpdateChatModelConfig mocks base method.
func (m *MockStore) UpdateChatModelConfig(ctx context.Context, arg database.UpdateChatModelConfigParams) (database.ChatModelConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatModelConfig", ctx, arg)
	ret0, _ := ret[0].(database.ChatModelConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateChatModelConfig indicates an expected call of UpdateChatModelConfig.
func (mr *MockStoreMockRecorder) UpdateChatModelConfig(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatModelConfig", reflect.TypeOf((*MockStore)(nil).UpdateChatModelConfig), ctx, arg)
}

// UpdateChatPinOrder mocks base method.
func (m *MockStore) UpdateChatPinOrder(ctx context.Context, arg database.UpdateChatPinOrderParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatPinOrder", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateChatPinOrder indicates an expected call of UpdateChatPinOrder.
func (mr *MockStoreMockRecorder) UpdateChatPinOrder(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatPinOrder", reflect.TypeOf((*MockStore)(nil).UpdateChatPinOrder), ctx, arg)
}

// UpdateChatPlanModeByID mocks base method.
func (m *MockStore) UpdateChatPlanModeByID(ctx context.Context, arg database.UpdateChatPlanModeByIDParams) (database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatPlanModeByID", ctx, arg)
	ret0, _ := ret[0].(database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateChatPlanModeByID indicates an expected call of UpdateChatPlanModeByID.
func (mr *MockStoreMockRecorder) UpdateChatPlanModeByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatPlanModeByID", reflect.TypeOf((*MockStore)(nil).UpdateChatPlanModeByID), ctx, arg)
}

// UpdateChatStatus mocks base method.
func (m *MockStore) UpdateChatStatus(ctx context.Context, arg database.UpdateChatStatusParams) (database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatStatus", ctx, arg)
	ret0, _ := ret[0].(database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateChatStatus indicates an expected call of UpdateChatStatus.
func (mr *MockStoreMockRecorder) UpdateChatStatus(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatStatus", reflect.TypeOf((*MockStore)(nil).UpdateChatStatus), ctx, arg)
}

// UpdateChatStatusPreserveUpdatedAt mocks base method.
func (m *MockStore) UpdateChatStatusPreserveUpdatedAt(ctx context.Context, arg database.UpdateChatStatusPreserveUpdatedAtParams) (database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatStatusPreserveUpdatedAt", ctx, arg)
	ret0, _ := ret[0].(database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateChatStatusPreserveUpdatedAt indicates an expected call of UpdateChatStatusPreserveUpdatedAt.
func (mr *MockStoreMockRecorder) UpdateChatStatusPreserveUpdatedAt(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatStatusPreserveUpdatedAt", reflect.TypeOf((*MockStore)(nil).UpdateChatStatusPreserveUpdatedAt), ctx, arg)
}

// UpdateChatTitleByID mocks base method.
func (m *MockStore) UpdateChatTitleByID(ctx context.Context, arg database.UpdateChatTitleByIDParams) (database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatTitleByID", ctx, arg)
	ret0, _ := ret[0].(database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateChatTitleByID indicates an expected call of UpdateChatTitleByID.
func (mr *MockStoreMockRecorder) UpdateChatTitleByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatTitleByID", reflect.TypeOf((*MockStore)(nil).UpdateChatTitleByID), ctx, arg)
}

// UpdateChatWorkspaceBinding mocks base method.
func (m *MockStore) UpdateChatWorkspaceBinding(ctx context.Context, arg database.UpdateChatWorkspaceBindingParams) (database.Chat, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateChatWorkspaceBinding", ctx, arg)
	ret0, _ := ret[0].(database.Chat)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateChatWorkspaceBinding indicates an expected call of UpdateChatWorkspaceBinding.
func (mr *MockStoreMockRecorder) UpdateChatWorkspaceBinding(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateChatWorkspaceBinding", reflect.TypeOf((*MockStore)(nil).UpdateChatWorkspaceBinding), ctx, arg)
}

// UpdateCryptoKeyDeletesAt mocks base method.
func (m *MockStore) UpdateCryptoKeyDeletesAt(ctx context.Context, arg database.UpdateCryptoKeyDeletesAtParams) (database.CryptoKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCryptoKeyDeletesAt", ctx, arg)
	ret0, _ := ret[0].(database.CryptoKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateCryptoKeyDeletesAt indicates an expected call of UpdateCryptoKeyDeletesAt.
func (mr *MockStoreMockRecorder) UpdateCryptoKeyDeletesAt(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCryptoKeyDeletesAt", reflect.TypeOf((*MockStore)(nil).UpdateCryptoKeyDeletesAt), ctx, arg)
}

// UpdateCustomRole mocks base method.
func (m *MockStore) UpdateCustomRole(ctx context.Context, arg database.UpdateCustomRoleParams) (database.CustomRole, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCustomRole", ctx, arg)
	ret0, _ := ret[0].(database.CustomRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateCustomRole indicates an expected call of UpdateCustomRole.
func (mr *MockStoreMockRecorder) UpdateCustomRole(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCustomRole", reflect.TypeOf((*MockStore)(nil).UpdateCustomRole), ctx, arg)
}

// UpdateEncryptedAIProviderKey mocks base method.
func (m *MockStore) UpdateEncryptedAIProviderKey(ctx context.Context, arg database.UpdateEncryptedAIProviderKeyParams) (database.AIProviderKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateEncryptedAIProviderKey", ctx, arg)
	ret0, _ := ret[0].(database.AIProviderKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateEncryptedAIProviderKey indicates an expected call of UpdateEncryptedAIProviderKey.
func (mr *MockStoreMockRecorder) UpdateEncryptedAIProviderKey(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEncryptedAIProviderKey", reflect.TypeOf((*MockStore)(nil).UpdateEncryptedAIProviderKey), ctx, arg)
}

// UpdateEncryptedAIProviderSettings mocks base method.
func (m *MockStore) UpdateEncryptedAIProviderSettings(ctx context.Context, arg database.UpdateEncryptedAIProviderSettingsParams) (database.AIProvider, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateEncryptedAIProviderSettings", ctx, arg)
	ret0, _ := ret[0].(database.AIProvider)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateEncryptedAIProviderSettings indicates an expected call of UpdateEncryptedAIProviderSettings.
func (mr *MockStoreMockRecorder) UpdateEncryptedAIProviderSettings(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEncryptedAIProviderSettings", reflect.TypeOf((*MockStore)(nil).UpdateEncryptedAIProviderSettings), ctx, arg)
}

// UpdateEncryptedUserAIProviderKey mocks base method.
func (m *MockStore) UpdateEncryptedUserAIProviderKey(ctx context.Context, arg database.UpdateEncryptedUserAIProviderKeyParams) (database.UserAiProviderKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateEncryptedUserAIProviderKey", ctx, arg)
	ret0, _ := ret[0].(database.UserAiProviderKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateEncryptedUserAIProviderKey indicates an expected call of UpdateEncryptedUserAIProviderKey.
func (mr *MockStoreMockRecorder) UpdateEncryptedUserAIProviderKey(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEncryptedUserAIProviderKey", reflect.TypeOf((*MockStore)(nil).UpdateEncryptedUserAIProviderKey), ctx, arg)
}

// UpdateExternalAuthLink mocks base method.
func (m *MockStore) UpdateExternalAuthLink(ctx context.Context, arg database.UpdateExternalAuthLinkParams) (database.ExternalAuthLink, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateExternalAuthLink", ctx, arg)
	ret0, _ := ret[0].(database.ExternalAuthLink)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateExternalAuthLink indicates an expected call of UpdateExternalAuthLink.
func (mr *MockStoreMockRecorder) UpdateExternalAuthLink(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateExternalAuthLink", reflect.TypeOf((*MockStore)(nil).UpdateExternalAuthLink), ctx, arg)
}

// UpdateExternalAuthLinkRefreshToken mocks base method.
func (m *MockStore) UpdateExternalAuthLinkRefreshToken(ctx context.Context, arg database.UpdateExternalAuthLinkRefreshTokenParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateExternalAuthLinkRefreshToken", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateExternalAuthLinkRefreshToken indicates an expected call of UpdateExternalAuthLinkRefreshToken.
func (mr *MockStoreMockRecorder) UpdateExternalAuthLinkRefreshToken(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateExternalAuthLinkRefreshToken", reflect.TypeOf((*MockStore)(nil).UpdateExternalAuthLinkRefreshToken), ctx, arg)
}

// UpdateGitSSHKey mocks base method.
func (m *MockStore) UpdateGitSSHKey(ctx context.Context, arg database.UpdateGitSSHKeyParams) (database.GitSSHKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGitSSHKey", ctx, arg)
	ret0, _ := ret[0].(database.GitSSHKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateGitSSHKey indicates an expected call of UpdateGitSSHKey.
func (mr *MockStoreMockRecorder) UpdateGitSSHKey(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGitSSHKey", reflect.TypeOf((*MockStore)(nil).UpdateGitSSHKey), ctx, arg)
}

// UpdateGroupByID mocks base method.
func (m *MockStore) UpdateGroupByID(ctx context.Context, arg database.UpdateGroupByIDParams) (database.Group, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGroupByID", ctx, arg)
	ret0, _ := ret[0].(database.Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateGroupByID indicates an expected call of UpdateGroupByID.
func (mr *MockStoreMockRecorder) UpdateGroupByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGroupByID", reflect.TypeOf((*MockStore)(nil).UpdateGroupByID), ctx, arg)
}

// UpdateInactiveUsersToDormant mocks base method.
func (m *MockStore) UpdateInactiveUsersToDormant(ctx context.Context, arg database.UpdateInactiveUsersToDormantParams) ([]database.UpdateInactiveUsersToDormantRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateInactiveUsersToDormant", ctx, arg)
	ret0, _ := ret[0].([]database.UpdateInactiveUsersToDormantRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateInactiveUsersToDormant indicates an expected call of UpdateInactiveUsersToDormant.
func (mr *MockStoreMockRecorder) UpdateInactiveUsersToDormant(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateInactiveUsersToDormant", reflect.TypeOf((*MockStore)(nil).UpdateInactiveUsersToDormant), ctx, arg)
}

// UpdateInboxNotificationReadStatus mocks base method.
func (m *MockStore) UpdateInboxNotificationReadStatus(ctx context.Context, arg database.UpdateInboxNotificationReadStatusParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateInboxNotificationReadStatus", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateInboxNotificationReadStatus indicates an expected call of UpdateInboxNotificationReadStatus.
func (mr *MockStoreMockRecorder) UpdateInboxNotificationReadStatus(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateInboxNotificationReadStatus", reflect.TypeOf((*MockStore)(nil).UpdateInboxNotificationReadStatus), ctx, arg)
}

// UpdateMCPServerConfig mocks base method.
func (m *MockStore) UpdateMCPServerConfig(ctx context.Context, arg database.UpdateMCPServerConfigParams) (database.MCPServerConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMCPServerConfig", ctx, arg)
	ret0, _ := ret[0].(database.MCPServerConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateMCPServerConfig indicates an expected call of UpdateMCPServerConfig.
func (mr *MockStoreMockRecorder) UpdateMCPServerConfig(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMCPServerConfig", reflect.TypeOf((*MockStore)(nil).UpdateMCPServerConfig), ctx, arg)
}

// UpdateMemberRoles mocks base method.
func (m *MockStore) UpdateMemberRoles(ctx context.Context, arg database.UpdateMemberRolesParams) (database.OrganizationMember, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMemberRoles", ctx, arg)
	ret0, _ := ret[0].(database.OrganizationMember)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateMemberRoles indicates an expected call of UpdateMemberRoles.
func (mr *MockStoreMockRecorder) UpdateMemberRoles(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMemberRoles", reflect.TypeOf((*MockStore)(nil).UpdateMemberRoles), ctx, arg)
}

// UpdateMemoryResourceMonitor mocks base method.
func (m *MockStore) UpdateMemoryResourceMonitor(ctx context.Context, arg database.UpdateMemoryResourceMonitorParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMemoryResourceMonitor", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateMemoryResourceMonitor indicates an expected call of UpdateMemoryResourceMonitor.
func (mr *MockStoreMockRecorder) UpdateMemoryResourceMonitor(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMemoryResourceMonitor", reflect.TypeOf((*MockStore)(nil).UpdateMemoryResourceMonitor), ctx, arg)
}

// UpdateNotificationTemplateMethodByID mocks base method.
func (m *MockStore) UpdateNotificationTemplateMethodByID(ctx context.Context, arg database.UpdateNotificationTemplateMethodByIDParams) (database.NotificationTemplate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNotificationTemplateMethodByID", ctx, arg)
	ret0, _ := ret[0].(database.NotificationTemplate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateNotificationTemplateMethodByID indicates an expected call of UpdateNotificationTemplateMethodByID.
func (mr *MockStoreMockRecorder) UpdateNotificationTemplateMethodByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNotificationTemplateMethodByID", reflect.TypeOf((*MockStore)(nil).UpdateNotificationTemplateMethodByID), ctx, arg)
}

// UpdateOAuth2ProviderAppByClientID mocks base method.
func (m *MockStore) UpdateOAuth2ProviderAppByClientID(ctx context.Context, arg database.UpdateOAuth2ProviderAppByClientIDParams) (database.OAuth2ProviderApp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOAuth2ProviderAppByClientID", ctx, arg)
	ret0, _ := ret[0].(database.OAuth2ProviderApp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateOAuth2ProviderAppByClientID indicates an expected call of UpdateOAuth2ProviderAppByClientID.
func (mr *MockStoreMockRecorder) UpdateOAuth2ProviderAppByClientID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOAuth2ProviderAppByClientID", reflect.TypeOf((*MockStore)(nil).UpdateOAuth2ProviderAppByClientID), ctx, arg)
}

// UpdateOAuth2ProviderAppByID mocks base method.
func (m *MockStore) UpdateOAuth2ProviderAppByID(ctx context.Context, arg database.UpdateOAuth2ProviderAppByIDParams) (database.OAuth2ProviderApp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOAuth2ProviderAppByID", ctx, arg)
	ret0, _ := ret[0].(database.OAuth2ProviderApp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateOAuth2ProviderAppByID indicates an expected call of UpdateOAuth2ProviderAppByID.
func (mr *MockStoreMockRecorder) UpdateOAuth2ProviderAppByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOAuth2ProviderAppByID", reflect.TypeOf((*MockStore)(nil).UpdateOAuth2ProviderAppByID), ctx, arg)
}

// UpdateOrganization mocks base method.
func (m *MockStore) UpdateOrganization(ctx context.Context, arg database.UpdateOrganizationParams) (database.Organization, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOrganization", ctx, arg)
	ret0, _ := ret[0].(database.Organization)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateOrganization indicates an expected call of UpdateOrganization.
func (mr *MockStoreMockRecorder) UpdateOrganization(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOrganization", reflect.TypeOf((*MockStore)(nil).UpdateOrganization), ctx, arg)
}

// UpdateOrganizationDeletedByID mocks base method.
func (m *MockStore) UpdateOrganizationDeletedByID(ctx context.Context, arg database.UpdateOrganizationDeletedByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOrganizationDeletedByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateOrganizationDeletedByID indicates an expected call of UpdateOrganizationDeletedByID.
func (mr *MockStoreMockRecorder) UpdateOrganizationDeletedByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOrganizationDeletedByID", reflect.TypeOf((*MockStore)(nil).UpdateOrganizationDeletedByID), ctx, arg)
}

// UpdateOrganizationWorkspaceSharingSettings mocks base method.
func (m *MockStore) UpdateOrganizationWorkspaceSharingSettings(ctx context.Context, arg database.UpdateOrganizationWorkspaceSharingSettingsParams) (database.Organization, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOrganizationWorkspaceSharingSettings", ctx, arg)
	ret0, _ := ret[0].(database.Organization)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateOrganizationWorkspaceSharingSettings indicates an expected call of UpdateOrganizationWorkspaceSharingSettings.
func (mr *MockStoreMockRecorder) UpdateOrganizationWorkspaceSharingSettings(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOrganizationWorkspaceSharingSettings", reflect.TypeOf((*MockStore)(nil).UpdateOrganizationWorkspaceSharingSettings), ctx, arg)
}

// UpdatePrebuildProvisionerJobWithCancel mocks base method.
func (m *MockStore) UpdatePrebuildProvisionerJobWithCancel(ctx context.Context, arg database.UpdatePrebuildProvisionerJobWithCancelParams) ([]database.UpdatePrebuildProvisionerJobWithCancelRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePrebuildProvisionerJobWithCancel", ctx, arg)
	ret0, _ := ret[0].([]database.UpdatePrebuildProvisionerJobWithCancelRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePrebuildProvisionerJobWithCancel indicates an expected call of UpdatePrebuildProvisionerJobWithCancel.
func (mr *MockStoreMockRecorder) UpdatePrebuildProvisionerJobWithCancel(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePrebuildProvisionerJobWithCancel", reflect.TypeOf((*MockStore)(nil).UpdatePrebuildProvisionerJobWithCancel), ctx, arg)
}

// UpdatePresetPrebuildStatus mocks base method.
func (m *MockStore) UpdatePresetPrebuildStatus(ctx context.Context, arg database.UpdatePresetPrebuildStatusParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePresetPrebuildStatus", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdatePresetPrebuildStatus indicates an expected call of UpdatePresetPrebuildStatus.
func (mr *MockStoreMockRecorder) UpdatePresetPrebuildStatus(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePresetPrebuildStatus", reflect.TypeOf((*MockStore)(nil).UpdatePresetPrebuildStatus), ctx, arg)
}

// UpdatePresetsLastInvalidatedAt mocks base method.
func (m *MockStore) UpdatePresetsLastInvalidatedAt(ctx context.Context, arg database.UpdatePresetsLastInvalidatedAtParams) ([]database.UpdatePresetsLastInvalidatedAtRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePresetsLastInvalidatedAt", ctx, arg)
	ret0, _ := ret[0].([]database.UpdatePresetsLastInvalidatedAtRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePresetsLastInvalidatedAt indicates an expected call of UpdatePresetsLastInvalidatedAt.
func (mr *MockStoreMockRecorder) UpdatePresetsLastInvalidatedAt(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePresetsLastInvalidatedAt", reflect.TypeOf((*MockStore)(nil).UpdatePresetsLastInvalidatedAt), ctx, arg)
}

// UpdateProvisionerDaemonLastSeenAt mocks base method.
func (m *MockStore) UpdateProvisionerDaemonLastSeenAt(ctx context.Context, arg database.UpdateProvisionerDaemonLastSeenAtParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateProvisionerDaemonLastSeenAt", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateProvisionerDaemonLastSeenAt indicates an expected call of UpdateProvisionerDaemonLastSeenAt.
func (mr *MockStoreMockRecorder) UpdateProvisionerDaemonLastSeenAt(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProvisionerDaemonLastSeenAt", reflect.TypeOf((*MockStore)(nil).UpdateProvisionerDaemonLastSeenAt), ctx, arg)
}

// UpdateProvisionerJobByID mocks base method.
func (m *MockStore) UpdateProvisionerJobByID(ctx context.Context, arg database.UpdateProvisionerJobByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateProvisionerJobByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateProvisionerJobByID indicates an expected call of UpdateProvisionerJobByID.
func (mr *MockStoreMockRecorder) UpdateProvisionerJobByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProvisionerJobByID", reflect.TypeOf((*MockStore)(nil).UpdateProvisionerJobByID), ctx, arg)
}

// UpdateProvisionerJobLogsLength mocks base method.
func (m *MockStore) UpdateProvisionerJobLogsLength(ctx context.Context, arg database.UpdateProvisionerJobLogsLengthParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateProvisionerJobLogsLength", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateProvisionerJobLogsLength indicates an expected call of UpdateProvisionerJobLogsLength.
func (mr *MockStoreMockRecorder) UpdateProvisionerJobLogsLength(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProvisionerJobLogsLength", reflect.TypeOf((*MockStore)(nil).UpdateProvisionerJobLogsLength), ctx, arg)
}

// UpdateProvisionerJobLogsOverflowed mocks base method.
func (m *MockStore) UpdateProvisionerJobLogsOverflowed(ctx context.Context, arg database.UpdateProvisionerJobLogsOverflowedParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateProvisionerJobLogsOverflowed", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateProvisionerJobLogsOverflowed indicates an expected call of UpdateProvisionerJobLogsOverflowed.
func (mr *MockStoreMockRecorder) UpdateProvisionerJobLogsOverflowed(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProvisionerJobLogsOverflowed", reflect.TypeOf((*MockStore)(nil).UpdateProvisionerJobLogsOverflowed), ctx, arg)
}

// UpdateProvisionerJobWithCancelByID mocks base method.
func (m *MockStore) UpdateProvisionerJobWithCancelByID(ctx context.Context, arg database.UpdateProvisionerJobWithCancelByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateProvisionerJobWithCancelByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateProvisionerJobWithCancelByID indicates an expected call of UpdateProvisionerJobWithCancelByID.
func (mr *MockStoreMockRecorder) UpdateProvisionerJobWithCancelByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProvisionerJobWithCancelByID", reflect.TypeOf((*MockStore)(nil).UpdateProvisionerJobWithCancelByID), ctx, arg)
}

// UpdateProvisionerJobWithCompleteByID mocks base method.
func (m *MockStore) UpdateProvisionerJobWithCompleteByID(ctx context.Context, arg database.UpdateProvisionerJobWithCompleteByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateProvisionerJobWithCompleteByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateProvisionerJobWithCompleteByID indicates an expected call of UpdateProvisionerJobWithCompleteByID.
func (mr *MockStoreMockRecorder) UpdateProvisionerJobWithCompleteByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProvisionerJobWithCompleteByID", reflect.TypeOf((*MockStore)(nil).UpdateProvisionerJobWithCompleteByID), ctx, arg)
}

// UpdateProvisionerJobWithCompleteWithStartedAtByID mocks base method.
func (m *MockStore) UpdateProvisionerJobWithCompleteWithStartedAtByID(ctx context.Context, arg database.UpdateProvisionerJobWithCompleteWithStartedAtByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateProvisionerJobWithCompleteWithStartedAtByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateProvisionerJobWithCompleteWithStartedAtByID indicates an expected call of UpdateProvisionerJobWithCompleteWithStartedAtByID.
func (mr *MockStoreMockRecorder) UpdateProvisionerJobWithCompleteWithStartedAtByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProvisionerJobWithCompleteWithStartedAtByID", reflect.TypeOf((*MockStore)(nil).UpdateProvisionerJobWithCompleteWithStartedAtByID), ctx, arg)
}

// UpdateReplica mocks base method.
func (m *MockStore) UpdateReplica(ctx context.Context, arg database.UpdateReplicaParams) (database.Replica, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateReplica", ctx, arg)
	ret0, _ := ret[0].(database.Replica)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateReplica indicates an expected call of UpdateReplica.
func (mr *MockStoreMockRecorder) UpdateReplica(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateReplica", reflect.TypeOf((*MockStore)(nil).UpdateReplica), ctx, arg)
}

// UpdateTailnetPeerStatusByCoordinator mocks base method.
func (m *MockStore) UpdateTailnetPeerStatusByCoordinator(ctx context.Context, arg database.UpdateTailnetPeerStatusByCoordinatorParams) ([]uuid.UUID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTailnetPeerStatusByCoordinator", ctx, arg)
	ret0, _ := ret[0].([]uuid.UUID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTailnetPeerStatusByCoordinator indicates an expected call of UpdateTailnetPeerStatusByCoordinator.
func (mr *MockStoreMockRecorder) UpdateTailnetPeerStatusByCoordinator(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTailnetPeerStatusByCoordinator", reflect.TypeOf((*MockStore)(nil).UpdateTailnetPeerStatusByCoordinator), ctx, arg)
}

// UpdateTaskPrompt mocks base method.
func (m *MockStore) UpdateTaskPrompt(ctx context.Context, arg database.UpdateTaskPromptParams) (database.TaskTable, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTaskPrompt", ctx, arg)
	ret0, _ := ret[0].(database.TaskTable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTaskPrompt indicates an expected call of UpdateTaskPrompt.
func (mr *MockStoreMockRecorder) UpdateTaskPrompt(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskPrompt", reflect.TypeOf((*MockStore)(nil).UpdateTaskPrompt), ctx, arg)
}

// UpdateTaskWorkspaceID mocks base method.
func (m *MockStore) UpdateTaskWorkspaceID(ctx context.Context, arg database.UpdateTaskWorkspaceIDParams) (database.TaskTable, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTaskWorkspaceID", ctx, arg)
	ret0, _ := ret[0].(database.TaskTable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateTaskWorkspaceID indicates an expected call of UpdateTaskWorkspaceID.
func (mr *MockStoreMockRecorder) UpdateTaskWorkspaceID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskWorkspaceID", reflect.TypeOf((*MockStore)(nil).UpdateTaskWorkspaceID), ctx, arg)
}

// UpdateTemplateACLByID mocks base method.
func (m *MockStore) UpdateTemplateACLByID(ctx context.Context, arg database.UpdateTemplateACLByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplateACLByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTemplateACLByID indicates an expected call of UpdateTemplateACLByID.
func (mr *MockStoreMockRecorder) UpdateTemplateACLByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTemplateACLByID", reflect.TypeOf((*MockStore)(nil).UpdateTemplateACLByID), ctx, arg)
}

// UpdateTemplateAccessControlByID mocks base method.
func (m *MockStore) UpdateTemplateAccessControlByID(ctx context.Context, arg database.UpdateTemplateAccessControlByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplateAccessControlByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTemplateAccessControlByID indicates an expected call of UpdateTemplateAccessControlByID.
func (mr *MockStoreMockRecorder) UpdateTemplateAccessControlByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTemplateAccessControlByID", reflect.TypeOf((*MockStore)(nil).UpdateTemplateAccessControlByID), ctx, arg)
}

// UpdateTemplateActiveVersionByID mocks base method.
func (m *MockStore) UpdateTemplateActiveVersionByID(ctx context.Context, arg database.UpdateTemplateActiveVersionByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplateActiveVersionByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTemplateActiveVersionByID indicates an expected call of UpdateTemplateActiveVersionByID.
func (mr *MockStoreMockRecorder) UpdateTemplateActiveVersionByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTemplateActiveVersionByID", reflect.TypeOf((*MockStore)(nil).UpdateTemplateActiveVersionByID), ctx, arg)
}

// UpdateTemplateDeletedByID mocks base method.
func (m *MockStore) UpdateTemplateDeletedByID(ctx context.Context, arg database.UpdateTemplateDeletedByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplateDeletedByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTemplateDeletedByID indicates an expected call of UpdateTemplateDeletedByID.
func (mr *MockStoreMockRecorder) UpdateTemplateDeletedByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTemplateDeletedByID", reflect.TypeOf((*MockStore)(nil).UpdateTemplateDeletedByID), ctx, arg)
}

// UpdateTemplateMetaByID mocks base method.
func (m *MockStore) UpdateTemplateMetaByID(ctx context.Context, arg database.UpdateTemplateMetaByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplateMetaByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTemplateMetaByID indicates an expected call of UpdateTemplateMetaByID.
func (mr *MockStoreMockRecorder) UpdateTemplateMetaByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTemplateMetaByID", reflect.TypeOf((*MockStore)(nil).UpdateTemplateMetaByID), ctx, arg)
}

// UpdateTemplateScheduleByID mocks base method.
func (m *MockStore) UpdateTemplateScheduleByID(ctx context.Context, arg database.UpdateTemplateScheduleByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplateScheduleByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTemplateScheduleByID indicates an expected call of UpdateTemplateScheduleByID.
func (mr *MockStoreMockRecorder) UpdateTemplateScheduleByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTemplateScheduleByID", reflect.TypeOf((*MockStore)(nil).UpdateTemplateScheduleByID), ctx, arg)
}

// UpdateTemplateVersionByID mocks base method.
func (m *MockStore) UpdateTemplateVersionByID(ctx context.Context, arg database.UpdateTemplateVersionByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplateVersionByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTemplateVersionByID indicates an expected call of UpdateTemplateVersionByID.
func (mr *MockStoreMockRecorder) UpdateTemplateVersionByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTemplateVersionByID", reflect.TypeOf((*MockStore)(nil).UpdateTemplateVersionByID), ctx, arg)
}

// UpdateTemplateVersionDescriptionByJobID mocks base method.
func (m *MockStore) UpdateTemplateVersionDescriptionByJobID(ctx context.Context, arg database.UpdateTemplateVersionDescriptionByJobIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplateVersionDescriptionByJobID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTemplateVersionDescriptionByJobID indicates an expected call of UpdateTemplateVersionDescriptionByJobID.
func (mr *MockStoreMockRecorder) UpdateTemplateVersionDescriptionByJobID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTemplateVersionDescriptionByJobID", reflect.TypeOf((*MockStore)(nil).UpdateTemplateVersionDescriptionByJobID), ctx, arg)
}

// UpdateTemplateVersionExternalAuthProvidersByJobID mocks base method.
func (m *MockStore) UpdateTemplateVersionExternalAuthProvidersByJobID(ctx context.Context, arg database.UpdateTemplateVersionExternalAuthProvidersByJobIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplateVersionExternalAuthProvidersByJobID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTemplateVersionExternalAuthProvidersByJobID indicates an expected call of UpdateTemplateVersionExternalAuthProvidersByJobID.
func (mr *MockStoreMockRecorder) UpdateTemplateVersionExternalAuthProvidersByJobID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTemplateVersionExternalAuthProvidersByJobID", reflect.TypeOf((*MockStore)(nil).UpdateTemplateVersionExternalAuthProvidersByJobID), ctx, arg)
}

// UpdateTemplateVersionFlagsByJobID mocks base method.
func (m *MockStore) UpdateTemplateVersionFlagsByJobID(ctx context.Context, arg database.UpdateTemplateVersionFlagsByJobIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplateVersionFlagsByJobID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTemplateVersionFlagsByJobID indicates an expected call of UpdateTemplateVersionFlagsByJobID.
func (mr *MockStoreMockRecorder) UpdateTemplateVersionFlagsByJobID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTemplateVersionFlagsByJobID", reflect.TypeOf((*MockStore)(nil).UpdateTemplateVersionFlagsByJobID), ctx, arg)
}

// UpdateTemplateWorkspacesLastUsedAt mocks base method.
func (m *MockStore) UpdateTemplateWorkspacesLastUsedAt(ctx context.Context, arg database.UpdateTemplateWorkspacesLastUsedAtParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplateWorkspacesLastUsedAt", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateTemplateWorkspacesLastUsedAt indicates an expected call of UpdateTemplateWorkspacesLastUsedAt.
func (mr *MockStoreMockRecorder) UpdateTemplateWorkspacesLastUsedAt(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTemplateWorkspacesLastUsedAt", reflect.TypeOf((*MockStore)(nil).UpdateTemplateWorkspacesLastUsedAt), ctx, arg)
}

// UpdateUsageEventsPostPublish mocks base method.
func (m *MockStore) UpdateUsageEventsPostPublish(ctx context.Context, arg database.UpdateUsageEventsPostPublishParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUsageEventsPostPublish", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateUsageEventsPostPublish indicates an expected call of UpdateUsageEventsPostPublish.
func (mr *MockStoreMockRecorder) UpdateUsageEventsPostPublish(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUsageEventsPostPublish", reflect.TypeOf((*MockStore)(nil).UpdateUsageEventsPostPublish), ctx, arg)
}

// UpdateUserAIProviderKey mocks base method.
func (m *MockStore) UpdateUserAIProviderKey(ctx context.Context, arg database.UpdateUserAIProviderKeyParams) (database.UserAiProviderKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserAIProviderKey", ctx, arg)
	ret0, _ := ret[0].(database.UserAiProviderKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserAIProviderKey indicates an expected call of UpdateUserAIProviderKey.
func (mr *MockStoreMockRecorder) UpdateUserAIProviderKey(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserAIProviderKey", reflect.TypeOf((*MockStore)(nil).UpdateUserAIProviderKey), ctx, arg)
}

// UpdateUserAgentChatSendShortcut mocks base method.
func (m *MockStore) UpdateUserAgentChatSendShortcut(ctx context.Context, arg database.UpdateUserAgentChatSendShortcutParams) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserAgentChatSendShortcut", ctx, arg)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserAgentChatSendShortcut indicates an expected call of UpdateUserAgentChatSendShortcut.
func (mr *MockStoreMockRecorder) UpdateUserAgentChatSendShortcut(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserAgentChatSendShortcut", reflect.TypeOf((*MockStore)(nil).UpdateUserAgentChatSendShortcut), ctx, arg)
}

// UpdateUserChatCompactionThreshold mocks base method.
func (m *MockStore) UpdateUserChatCompactionThreshold(ctx context.Context, arg database.UpdateUserChatCompactionThresholdParams) (database.UserConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserChatCompactionThreshold", ctx, arg)
	ret0, _ := ret[0].(database.UserConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserChatCompactionThreshold indicates an expected call of UpdateUserChatCompactionThreshold.
func (mr *MockStoreMockRecorder) UpdateUserChatCompactionThreshold(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserChatCompactionThreshold", reflect.TypeOf((*MockStore)(nil).UpdateUserChatCompactionThreshold), ctx, arg)
}

// UpdateUserChatCustomPrompt mocks base method.
func (m *MockStore) UpdateUserChatCustomPrompt(ctx context.Context, arg database.UpdateUserChatCustomPromptParams) (database.UserConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserChatCustomPrompt", ctx, arg)
	ret0, _ := ret[0].(database.UserConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserChatCustomPrompt indicates an expected call of UpdateUserChatCustomPrompt.
func (mr *MockStoreMockRecorder) UpdateUserChatCustomPrompt(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserChatCustomPrompt", reflect.TypeOf((*MockStore)(nil).UpdateUserChatCustomPrompt), ctx, arg)
}

// UpdateUserCodeDiffDisplayMode mocks base method.
func (m *MockStore) UpdateUserCodeDiffDisplayMode(ctx context.Context, arg database.UpdateUserCodeDiffDisplayModeParams) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserCodeDiffDisplayMode", ctx, arg)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserCodeDiffDisplayMode indicates an expected call of UpdateUserCodeDiffDisplayMode.
func (mr *MockStoreMockRecorder) UpdateUserCodeDiffDisplayMode(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserCodeDiffDisplayMode", reflect.TypeOf((*MockStore)(nil).UpdateUserCodeDiffDisplayMode), ctx, arg)
}

// UpdateUserDeletedByID mocks base method.
func (m *MockStore) UpdateUserDeletedByID(ctx context.Context, id uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserDeletedByID", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UpdateUserGithubComUserID mocks base method.
func (m *MockStore) UpdateUserGithubComUserID(ctx context.Context, arg database.UpdateUserGithubComUserIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserGithubComUserID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateUserGithubComUserID indicates an expected call of UpdateUserGithubComUserID.
func (mr *MockStoreMockRecorder) UpdateUserGithubComUserID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserGithubComUserID", reflect.TypeOf((*MockStore)(nil).UpdateUserGithubComUserID), ctx, arg)
}

// UpdateUserHashedOneTimePasscode mocks base method.
func (m *MockStore) UpdateUserHashedOneTimePasscode(ctx context.Context, arg database.UpdateUserHashedOneTimePasscodeParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserHashedOneTimePasscode", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateUserHashedOneTimePasscode indicates an expected call of UpdateUserHashedOneTimePasscode.
func (mr *MockStoreMockRecorder) UpdateUserHashedOneTimePasscode(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserHashedOneTimePasscode", reflect.TypeOf((*MockStore)(nil).UpdateUserHashedOneTimePasscode), ctx, arg)
}

// UpdateUserHashedPassword mocks base method.
func (m *MockStore) UpdateUserHashedPassword(ctx context.Context, arg database.UpdateUserHashedPasswordParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserHashedPassword", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateUserHashedPassword indicates an expected call of UpdateUserHashedPassword.
func (mr *MockStoreMockRecorder) UpdateUserHashedPassword(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserHashedPassword", reflect.TypeOf((*MockStore)(nil).UpdateUserHashedPassword), ctx, arg)
}

// UpdateUserLastSeenAt mocks base method.
func (m *MockStore) UpdateUserLastSeenAt(ctx context.Context, arg database.UpdateUserLastSeenAtParams) (database.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserLastSeenAt", ctx, arg)
	ret0, _ := ret[0].(database.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserLastSeenAt indicates an expected call of UpdateUserLastSeenAt.
func (mr *MockStoreMockRecorder) UpdateUserLastSeenAt(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserLastSeenAt", reflect.TypeOf((*MockStore)(nil).UpdateUserLastSeenAt), ctx, arg)
}

// UpdateUserLink mocks base method.
func (m *MockStore) UpdateUserLink(ctx context.Context, arg database.UpdateUserLinkParams) (database.UserLink, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserLink", ctx, arg)
	ret0, _ := ret[0].(database.UserLink)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserLink indicates an expected call of UpdateUserLink.
func (mr *MockStoreMockRecorder) UpdateUserLink(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserLink", reflect.TypeOf((*MockStore)(nil).UpdateUserLink), ctx, arg)
}

// UpdateUserLoginType mocks base method.
func (m *MockStore) UpdateUserLoginType(ctx context.Context, arg database.UpdateUserLoginTypeParams) (database.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserLoginType", ctx, arg)
	ret0, _ := ret[0].(database.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserLoginType indicates an expected call of UpdateUserLoginType.
func (mr *MockStoreMockRecorder) UpdateUserLoginType(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserLoginType", reflect.TypeOf((*MockStore)(nil).UpdateUserLoginType), ctx, arg)
}

// UpdateUserNotificationPreferences mocks base method.
func (m *MockStore) UpdateUserNotificationPreferences(ctx context.Context, arg database.UpdateUserNotificationPreferencesParams) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserNotificationPreferences", ctx, arg)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserNotificationPreferences indicates an expected call of UpdateUserNotificationPreferences.
func (mr *MockStoreMockRecorder) UpdateUserNotificationPreferences(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserNotificationPreferences", reflect.TypeOf((*MockStore)(nil).UpdateUserNotificationPreferences), ctx, arg)
}

// UpdateUserProfile mocks base method.
func (m *MockStore) UpdateUserProfile(ctx context.Context, arg database.UpdateUserProfileParams) (database.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserProfile", ctx, arg)
	ret0, _ := ret[0].(database.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserProfile indicates an expected call of UpdateUserProfile.
func (mr *MockStoreMockRecorder) UpdateUserProfile(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserProfile", reflect.TypeOf((*MockStore)(nil).UpdateUserProfile), ctx, arg)
}

// UpdateUserQuietHoursSchedule mocks base method.
func (m *MockStore) UpdateUserQuietHoursSchedule(ctx context.Context, arg database.UpdateUserQuietHoursScheduleParams) (database.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserQuietHoursSchedule", ctx, arg)
	ret0, _ := ret[0].(database.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserQuietHoursSchedule indicates an expected call of UpdateUserQuietHoursSchedule.
func (mr *MockStoreMockRecorder) UpdateUserQuietHoursSchedule(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserQuietHoursSchedule", reflect.TypeOf((*MockStore)(nil).UpdateUserQuietHoursSchedule), ctx, arg)
}

// UpdateUserRoles mocks base method.
func (m *MockStore) UpdateUserRoles(ctx context.Context, arg database.UpdateUserRolesParams) (database.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserRoles", ctx, arg)
	ret0, _ := ret[0].(database.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserRoles indicates an expected call of UpdateUserRoles.
func (mr *MockStoreMockRecorder) UpdateUserRoles(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserRoles", reflect.TypeOf((*MockStore)(nil).UpdateUserRoles), ctx, arg)
}

// UpdateUserSecretByUserIDAndName mocks base method.
func (m *MockStore) UpdateUserSecretByUserIDAndName(ctx context.Context, arg database.UpdateUserSecretByUserIDAndNameParams) (database.UserSecret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserSecretByUserIDAndName", ctx, arg)
	ret0, _ := ret[0].(database.UserSecret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserSecretByUserIDAndName indicates an expected call of UpdateUserSecretByUserIDAndName.
func (mr *MockStoreMockRecorder) UpdateUserSecretByUserIDAndName(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserSecretByUserIDAndName", reflect.TypeOf((*MockStore)(nil).UpdateUserSecretByUserIDAndName), ctx, arg)
}

// UpdateUserShellToolDisplayMode mocks base method.
func (m *MockStore) UpdateUserShellToolDisplayMode(ctx context.Context, arg database.UpdateUserShellToolDisplayModeParams) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserShellToolDisplayMode", ctx, arg)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserShellToolDisplayMode indicates an expected call of UpdateUserShellToolDisplayMode.
func (mr *MockStoreMockRecorder) UpdateUserShellToolDisplayMode(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserShellToolDisplayMode", reflect.TypeOf((*MockStore)(nil).UpdateUserShellToolDisplayMode), ctx, arg)
}

// UpdateUserSkillByUserIDAndName mocks base method.
func (m *MockStore) UpdateUserSkillByUserIDAndName(ctx context.Context, arg database.UpdateUserSkillByUserIDAndNameParams) (database.UserSkill, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserSkillByUserIDAndName", ctx, arg)
	ret0, _ := ret[0].(database.UserSkill)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserSkillByUserIDAndName indicates an expected call of UpdateUserSkillByUserIDAndName.
func (mr *MockStoreMockRecorder) UpdateUserSkillByUserIDAndName(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserSkillByUserIDAndName", reflect.TypeOf((*MockStore)(nil).UpdateUserSkillByUserIDAndName), ctx, arg)
}

// UpdateUserStatus mocks base method.
func (m *MockStore) UpdateUserStatus(ctx context.Context, arg database.UpdateUserStatusParams) (database.User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserStatus", ctx, arg)
	ret0, _ := ret[0].(database.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserStatus indicates an expected call of UpdateUserStatus.
func (mr *MockStoreMockRecorder) UpdateUserStatus(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserStatus", reflect.TypeOf((*MockStore)(nil).UpdateUserStatus), ctx, arg)
}

// UpdateUserTaskNotificationAlertDismissed mocks base method.
func (m *MockStore) UpdateUserTaskNotificationAlertDismissed(ctx context.Context, arg database.UpdateUserTaskNotificationAlertDismissedParams) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserTaskNotificationAlertDismissed", ctx, arg)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserTaskNotificationAlertDismissed indicates an expected call of UpdateUserTaskNotificationAlertDismissed.
func (mr *MockStoreMockRecorder) UpdateUserTaskNotificationAlertDismissed(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserTaskNotificationAlertDismissed", reflect.TypeOf((*MockStore)(nil).UpdateUserTaskNotificationAlertDismissed), ctx, arg)
}

// UpdateUserTerminalFont mocks base method.
func (m *MockStore) UpdateUserTerminalFont(ctx context.Context, arg database.UpdateUserTerminalFontParams) (database.UserConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserTerminalFont", ctx, arg)
	ret0, _ := ret[0].(database.UserConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserTerminalFont indicates an expected call of UpdateUserTerminalFont.
func (mr *MockStoreMockRecorder) UpdateUserTerminalFont(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserTerminalFont", reflect.TypeOf((*MockStore)(nil).UpdateUserTerminalFont), ctx, arg)
}

// UpdateUserThemeDark mocks base method.
func (m *MockStore) UpdateUserThemeDark(ctx context.Context, arg database.UpdateUserThemeDarkParams) (database.UserConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserThemeDark", ctx, arg)
	ret0, _ := ret[0].(database.UserConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserThemeDark indicates an expected call of UpdateUserThemeDark.
func (mr *MockStoreMockRecorder) UpdateUserThemeDark(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserThemeDark", reflect.TypeOf((*MockStore)(nil).UpdateUserThemeDark), ctx, arg)
}

// UpdateUserThemeLight mocks base method.
func (m *MockStore) UpdateUserThemeLight(ctx context.Context, arg database.UpdateUserThemeLightParams) (database.UserConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserThemeLight", ctx, arg)
	ret0, _ := ret[0].(database.UserConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserThemeLight indicates an expected call of UpdateUserThemeLight.
func (mr *MockStoreMockRecorder) UpdateUserThemeLight(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserThemeLight", reflect.TypeOf((*MockStore)(nil).UpdateUserThemeLight), ctx, arg)
}

// UpdateUserThemeMode mocks base method.
func (m *MockStore) UpdateUserThemeMode(ctx context.Context, arg database.UpdateUserThemeModeParams) (database.UserConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserThemeMode", ctx, arg)
	ret0, _ := ret[0].(database.UserConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserThemeMode indicates an expected call of UpdateUserThemeMode.
func (mr *MockStoreMockRecorder) UpdateUserThemeMode(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserThemeMode", reflect.TypeOf((*MockStore)(nil).UpdateUserThemeMode), ctx, arg)
}

// UpdateUserThemePreference mocks base method.
func (m *MockStore) UpdateUserThemePreference(ctx context.Context, arg database.UpdateUserThemePreferenceParams) (database.UserConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserThemePreference", ctx, arg)
	ret0, _ := ret[0].(database.UserConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserThemePreference indicates an expected call of UpdateUserThemePreference.
func (mr *MockStoreMockRecorder) UpdateUserThemePreference(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserThemePreference", reflect.TypeOf((*MockStore)(nil).UpdateUserThemePreference), ctx, arg)
}

// UpdateUserThinkingDisplayMode mocks base method.
func (m *MockStore) UpdateUserThinkingDisplayMode(ctx context.Context, arg database.UpdateUserThinkingDisplayModeParams) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUserThinkingDisplayMode", ctx, arg)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUserThinkingDisplayMode indicates an expected call of UpdateUserThinkingDisplayMode.
func (mr *MockStoreMockRecorder) UpdateUserThinkingDisplayMode(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserThinkingDisplayMode", reflect.TypeOf((*MockStore)(nil).UpdateUserThinkingDisplayMode), ctx, arg)
}

// UpdateVolumeResourceMonitor mocks base method.
func (m *MockStore) UpdateVolumeResourceMonitor(ctx context.Context, arg database.UpdateVolumeResourceMonitorParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateVolumeResourceMonitor", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateVolumeResourceMonitor indicates an expected call of UpdateVolumeResourceMonitor.
func (mr *MockStoreMockRecorder) UpdateVolumeResourceMonitor(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateVolumeResourceMonitor", reflect.TypeOf((*MockStore)(nil).UpdateVolumeResourceMonitor), ctx, arg)
}

// UpdateWorkspace mocks base method.
func (m *MockStore) UpdateWorkspace(ctx context.Context, arg database.UpdateWorkspaceParams) (database.WorkspaceTable, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspace", ctx, arg)
	ret0, _ := ret[0].(database.WorkspaceTable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateWorkspace indicates an expected call of UpdateWorkspace.
func (mr *MockStoreMockRecorder) UpdateWorkspace(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspace", reflect.TypeOf((*MockStore)(nil).UpdateWorkspace), ctx, arg)
}

// UpdateWorkspaceACLByID mocks base method.
func (m *MockStore) UpdateWorkspaceACLByID(ctx context.Context, arg database.UpdateWorkspaceACLByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceACLByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceACLByID indicates an expected call of UpdateWorkspaceACLByID.
func (mr *MockStoreMockRecorder) UpdateWorkspaceACLByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceACLByID", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceACLByID), ctx, arg)
}

// UpdateWorkspaceAgentConnectionByID mocks base method.
func (m *MockStore) UpdateWorkspaceAgentConnectionByID(ctx context.Context, arg database.UpdateWorkspaceAgentConnectionByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceAgentConnectionByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceAgentConnectionByID indicates an expected call of UpdateWorkspaceAgentConnectionByID.
func (mr *MockStoreMockRecorder) UpdateWorkspaceAgentConnectionByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceAgentConnectionByID", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceAgentConnectionByID), ctx, arg)
}

// UpdateWorkspaceAgentDirectoryByID mocks base method.
func (m *MockStore) UpdateWorkspaceAgentDirectoryByID(ctx context.Context, arg database.UpdateWorkspaceAgentDirectoryByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceAgentDirectoryByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceAgentDirectoryByID indicates an expected call of UpdateWorkspaceAgentDirectoryByID.
func (mr *MockStoreMockRecorder) UpdateWorkspaceAgentDirectoryByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceAgentDirectoryByID", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceAgentDirectoryByID), ctx, arg)
}

// UpdateWorkspaceAgentDisplayAppsByID mocks base method.
func (m *MockStore) UpdateWorkspaceAgentDisplayAppsByID(ctx context.Context, arg database.UpdateWorkspaceAgentDisplayAppsByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceAgentDisplayAppsByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceAgentDisplayAppsByID indicates an expected call of UpdateWorkspaceAgentDisplayAppsByID.
func (mr *MockStoreMockRecorder) UpdateWorkspaceAgentDisplayAppsByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceAgentDisplayAppsByID", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceAgentDisplayAppsByID), ctx, arg)
}

// UpdateWorkspaceAgentLifecycleStateByID mocks base method.
func (m *MockStore) UpdateWorkspaceAgentLifecycleStateByID(ctx context.Context, arg database.UpdateWorkspaceAgentLifecycleStateByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceAgentLifecycleStateByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceAgentLifecycleStateByID indicates an expected call of UpdateWorkspaceAgentLifecycleStateByID.
func (mr *MockStoreMockRecorder) UpdateWorkspaceAgentLifecycleStateByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceAgentLifecycleStateByID", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceAgentLifecycleStateByID), ctx, arg)
}

// UpdateWorkspaceAgentLogOverflowByID mocks base method.
func (m *MockStore) UpdateWorkspaceAgentLogOverflowByID(ctx context.Context, arg database.UpdateWorkspaceAgentLogOverflowByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceAgentLogOverflowByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceAgentLogOverflowByID indicates an expected call of UpdateWorkspaceAgentLogOverflowByID.
func (mr *MockStoreMockRecorder) UpdateWorkspaceAgentLogOverflowByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceAgentLogOverflowByID", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceAgentLogOverflowByID), ctx, arg)
}

// UpdateWorkspaceAgentMetadata mocks base method.
func (m *MockStore) UpdateWorkspaceAgentMetadata(ctx context.Context, arg database.UpdateWorkspaceAgentMetadataParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceAgentMetadata", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceAgentMetadata indicates an expected call of UpdateWorkspaceAgentMetadata.
func (mr *MockStoreMockRecorder) UpdateWorkspaceAgentMetadata(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceAgentMetadata", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceAgentMetadata), ctx, arg)
}

// UpdateWorkspaceAgentStartupByID mocks base method.
func (m *MockStore) UpdateWorkspaceAgentStartupByID(ctx context.Context, arg database.UpdateWorkspaceAgentStartupByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceAgentStartupByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceAgentStartupByID indicates an expected call of UpdateWorkspaceAgentStartupByID.
func (mr *MockStoreMockRecorder) UpdateWorkspaceAgentStartupByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceAgentStartupByID", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceAgentStartupByID), ctx, arg)
}

// UpdateWorkspaceAppHealthByID mocks base method.
func (m *MockStore) UpdateWorkspaceAppHealthByID(ctx context.Context, arg database.UpdateWorkspaceAppHealthByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceAppHealthByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceAppHealthByID indicates an expected call of UpdateWorkspaceAppHealthByID.
func (mr *MockStoreMockRecorder) UpdateWorkspaceAppHealthByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceAppHealthByID", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceAppHealthByID), ctx, arg)
}

// UpdateWorkspaceAutomaticUpdates mocks base method.
func (m *MockStore) UpdateWorkspaceAutomaticUpdates(ctx context.Context, arg database.UpdateWorkspaceAutomaticUpdatesParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceAutomaticUpdates", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceAutomaticUpdates indicates an expected call of UpdateWorkspaceAutomaticUpdates.
func (mr *MockStoreMockRecorder) UpdateWorkspaceAutomaticUpdates(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceAutomaticUpdates", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceAutomaticUpdates), ctx, arg)
}

// UpdateWorkspaceAutostart mocks base method.
func (m *MockStore) UpdateWorkspaceAutostart(ctx context.Context, arg database.UpdateWorkspaceAutostartParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceAutostart", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceAutostart indicates an expected call of UpdateWorkspaceAutostart.
func (mr *MockStoreMockRecorder) UpdateWorkspaceAutostart(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceAutostart", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceAutostart), ctx, arg)
}

// UpdateWorkspaceBuildCostByID mocks base method.
func (m *MockStore) UpdateWorkspaceBuildCostByID(ctx context.Context, arg database.UpdateWorkspaceBuildCostByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceBuildCostByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceBuildCostByID indicates an expected call of UpdateWorkspaceBuildCostByID.
func (mr *MockStoreMockRecorder) UpdateWorkspaceBuildCostByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceBuildCostByID", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceBuildCostByID), ctx, arg)
}

// UpdateWorkspaceBuildDeadlineByID mocks base method.
func (m *MockStore) UpdateWorkspaceBuildDeadlineByID(ctx context.Context, arg database.UpdateWorkspaceBuildDeadlineByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceBuildDeadlineByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceBuildDeadlineByID indicates an expected call of UpdateWorkspaceBuildDeadlineByID.
func (mr *MockStoreMockRecorder) UpdateWorkspaceBuildDeadlineByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceBuildDeadlineByID", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceBuildDeadlineByID), ctx, arg)
}

// UpdateWorkspaceBuildFlagsByID mocks base method.
func (m *MockStore) UpdateWorkspaceBuildFlagsByID(ctx context.Context, arg database.UpdateWorkspaceBuildFlagsByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceBuildFlagsByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceBuildFlagsByID indicates an expected call of UpdateWorkspaceBuildFlagsByID.
func (mr *MockStoreMockRecorder) UpdateWorkspaceBuildFlagsByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceBuildFlagsByID", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceBuildFlagsByID), ctx, arg)
}

// UpdateWorkspaceBuildProvisionerStateByID mocks base method.
func (m *MockStore) UpdateWorkspaceBuildProvisionerStateByID(ctx context.Context, arg database.UpdateWorkspaceBuildProvisionerStateByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceBuildProvisionerStateByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceBuildProvisionerStateByID indicates an expected call of UpdateWorkspaceBuildProvisionerStateByID.
func (mr *MockStoreMockRecorder) UpdateWorkspaceBuildProvisionerStateByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceBuildProvisionerStateByID", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceBuildProvisionerStateByID), ctx, arg)
}

// UpdateWorkspaceDeletedByID mocks base method.
func (m *MockStore) UpdateWorkspaceDeletedByID(ctx context.Context, arg database.UpdateWorkspaceDeletedByIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceDeletedByID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceDeletedByID indicates an expected call of UpdateWorkspaceDeletedByID.
func (mr *MockStoreMockRecorder) UpdateWorkspaceDeletedByID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceDeletedByID", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceDeletedByID), ctx, arg)
}

// UpdateWorkspaceDormantDeletingAt mocks base method.
func (m *MockStore) UpdateWorkspaceDormantDeletingAt(ctx context.Context, arg database.UpdateWorkspaceDormantDeletingAtParams) (database.WorkspaceTable, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceDormantDeletingAt", ctx, arg)
	ret0, _ := ret[0].(database.WorkspaceTable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateWorkspaceDormantDeletingAt indicates an expected call of UpdateWorkspaceDormantDeletingAt.
func (mr *MockStoreMockRecorder) UpdateWorkspaceDormantDeletingAt(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceDormantDeletingAt", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceDormantDeletingAt), ctx, arg)
}

// UpdateWorkspaceLastUsedAt mocks base method.
func (m *MockStore) UpdateWorkspaceLastUsedAt(ctx context.Context, arg database.UpdateWorkspaceLastUsedAtParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceLastUsedAt", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceLastUsedAt indicates an expected call of UpdateWorkspaceLastUsedAt.
func (mr *MockStoreMockRecorder) UpdateWorkspaceLastUsedAt(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceLastUsedAt", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceLastUsedAt), ctx, arg)
}

// UpdateWorkspaceNextStartAt mocks base method.
func (m *MockStore) UpdateWorkspaceNextStartAt(ctx context.Context, arg database.UpdateWorkspaceNextStartAtParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceNextStartAt", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceNextStartAt indicates an expected call of UpdateWorkspaceNextStartAt.
func (mr *MockStoreMockRecorder) UpdateWorkspaceNextStartAt(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceNextStartAt", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceNextStartAt), ctx, arg)
}

// UpdateWorkspaceProxy mocks base method.
func (m *MockStore) UpdateWorkspaceProxy(ctx context.Context, arg database.UpdateWorkspaceProxyParams) (database.WorkspaceProxy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceProxy", ctx, arg)
	ret0, _ := ret[0].(database.WorkspaceProxy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateWorkspaceProxy indicates an expected call of UpdateWorkspaceProxy.
func (mr *MockStoreMockRecorder) UpdateWorkspaceProxy(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceProxy", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceProxy), ctx, arg)
}

// UpdateWorkspaceProxyDeleted mocks base method.
func (m *MockStore) UpdateWorkspaceProxyDeleted(ctx context.Context, arg database.UpdateWorkspaceProxyDeletedParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceProxyDeleted", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceProxyDeleted indicates an expected call of UpdateWorkspaceProxyDeleted.
func (mr *MockStoreMockRecorder) UpdateWorkspaceProxyDeleted(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceProxyDeleted", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceProxyDeleted), ctx, arg)
}

// UpdateWorkspaceTTL mocks base method.
func (m *MockStore) UpdateWorkspaceTTL(ctx context.Context, arg database.UpdateWorkspaceTTLParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspaceTTL", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspaceTTL indicates an expected call of UpdateWorkspaceTTL.
func (mr *MockStoreMockRecorder) UpdateWorkspaceTTL(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceTTL", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceTTL), ctx, arg)
}

// UpdateWorkspacesDormantDeletingAtByTemplateID mocks base method.
func (m *MockStore) UpdateWorkspacesDormantDeletingAtByTemplateID(ctx context.Context, arg database.UpdateWorkspacesDormantDeletingAtByTemplateIDParams) ([]database.WorkspaceTable, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspacesDormantDeletingAtByTemplateID", ctx, arg)
	ret0, _ := ret[0].([]database.WorkspaceTable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateWorkspacesDormantDeletingAtByTemplateID indicates an expected call of UpdateWorkspacesDormantDeletingAtByTemplateID.
func (mr *MockStoreMockRecorder) UpdateWorkspacesDormantDeletingAtByTemplateID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspacesDormantDeletingAtByTemplateID", reflect.TypeOf((*MockStore)(nil).UpdateWorkspacesDormantDeletingAtByTemplateID), ctx, arg)
}

// UpdateWorkspacesTTLByTemplateID mocks base method.
func (m *MockStore) UpdateWorkspacesTTLByTemplateID(ctx context.Context, arg database.UpdateWorkspacesTTLByTemplateIDParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkspacesTTLByTemplateID", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWorkspacesTTLByTemplateID indicates an expected call of UpdateWorkspacesTTLByTemplateID.
func (mr *MockStoreMockRecorder) UpdateWorkspacesTTLByTemplateID(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspacesTTLByTemplateID", reflect.TypeOf((*MockStore)(nil).UpdateWorkspacesTTLByTemplateID), ctx, arg)
}

// UpsertAIModelPrices mocks base method.
func (m *MockStore) UpsertAIModelPrices(ctx context.Context, seed json.RawMessage) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertAIModelPrices", ctx, seed)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertAIModelPrices indicates an expected call of UpsertAIModelPrices.
func (mr *MockStoreMockRecorder) UpsertAIModelPrices(ctx, seed any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertAIModelPrices", reflect.TypeOf((*MockStore)(nil).UpsertAIModelPrices), ctx, seed)
}

// UpsertAISeatState mocks base method.
func (m *MockStore) UpsertAISeatState(ctx context.Context, arg database.UpsertAISeatStateParams) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertAISeatState", ctx, arg)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertAISeatState indicates an expected call of UpsertAISeatState.
func (mr *MockStoreMockRecorder) UpsertAISeatState(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertAISeatState", reflect.TypeOf((*MockStore)(nil).UpsertAISeatState), ctx, arg)
}

// UpsertAnnouncementBanners mocks base method.
func (m *MockStore) UpsertAnnouncementBanners(ctx context.Context, value string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertAnnouncementBanners", ctx, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertAnnouncementBanners indicates an expected call of UpsertAnnouncementBanners.
func (mr *MockStoreMockRecorder) UpsertAnnouncementBanners(ctx, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertAnnouncementBanners", reflect.TypeOf((*MockStore)(nil).UpsertAnnouncementBanners), ctx, value)
}

// UpsertApplicationName mocks base method.
func (m *MockStore) UpsertApplicationName(ctx context.Context, value string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertApplicationName", ctx, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertApplicationName indicates an expected call of UpsertApplicationName.
func (mr *MockStoreMockRecorder) UpsertApplicationName(ctx, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertApplicationName", reflect.TypeOf((*MockStore)(nil).UpsertApplicationName), ctx, value)
}

// UpsertBoundaryUsageStats mocks base method.
func (m *MockStore) UpsertBoundaryUsageStats(ctx context.Context, arg database.UpsertBoundaryUsageStatsParams) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertBoundaryUsageStats", ctx, arg)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertBoundaryUsageStats indicates an expected call of UpsertBoundaryUsageStats.
func (mr *MockStoreMockRecorder) UpsertBoundaryUsageStats(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertBoundaryUsageStats", reflect.TypeOf((*MockStore)(nil).UpsertBoundaryUsageStats), ctx, arg)
}

// UpsertChatAdvisorConfig mocks base method.
func (m *MockStore) UpsertChatAdvisorConfig(ctx context.Context, value string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatAdvisorConfig", ctx, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertChatAdvisorConfig indicates an expected call of UpsertChatAdvisorConfig.
func (mr *MockStoreMockRecorder) UpsertChatAdvisorConfig(ctx, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatAdvisorConfig", reflect.TypeOf((*MockStore)(nil).UpsertChatAdvisorConfig), ctx, value)
}

// UpsertChatAutoArchiveDays mocks base method.
func (m *MockStore) UpsertChatAutoArchiveDays(ctx context.Context, autoArchiveDays int32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatAutoArchiveDays", ctx, autoArchiveDays)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertChatAutoArchiveDays indicates an expected call of UpsertChatAutoArchiveDays.
func (mr *MockStoreMockRecorder) UpsertChatAutoArchiveDays(ctx, autoArchiveDays any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatAutoArchiveDays", reflect.TypeOf((*MockStore)(nil).UpsertChatAutoArchiveDays), ctx, autoArchiveDays)
}

// UpsertChatComputerUseProvider mocks base method.
func (m *MockStore) UpsertChatComputerUseProvider(ctx context.Context, provider string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatComputerUseProvider", ctx, provider)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertChatComputerUseProvider indicates an expected call of UpsertChatComputerUseProvider.
func (mr *MockStoreMockRecorder) UpsertChatComputerUseProvider(ctx, provider any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatComputerUseProvider", reflect.TypeOf((*MockStore)(nil).UpsertChatComputerUseProvider), ctx, provider)
}

// UpsertChatDebugLoggingAllowUsers mocks base method.
func (m *MockStore) UpsertChatDebugLoggingAllowUsers(ctx context.Context, allowUsers bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatDebugLoggingAllowUsers", ctx, allowUsers)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertChatDebugLoggingAllowUsers indicates an expected call of UpsertChatDebugLoggingAllowUsers.
func (mr *MockStoreMockRecorder) UpsertChatDebugLoggingAllowUsers(ctx, allowUsers any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatDebugLoggingAllowUsers", reflect.TypeOf((*MockStore)(nil).UpsertChatDebugLoggingAllowUsers), ctx, allowUsers)
}

// UpsertChatDebugRetentionDays mocks base method.
func (m *MockStore) UpsertChatDebugRetentionDays(ctx context.Context, debugRetentionDays int32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatDebugRetentionDays", ctx, debugRetentionDays)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertChatDebugRetentionDays indicates an expected call of UpsertChatDebugRetentionDays.
func (mr *MockStoreMockRecorder) UpsertChatDebugRetentionDays(ctx, debugRetentionDays any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatDebugRetentionDays", reflect.TypeOf((*MockStore)(nil).UpsertChatDebugRetentionDays), ctx, debugRetentionDays)
}

// UpsertChatDesktopEnabled mocks base method.
func (m *MockStore) UpsertChatDesktopEnabled(ctx context.Context, enableDesktop bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatDesktopEnabled", ctx, enableDesktop)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertChatDesktopEnabled indicates an expected call of UpsertChatDesktopEnabled.
func (mr *MockStoreMockRecorder) UpsertChatDesktopEnabled(ctx, enableDesktop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatDesktopEnabled", reflect.TypeOf((*MockStore)(nil).UpsertChatDesktopEnabled), ctx, enableDesktop)
}

// UpsertChatDiffStatus mocks base method.
func (m *MockStore) UpsertChatDiffStatus(ctx context.Context, arg database.UpsertChatDiffStatusParams) (database.ChatDiffStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatDiffStatus", ctx, arg)
	ret0, _ := ret[0].(database.ChatDiffStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertChatDiffStatus indicates an expected call of UpsertChatDiffStatus.
func (mr *MockStoreMockRecorder) UpsertChatDiffStatus(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatDiffStatus", reflect.TypeOf((*MockStore)(nil).UpsertChatDiffStatus), ctx, arg)
}

// UpsertChatDiffStatusReference mocks base method.
func (m *MockStore) UpsertChatDiffStatusReference(ctx context.Context, arg database.UpsertChatDiffStatusReferenceParams) (database.ChatDiffStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatDiffStatusReference", ctx, arg)
	ret0, _ := ret[0].(database.ChatDiffStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertChatDiffStatusReference indicates an expected call of UpsertChatDiffStatusReference.
func (mr *MockStoreMockRecorder) UpsertChatDiffStatusReference(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatDiffStatusReference", reflect.TypeOf((*MockStore)(nil).UpsertChatDiffStatusReference), ctx, arg)
}

// UpsertChatExploreModelOverride mocks base method.
func (m *MockStore) UpsertChatExploreModelOverride(ctx context.Context, value string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatExploreModelOverride", ctx, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertChatExploreModelOverride indicates an expected call of UpsertChatExploreModelOverride.
func (mr *MockStoreMockRecorder) UpsertChatExploreModelOverride(ctx, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatExploreModelOverride", reflect.TypeOf((*MockStore)(nil).UpsertChatExploreModelOverride), ctx, value)
}

// UpsertChatGeneralModelOverride mocks base method.
func (m *MockStore) UpsertChatGeneralModelOverride(ctx context.Context, value string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatGeneralModelOverride", ctx, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertChatGeneralModelOverride indicates an expected call of UpsertChatGeneralModelOverride.
func (mr *MockStoreMockRecorder) UpsertChatGeneralModelOverride(ctx, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatGeneralModelOverride", reflect.TypeOf((*MockStore)(nil).UpsertChatGeneralModelOverride), ctx, value)
}

// UpsertChatIncludeDefaultSystemPrompt mocks base method.
func (m *MockStore) UpsertChatIncludeDefaultSystemPrompt(ctx context.Context, includeDefaultSystemPrompt bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatIncludeDefaultSystemPrompt", ctx, includeDefaultSystemPrompt)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertChatIncludeDefaultSystemPrompt indicates an expected call of UpsertChatIncludeDefaultSystemPrompt.
func (mr *MockStoreMockRecorder) UpsertChatIncludeDefaultSystemPrompt(ctx, includeDefaultSystemPrompt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatIncludeDefaultSystemPrompt", reflect.TypeOf((*MockStore)(nil).UpsertChatIncludeDefaultSystemPrompt), ctx, includeDefaultSystemPrompt)
}

// UpsertChatPersonalModelOverridesEnabled mocks base method.
func (m *MockStore) UpsertChatPersonalModelOverridesEnabled(ctx context.Context, enabled bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatPersonalModelOverridesEnabled", ctx, enabled)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertChatPersonalModelOverridesEnabled indicates an expected call of UpsertChatPersonalModelOverridesEnabled.
func (mr *MockStoreMockRecorder) UpsertChatPersonalModelOverridesEnabled(ctx, enabled any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatPersonalModelOverridesEnabled", reflect.TypeOf((*MockStore)(nil).UpsertChatPersonalModelOverridesEnabled), ctx, enabled)
}

// UpsertChatPlanModeInstructions mocks base method.
func (m *MockStore) UpsertChatPlanModeInstructions(ctx context.Context, value string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatPlanModeInstructions", ctx, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertChatPlanModeInstructions indicates an expected call of UpsertChatPlanModeInstructions.
func (mr *MockStoreMockRecorder) UpsertChatPlanModeInstructions(ctx, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatPlanModeInstructions", reflect.TypeOf((*MockStore)(nil).UpsertChatPlanModeInstructions), ctx, value)
}

// UpsertChatRetentionDays mocks base method.
func (m *MockStore) UpsertChatRetentionDays(ctx context.Context, retentionDays int32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatRetentionDays", ctx, retentionDays)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertChatRetentionDays indicates an expected call of UpsertChatRetentionDays.
func (mr *MockStoreMockRecorder) UpsertChatRetentionDays(ctx, retentionDays any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatRetentionDays", reflect.TypeOf((*MockStore)(nil).UpsertChatRetentionDays), ctx, retentionDays)
}

// UpsertChatSystemPrompt mocks base method.
func (m *MockStore) UpsertChatSystemPrompt(ctx context.Context, value string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatSystemPrompt", ctx, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertChatSystemPrompt indicates an expected call of UpsertChatSystemPrompt.
func (mr *MockStoreMockRecorder) UpsertChatSystemPrompt(ctx, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatSystemPrompt", reflect.TypeOf((*MockStore)(nil).UpsertChatSystemPrompt), ctx, value)
}

// UpsertChatTemplateAllowlist mocks base method.
func (m *MockStore) UpsertChatTemplateAllowlist(ctx context.Context, templateAllowlist string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatTemplateAllowlist", ctx, templateAllowlist)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertChatTemplateAllowlist indicates an expected call of UpsertChatTemplateAllowlist.
func (mr *MockStoreMockRecorder) UpsertChatTemplateAllowlist(ctx, templateAllowlist any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatTemplateAllowlist", reflect.TypeOf((*MockStore)(nil).UpsertChatTemplateAllowlist), ctx, templateAllowlist)
}

// UpsertChatTitleGenerationModelOverride mocks base method.
func (m *MockStore) UpsertChatTitleGenerationModelOverride(ctx context.Context, value string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatTitleGenerationModelOverride", ctx, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertChatTitleGenerationModelOverride indicates an expected call of UpsertChatTitleGenerationModelOverride.
func (mr *MockStoreMockRecorder) UpsertChatTitleGenerationModelOverride(ctx, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatTitleGenerationModelOverride", reflect.TypeOf((*MockStore)(nil).UpsertChatTitleGenerationModelOverride), ctx, value)
}

// UpsertChatUsageLimitConfig mocks base method.
func (m *MockStore) UpsertChatUsageLimitConfig(ctx context.Context, arg database.UpsertChatUsageLimitConfigParams) (database.ChatUsageLimitConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatUsageLimitConfig", ctx, arg)
	ret0, _ := ret[0].(database.ChatUsageLimitConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertChatUsageLimitConfig indicates an expected call of UpsertChatUsageLimitConfig.
func (mr *MockStoreMockRecorder) UpsertChatUsageLimitConfig(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatUsageLimitConfig", reflect.TypeOf((*MockStore)(nil).UpsertChatUsageLimitConfig), ctx, arg)
}

// UpsertChatUsageLimitGroupOverride mocks base method.
func (m *MockStore) UpsertChatUsageLimitGroupOverride(ctx context.Context, arg database.UpsertChatUsageLimitGroupOverrideParams) (database.UpsertChatUsageLimitGroupOverrideRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatUsageLimitGroupOverride", ctx, arg)
	ret0, _ := ret[0].(database.UpsertChatUsageLimitGroupOverrideRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertChatUsageLimitGroupOverride indicates an expected call of UpsertChatUsageLimitGroupOverride.
func (mr *MockStoreMockRecorder) UpsertChatUsageLimitGroupOverride(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatUsageLimitGroupOverride", reflect.TypeOf((*MockStore)(nil).UpsertChatUsageLimitGroupOverride), ctx, arg)
}

// UpsertChatUsageLimitUserOverride mocks base method.
func (m *MockStore) UpsertChatUsageLimitUserOverride(ctx context.Context, arg database.UpsertChatUsageLimitUserOverrideParams) (database.UpsertChatUsageLimitUserOverrideRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatUsageLimitUserOverride", ctx, arg)
	ret0, _ := ret[0].(database.UpsertChatUsageLimitUserOverrideRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertChatUsageLimitUserOverride indicates an expected call of UpsertChatUsageLimitUserOverride.
func (mr *MockStoreMockRecorder) UpsertChatUsageLimitUserOverride(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatUsageLimitUserOverride", reflect.TypeOf((*MockStore)(nil).UpsertChatUsageLimitUserOverride), ctx, arg)
}

// UpsertChatWorkspaceTTL mocks base method.
func (m *MockStore) UpsertChatWorkspaceTTL(ctx context.Context, workspaceTtl string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertChatWorkspaceTTL", ctx, workspaceTtl)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertChatWorkspaceTTL indicates an expected call of UpsertChatWorkspaceTTL.
func (mr *MockStoreMockRecorder) UpsertChatWorkspaceTTL(ctx, workspaceTtl any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertChatWorkspaceTTL", reflect.TypeOf((*MockStore)(nil).UpsertChatWorkspaceTTL), ctx, workspaceTtl)
}

// UpsertDefaultProxy mocks base method.
func (m *MockStore) UpsertDefaultProxy(ctx context.Context, arg database.UpsertDefaultProxyParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertDefaultProxy", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertDefaultProxy indicates an expected call of UpsertDefaultProxy.
func (mr *MockStoreMockRecorder) UpsertDefaultProxy(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertDefaultProxy", reflect.TypeOf((*MockStore)(nil).UpsertDefaultProxy), ctx, arg)
}

// UpsertGroupAIBudget mocks base method.
func (m *MockStore) UpsertGroupAIBudget(ctx context.Context, arg database.UpsertGroupAIBudgetParams) (database.GroupAiBudget, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertGroupAIBudget", ctx, arg)
	ret0, _ := ret[0].(database.GroupAiBudget)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertGroupAIBudget indicates an expected call of UpsertGroupAIBudget.
func (mr *MockStoreMockRecorder) UpsertGroupAIBudget(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertGroupAIBudget", reflect.TypeOf((*MockStore)(nil).UpsertGroupAIBudget), ctx, arg)
}

// UpsertHealthSettings mocks base method.
func (m *MockStore) UpsertHealthSettings(ctx context.Context, value string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertHealthSettings", ctx, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertHealthSettings indicates an expected call of UpsertHealthSettings.
func (mr *MockStoreMockRecorder) UpsertHealthSettings(ctx, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertHealthSettings", reflect.TypeOf((*MockStore)(nil).UpsertHealthSettings), ctx, value)
}

// UpsertLastUpdateCheck mocks base method.
func (m *MockStore) UpsertLastUpdateCheck(ctx context.Context, value string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertLastUpdateCheck", ctx, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertLastUpdateCheck indicates an expected call of UpsertLastUpdateCheck.
func (mr *MockStoreMockRecorder) UpsertLastUpdateCheck(ctx, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertLastUpdateCheck", reflect.TypeOf((*MockStore)(nil).UpsertLastUpdateCheck), ctx, value)
}

// UpsertLogoURL mocks base method.
func (m *MockStore) UpsertLogoURL(ctx context.Context, value string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertLogoURL", ctx, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertLogoURL indicates an expected call of UpsertLogoURL.
func (mr *MockStoreMockRecorder) UpsertLogoURL(ctx, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertLogoURL", reflect.TypeOf((*MockStore)(nil).UpsertLogoURL), ctx, value)
}

// UpsertMCPServerUserToken mocks base method.
func (m *MockStore) UpsertMCPServerUserToken(ctx context.Context, arg database.UpsertMCPServerUserTokenParams) (database.MCPServerUserToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertMCPServerUserToken", ctx, arg)
	ret0, _ := ret[0].(database.MCPServerUserToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertMCPServerUserToken indicates an expected call of UpsertMCPServerUserToken.
func (mr *MockStoreMockRecorder) UpsertMCPServerUserToken(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertMCPServerUserToken", reflect.TypeOf((*MockStore)(nil).UpsertMCPServerUserToken), ctx, arg)
}

// UpsertNotificationReportGeneratorLog mocks base method.
func (m *MockStore) UpsertNotificationReportGeneratorLog(ctx context.Context, arg database.UpsertNotificationReportGeneratorLogParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertNotificationReportGeneratorLog", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertNotificationReportGeneratorLog indicates an expected call of UpsertNotificationReportGeneratorLog.
func (mr *MockStoreMockRecorder) UpsertNotificationReportGeneratorLog(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertNotificationReportGeneratorLog", reflect.TypeOf((*MockStore)(nil).UpsertNotificationReportGeneratorLog), ctx, arg)
}

// UpsertNotificationsSettings mocks base method.
func (m *MockStore) UpsertNotificationsSettings(ctx context.Context, value string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertNotificationsSettings", ctx, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertNotificationsSettings indicates an expected call of UpsertNotificationsSettings.
func (mr *MockStoreMockRecorder) UpsertNotificationsSettings(ctx, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertNotificationsSettings", reflect.TypeOf((*MockStore)(nil).UpsertNotificationsSettings), ctx, value)
}

// UpsertOAuth2GithubDefaultEligible mocks base method.
func (m *MockStore) UpsertOAuth2GithubDefaultEligible(ctx context.Context, eligible bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertOAuth2GithubDefaultEligible", ctx, eligible)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertOAuth2GithubDefaultEligible indicates an expected call of UpsertOAuth2GithubDefaultEligible.
func (mr *MockStoreMockRecorder) UpsertOAuth2GithubDefaultEligible(ctx, eligible any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertOAuth2GithubDefaultEligible", reflect.TypeOf((*MockStore)(nil).UpsertOAuth2GithubDefaultEligible), ctx, eligible)
}

// UpsertPrebuildsSettings mocks base method.
func (m *MockStore) UpsertPrebuildsSettings(ctx context.Context, value string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertPrebuildsSettings", ctx, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertPrebuildsSettings indicates an expected call of UpsertPrebuildsSettings.
func (mr *MockStoreMockRecorder) UpsertPrebuildsSettings(ctx, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertPrebuildsSettings", reflect.TypeOf((*MockStore)(nil).UpsertPrebuildsSettings), ctx, value)
}

// UpsertProvisionerDaemon mocks base method.
func (m *MockStore) UpsertProvisionerDaemon(ctx context.Context, arg database.UpsertProvisionerDaemonParams) (database.ProvisionerDaemon, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertProvisionerDaemon", ctx, arg)
	ret0, _ := ret[0].(database.ProvisionerDaemon)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertProvisionerDaemon indicates an expected call of UpsertProvisionerDaemon.
func (mr *MockStoreMockRecorder) UpsertProvisionerDaemon(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertProvisionerDaemon", reflect.TypeOf((*MockStore)(nil).UpsertProvisionerDaemon), ctx, arg)
}

// UpsertRuntimeConfig mocks base method.
func (m *MockStore) UpsertRuntimeConfig(ctx context.Context, arg database.UpsertRuntimeConfigParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertRuntimeConfig", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertRuntimeConfig indicates an expected call of UpsertRuntimeConfig.
func (mr *MockStoreMockRecorder) UpsertRuntimeConfig(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertRuntimeConfig", reflect.TypeOf((*MockStore)(nil).UpsertRuntimeConfig), ctx, arg)
}

// UpsertTailnetCoordinator mocks base method.
func (m *MockStore) UpsertTailnetCoordinator(ctx context.Context, id uuid.UUID) (database.TailnetCoordinator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertTailnetCoordinator", ctx, id)
	ret0, _ := ret[0].(database.TailnetCoordinator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpsertTailnetPeer mocks base method.
func (m *MockStore) UpsertTailnetPeer(ctx context.Context, arg database.UpsertTailnetPeerParams) (database.TailnetPeer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertTailnetPeer", ctx, arg)
	ret0, _ := ret[0].(database.TailnetPeer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertTailnetPeer indicates an expected call of UpsertTailnetPeer.
func (mr *MockStoreMockRecorder) UpsertTailnetPeer(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertTailnetPeer", reflect.TypeOf((*MockStore)(nil).UpsertTailnetPeer), ctx, arg)
}

// UpsertTailnetTunnel mocks base method.
func (m *MockStore) UpsertTailnetTunnel(ctx context.Context, arg database.UpsertTailnetTunnelParams) (database.TailnetTunnel, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertTailnetTunnel", ctx, arg)
	ret0, _ := ret[0].(database.TailnetTunnel)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertTailnetTunnel indicates an expected call of UpsertTailnetTunnel.
func (mr *MockStoreMockRecorder) UpsertTailnetTunnel(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertTailnetTunnel", reflect.TypeOf((*MockStore)(nil).UpsertTailnetTunnel), ctx, arg)
}

// UpsertTaskSnapshot mocks base method.
func (m *MockStore) UpsertTaskSnapshot(ctx context.Context, arg database.UpsertTaskSnapshotParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertTaskSnapshot", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertTaskSnapshot indicates an expected call of UpsertTaskSnapshot.
func (mr *MockStoreMockRecorder) UpsertTaskSnapshot(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertTaskSnapshot", reflect.TypeOf((*MockStore)(nil).UpsertTaskSnapshot), ctx, arg)
}

// UpsertTaskWorkspaceApp mocks base method.
func (m *MockStore) UpsertTaskWorkspaceApp(ctx context.Context, arg database.UpsertTaskWorkspaceAppParams) (database.TaskWorkspaceApp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertTaskWorkspaceApp", ctx, arg)
	ret0, _ := ret[0].(database.TaskWorkspaceApp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertTaskWorkspaceApp indicates an expected call of UpsertTaskWorkspaceApp.
func (mr *MockStoreMockRecorder) UpsertTaskWorkspaceApp(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertTaskWorkspaceApp", reflect.TypeOf((*MockStore)(nil).UpsertTaskWorkspaceApp), ctx, arg)
}

// UpsertTelemetryItem mocks base method.
func (m *MockStore) UpsertTelemetryItem(ctx context.Context, arg database.UpsertTelemetryItemParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertTelemetryItem", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertTelemetryItem indicates an expected call of UpsertTelemetryItem.
func (mr *MockStoreMockRecorder) UpsertTelemetryItem(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertTelemetryItem", reflect.TypeOf((*MockStore)(nil).UpsertTelemetryItem), ctx, arg)
}

// UpsertTemplateUsageStats mocks base method.
func (m *MockStore) UpsertTemplateUsageStats(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertTemplateUsageStats", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UpsertUserAIProviderKey mocks base method.
func (m *MockStore) UpsertUserAIProviderKey(ctx context.Context, arg database.UpsertUserAIProviderKeyParams) (database.UserAiProviderKey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertUserAIProviderKey", ctx, arg)
	ret0, _ := ret[0].(database.UserAiProviderKey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertUserAIProviderKey indicates an expected call of UpsertUserAIProviderKey.
func (mr *MockStoreMockRecorder) UpsertUserAIProviderKey(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertUserAIProviderKey", reflect.TypeOf((*MockStore)(nil).UpsertUserAIProviderKey), ctx, arg)
}

// UpsertUserChatDebugLoggingEnabled mocks base method.
func (m *MockStore) UpsertUserChatDebugLoggingEnabled(ctx context.Context, arg database.UpsertUserChatDebugLoggingEnabledParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertUserChatDebugLoggingEnabled", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertUserChatDebugLoggingEnabled indicates an expected call of UpsertUserChatDebugLoggingEnabled.
func (mr *MockStoreMockRecorder) UpsertUserChatDebugLoggingEnabled(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertUserChatDebugLoggingEnabled", reflect.TypeOf((*MockStore)(nil).UpsertUserChatDebugLoggingEnabled), ctx, arg)
}

// UpsertUserChatPersonalModelOverride mocks base method.
func (m *MockStore) UpsertUserChatPersonalModelOverride(ctx context.Context, arg database.UpsertUserChatPersonalModelOverrideParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertUserChatPersonalModelOverride", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertUserChatPersonalModelOverride indicates an expected call of UpsertUserChatPersonalModelOverride.
func (mr *MockStoreMockRecorder) UpsertUserChatPersonalModelOverride(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertUserChatPersonalModelOverride", reflect.TypeOf((*MockStore)(nil).UpsertUserChatPersonalModelOverride), ctx, arg)
}

// UpsertWebpushVAPIDKeys mocks base method.
func (m *MockStore) UpsertWebpushVAPIDKeys(ctx context.Context, arg database.UpsertWebpushVAPIDKeysParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertWebpushVAPIDKeys", ctx, arg)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpsertWebpushVAPIDKeys indicates an expected call of UpsertWebpushVAPIDKeys.
func (mr *MockStoreMockRecorder) UpsertWebpushVAPIDKeys(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertWebpushVAPIDKeys", reflect.TypeOf((*MockStore)(nil).UpsertWebpushVAPIDKeys), ctx, arg)
}

// UpsertWorkspaceAgentPortShare mocks base method.
func (m *MockStore) UpsertWorkspaceAgentPortShare(ctx context.Context, arg database.UpsertWorkspaceAgentPortShareParams) (database.WorkspaceAgentPortShare, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertWorkspaceAgentPortShare", ctx, arg)
	ret0, _ := ret[0].(database.WorkspaceAgentPortShare)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertWorkspaceAgentPortShare indicates an expected call of UpsertWorkspaceAgentPortShare.
func (mr *MockStoreMockRecorder) UpsertWorkspaceAgentPortShare(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertWorkspaceAgentPortShare", reflect.TypeOf((*MockStore)(nil).UpsertWorkspaceAgentPortShare), ctx, arg)
}

// UpsertWorkspaceApp mocks base method.
func (m *MockStore) UpsertWorkspaceApp(ctx context.Context, arg database.UpsertWorkspaceAppParams) (database.WorkspaceApp, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertWorkspaceApp", ctx, arg)
	ret0, _ := ret[0].(database.WorkspaceApp)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertWorkspaceApp indicates an expected call of UpsertWorkspaceApp.
func (mr *MockStoreMockRecorder) UpsertWorkspaceApp(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertWorkspaceApp", reflect.TypeOf((*MockStore)(nil).UpsertWorkspaceApp), ctx, arg)
}

// UpsertWorkspaceAppAuditSession mocks base method.
func (m *MockStore) UpsertWorkspaceAppAuditSession(ctx context.Context, arg database.UpsertWorkspaceAppAuditSessionParams) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertWorkspaceAppAuditSession", ctx, arg)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertWorkspaceAppAuditSession indicates an expected call of UpsertWorkspaceAppAuditSession.
func (mr *MockStoreMockRecorder) UpsertWorkspaceAppAuditSession(ctx, arg any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertWorkspaceAppAuditSession", reflect.TypeOf((*MockStore)(nil).UpsertWorkspaceAppAuditSession), ctx, arg)
}

// UsageEventExistsByID mocks base method.
func (m *MockStore) UsageEventExistsByID(ctx context.Context, id string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UsageEventExistsByID", ctx, id)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ValidateGroupIDs mocks base method.
func (m *MockStore) ValidateGroupIDs(ctx context.Context, groupIds []uuid.UUID) (database.ValidateGroupIDsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateGroupIDs", ctx, groupIds)
	ret0, _ := ret[0].(database.ValidateGroupIDsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidateGroupIDs indicates an expected call of ValidateGroupIDs.
func (mr *MockStoreMockRecorder) ValidateGroupIDs(ctx, groupIds any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateGroupIDs", reflect.TypeOf((*MockStore)(nil).ValidateGroupIDs), ctx, groupIds)
}

// ValidateUserIDs mocks base method.
func (m *MockStore) ValidateUserIDs(ctx context.Context, userIds []uuid.UUID) (database.ValidateUserIDsRow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateUserIDs", ctx, userIds)
	ret0, _ := ret[0].(database.ValidateUserIDsRow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidateUserIDs indicates an expected call of ValidateUserIDs.
func (mr *MockStoreMockRecorder) ValidateUserIDs(ctx, userIds any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateUserIDs", reflect.TypeOf((*MockStore)(nil).ValidateUserIDs), ctx, userIds)
}

// Wrappers mocks base method.
func (m *MockStore) Wrappers() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Wrappers")
	ret0, _ := ret[0].([]string)
	return ret0
}

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