// Code generated by mockery v2.28.1. DO NOT EDIT.

package mocks

import (
	context "context"

	params "github.com/cloudbase/garm/params"
	mock "github.com/stretchr/testify/mock"
)

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

// AddInstanceEvent provides a mock function with given fields: ctx, instanceID, event, eventLevel, eventMessage
func (_m *Store) AddInstanceEvent(ctx context.Context, instanceID string, event params.EventType, eventLevel params.EventLevel, eventMessage string) error {
	ret := _m.Called(ctx, instanceID, event, eventLevel, eventMessage)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, params.EventType, params.EventLevel, string) error); ok {
		r0 = rf(ctx, instanceID, event, eventLevel, eventMessage)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// BreakLockJobIsQueued provides a mock function with given fields: ctx, jobID
func (_m *Store) BreakLockJobIsQueued(ctx context.Context, jobID int64) error {
	ret := _m.Called(ctx, jobID)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, int64) error); ok {
		r0 = rf(ctx, jobID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ControllerInfo provides a mock function with given fields:
func (_m *Store) ControllerInfo() (params.ControllerInfo, error) {
	ret := _m.Called()

	var r0 params.ControllerInfo
	var r1 error
	if rf, ok := ret.Get(0).(func() (params.ControllerInfo, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() params.ControllerInfo); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(params.ControllerInfo)
	}

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateEnterprise provides a mock function with given fields: ctx, name, credentialsName, webhookSecret
func (_m *Store) CreateEnterprise(ctx context.Context, name string, credentialsName string, webhookSecret string) (params.Enterprise, error) {
	ret := _m.Called(ctx, name, credentialsName, webhookSecret)

	var r0 params.Enterprise
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) (params.Enterprise, error)); ok {
		return rf(ctx, name, credentialsName, webhookSecret)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) params.Enterprise); ok {
		r0 = rf(ctx, name, credentialsName, webhookSecret)
	} else {
		r0 = ret.Get(0).(params.Enterprise)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = rf(ctx, name, credentialsName, webhookSecret)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateEnterprisePool provides a mock function with given fields: ctx, enterpriseID, param
func (_m *Store) CreateEnterprisePool(ctx context.Context, enterpriseID string, param params.CreatePoolParams) (params.Pool, error) {
	ret := _m.Called(ctx, enterpriseID, param)

	var r0 params.Pool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, params.CreatePoolParams) (params.Pool, error)); ok {
		return rf(ctx, enterpriseID, param)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, params.CreatePoolParams) params.Pool); ok {
		r0 = rf(ctx, enterpriseID, param)
	} else {
		r0 = ret.Get(0).(params.Pool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, params.CreatePoolParams) error); ok {
		r1 = rf(ctx, enterpriseID, param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateInstance provides a mock function with given fields: ctx, poolID, param
func (_m *Store) CreateInstance(ctx context.Context, poolID string, param params.CreateInstanceParams) (params.Instance, error) {
	ret := _m.Called(ctx, poolID, param)

	var r0 params.Instance
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, params.CreateInstanceParams) (params.Instance, error)); ok {
		return rf(ctx, poolID, param)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, params.CreateInstanceParams) params.Instance); ok {
		r0 = rf(ctx, poolID, param)
	} else {
		r0 = ret.Get(0).(params.Instance)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, params.CreateInstanceParams) error); ok {
		r1 = rf(ctx, poolID, param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateOrUpdateJob provides a mock function with given fields: ctx, job
func (_m *Store) CreateOrUpdateJob(ctx context.Context, job params.Job) (params.Job, error) {
	ret := _m.Called(ctx, job)

	var r0 params.Job
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, params.Job) (params.Job, error)); ok {
		return rf(ctx, job)
	}
	if rf, ok := ret.Get(0).(func(context.Context, params.Job) params.Job); ok {
		r0 = rf(ctx, job)
	} else {
		r0 = ret.Get(0).(params.Job)
	}

	if rf, ok := ret.Get(1).(func(context.Context, params.Job) error); ok {
		r1 = rf(ctx, job)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateOrganization provides a mock function with given fields: ctx, name, credentialsName, webhookSecret
func (_m *Store) CreateOrganization(ctx context.Context, name string, credentialsName string, webhookSecret string) (params.Organization, error) {
	ret := _m.Called(ctx, name, credentialsName, webhookSecret)

	var r0 params.Organization
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) (params.Organization, error)); ok {
		return rf(ctx, name, credentialsName, webhookSecret)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string) params.Organization); ok {
		r0 = rf(ctx, name, credentialsName, webhookSecret)
	} else {
		r0 = ret.Get(0).(params.Organization)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
		r1 = rf(ctx, name, credentialsName, webhookSecret)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateOrganizationPool provides a mock function with given fields: ctx, orgId, param
func (_m *Store) CreateOrganizationPool(ctx context.Context, orgId string, param params.CreatePoolParams) (params.Pool, error) {
	ret := _m.Called(ctx, orgId, param)

	var r0 params.Pool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, params.CreatePoolParams) (params.Pool, error)); ok {
		return rf(ctx, orgId, param)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, params.CreatePoolParams) params.Pool); ok {
		r0 = rf(ctx, orgId, param)
	} else {
		r0 = ret.Get(0).(params.Pool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, params.CreatePoolParams) error); ok {
		r1 = rf(ctx, orgId, param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateRepository provides a mock function with given fields: ctx, owner, name, credentialsName, webhookSecret
func (_m *Store) CreateRepository(ctx context.Context, owner string, name string, credentialsName string, webhookSecret string) (params.Repository, error) {
	ret := _m.Called(ctx, owner, name, credentialsName, webhookSecret)

	var r0 params.Repository
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) (params.Repository, error)); ok {
		return rf(ctx, owner, name, credentialsName, webhookSecret)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) params.Repository); ok {
		r0 = rf(ctx, owner, name, credentialsName, webhookSecret)
	} else {
		r0 = ret.Get(0).(params.Repository)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
		r1 = rf(ctx, owner, name, credentialsName, webhookSecret)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateRepositoryPool provides a mock function with given fields: ctx, repoId, param
func (_m *Store) CreateRepositoryPool(ctx context.Context, repoId string, param params.CreatePoolParams) (params.Pool, error) {
	ret := _m.Called(ctx, repoId, param)

	var r0 params.Pool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, params.CreatePoolParams) (params.Pool, error)); ok {
		return rf(ctx, repoId, param)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, params.CreatePoolParams) params.Pool); ok {
		r0 = rf(ctx, repoId, param)
	} else {
		r0 = ret.Get(0).(params.Pool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, params.CreatePoolParams) error); ok {
		r1 = rf(ctx, repoId, param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateUser provides a mock function with given fields: ctx, user
func (_m *Store) CreateUser(ctx context.Context, user params.NewUserParams) (params.User, error) {
	ret := _m.Called(ctx, user)

	var r0 params.User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, params.NewUserParams) (params.User, error)); ok {
		return rf(ctx, user)
	}
	if rf, ok := ret.Get(0).(func(context.Context, params.NewUserParams) params.User); ok {
		r0 = rf(ctx, user)
	} else {
		r0 = ret.Get(0).(params.User)
	}

	if rf, ok := ret.Get(1).(func(context.Context, params.NewUserParams) error); ok {
		r1 = rf(ctx, user)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteCompletedJobs provides a mock function with given fields: ctx
func (_m *Store) DeleteCompletedJobs(ctx context.Context) error {
	ret := _m.Called(ctx)

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

	return r0
}

// DeleteEnterprise provides a mock function with given fields: ctx, enterpriseID
func (_m *Store) DeleteEnterprise(ctx context.Context, enterpriseID string) error {
	ret := _m.Called(ctx, enterpriseID)

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

	return r0
}

// DeleteEnterprisePool provides a mock function with given fields: ctx, enterpriseID, poolID
func (_m *Store) DeleteEnterprisePool(ctx context.Context, enterpriseID string, poolID string) error {
	ret := _m.Called(ctx, enterpriseID, poolID)

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

	return r0
}

// DeleteInstance provides a mock function with given fields: ctx, poolID, instanceName
func (_m *Store) DeleteInstance(ctx context.Context, poolID string, instanceName string) error {
	ret := _m.Called(ctx, poolID, instanceName)

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

	return r0
}

// DeleteJob provides a mock function with given fields: ctx, jobID
func (_m *Store) DeleteJob(ctx context.Context, jobID int64) error {
	ret := _m.Called(ctx, jobID)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, int64) error); ok {
		r0 = rf(ctx, jobID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DeleteOrganization provides a mock function with given fields: ctx, orgID
func (_m *Store) DeleteOrganization(ctx context.Context, orgID string) error {
	ret := _m.Called(ctx, orgID)

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

	return r0
}

// DeleteOrganizationPool provides a mock function with given fields: ctx, orgID, poolID
func (_m *Store) DeleteOrganizationPool(ctx context.Context, orgID string, poolID string) error {
	ret := _m.Called(ctx, orgID, poolID)

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

	return r0
}

// DeletePoolByID provides a mock function with given fields: ctx, poolID
func (_m *Store) DeletePoolByID(ctx context.Context, poolID string) error {
	ret := _m.Called(ctx, poolID)

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

	return r0
}

// DeleteRepository provides a mock function with given fields: ctx, repoID
func (_m *Store) DeleteRepository(ctx context.Context, repoID string) error {
	ret := _m.Called(ctx, repoID)

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

	return r0
}

// DeleteRepositoryPool provides a mock function with given fields: ctx, repoID, poolID
func (_m *Store) DeleteRepositoryPool(ctx context.Context, repoID string, poolID string) error {
	ret := _m.Called(ctx, repoID, poolID)

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

	return r0
}

// FindEnterprisePoolByTags provides a mock function with given fields: ctx, enterpriseID, tags
func (_m *Store) FindEnterprisePoolByTags(ctx context.Context, enterpriseID string, tags []string) (params.Pool, error) {
	ret := _m.Called(ctx, enterpriseID, tags)

	var r0 params.Pool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, []string) (params.Pool, error)); ok {
		return rf(ctx, enterpriseID, tags)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, []string) params.Pool); ok {
		r0 = rf(ctx, enterpriseID, tags)
	} else {
		r0 = ret.Get(0).(params.Pool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, []string) error); ok {
		r1 = rf(ctx, enterpriseID, tags)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// FindOrganizationPoolByTags provides a mock function with given fields: ctx, orgID, tags
func (_m *Store) FindOrganizationPoolByTags(ctx context.Context, orgID string, tags []string) (params.Pool, error) {
	ret := _m.Called(ctx, orgID, tags)

	var r0 params.Pool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, []string) (params.Pool, error)); ok {
		return rf(ctx, orgID, tags)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, []string) params.Pool); ok {
		r0 = rf(ctx, orgID, tags)
	} else {
		r0 = ret.Get(0).(params.Pool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, []string) error); ok {
		r1 = rf(ctx, orgID, tags)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// FindPoolsMatchingAllTags provides a mock function with given fields: ctx, entityType, entityID, tags
func (_m *Store) FindPoolsMatchingAllTags(ctx context.Context, entityType params.PoolType, entityID string, tags []string) ([]params.Pool, error) {
	ret := _m.Called(ctx, entityType, entityID, tags)

	var r0 []params.Pool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, params.PoolType, string, []string) ([]params.Pool, error)); ok {
		return rf(ctx, entityType, entityID, tags)
	}
	if rf, ok := ret.Get(0).(func(context.Context, params.PoolType, string, []string) []params.Pool); ok {
		r0 = rf(ctx, entityType, entityID, tags)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]params.Pool)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, params.PoolType, string, []string) error); ok {
		r1 = rf(ctx, entityType, entityID, tags)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// FindRepositoryPoolByTags provides a mock function with given fields: ctx, repoID, tags
func (_m *Store) FindRepositoryPoolByTags(ctx context.Context, repoID string, tags []string) (params.Pool, error) {
	ret := _m.Called(ctx, repoID, tags)

	var r0 params.Pool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, []string) (params.Pool, error)); ok {
		return rf(ctx, repoID, tags)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, []string) params.Pool); ok {
		r0 = rf(ctx, repoID, tags)
	} else {
		r0 = ret.Get(0).(params.Pool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, []string) error); ok {
		r1 = rf(ctx, repoID, tags)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetEnterprise provides a mock function with given fields: ctx, name
func (_m *Store) GetEnterprise(ctx context.Context, name string) (params.Enterprise, error) {
	ret := _m.Called(ctx, name)

	var r0 params.Enterprise
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (params.Enterprise, error)); ok {
		return rf(ctx, name)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) params.Enterprise); ok {
		r0 = rf(ctx, name)
	} else {
		r0 = ret.Get(0).(params.Enterprise)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, name)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetEnterpriseByID provides a mock function with given fields: ctx, enterpriseID
func (_m *Store) GetEnterpriseByID(ctx context.Context, enterpriseID string) (params.Enterprise, error) {
	ret := _m.Called(ctx, enterpriseID)

	var r0 params.Enterprise
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (params.Enterprise, error)); ok {
		return rf(ctx, enterpriseID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) params.Enterprise); ok {
		r0 = rf(ctx, enterpriseID)
	} else {
		r0 = ret.Get(0).(params.Enterprise)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, enterpriseID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetEnterprisePool provides a mock function with given fields: ctx, enterpriseID, poolID
func (_m *Store) GetEnterprisePool(ctx context.Context, enterpriseID string, poolID string) (params.Pool, error) {
	ret := _m.Called(ctx, enterpriseID, poolID)

	var r0 params.Pool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) (params.Pool, error)); ok {
		return rf(ctx, enterpriseID, poolID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string) params.Pool); ok {
		r0 = rf(ctx, enterpriseID, poolID)
	} else {
		r0 = ret.Get(0).(params.Pool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = rf(ctx, enterpriseID, poolID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetInstanceByName provides a mock function with given fields: ctx, instanceName
func (_m *Store) GetInstanceByName(ctx context.Context, instanceName string) (params.Instance, error) {
	ret := _m.Called(ctx, instanceName)

	var r0 params.Instance
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (params.Instance, error)); ok {
		return rf(ctx, instanceName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) params.Instance); ok {
		r0 = rf(ctx, instanceName)
	} else {
		r0 = ret.Get(0).(params.Instance)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, instanceName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetJobByID provides a mock function with given fields: ctx, jobID
func (_m *Store) GetJobByID(ctx context.Context, jobID int64) (params.Job, error) {
	ret := _m.Called(ctx, jobID)

	var r0 params.Job
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, int64) (params.Job, error)); ok {
		return rf(ctx, jobID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, int64) params.Job); ok {
		r0 = rf(ctx, jobID)
	} else {
		r0 = ret.Get(0).(params.Job)
	}

	if rf, ok := ret.Get(1).(func(context.Context, int64) error); ok {
		r1 = rf(ctx, jobID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetOrganization provides a mock function with given fields: ctx, name
func (_m *Store) GetOrganization(ctx context.Context, name string) (params.Organization, error) {
	ret := _m.Called(ctx, name)

	var r0 params.Organization
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (params.Organization, error)); ok {
		return rf(ctx, name)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) params.Organization); ok {
		r0 = rf(ctx, name)
	} else {
		r0 = ret.Get(0).(params.Organization)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, name)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetOrganizationByID provides a mock function with given fields: ctx, orgID
func (_m *Store) GetOrganizationByID(ctx context.Context, orgID string) (params.Organization, error) {
	ret := _m.Called(ctx, orgID)

	var r0 params.Organization
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (params.Organization, error)); ok {
		return rf(ctx, orgID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) params.Organization); ok {
		r0 = rf(ctx, orgID)
	} else {
		r0 = ret.Get(0).(params.Organization)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, orgID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetOrganizationPool provides a mock function with given fields: ctx, orgID, poolID
func (_m *Store) GetOrganizationPool(ctx context.Context, orgID string, poolID string) (params.Pool, error) {
	ret := _m.Called(ctx, orgID, poolID)

	var r0 params.Pool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) (params.Pool, error)); ok {
		return rf(ctx, orgID, poolID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string) params.Pool); ok {
		r0 = rf(ctx, orgID, poolID)
	} else {
		r0 = ret.Get(0).(params.Pool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = rf(ctx, orgID, poolID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPoolByID provides a mock function with given fields: ctx, poolID
func (_m *Store) GetPoolByID(ctx context.Context, poolID string) (params.Pool, error) {
	ret := _m.Called(ctx, poolID)

	var r0 params.Pool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (params.Pool, error)); ok {
		return rf(ctx, poolID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) params.Pool); ok {
		r0 = rf(ctx, poolID)
	} else {
		r0 = ret.Get(0).(params.Pool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, poolID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetPoolInstanceByName provides a mock function with given fields: ctx, poolID, instanceName
func (_m *Store) GetPoolInstanceByName(ctx context.Context, poolID string, instanceName string) (params.Instance, error) {
	ret := _m.Called(ctx, poolID, instanceName)

	var r0 params.Instance
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) (params.Instance, error)); ok {
		return rf(ctx, poolID, instanceName)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string) params.Instance); ok {
		r0 = rf(ctx, poolID, instanceName)
	} else {
		r0 = ret.Get(0).(params.Instance)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = rf(ctx, poolID, instanceName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetRepository provides a mock function with given fields: ctx, owner, name
func (_m *Store) GetRepository(ctx context.Context, owner string, name string) (params.Repository, error) {
	ret := _m.Called(ctx, owner, name)

	var r0 params.Repository
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) (params.Repository, error)); ok {
		return rf(ctx, owner, name)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string) params.Repository); ok {
		r0 = rf(ctx, owner, name)
	} else {
		r0 = ret.Get(0).(params.Repository)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = rf(ctx, owner, name)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetRepositoryByID provides a mock function with given fields: ctx, repoID
func (_m *Store) GetRepositoryByID(ctx context.Context, repoID string) (params.Repository, error) {
	ret := _m.Called(ctx, repoID)

	var r0 params.Repository
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (params.Repository, error)); ok {
		return rf(ctx, repoID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) params.Repository); ok {
		r0 = rf(ctx, repoID)
	} else {
		r0 = ret.Get(0).(params.Repository)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, repoID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetRepositoryPool provides a mock function with given fields: ctx, repoID, poolID
func (_m *Store) GetRepositoryPool(ctx context.Context, repoID string, poolID string) (params.Pool, error) {
	ret := _m.Called(ctx, repoID, poolID)

	var r0 params.Pool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) (params.Pool, error)); ok {
		return rf(ctx, repoID, poolID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string) params.Pool); ok {
		r0 = rf(ctx, repoID, poolID)
	} else {
		r0 = ret.Get(0).(params.Pool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
		r1 = rf(ctx, repoID, poolID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetUser provides a mock function with given fields: ctx, user
func (_m *Store) GetUser(ctx context.Context, user string) (params.User, error) {
	ret := _m.Called(ctx, user)

	var r0 params.User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (params.User, error)); ok {
		return rf(ctx, user)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) params.User); ok {
		r0 = rf(ctx, user)
	} else {
		r0 = ret.Get(0).(params.User)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, user)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetUserByID provides a mock function with given fields: ctx, userID
func (_m *Store) GetUserByID(ctx context.Context, userID string) (params.User, error) {
	ret := _m.Called(ctx, userID)

	var r0 params.User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (params.User, error)); ok {
		return rf(ctx, userID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) params.User); ok {
		r0 = rf(ctx, userID)
	} else {
		r0 = ret.Get(0).(params.User)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, userID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// HasAdminUser provides a mock function with given fields: ctx
func (_m *Store) HasAdminUser(ctx context.Context) bool {
	ret := _m.Called(ctx)

	var r0 bool
	if rf, ok := ret.Get(0).(func(context.Context) bool); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// InitController provides a mock function with given fields:
func (_m *Store) InitController() (params.ControllerInfo, error) {
	ret := _m.Called()

	var r0 params.ControllerInfo
	var r1 error
	if rf, ok := ret.Get(0).(func() (params.ControllerInfo, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() params.ControllerInfo); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(params.ControllerInfo)
	}

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAllInstances provides a mock function with given fields: ctx
func (_m *Store) ListAllInstances(ctx context.Context) ([]params.Instance, error) {
	ret := _m.Called(ctx)

	var r0 []params.Instance
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]params.Instance, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []params.Instance); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]params.Instance)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAllJobs provides a mock function with given fields: ctx
func (_m *Store) ListAllJobs(ctx context.Context) ([]params.Job, error) {
	ret := _m.Called(ctx)

	var r0 []params.Job
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]params.Job, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []params.Job); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]params.Job)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAllPools provides a mock function with given fields: ctx
func (_m *Store) ListAllPools(ctx context.Context) ([]params.Pool, error) {
	ret := _m.Called(ctx)

	var r0 []params.Pool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]params.Pool, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []params.Pool); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]params.Pool)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListEnterpriseInstances provides a mock function with given fields: ctx, enterpriseID
func (_m *Store) ListEnterpriseInstances(ctx context.Context, enterpriseID string) ([]params.Instance, error) {
	ret := _m.Called(ctx, enterpriseID)

	var r0 []params.Instance
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) ([]params.Instance, error)); ok {
		return rf(ctx, enterpriseID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) []params.Instance); ok {
		r0 = rf(ctx, enterpriseID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]params.Instance)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, enterpriseID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListEnterprisePools provides a mock function with given fields: ctx, enterpriseID
func (_m *Store) ListEnterprisePools(ctx context.Context, enterpriseID string) ([]params.Pool, error) {
	ret := _m.Called(ctx, enterpriseID)

	var r0 []params.Pool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) ([]params.Pool, error)); ok {
		return rf(ctx, enterpriseID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) []params.Pool); ok {
		r0 = rf(ctx, enterpriseID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]params.Pool)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, enterpriseID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListEnterprises provides a mock function with given fields: ctx
func (_m *Store) ListEnterprises(ctx context.Context) ([]params.Enterprise, error) {
	ret := _m.Called(ctx)

	var r0 []params.Enterprise
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]params.Enterprise, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []params.Enterprise); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]params.Enterprise)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListEntityJobsByStatus provides a mock function with given fields: ctx, entityType, entityID, status
func (_m *Store) ListEntityJobsByStatus(ctx context.Context, entityType params.PoolType, entityID string, status params.JobStatus) ([]params.Job, error) {
	ret := _m.Called(ctx, entityType, entityID, status)

	var r0 []params.Job
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, params.PoolType, string, params.JobStatus) ([]params.Job, error)); ok {
		return rf(ctx, entityType, entityID, status)
	}
	if rf, ok := ret.Get(0).(func(context.Context, params.PoolType, string, params.JobStatus) []params.Job); ok {
		r0 = rf(ctx, entityType, entityID, status)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]params.Job)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, params.PoolType, string, params.JobStatus) error); ok {
		r1 = rf(ctx, entityType, entityID, status)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListInstanceEvents provides a mock function with given fields: ctx, instanceID, eventType, eventLevel
func (_m *Store) ListInstanceEvents(ctx context.Context, instanceID string, eventType params.EventType, eventLevel params.EventLevel) ([]params.StatusMessage, error) {
	ret := _m.Called(ctx, instanceID, eventType, eventLevel)

	var r0 []params.StatusMessage
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, params.EventType, params.EventLevel) ([]params.StatusMessage, error)); ok {
		return rf(ctx, instanceID, eventType, eventLevel)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, params.EventType, params.EventLevel) []params.StatusMessage); ok {
		r0 = rf(ctx, instanceID, eventType, eventLevel)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]params.StatusMessage)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, params.EventType, params.EventLevel) error); ok {
		r1 = rf(ctx, instanceID, eventType, eventLevel)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListJobsByStatus provides a mock function with given fields: ctx, status
func (_m *Store) ListJobsByStatus(ctx context.Context, status params.JobStatus) ([]params.Job, error) {
	ret := _m.Called(ctx, status)

	var r0 []params.Job
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, params.JobStatus) ([]params.Job, error)); ok {
		return rf(ctx, status)
	}
	if rf, ok := ret.Get(0).(func(context.Context, params.JobStatus) []params.Job); ok {
		r0 = rf(ctx, status)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]params.Job)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, params.JobStatus) error); ok {
		r1 = rf(ctx, status)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListOrgInstances provides a mock function with given fields: ctx, orgID
func (_m *Store) ListOrgInstances(ctx context.Context, orgID string) ([]params.Instance, error) {
	ret := _m.Called(ctx, orgID)

	var r0 []params.Instance
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) ([]params.Instance, error)); ok {
		return rf(ctx, orgID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) []params.Instance); ok {
		r0 = rf(ctx, orgID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]params.Instance)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, orgID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListOrgPools provides a mock function with given fields: ctx, orgID
func (_m *Store) ListOrgPools(ctx context.Context, orgID string) ([]params.Pool, error) {
	ret := _m.Called(ctx, orgID)

	var r0 []params.Pool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) ([]params.Pool, error)); ok {
		return rf(ctx, orgID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) []params.Pool); ok {
		r0 = rf(ctx, orgID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]params.Pool)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, orgID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListOrganizations provides a mock function with given fields: ctx
func (_m *Store) ListOrganizations(ctx context.Context) ([]params.Organization, error) {
	ret := _m.Called(ctx)

	var r0 []params.Organization
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]params.Organization, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []params.Organization); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]params.Organization)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListPoolInstances provides a mock function with given fields: ctx, poolID
func (_m *Store) ListPoolInstances(ctx context.Context, poolID string) ([]params.Instance, error) {
	ret := _m.Called(ctx, poolID)

	var r0 []params.Instance
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) ([]params.Instance, error)); ok {
		return rf(ctx, poolID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) []params.Instance); ok {
		r0 = rf(ctx, poolID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]params.Instance)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, poolID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListRepoInstances provides a mock function with given fields: ctx, repoID
func (_m *Store) ListRepoInstances(ctx context.Context, repoID string) ([]params.Instance, error) {
	ret := _m.Called(ctx, repoID)

	var r0 []params.Instance
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) ([]params.Instance, error)); ok {
		return rf(ctx, repoID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) []params.Instance); ok {
		r0 = rf(ctx, repoID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]params.Instance)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, repoID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListRepoPools provides a mock function with given fields: ctx, repoID
func (_m *Store) ListRepoPools(ctx context.Context, repoID string) ([]params.Pool, error) {
	ret := _m.Called(ctx, repoID)

	var r0 []params.Pool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) ([]params.Pool, error)); ok {
		return rf(ctx, repoID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) []params.Pool); ok {
		r0 = rf(ctx, repoID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]params.Pool)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, repoID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListRepositories provides a mock function with given fields: ctx
func (_m *Store) ListRepositories(ctx context.Context) ([]params.Repository, error) {
	ret := _m.Called(ctx)

	var r0 []params.Repository
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) ([]params.Repository, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) []params.Repository); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]params.Repository)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
		r1 = rf(ctx)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LockJob provides a mock function with given fields: ctx, jobID, entityID
func (_m *Store) LockJob(ctx context.Context, jobID int64, entityID string) error {
	ret := _m.Called(ctx, jobID, entityID)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, int64, string) error); ok {
		r0 = rf(ctx, jobID, entityID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// PoolInstanceCount provides a mock function with given fields: ctx, poolID
func (_m *Store) PoolInstanceCount(ctx context.Context, poolID string) (int64, error) {
	ret := _m.Called(ctx, poolID)

	var r0 int64
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (int64, error)); ok {
		return rf(ctx, poolID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) int64); ok {
		r0 = rf(ctx, poolID)
	} else {
		r0 = ret.Get(0).(int64)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, poolID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UnlockJob provides a mock function with given fields: ctx, jobID, entityID
func (_m *Store) UnlockJob(ctx context.Context, jobID int64, entityID string) error {
	ret := _m.Called(ctx, jobID, entityID)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, int64, string) error); ok {
		r0 = rf(ctx, jobID, entityID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// UpdateEnterprise provides a mock function with given fields: ctx, enterpriseID, param
func (_m *Store) UpdateEnterprise(ctx context.Context, enterpriseID string, param params.UpdateEntityParams) (params.Enterprise, error) {
	ret := _m.Called(ctx, enterpriseID, param)

	var r0 params.Enterprise
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateEntityParams) (params.Enterprise, error)); ok {
		return rf(ctx, enterpriseID, param)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateEntityParams) params.Enterprise); ok {
		r0 = rf(ctx, enterpriseID, param)
	} else {
		r0 = ret.Get(0).(params.Enterprise)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, params.UpdateEntityParams) error); ok {
		r1 = rf(ctx, enterpriseID, param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateEnterprisePool provides a mock function with given fields: ctx, enterpriseID, poolID, param
func (_m *Store) UpdateEnterprisePool(ctx context.Context, enterpriseID string, poolID string, param params.UpdatePoolParams) (params.Pool, error) {
	ret := _m.Called(ctx, enterpriseID, poolID, param)

	var r0 params.Pool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, params.UpdatePoolParams) (params.Pool, error)); ok {
		return rf(ctx, enterpriseID, poolID, param)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, params.UpdatePoolParams) params.Pool); ok {
		r0 = rf(ctx, enterpriseID, poolID, param)
	} else {
		r0 = ret.Get(0).(params.Pool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, params.UpdatePoolParams) error); ok {
		r1 = rf(ctx, enterpriseID, poolID, param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateInstance provides a mock function with given fields: ctx, instanceID, param
func (_m *Store) UpdateInstance(ctx context.Context, instanceID string, param params.UpdateInstanceParams) (params.Instance, error) {
	ret := _m.Called(ctx, instanceID, param)

	var r0 params.Instance
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateInstanceParams) (params.Instance, error)); ok {
		return rf(ctx, instanceID, param)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateInstanceParams) params.Instance); ok {
		r0 = rf(ctx, instanceID, param)
	} else {
		r0 = ret.Get(0).(params.Instance)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, params.UpdateInstanceParams) error); ok {
		r1 = rf(ctx, instanceID, param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateOrganization provides a mock function with given fields: ctx, orgID, param
func (_m *Store) UpdateOrganization(ctx context.Context, orgID string, param params.UpdateEntityParams) (params.Organization, error) {
	ret := _m.Called(ctx, orgID, param)

	var r0 params.Organization
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateEntityParams) (params.Organization, error)); ok {
		return rf(ctx, orgID, param)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateEntityParams) params.Organization); ok {
		r0 = rf(ctx, orgID, param)
	} else {
		r0 = ret.Get(0).(params.Organization)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, params.UpdateEntityParams) error); ok {
		r1 = rf(ctx, orgID, param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateOrganizationPool provides a mock function with given fields: ctx, orgID, poolID, param
func (_m *Store) UpdateOrganizationPool(ctx context.Context, orgID string, poolID string, param params.UpdatePoolParams) (params.Pool, error) {
	ret := _m.Called(ctx, orgID, poolID, param)

	var r0 params.Pool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, params.UpdatePoolParams) (params.Pool, error)); ok {
		return rf(ctx, orgID, poolID, param)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, params.UpdatePoolParams) params.Pool); ok {
		r0 = rf(ctx, orgID, poolID, param)
	} else {
		r0 = ret.Get(0).(params.Pool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, params.UpdatePoolParams) error); ok {
		r1 = rf(ctx, orgID, poolID, param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateRepository provides a mock function with given fields: ctx, repoID, param
func (_m *Store) UpdateRepository(ctx context.Context, repoID string, param params.UpdateEntityParams) (params.Repository, error) {
	ret := _m.Called(ctx, repoID, param)

	var r0 params.Repository
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateEntityParams) (params.Repository, error)); ok {
		return rf(ctx, repoID, param)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateEntityParams) params.Repository); ok {
		r0 = rf(ctx, repoID, param)
	} else {
		r0 = ret.Get(0).(params.Repository)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, params.UpdateEntityParams) error); ok {
		r1 = rf(ctx, repoID, param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateRepositoryPool provides a mock function with given fields: ctx, repoID, poolID, param
func (_m *Store) UpdateRepositoryPool(ctx context.Context, repoID string, poolID string, param params.UpdatePoolParams) (params.Pool, error) {
	ret := _m.Called(ctx, repoID, poolID, param)

	var r0 params.Pool
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, params.UpdatePoolParams) (params.Pool, error)); ok {
		return rf(ctx, repoID, poolID, param)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, params.UpdatePoolParams) params.Pool); ok {
		r0 = rf(ctx, repoID, poolID, param)
	} else {
		r0 = ret.Get(0).(params.Pool)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, params.UpdatePoolParams) error); ok {
		r1 = rf(ctx, repoID, poolID, param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateUser provides a mock function with given fields: ctx, user, param
func (_m *Store) UpdateUser(ctx context.Context, user string, param params.UpdateUserParams) (params.User, error) {
	ret := _m.Called(ctx, user, param)

	var r0 params.User
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateUserParams) (params.User, error)); ok {
		return rf(ctx, user, param)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, params.UpdateUserParams) params.User); ok {
		r0 = rf(ctx, user, param)
	} else {
		r0 = ret.Get(0).(params.User)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, params.UpdateUserParams) error); ok {
		r1 = rf(ctx, user, param)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type mockConstructorTestingTNewStore interface {
	mock.TestingT
	Cleanup(func())
}

// NewStore creates a new instance of Store. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
func NewStore(t mockConstructorTestingTNewStore) *Store {
	mock := &Store{}
	mock.Mock.Test(t)

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

	return mock
}