coder/coderd/database/dbmock/dbmock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/coder/coder/v2/coderd/database (interfaces: Store)

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

import (
	context "context"
	sql "database/sql"
	reflect "reflect"
	time "time"

	database "github.com/coder/coder/v2/coderd/database"
	rbac "github.com/coder/coder/v2/coderd/rbac"
	gomock "github.com/golang/mock/gomock"
	uuid "github.com/google/uuid"
)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetAuthorizedTemplates indicates an expected call of GetAuthorizedTemplates.
func (mr *MockStoreMockRecorder) GetAuthorizedTemplates(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthorizedTemplates", reflect.TypeOf((*MockStore)(nil).GetAuthorizedTemplates), arg0, arg1, arg2)
}

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

// GetAuthorizedUsers indicates an expected call of GetAuthorizedUsers.
func (mr *MockStoreMockRecorder) GetAuthorizedUsers(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthorizedUsers", reflect.TypeOf((*MockStore)(nil).GetAuthorizedUsers), arg0, arg1, arg2)
}

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

// GetAuthorizedWorkspaces indicates an expected call of GetAuthorizedWorkspaces.
func (mr *MockStoreMockRecorder) GetAuthorizedWorkspaces(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthorizedWorkspaces", reflect.TypeOf((*MockStore)(nil).GetAuthorizedWorkspaces), arg0, arg1, arg2)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// InTx mocks base method.
func (m *MockStore) InTx(arg0 func(database.Store) error, arg1 *sql.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 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InTx", reflect.TypeOf((*MockStore)(nil).InTx), arg0, arg1)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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