coder/coderd/database/dbmock/dbmock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/coder/coder/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/coderd/database"
	rbac "github.com/coder/coder/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)
}

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

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

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

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

// DeleteOldWorkspaceAgentStartupLogs indicates an expected call of DeleteOldWorkspaceAgentStartupLogs.
func (mr *MockStoreMockRecorder) DeleteOldWorkspaceAgentStartupLogs(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOldWorkspaceAgentStartupLogs", reflect.TypeOf((*MockStore)(nil).DeleteOldWorkspaceAgentStartupLogs), 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)
}

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

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

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

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

// GetAuthorizedUserCount indicates an expected call of GetAuthorizedUserCount.
func (mr *MockStoreMockRecorder) GetAuthorizedUserCount(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAuthorizedUserCount", reflect.TypeOf((*MockStore)(nil).GetAuthorizedUserCount), 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)
}

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

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

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

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

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

// GetGitAuthLink indicates an expected call of GetGitAuthLink.
func (mr *MockStoreMockRecorder) GetGitAuthLink(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGitAuthLink", reflect.TypeOf((*MockStore)(nil).GetGitAuthLink), 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)
}

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

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

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

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

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

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

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

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

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

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

// GetWorkspaceAgentByAuthToken indicates an expected call of GetWorkspaceAgentByAuthToken.
func (mr *MockStoreMockRecorder) GetWorkspaceAgentByAuthToken(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceAgentByAuthToken", reflect.TypeOf((*MockStore)(nil).GetWorkspaceAgentByAuthToken), 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)
}

// GetWorkspaceAgentMetadata mocks base method.
func (m *MockStore) GetWorkspaceAgentMetadata(arg0 context.Context, arg1 uuid.UUID) ([]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)
}

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

// GetWorkspaceAgentStartupLogsAfter indicates an expected call of GetWorkspaceAgentStartupLogsAfter.
func (mr *MockStoreMockRecorder) GetWorkspaceAgentStartupLogsAfter(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspaceAgentStartupLogsAfter", reflect.TypeOf((*MockStore)(nil).GetWorkspaceAgentStartupLogsAfter), 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)
}

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

// GetWorkspacesEligibleForAutoStartStop indicates an expected call of GetWorkspacesEligibleForAutoStartStop.
func (mr *MockStoreMockRecorder) GetWorkspacesEligibleForAutoStartStop(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkspacesEligibleForAutoStartStop", reflect.TypeOf((*MockStore)(nil).GetWorkspacesEligibleForAutoStartStop), 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)
}

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

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

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

// InsertGitAuthLink indicates an expected call of InsertGitAuthLink.
func (mr *MockStoreMockRecorder) InsertGitAuthLink(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertGitAuthLink", reflect.TypeOf((*MockStore)(nil).InsertGitAuthLink), 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)
}

// 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) (database.Template, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertTemplate", arg0, arg1)
	ret0, _ := ret[0].(database.Template)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// 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) (database.TemplateVersion, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertTemplateVersion", arg0, arg1)
	ret0, _ := ret[0].(database.TemplateVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// InsertWorkspaceAgentStartupLogs indicates an expected call of InsertWorkspaceAgentStartupLogs.
func (mr *MockStoreMockRecorder) InsertWorkspaceAgentStartupLogs(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWorkspaceAgentStartupLogs", reflect.TypeOf((*MockStore)(nil).InsertWorkspaceAgentStartupLogs), 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)
}

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

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

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

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

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

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

// UpdateGitAuthLink indicates an expected call of UpdateGitAuthLink.
func (mr *MockStoreMockRecorder) UpdateGitAuthLink(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGitAuthLink", reflect.TypeOf((*MockStore)(nil).UpdateGitAuthLink), 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)
}

// 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) (database.Template, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplateACLByID", arg0, arg1)
	ret0, _ := ret[0].(database.Template)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// 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) (database.Template, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplateMetaByID", arg0, arg1)
	ret0, _ := ret[0].(database.Template)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// 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) (database.Template, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplateScheduleByID", arg0, arg1)
	ret0, _ := ret[0].(database.Template)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// 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) (database.TemplateVersion, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTemplateVersionByID", arg0, arg1)
	ret0, _ := ret[0].(database.TemplateVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// UpdateTemplateVersionGitAuthProvidersByJobID indicates an expected call of UpdateTemplateVersionGitAuthProvidersByJobID.
func (mr *MockStoreMockRecorder) UpdateTemplateVersionGitAuthProvidersByJobID(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTemplateVersionGitAuthProvidersByJobID", reflect.TypeOf((*MockStore)(nil).UpdateTemplateVersionGitAuthProvidersByJobID), 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)
}

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

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

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

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

// UpdateWorkspaceAgentStartupLogOverflowByID indicates an expected call of UpdateWorkspaceAgentStartupLogOverflowByID.
func (mr *MockStoreMockRecorder) UpdateWorkspaceAgentStartupLogOverflowByID(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceAgentStartupLogOverflowByID", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceAgentStartupLogOverflowByID), 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)
}

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

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

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

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

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

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

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

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

// UpdateWorkspaceTTLToBeWithinTemplateMax indicates an expected call of UpdateWorkspaceTTLToBeWithinTemplateMax.
func (mr *MockStoreMockRecorder) UpdateWorkspaceTTLToBeWithinTemplateMax(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkspaceTTLToBeWithinTemplateMax", reflect.TypeOf((*MockStore)(nil).UpdateWorkspaceTTLToBeWithinTemplateMax), 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)
}

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

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

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

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