core/dev.kaccelero.commons.repositories

Package-level declarations

Types

CountChildModelFromRepositorySuspendUseCase

open class CountChildModelFromRepositorySuspendUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId>(repository: IChildModelSuspendRepository<Model, *, *, *, ParentId>) : ICountChildModelSuspendUseCase<Model, ParentId>

CountChildModelFromRepositoryUseCase

open class CountChildModelFromRepositoryUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId>(repository: IChildModelRepository<Model, *, *, *, ParentId>) : ICountChildModelUseCase<Model, ParentId>

CountChildModelWithContextFromRepositorySuspendUseCase

open class CountChildModelWithContextFromRepositorySuspendUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId>(repository: IChildModelSuspendRepository<Model, *, *, *, ParentId>) : ICountChildModelWithContextSuspendUseCase<Model, ParentId>

CountChildModelWithContextFromRepositoryUseCase

open class CountChildModelWithContextFromRepositoryUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId>(repository: IChildModelRepository<Model, *, *, *, ParentId>) : ICountChildModelWithContextUseCase<Model, ParentId>

CountModelFromRepositorySuspendUseCase

open class CountModelFromRepositorySuspendUseCase<Model : IModel<*, *, *>>(repository: IModelSuspendRepository<Model, *, *, *>) : CountChildModelFromRepositorySuspendUseCase<Model, Unit> , ICountModelSuspendUseCase<Model>

CountModelFromRepositoryUseCase

open class CountModelFromRepositoryUseCase<Model : IModel<*, *, *>>(repository: IModelRepository<Model, *, *, *>) : CountChildModelFromRepositoryUseCase<Model, Unit> , ICountModelUseCase<Model>

CountModelWithContextFromRepositorySuspendUseCase

open class CountModelWithContextFromRepositorySuspendUseCase<Model : IModel<*, *, *>>(repository: IModelSuspendRepository<Model, *, *, *>) : CountChildModelWithContextFromRepositorySuspendUseCase<Model, Unit> , ICountModelWithContextSuspendUseCase<Model>

CountModelWithContextFromRepositoryUseCase

open class CountModelWithContextFromRepositoryUseCase<Model : IModel<*, *, *>>(repository: IModelRepository<Model, *, *, *>) : CountChildModelWithContextFromRepositoryUseCase<Model, Unit> , ICountModelWithContextUseCase<Model>

CreateChildModelFromRepositorySuspendUseCase

open class CreateChildModelFromRepositorySuspendUseCase<Model : IChildModel<*, CreatePayload, *, ParentId>, CreatePayload, ParentId>(repository: IChildModelSuspendRepository<Model, *, CreatePayload, *, ParentId>) : ICreateChildModelSuspendUseCase<Model, CreatePayload, ParentId>

CreateChildModelFromRepositoryUseCase

open class CreateChildModelFromRepositoryUseCase<Model : IChildModel<*, CreatePayload, *, ParentId>, CreatePayload, ParentId>(repository: IChildModelRepository<Model, *, CreatePayload, *, ParentId>) : ICreateChildModelUseCase<Model, CreatePayload, ParentId>

CreateChildModelWithContextFromRepositorySuspendUseCase

open class CreateChildModelWithContextFromRepositorySuspendUseCase<Model : IChildModel<*, CreatePayload, *, ParentId>, CreatePayload, ParentId>(repository: IChildModelSuspendRepository<Model, *, CreatePayload, *, ParentId>) : ICreateChildModelWithContextSuspendUseCase<Model, CreatePayload, ParentId>

CreateChildModelWithContextFromRepositoryUseCase

open class CreateChildModelWithContextFromRepositoryUseCase<Model : IChildModel<*, CreatePayload, *, ParentId>, CreatePayload, ParentId>(repository: IChildModelRepository<Model, *, CreatePayload, *, ParentId>) : ICreateChildModelWithContextUseCase<Model, CreatePayload, ParentId>

CreateModelFromRepositorySuspendUseCase

open class CreateModelFromRepositorySuspendUseCase<Model : IModel<*, CreatePayload, *>, CreatePayload>(repository: IModelSuspendRepository<Model, *, CreatePayload, *>) : CreateChildModelFromRepositorySuspendUseCase<Model, CreatePayload, Unit> , ICreateModelSuspendUseCase<Model, CreatePayload>

CreateModelFromRepositoryUseCase

open class CreateModelFromRepositoryUseCase<Model : IModel<*, CreatePayload, *>, CreatePayload>(repository: IModelRepository<Model, *, CreatePayload, *>) : CreateChildModelFromRepositoryUseCase<Model, CreatePayload, Unit> , ICreateModelUseCase<Model, CreatePayload>

CreateModelWithContextFromRepositorySuspendUseCase

open class CreateModelWithContextFromRepositorySuspendUseCase<Model : IModel<*, CreatePayload, *>, CreatePayload>(repository: IModelSuspendRepository<Model, *, CreatePayload, *>) : CreateChildModelWithContextFromRepositorySuspendUseCase<Model, CreatePayload, Unit> , ICreateModelWithContextSuspendUseCase<Model, CreatePayload>

CreateModelWithContextFromRepositoryUseCase

open class CreateModelWithContextFromRepositoryUseCase<Model : IModel<*, CreatePayload, *>, CreatePayload>(repository: IModelRepository<Model, *, CreatePayload, *>) : CreateChildModelWithContextFromRepositoryUseCase<Model, CreatePayload, Unit> , ICreateModelWithContextUseCase<Model, CreatePayload>

DeleteChildModelFromRepositorySuspendUseCase

open class DeleteChildModelFromRepositorySuspendUseCase<Model : IChildModel<Id, *, *, ParentId>, Id, ParentId>(repository: IChildModelSuspendRepository<Model, Id, *, *, ParentId>) : IDeleteChildModelSuspendUseCase<Model, Id, ParentId>

DeleteChildModelFromRepositoryUseCase

open class DeleteChildModelFromRepositoryUseCase<Model : IChildModel<Id, *, *, ParentId>, Id, ParentId>(repository: IChildModelRepository<Model, Id, *, *, ParentId>) : IDeleteChildModelUseCase<Model, Id, ParentId>

DeleteChildModelWithContextFromRepositorySuspendUseCase

open class DeleteChildModelWithContextFromRepositorySuspendUseCase<Model : IChildModel<Id, *, *, ParentId>, Id, ParentId>(repository: IChildModelSuspendRepository<Model, Id, *, *, ParentId>) : IDeleteChildModelWithContextSuspendUseCase<Model, Id, ParentId>

DeleteChildModelWithContextFromRepositoryUseCase

open class DeleteChildModelWithContextFromRepositoryUseCase<Model : IChildModel<Id, *, *, ParentId>, Id, ParentId>(repository: IChildModelRepository<Model, Id, *, *, ParentId>) : IDeleteChildModelWithContextUseCase<Model, Id, ParentId>

DeleteModelFromRepositorySuspendUseCase

open class DeleteModelFromRepositorySuspendUseCase<Model : IModel<Id, *, *>, Id>(repository: IModelSuspendRepository<Model, Id, *, *>) : DeleteChildModelFromRepositorySuspendUseCase<Model, Id, Unit> , IDeleteModelSuspendUseCase<Model, Id>

DeleteModelFromRepositoryUseCase

open class DeleteModelFromRepositoryUseCase<Model : IModel<Id, *, *>, Id>(repository: IModelRepository<Model, Id, *, *>) : DeleteChildModelFromRepositoryUseCase<Model, Id, Unit> , IDeleteModelUseCase<Model, Id>

DeleteModelWithContextFromRepositorySuspendUseCase

open class DeleteModelWithContextFromRepositorySuspendUseCase<Model : IModel<Id, *, *>, Id>(repository: IModelSuspendRepository<Model, Id, *, *>) : DeleteChildModelWithContextFromRepositorySuspendUseCase<Model, Id, Unit> , IDeleteModelWithContextSuspendUseCase<Model, Id>

DeleteModelWithContextFromRepositoryUseCase

open class DeleteModelWithContextFromRepositoryUseCase<Model : IModel<Id, *, *>, Id>(repository: IModelRepository<Model, Id, *, *>) : DeleteChildModelWithContextFromRepositoryUseCase<Model, Id, Unit> , IDeleteModelWithContextUseCase<Model, Id>

GetChildModelFromRepositorySuspendUseCase

open class GetChildModelFromRepositorySuspendUseCase<Model : IChildModel<Id, *, *, ParentId>, Id, ParentId>(repository: IChildModelSuspendRepository<Model, Id, *, *, ParentId>) : IGetChildModelSuspendUseCase<Model, Id, ParentId>

GetChildModelFromRepositoryUseCase

open class GetChildModelFromRepositoryUseCase<Model : IChildModel<Id, *, *, ParentId>, Id, ParentId>(repository: IChildModelRepository<Model, Id, *, *, ParentId>) : IGetChildModelUseCase<Model, Id, ParentId>

GetChildModelWithContextFromRepositorySuspendUseCase

open class GetChildModelWithContextFromRepositorySuspendUseCase<Model : IChildModel<Id, *, *, ParentId>, Id, ParentId>(repository: IChildModelSuspendRepository<Model, Id, *, *, ParentId>) : IGetChildModelWithContextSuspendUseCase<Model, Id, ParentId>

GetChildModelWithContextFromRepositoryUseCase

open class GetChildModelWithContextFromRepositoryUseCase<Model : IChildModel<Id, *, *, ParentId>, Id, ParentId>(repository: IChildModelRepository<Model, Id, *, *, ParentId>) : IGetChildModelWithContextUseCase<Model, Id, ParentId>

GetModelFromRepositorySuspendUseCase

open class GetModelFromRepositorySuspendUseCase<Model : IModel<Id, *, *>, Id>(repository: IModelSuspendRepository<Model, Id, *, *>) : GetChildModelFromRepositorySuspendUseCase<Model, Id, Unit> , IGetModelSuspendUseCase<Model, Id>

GetModelFromRepositoryUseCase

open class GetModelFromRepositoryUseCase<Model : IModel<Id, *, *>, Id>(repository: IModelRepository<Model, Id, *, *>) : GetChildModelFromRepositoryUseCase<Model, Id, Unit> , IGetModelUseCase<Model, Id>

GetModelWithContextFromRepositorySuspendUseCase

open class GetModelWithContextFromRepositorySuspendUseCase<Model : IModel<Id, *, *>, Id>(repository: IModelSuspendRepository<Model, Id, *, *>) : GetChildModelWithContextFromRepositorySuspendUseCase<Model, Id, Unit> , IGetModelWithContextSuspendUseCase<Model, Id>

GetModelWithContextFromRepositoryUseCase

open class GetModelWithContextFromRepositoryUseCase<Model : IModel<Id, *, *>, Id>(repository: IModelRepository<Model, Id, *, *>) : GetChildModelWithContextFromRepositoryUseCase<Model, Id, Unit> , IGetModelWithContextUseCase<Model, Id>

ICountChildModelSuspendUseCase

interface ICountChildModelSuspendUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId> : ISuspendUseCase<ParentId, Long>

ICountChildModelUseCase

interface ICountChildModelUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId> : IUseCase<ParentId, Long>

ICountChildModelWithContextSuspendUseCase

interface ICountChildModelWithContextSuspendUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId> : IPairSuspendUseCase<ParentId, IContext, Long>

ICountChildModelWithContextUseCase

interface ICountChildModelWithContextUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId> : IPairUseCase<ParentId, IContext, Long>

ICountModelSuspendUseCase

interface ICountModelSuspendUseCase<Model : IModel<*, *, *>> : ICountChildModelSuspendUseCase<Model, Unit>

ICountModelUseCase

interface ICountModelUseCase<Model : IModel<*, *, *>> : ICountChildModelUseCase<Model, Unit>

ICountModelWithContextSuspendUseCase

interface ICountModelWithContextSuspendUseCase<Model : IModel<*, *, *>> : ICountChildModelWithContextSuspendUseCase<Model, Unit>

ICountModelWithContextUseCase

interface ICountModelWithContextUseCase<Model : IModel<*, *, *>> : ICountChildModelWithContextUseCase<Model, Unit>

ICreateChildModelSuspendUseCase

interface ICreateChildModelSuspendUseCase<Model : IChildModel<*, CreatePayload, *, ParentId>, CreatePayload, ParentId> : IPairSuspendUseCase<CreatePayload, ParentId, Model?>

ICreateChildModelUseCase

interface ICreateChildModelUseCase<Model : IChildModel<*, CreatePayload, *, ParentId>, CreatePayload, ParentId> : IPairUseCase<CreatePayload, ParentId, Model?>

ICreateChildModelWithContextSuspendUseCase

interface ICreateChildModelWithContextSuspendUseCase<Model : IChildModel<*, CreatePayload, *, ParentId>, CreatePayload, ParentId> : ITripleSuspendUseCase<CreatePayload, ParentId, IContext, Model?>

ICreateChildModelWithContextUseCase

interface ICreateChildModelWithContextUseCase<Model : IChildModel<*, CreatePayload, *, ParentId>, CreatePayload, ParentId> : ITripleUseCase<CreatePayload, ParentId, IContext, Model?>

ICreateModelSuspendUseCase

interface ICreateModelSuspendUseCase<Model : IModel<*, CreatePayload, *>, CreatePayload> : ICreateChildModelSuspendUseCase<Model, CreatePayload, Unit>

ICreateModelUseCase

interface ICreateModelUseCase<Model : IModel<*, CreatePayload, *>, CreatePayload> : ICreateChildModelUseCase<Model, CreatePayload, Unit>

ICreateModelWithContextSuspendUseCase

interface ICreateModelWithContextSuspendUseCase<Model : IModel<*, CreatePayload, *>, CreatePayload> : ICreateChildModelWithContextSuspendUseCase<Model, CreatePayload, Unit>

ICreateModelWithContextUseCase

interface ICreateModelWithContextUseCase<Model : IModel<*, CreatePayload, *>, CreatePayload> : ICreateChildModelWithContextUseCase<Model, CreatePayload, Unit>

IDeleteChildModelSuspendUseCase

interface IDeleteChildModelSuspendUseCase<Model : IChildModel<Id, *, *, ParentId>, Id, ParentId> : IPairSuspendUseCase<Id, ParentId, Boolean>

IDeleteChildModelUseCase

interface IDeleteChildModelUseCase<Model : IChildModel<Id, *, *, ParentId>, Id, ParentId> : IPairUseCase<Id, ParentId, Boolean>

IDeleteChildModelWithContextSuspendUseCase

interface IDeleteChildModelWithContextSuspendUseCase<Model : IChildModel<Id, *, *, ParentId>, Id, ParentId> : ITripleSuspendUseCase<Id, ParentId, IContext, Boolean>

IDeleteChildModelWithContextUseCase

interface IDeleteChildModelWithContextUseCase<Model : IChildModel<Id, *, *, ParentId>, Id, ParentId> : ITripleUseCase<Id, ParentId, IContext, Boolean>

IDeleteModelSuspendUseCase

interface IDeleteModelSuspendUseCase<Model : IModel<Id, *, *>, Id> : IDeleteChildModelSuspendUseCase<Model, Id, Unit>

IDeleteModelUseCase

interface IDeleteModelUseCase<Model : IModel<Id, *, *>, Id> : IDeleteChildModelUseCase<Model, Id, Unit>

IDeleteModelWithContextSuspendUseCase

interface IDeleteModelWithContextSuspendUseCase<Model : IModel<Id, *, *>, Id> : IDeleteChildModelWithContextSuspendUseCase<Model, Id, Unit>

IDeleteModelWithContextUseCase

interface IDeleteModelWithContextUseCase<Model : IModel<Id, *, *>, Id> : IDeleteChildModelWithContextUseCase<Model, Id, Unit>

IGetChildModelSuspendUseCase

interface IGetChildModelSuspendUseCase<Model : IChildModel<Id, *, *, ParentId>, Id, ParentId> : IPairSuspendUseCase<Id, ParentId, Model?>

IGetChildModelUseCase

interface IGetChildModelUseCase<Model : IChildModel<Id, *, *, ParentId>, Id, ParentId> : IPairUseCase<Id, ParentId, Model?>

IGetChildModelWithContextSuspendUseCase

interface IGetChildModelWithContextSuspendUseCase<Model : IChildModel<Id, *, *, ParentId>, Id, ParentId> : ITripleSuspendUseCase<Id, ParentId, IContext, Model?>

IGetChildModelWithContextUseCase

interface IGetChildModelWithContextUseCase<Model : IChildModel<Id, *, *, ParentId>, Id, ParentId> : ITripleUseCase<Id, ParentId, IContext, Model?>

IGetModelSuspendUseCase

interface IGetModelSuspendUseCase<Model : IModel<Id, *, *>, Id> : IGetChildModelSuspendUseCase<Model, Id, Unit>

IGetModelUseCase

interface IGetModelUseCase<Model : IModel<Id, *, *>, Id> : IGetChildModelUseCase<Model, Id, Unit>

IGetModelWithContextSuspendUseCase

interface IGetModelWithContextSuspendUseCase<Model : IModel<Id, *, *>, Id> : IGetChildModelWithContextSuspendUseCase<Model, Id, Unit>

IGetModelWithContextUseCase

interface IGetModelWithContextUseCase<Model : IModel<Id, *, *>, Id> : IGetChildModelWithContextUseCase<Model, Id, Unit>

IListChildModelSuspendUseCase

interface IListChildModelSuspendUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId> : ISuspendUseCase<ParentId, List<Model>>

IListChildModelUseCase

interface IListChildModelUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId> : IUseCase<ParentId, List<Model>>

IListChildModelWithContextSuspendUseCase

interface IListChildModelWithContextSuspendUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId> : IPairSuspendUseCase<ParentId, IContext, List<Model>>

IListChildModelWithContextUseCase

interface IListChildModelWithContextUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId> : IPairUseCase<ParentId, IContext, List<Model>>

IListModelSuspendUseCase

interface IListModelSuspendUseCase<Model : IModel<*, *, *>> : IListChildModelSuspendUseCase<Model, Unit>

IListModelUseCase

interface IListModelUseCase<Model : IModel<*, *, *>> : IListChildModelUseCase<Model, Unit>

IListModelWithContextSuspendUseCase

interface IListModelWithContextSuspendUseCase<Model : IModel<*, *, *>> : IListChildModelWithContextSuspendUseCase<Model, Unit>

IListModelWithContextUseCase

interface IListModelWithContextUseCase<Model : IModel<*, *, *>> : IListChildModelWithContextUseCase<Model, Unit>

IListSliceChildModelSuspendUseCase

interface IListSliceChildModelSuspendUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId> : IPairSuspendUseCase<Pagination, ParentId, List<Model>>

IListSliceChildModelUseCase

interface IListSliceChildModelUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId> : IPairUseCase<Pagination, ParentId, List<Model>>

IListSliceChildModelWithContextSuspendUseCase

interface IListSliceChildModelWithContextSuspendUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId> : ITripleSuspendUseCase<Pagination, ParentId, IContext, List<Model>>

IListSliceChildModelWithContextUseCase

interface IListSliceChildModelWithContextUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId> : ITripleUseCase<Pagination, ParentId, IContext, List<Model>>

IListSliceModelSuspendUseCase

interface IListSliceModelSuspendUseCase<Model : IModel<*, *, *>> : IListSliceChildModelSuspendUseCase<Model, Unit>

IListSliceModelUseCase

interface IListSliceModelUseCase<Model : IModel<*, *, *>> : IListSliceChildModelUseCase<Model, Unit>

IListSliceModelWithContextSuspendUseCase

interface IListSliceModelWithContextSuspendUseCase<Model : IModel<*, *, *>> : IListSliceChildModelWithContextSuspendUseCase<Model, Unit>

IListSliceModelWithContextUseCase

interface IListSliceModelWithContextUseCase<Model : IModel<*, *, *>> : IListSliceChildModelWithContextUseCase<Model, Unit>

IUpdateChildModelSuspendUseCase

interface IUpdateChildModelSuspendUseCase<Model : IChildModel<Id, *, UpdatePayload, ParentId>, Id, UpdatePayload, ParentId> : ITripleSuspendUseCase<Id, UpdatePayload, ParentId, Model?>

IUpdateChildModelUseCase

interface IUpdateChildModelUseCase<Model : IChildModel<Id, *, UpdatePayload, ParentId>, Id, UpdatePayload, ParentId> : ITripleUseCase<Id, UpdatePayload, ParentId, Model?>

IUpdateChildModelWithContextSuspendUseCase

interface IUpdateChildModelWithContextSuspendUseCase<Model : IChildModel<Id, *, UpdatePayload, ParentId>, Id, UpdatePayload, ParentId> : IQuadSuspendUseCase<Id, UpdatePayload, ParentId, IContext, Model?>

IUpdateChildModelWithContextUseCase

interface IUpdateChildModelWithContextUseCase<Model : IChildModel<Id, *, UpdatePayload, ParentId>, Id, UpdatePayload, ParentId> : IQuadUseCase<Id, UpdatePayload, ParentId, IContext, Model?>

IUpdateModelSuspendUseCase

interface IUpdateModelSuspendUseCase<Model : IModel<Id, *, UpdatePayload>, Id, UpdatePayload> : IUpdateChildModelSuspendUseCase<Model, Id, UpdatePayload, Unit>

IUpdateModelUseCase

interface IUpdateModelUseCase<Model : IModel<Id, *, UpdatePayload>, Id, UpdatePayload> : IUpdateChildModelUseCase<Model, Id, UpdatePayload, Unit>

IUpdateModelWithContextSuspendUseCase

interface IUpdateModelWithContextSuspendUseCase<Model : IModel<Id, *, UpdatePayload>, Id, UpdatePayload> : IUpdateChildModelWithContextSuspendUseCase<Model, Id, UpdatePayload, Unit>

IUpdateModelWithContextUseCase

interface IUpdateModelWithContextUseCase<Model : IModel<Id, *, UpdatePayload>, Id, UpdatePayload> : IUpdateChildModelWithContextUseCase<Model, Id, UpdatePayload, Unit>

ListChildModelFromRepositorySuspendUseCase

open class ListChildModelFromRepositorySuspendUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId>(repository: IChildModelSuspendRepository<Model, *, *, *, ParentId>) : IListChildModelSuspendUseCase<Model, ParentId>

ListChildModelFromRepositoryUseCase

open class ListChildModelFromRepositoryUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId>(repository: IChildModelRepository<Model, *, *, *, ParentId>) : IListChildModelUseCase<Model, ParentId>

ListChildModelWithContextFromRepositorySuspendUseCase

open class ListChildModelWithContextFromRepositorySuspendUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId>(repository: IChildModelSuspendRepository<Model, *, *, *, ParentId>) : IListChildModelWithContextSuspendUseCase<Model, ParentId>

ListChildModelWithContextFromRepositoryUseCase

open class ListChildModelWithContextFromRepositoryUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId>(repository: IChildModelRepository<Model, *, *, *, ParentId>) : IListChildModelWithContextUseCase<Model, ParentId>

ListModelFromRepositorySuspendUseCase

open class ListModelFromRepositorySuspendUseCase<Model : IModel<*, *, *>>(repository: IModelSuspendRepository<Model, *, *, *>) : ListChildModelFromRepositorySuspendUseCase<Model, Unit> , IListModelSuspendUseCase<Model>

ListModelFromRepositoryUseCase

open class ListModelFromRepositoryUseCase<Model : IModel<*, *, *>>(repository: IModelRepository<Model, *, *, *>) : ListChildModelFromRepositoryUseCase<Model, Unit> , IListModelUseCase<Model>

ListModelWithContextFromRepositorySuspendUseCase

open class ListModelWithContextFromRepositorySuspendUseCase<Model : IModel<*, *, *>>(repository: IModelSuspendRepository<Model, *, *, *>) : ListChildModelWithContextFromRepositorySuspendUseCase<Model, Unit> , IListModelWithContextSuspendUseCase<Model>

ListModelWithContextFromRepositoryUseCase

open class ListModelWithContextFromRepositoryUseCase<Model : IModel<*, *, *>>(repository: IModelRepository<Model, *, *, *>) : ListChildModelWithContextFromRepositoryUseCase<Model, Unit> , IListModelWithContextUseCase<Model>

ListSliceChildModelFromRepositorySuspendUseCase

open class ListSliceChildModelFromRepositorySuspendUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId>(repository: IChildModelSuspendRepository<Model, *, *, *, ParentId>) : IListSliceChildModelSuspendUseCase<Model, ParentId>

ListSliceChildModelFromRepositoryUseCase

open class ListSliceChildModelFromRepositoryUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId>(repository: IChildModelRepository<Model, *, *, *, ParentId>) : IListSliceChildModelUseCase<Model, ParentId>

ListSliceChildModelWithContextFromRepositorySuspendUseCase

open class ListSliceChildModelWithContextFromRepositorySuspendUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId>(repository: IChildModelSuspendRepository<Model, *, *, *, ParentId>) : IListSliceChildModelWithContextSuspendUseCase<Model, ParentId>

ListSliceChildModelWithContextFromRepositoryUseCase

open class ListSliceChildModelWithContextFromRepositoryUseCase<Model : IChildModel<*, *, *, ParentId>, ParentId>(repository: IChildModelRepository<Model, *, *, *, ParentId>) : IListSliceChildModelWithContextUseCase<Model, ParentId>

ListSliceModelFromRepositorySuspendUseCase

open class ListSliceModelFromRepositorySuspendUseCase<Model : IModel<*, *, *>>(repository: IModelSuspendRepository<Model, *, *, *>) : ListSliceChildModelFromRepositorySuspendUseCase<Model, Unit> , IListSliceModelSuspendUseCase<Model>

ListSliceModelFromRepositoryUseCase

open class ListSliceModelFromRepositoryUseCase<Model : IModel<*, *, *>>(repository: IModelRepository<Model, *, *, *>) : ListSliceChildModelFromRepositoryUseCase<Model, Unit> , IListSliceModelUseCase<Model>

ListSliceModelWithContextFromRepositorySuspendUseCase

open class ListSliceModelWithContextFromRepositorySuspendUseCase<Model : IModel<*, *, *>>(repository: IModelSuspendRepository<Model, *, *, *>) : ListSliceChildModelWithContextFromRepositorySuspendUseCase<Model, Unit> , IListSliceModelWithContextSuspendUseCase<Model>

ListSliceModelWithContextFromRepositoryUseCase

open class ListSliceModelWithContextFromRepositoryUseCase<Model : IModel<*, *, *>>(repository: IModelRepository<Model, *, *, *>) : ListSliceChildModelWithContextFromRepositoryUseCase<Model, Unit> , IListSliceModelWithContextUseCase<Model>

UpdateChildModelFromRepositorySuspendUseCase

open class UpdateChildModelFromRepositorySuspendUseCase<Model : IChildModel<Id, *, UpdatePayload, ParentId>, Id, UpdatePayload, ParentId>(repository: IChildModelSuspendRepository<Model, Id, *, UpdatePayload, ParentId>) : IUpdateChildModelSuspendUseCase<Model, Id, UpdatePayload, ParentId>

UpdateChildModelFromRepositoryUseCase

open class UpdateChildModelFromRepositoryUseCase<Model : IChildModel<Id, *, UpdatePayload, ParentId>, Id, UpdatePayload, ParentId>(repository: IChildModelRepository<Model, Id, *, UpdatePayload, ParentId>) : IUpdateChildModelUseCase<Model, Id, UpdatePayload, ParentId>

UpdateChildModelWithContextFromRepositorySuspendUseCase

open class UpdateChildModelWithContextFromRepositorySuspendUseCase<Model : IChildModel<Id, *, UpdatePayload, ParentId>, Id, UpdatePayload, ParentId>(repository: IChildModelSuspendRepository<Model, Id, *, UpdatePayload, ParentId>) : IUpdateChildModelWithContextSuspendUseCase<Model, Id, UpdatePayload, ParentId>

UpdateChildModelWithContextFromRepositoryUseCase

open class UpdateChildModelWithContextFromRepositoryUseCase<Model : IChildModel<Id, *, UpdatePayload, ParentId>, Id, UpdatePayload, ParentId>(repository: IChildModelRepository<Model, Id, *, UpdatePayload, ParentId>) : IUpdateChildModelWithContextUseCase<Model, Id, UpdatePayload, ParentId>

UpdateModelFromRepositorySuspendUseCase

open class UpdateModelFromRepositorySuspendUseCase<Model : IModel<Id, *, UpdatePayload>, Id, UpdatePayload>(repository: IModelSuspendRepository<Model, Id, *, UpdatePayload>) : UpdateChildModelFromRepositorySuspendUseCase<Model, Id, UpdatePayload, Unit> , IUpdateModelSuspendUseCase<Model, Id, UpdatePayload>

UpdateModelFromRepositoryUseCase

open class UpdateModelFromRepositoryUseCase<Model : IModel<Id, *, UpdatePayload>, Id, UpdatePayload>(repository: IModelRepository<Model, Id, *, UpdatePayload>) : UpdateChildModelFromRepositoryUseCase<Model, Id, UpdatePayload, Unit> , IUpdateModelUseCase<Model, Id, UpdatePayload>

UpdateModelWithContextFromRepositorySuspendUseCase

open class UpdateModelWithContextFromRepositorySuspendUseCase<Model : IModel<Id, *, UpdatePayload>, Id, UpdatePayload>(repository: IModelSuspendRepository<Model, Id, *, UpdatePayload>) : UpdateChildModelWithContextFromRepositorySuspendUseCase<Model, Id, UpdatePayload, Unit> , IUpdateModelWithContextSuspendUseCase<Model, Id, UpdatePayload>

UpdateModelWithContextFromRepositoryUseCase

open class UpdateModelWithContextFromRepositoryUseCase<Model : IModel<Id, *, UpdatePayload>, Id, UpdatePayload>(repository: IModelRepository<Model, Id, *, UpdatePayload>) : UpdateChildModelWithContextFromRepositoryUseCase<Model, Id, UpdatePayload, Unit> , IUpdateModelWithContextUseCase<Model, Id, UpdatePayload>