import { Model, ModelAggregate, PaginationListing } from "@mongez/monpulse";
import { GenericObject } from "@mongez/reinforcements";
import { CacheDriver } from "../cache";
import { BaseRepositoryManager } from "./base-repository-manager";
import { RepositoryListing } from "./repository-listing";
import { RepositoryManager } from "./repository-manager";
import { CachedRepositoryOptions, FilterByOptions, RepositoryOptions } from "./types";
export declare abstract class RepositoryListManager<T extends Model, M extends typeof Model = typeof Model> extends BaseRepositoryManager<T, M> {
    /**
     * List default options
     */
    protected defaultOptions: RepositoryOptions;
    /**
     * Default filters list
     */
    protected defaultFilters: FilterByOptions;
    /**
     * Filter By options
     */
    protected filterBy: FilterByOptions;
    /**
     * List of repositories that should clear its cache when this repository is created, updated or deleted
     */
    protected clearCacheOnUpdate: RepositoryManager<any>[];
    /**
     * Whether to enable caching
     */
    isCacheable: boolean;
    /**
     * Cache driver
     */
    protected cacheDriver: CacheDriver<any, any>;
    /**
     * Set the cache driver name
     * If set, then it will be used instead of the default value in this.cacheDriver
     */
    protected cacheDriverName: string;
    /**
     * Constructor
     */
    constructor();
    /**
     * Set cache driver
     */
    setCacheDriver(driver: CacheDriver<any, any>): this;
    /**
     * Get cache driver
     */
    getCacheDriver(): CacheDriver<any, any>;
    /**
     * List All records
     */
    all(options?: Omit<RepositoryOptions, "paginate">): Promise<T[]>;
    /**
     * Get all cached data
     */
    allCached(options?: Omit<RepositoryOptions, "paginate">): Promise<T[]>;
    /**
     * List All Active records
     */
    allActive(options?: Omit<RepositoryOptions, "paginate">): Promise<T[]>;
    /**
     * List all active cached records
     */
    allActiveCached(options?: Omit<RepositoryOptions, "paginate">): Promise<T[]>;
    /**
     * Prepare  cache
     */
    prepareCache(): Promise<void>;
    /**
     * Cache the given model
     */
    cacheModel(model: T): Promise<void>;
    /**
     * Clear the entire cache
     */
    clearCache(): Promise<void>;
    /**
     * Before listing
     * Called before listing records
     */
    beforeListing(_query: ModelAggregate<T>, _options: RepositoryOptions): Promise<void>;
    /**
     * On list
     * Called after listing records
     */
    onList(records: T[]): Promise<T[]>;
    /**
     * Merge default options with the given options
     */
    protected withDefaultOptions(options: RepositoryOptions): {
        [x: string]: any;
        defaultLimit?: number;
        paginate?: boolean;
        limit?: number;
        page?: number;
        select?: string[];
        deselect?: string[];
        purgeCache?: boolean;
        orderBy?: string | [string, "asc" | "desc"] | {
            [key: string]: "asc" | "desc";
        };
        perform?: (query: ModelAggregate<any>, options: RepositoryOptions) => void;
    };
    /**
     * Add default filters along side with the given filters
     */
    withDefaultFilters(filters?: FilterByOptions): {
        [x: string]: any;
    };
    /**
     * Get new query
     */
    newQuery(): ModelAggregate<T>;
    /**
     * An alias to newQuery
     */
    get query(): ModelAggregate<T>;
    /**
     * Get cached model
     */
    getCachedModel(id: number): Promise<any>;
    /**
     * Get cached model by the given column
     */
    getCachedModelBy(column: string, value: any, cacheKeyOptions?: GenericObject): Promise<any>;
    /**
     * Get cached model data
     */
    getCached(id: string | number): Promise<T>;
    /**
     * Get active cached model
     */
    getActiveCached(id: string | number): Promise<T>;
    /**
     * Generate cache key
     */
    cacheKey(key: string, moreOptions?: GenericObject): string;
    /**
     * Get cached data by the given column
     */
    getCachedBy(column: string, value: any, cacheKeyOptions?: GenericObject): Promise<T>;
    /**
     * Get and cached value by id then purge it from cache
     */
    getCachedPurge(id: number): Promise<T>;
    /**
     * Get and cached by the given column then purge it from cache
     */
    getCachedByPurge(column: string, value: any): Promise<T>;
    /**
     * List records
     */
    list(options?: RepositoryOptions): Promise<{
        documents: T[];
        paginationInfo: PaginationListing<T_1>;
    }>;
    /**
     * Find latest records
     */
    latest(options?: RepositoryOptions): Promise<{
        documents: T[];
        paginationInfo: PaginationListing<T_1>;
    }>;
    /**
     * Get latest and active records
     */
    latestActive(options?: RepositoryOptions): Promise<{
        documents: T[];
        paginationInfo: PaginationListing<T_1>;
    }>;
    /**
     * Get oldest records
     */
    oldest(options?: RepositoryOptions): Promise<{
        documents: T[];
        paginationInfo: PaginationListing<T_1>;
    }>;
    /**
     * Get oldest and active records
     */
    oldestActive(options?: RepositoryOptions): Promise<{
        documents: T[];
        paginationInfo: PaginationListing<T_1>;
    }>;
    /**
     * List cached records
     */
    listCached(options?: CachedRepositoryOptions): Promise<{
        documents: T[];
        paginationInfo: PaginationListing<T_1>;
    }>;
    /**
     * Fetch cached records or cache new ones
     */
    cacheList({ key, options, purge, expiresAfter, }: {
        key?: string;
        purge?: boolean;
        expiresAfter?: number;
        options?: CachedRepositoryOptions;
    }): Promise<{
        documents: T[];
        paginationInfo: PaginationListing<T_1>;
    }>;
    /**
     * Fetch cached records or cache new ones
     */
    cacheAll({ key, options, expiresAfter, purge, }: {
        key?: string;
        purge?: boolean;
        expiresAfter?: number;
        options?: CachedRepositoryOptions;
    }): Promise<T[]>;
    /**
     * Get new repository listing instance
     */
    newList(options?: RepositoryOptions): RepositoryListing<T, M>;
    /**
     * Map the given documents into models
     */
    mapModels(documents: any[]): T[];
    /**
     * Count total records based on the given options
     */
    count(options?: RepositoryOptions): Promise<any>;
    /**
     * Count total active records
     */
    countActive(options?: RepositoryOptions): Promise<any>;
    /**
     * Get total records based on the given options and cache it
     */
    countCached(options?: RepositoryOptions): Promise<any>;
    /**
     * Count active records and cache it
     */
    countActiveCached(options?: RepositoryOptions): Promise<any>;
    /**
     * Cache the given key and value
     */
    protected cache(key: string, value: any): Promise<any>;
    /**
     * List active cached records
     */
    listActiveCached(options?: CachedRepositoryOptions): Promise<{
        documents: T[];
        paginationInfo: PaginationListing<T_1>;
    }>;
    /**
     * List active records
     */
    listActive(options?: RepositoryOptions): Promise<{
        documents: T[];
        paginationInfo: PaginationListing<T_1>;
    }>;
    /**
     * Chunk records
     */
    chunk(options: RepositoryOptions, callback: (documents: T[], paginationInfo: PaginationListing<T>["paginationInfo"]) => Promise<false | any>): Promise<any>;
    /**
     * Chunk active records
     */
    chunkActive(options: RepositoryOptions, callback: (documents: T[], paginationInfo: PaginationListing<T>["paginationInfo"]) => Promise<false | any>): Promise<any>;
    /**
     * Get active record
     */
    getActive(id: number | string, options?: RepositoryOptions): Promise<T>;
    /**
     * Get single record by id
     */
    get(id: number, options?: RepositoryOptions): Promise<T>;
    /**
     * Get owned record
     */
    getOwned(userId: number, id: number, column?: string): Promise<T>;
    /**
     * Get owned records
     */
    listOwned(userId: number, options?: RepositoryOptions, column?: string): Promise<{
        documents: T[];
        paginationInfo: PaginationListing<T_1>;
    }>;
    /**
     * Get owned active records
     */
    listOwnedActive(userId: number, options?: RepositoryOptions, column?: string): Promise<{
        documents: T[];
        paginationInfo: PaginationListing<T_1>;
    }>;
    /**
     * Get first record
     */
    first(options?: RepositoryOptions): Promise<T>;
    /**
     * Get first cached record
     */
    firstCached(options?: RepositoryOptions): Promise<T>;
    /**
     * Get first active record
     */
    firstActive(options?: RepositoryOptions): Promise<T>;
    /**
     * Get first active cached record
     */
    firstActiveCached(options?: RepositoryOptions): Promise<T>;
    /**
     * Get last record
     */
    last(options?: RepositoryOptions): Promise<T>;
    /**
     * Get last cached record
     */
    lastCached(options?: RepositoryOptions): Promise<T>;
    /**
     * Get last active record
     */
    lastActive(options?: RepositoryOptions): Promise<T>;
    /**
     * Get last active cached record
     */
    lastActiveCached(options?: RepositoryOptions): Promise<T>;
    /**
     * Make filter
     */
    filter(_query: ModelAggregate<T>, _options: RepositoryOptions): Promise<void>;
    /**
     * {@inheritdoc}
     */
    orderBy(_options: RepositoryOptions): any;
    /**
     * Find By id
     */
    find(id: string | number | T): Promise<T>;
    /**
     * Find active document
     */
    findActive(id: string | number | T): Promise<T>;
    /**
     * Find by the given column
     */
    findBy(column: string, value: any): Promise<T>;
    /**
     * Find by the given column and make sure it is active
     */
    findByActive(column: string, value: any): Promise<T>;
    /**
     * Find by the given column and cache it
     * @alias getCached
     */
    findCached(id: number | string | T): Promise<string | number | T>;
    /**
     * Find by the given column and cache it
     * @alias getCachedBy
     */
    findByCached(column: string, value: any): Promise<T>;
}
//# sourceMappingURL=repository-list-manager.d.ts.map