@obisey/nest 0.1.0

package/prototipos/baseResolver.js

@@ -0,0 +1,597 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseResolver = BaseResolver;
+const lodash_1 = require("lodash");
+const keyInterface_1 = require("./utils/keyInterface");
+const formarwhere_1 = require("./utils/formarwhere");
+const chalk = require('chalk');
+const log = console.log;
+var imprimir = (texto) => {
+    log(chalk.green(texto));
+};
+var tiempo = 86400000;
+var isDev = false;
+const redisStore_1 = require("../redisStore");
+const cachear_1 = require("./utils/cachear");
+const paginar_1 = require("./utils/paginar");
+const _ = __importStar(require("lodash"));
+function BaseResolver(modelo) {
+    return class BaseResolver {
+        constructor(cacheManager, receptor = null) {
+            this.cacheManager = cacheManager;
+            this.receptor = receptor;
+        }
+        belongsTo(universo, planeta, IdEmpresa, pagina = null) {
+            // 1
+            return {
+                resolvefield: async (item, where, cacheable, Clase) => this.uno({
+                    universo,
+                    IdEmpresa,
+                    planeta,
+                    item,
+                    cacheable,
+                    where,
+                    Clase,
+                    tipo: 'resolverfield',
+                    relacion: 'belongsTo',
+                }, pagina),
+                query: async (servicio, IdModelo, Clase) => {
+                    imprimir(`${modelo} ${IdModelo} belongsTo query ${planeta}`);
+                    return servicio
+                        .findByPk(IdModelo, pagina)
+                        .then((item) => item.$get(planeta));
+                },
+                ligar: async (servicio, alias, objeto, peticion, borrarSSR = false) => {
+                    console.log({ alias, modelo, planeta, peticion });
+                    return this.eliminarCache([
+                        `${modelo}:${peticion.where.id}`,
+                        `${alias}:${objeto[`Id${(0, lodash_1.capitalize)(alias)}`]}`,
+                    ], borrarSSR) // El único diferente
+                        .then(() => servicio.update({ id: peticion.where.id, ...objeto }, peticion))
+                        .then(() => true);
+                },
+                desligar: async (servicio, alias, IdModelo, IdPlaneta, borrarSSR = false) => this.desligar({
+                    universo,
+                    servicio,
+                    alias,
+                    IdModelo,
+                    IdPlaneta,
+                    tipo: 'belongsTo',
+                    planeta,
+                    borrarSSR,
+                }),
+            };
+        }
+        hasOne(universo, planeta, IdEmpresa, pagina = null) {
+            // 3
+            return {
+                resolvefield: async (item, where, cacheable, Clase) => {
+                    console.log('hasOne');
+                    return this.uno({
+                        universo,
+                        IdEmpresa,
+                        planeta,
+                        item,
+                        cacheable,
+                        where,
+                        Clase,
+                        tipo: 'resolverfield',
+                        relacion: 'hasOne',
+                    }, pagina);
+                },
+                query: async (servicio, IdModelo, Clase) => {
+                    imprimir(`${modelo} ${IdModelo} hasOne query ${planeta}`);
+                    return servicio
+                        .findByPk(IdModelo, pagina)
+                        .then((item) => item.$get(planeta));
+                },
+                ligar: async (servicio, alias, IdModelo, IdPlaneta, through = null, borrarSSR = false) => this.ligar({
+                    universo,
+                    servicio,
+                    alias,
+                    IdModelo,
+                    IdPlaneta,
+                    tipo: 'hasOne',
+                    planeta,
+                    through,
+                    borrarSSR,
+                }),
+                desligar: async (servicio, alias, IdModelo, IdPlaneta, borrarSSR = false) => this.desligar({
+                    universo,
+                    servicio,
+                    alias,
+                    IdModelo,
+                    IdPlaneta,
+                    tipo: 'hasOne',
+                    planeta,
+                    borrarSSR,
+                }),
+            };
+        }
+        hasManyBelongsToMany(universo, planeta, IdEmpresa, pagina = null) {
+            // 2 y 4
+            return {
+                resolvefield: async (item, where, cacheable, Clase) => this.muchos({
+                    universo,
+                    IdEmpresa,
+                    planeta,
+                    item,
+                    cacheable,
+                    where,
+                    Clase,
+                    tipo: 'resolverfield',
+                    relacion: 'hasManyBelongsToMany',
+                }, pagina),
+                query: async (servicio, IdModelo, Clase) => {
+                    imprimir(`${modelo} ${IdModelo} hasManyBelongsToMany query ${planeta}`);
+                    return servicio
+                        .findByPk(IdModelo, pagina)
+                        .then((item) => item.$get(planeta));
+                },
+                ligar: async (servicio, alias, IdModelo, IdPlaneta, through = null, borrarSSR = false) => this.ligar({
+                    universo,
+                    servicio,
+                    alias,
+                    IdModelo,
+                    IdPlaneta,
+                    tipo: 'hasManyBelongsToMany',
+                    planeta,
+                    through,
+                    borrarSSR,
+                }),
+                desligar: async (servicio, alias, IdModelo, IdPlaneta, borrarSSR = false) => this.desligar({
+                    universo,
+                    servicio,
+                    alias,
+                    IdModelo,
+                    IdPlaneta,
+                    tipo: 'hasManyBelongsToMany',
+                    planeta,
+                    borrarSSR,
+                }),
+            };
+        }
+        nodo(universo, planeta, IdEmpresa, pagina = null) {
+            // 7
+            return {
+                resolvefield: async (item, where, cacheable, Clase) => this.muchos({
+                    universo,
+                    IdEmpresa,
+                    planeta,
+                    item,
+                    cacheable,
+                    where,
+                    Clase,
+                    tipo: 'resolverfield',
+                    relacion: 'nodo',
+                }, pagina),
+                query: async (servicio, IdModelo, Clase) => {
+                    imprimir(`${modelo} ${IdModelo} nodo query ${planeta}`);
+                    return servicio
+                        .findByPk(IdModelo, pagina)
+                        .then((item) => item.$get(planeta));
+                },
+                ligar: async (servicio, alias, IdModelo, IdPlaneta, through, borrarSSR = false) => this.ligar({
+                    universo,
+                    servicio,
+                    alias,
+                    IdModelo,
+                    IdPlaneta,
+                    tipo: 'nodo',
+                    planeta,
+                    through,
+                    borrarSSR,
+                }),
+                desligar: async (servicio, alias, IdModelo, IdPlaneta, borrarSSR = false) => this.desligar({
+                    universo,
+                    servicio,
+                    alias,
+                    IdModelo,
+                    IdPlaneta,
+                    tipo: 'nodo',
+                    planeta,
+                    borrarSSR,
+                }),
+            };
+        }
+        especial(universo, planeta, IdEmpresa, pagina = null) {
+            // 5
+            return {
+                resolvefield: async (item, where, cacheable, Clase) => this.uno({
+                    universo,
+                    IdEmpresa,
+                    planeta,
+                    item,
+                    cacheable,
+                    where,
+                    Clase,
+                    tipo: 'resolverfield',
+                    relacion: 'especial',
+                }, pagina),
+                query: async (servicio, IdModelo, Clase) => {
+                    imprimir(`${modelo} ${IdModelo} especial query ${planeta}`);
+                    return servicio
+                        .findByPk(IdModelo, pagina)
+                        .then((item) => item.$get(planeta));
+                },
+                ligar: async (servicio, alias, IdModelo, IdPlaneta, through = null, borrarSSR) => this.ligar({
+                    universo,
+                    servicio,
+                    alias,
+                    IdModelo,
+                    IdPlaneta,
+                    tipo: 'especial',
+                    planeta,
+                    through,
+                    borrarSSR,
+                }),
+                desligar: async (servicio, alias, IdModelo, IdPlaneta, borrarSSR) => this.desligar({
+                    universo,
+                    servicio,
+                    alias,
+                    IdModelo,
+                    IdPlaneta,
+                    tipo: 'especial',
+                    planeta,
+                    borrarSSR,
+                }),
+            };
+        }
+        recursiva(universo, planeta, IdEmpresa, pagina = null) {
+            // 6
+            return {
+                sucesores: async (servicio, item, singular, plural, clase) => this.basesucesores(universo, IdEmpresa, servicio, item, singular, plural, clase),
+                predecesores: async (servicio, item, singular, plural, clase) => this.basepredecesores(universo, IdEmpresa, servicio, item, singular, plural, clase),
+                arbol: async (item, where, cacheable, Clase) => { },
+                preResolvefield: async (item, where, cacheable, Clase) => this.uno({
+                    universo,
+                    IdEmpresa,
+                    planeta,
+                    item,
+                    cacheable,
+                    where,
+                    Clase,
+                    tipo: 'resolverfield',
+                    relacion: 'recursiva',
+                }, pagina),
+                preQuery: async (servicio, IdModelo, Clase) => {
+                    imprimir(`${modelo} ${IdModelo} recursiva query ${planeta}`);
+                    return servicio
+                        .findByPk(IdModelo, pagina)
+                        .then((item) => item.$get(planeta));
+                },
+                subResolvefield: async (item, where, cacheable, Clase) => this.muchos({
+                    universo,
+                    IdEmpresa,
+                    planeta,
+                    item,
+                    cacheable,
+                    where,
+                    Clase,
+                    tipo: 'resolverfield',
+                    relacion: 'recursiva',
+                }, pagina),
+                subQuery: async (servicio, IdModelo, Clase) => {
+                    imprimir(`${modelo} ${IdModelo} recursiva query ${planeta}`);
+                    return servicio
+                        .findByPk(IdModelo, pagina)
+                        .then((item) => item.$get(planeta));
+                },
+                ligar: async (IdModelo, IdPlaneta, borrarSSR) => {
+                    imprimir(`${modelo} ${IdModelo} ligar ligar ${planeta} ${IdPlaneta}`);
+                },
+                desligar: async (IdModelo, IdPlaneta, borrarSSR) => {
+                    imprimir(`${modelo} ${IdModelo} desligar desligar ${planeta} ${IdPlaneta}`);
+                },
+            };
+        }
+        async basesucesores(universo, IdEmpresa, servicio, item, singular, plural, clase) {
+            // console.log('me estoy ejecutando')
+            async function detective(item) {
+                console.log('item', item.nombre);
+                return await item
+                    .$get(`sub${plural}`)
+                    .then(async (items) => Promise.all(items.map(async (item) => await detective(item))))
+                    .then((items) => [...items, item.id]);
+            }
+            try {
+                if (['general', 'ecommerce', 'ecreator'].includes(universo) &&
+                    !IdEmpresa) {
+                    IdEmpresa = await this.receptor.buscarEmpresa();
+                }
+                const key = `${universo ? universo : 'pro'}:${IdEmpresa}:${singular}:${item}`;
+                const exist = await this.cacheManager.store.hexists(key, 'item');
+                console.log('key:', key);
+                if (exist) {
+                    const item = await this.cacheManager.store.hget(key, 'sucesores');
+                    if (item) {
+                        return JSON.parse(item);
+                    }
+                }
+                console.log('exist:', exist);
+                const resultado = await servicio
+                    .findByPk(item)
+                    .then((response) => detective(response))
+                    .then((response) => (0, lodash_1.flattenDeep)(response));
+                this.cacheManager.store.hset(key, 'sucesores', JSON.stringify(resultado));
+                return resultado;
+            }
+            catch (err) {
+                // console.log({ err });
+            }
+        }
+        async basepredecesores(universo, IdEmpresa, servicio, item, singular, plural, clase) {
+            async function detective(item, array) {
+                item && array.push(item.id);
+                return !_.isNull(item)
+                    ? await item
+                        .$get(`pre${modelo}`)
+                        .then((response) => detective(response, array))
+                    : array;
+            }
+            try {
+                if (['general', 'ecommerce', 'ecreator'].includes(universo) &&
+                    !IdEmpresa) {
+                    IdEmpresa = await this.receptor.buscarEmpresa();
+                }
+                const key = `${universo ? universo : 'pro'}:${IdEmpresa}:${singular}:${item}`;
+                const exist = await this.cacheManager.store.hexists(key, 'item');
+                if (exist) {
+                    const item = await this.cacheManager.store.hget(key, 'predecesores');
+                    if (item) {
+                        return JSON.parse(item);
+                    }
+                }
+                const resultado = await servicio
+                    .findByPk(item)
+                    .then((response) => detective(response, []))
+                    .then((response) => (0, lodash_1.flattenDeep)(response));
+                this.cacheManager.store.hset(key, 'predecesores', JSON.stringify(resultado));
+                return resultado;
+            }
+            catch (err) {
+                console.log({ err });
+            }
+        }
+        async uno({ universo, IdEmpresa, planeta, item, cacheable, where, Clase, tipo, relacion, }, pagina = null) {
+            let tiempo;
+            // if (isDev) tiempo = moment();
+            try {
+                if (['general', 'ecommerce', 'ecreator'].includes(universo) &&
+                    !IdEmpresa) {
+                    IdEmpresa = await this.receptor.buscarEmpresa();
+                }
+                let nkey = `${universo ? universo : 'pro'}:${IdEmpresa}:${modelo}:${item.id}`;
+                const { resultado, cache } = await (0, cachear_1.cachear)(cacheable, this.cacheManager, (0, keyInterface_1.transformarKey)({
+                    universo,
+                    IdEmpresa,
+                    tipo,
+                    fragmentos: [
+                        { nombre: modelo, id: item.id },
+                        { nombre: planeta },
+                    ],
+                }), (cache) => Promise.resolve(new Clase(JSON.parse(cache))), //Revisar
+                (resultado) => Promise.resolve(resultado ? resultado.get({ plain: true }) : null), //transformar
+                () => item.$get(planeta, { where: (0, formarwhere_1.formarWhere)(where) }), //Pedir
+                () => new Promise(async (resolve) => {
+                    try {
+                        let e = await this.cacheManager.store.hexists(nkey, planeta);
+                        if (e) {
+                            let id = await this.cacheManager.store.hget(nkey, planeta);
+                            let key = `${universo ? universo : 'pro'}:${IdEmpresa}:${planeta}:${id}`;
+                            const exist = await this.cacheManager.store.hexists(key, 'item');
+                            if (exist) {
+                                let item = await this.cacheManager.store.hget(key, 'item');
+                                resolve(item);
+                            }
+                            else {
+                                resolve(undefined);
+                            }
+                        }
+                        else {
+                            return resolve(undefined);
+                        }
+                    }
+                    catch (err) {
+                        console.log(this.cacheManager);
+                    }
+                }), //observar
+                (__, resultado) => {
+                    if (resultado)
+                        this.cacheManager.store.hset(`${universo ? universo : 'pro'}:${IdEmpresa}:${planeta}:${resultado.id}`, 'item', JSON.stringify(resultado));
+                    return this.cacheManager.store.hset(nkey, planeta, resultado ? JSON.stringify(resultado.id) : null);
+                });
+                if (resultado)
+                    await (0, paginar_1.paginar)(this.cacheManager, IdEmpresa, pagina, planeta, resultado.get({ plain: true }));
+                if (isDev)
+                    console.log(
+                    // moment().diff(moment(tiempo), 'milliseconds', true),
+                    'uno', cache);
+                return resultado;
+            }
+            catch (err) {
+                console.log(err);
+                log(chalk.red('uno', { modelo, err }, '***********'));
+            }
+        }
+        async muchos({ universo, IdEmpresa, planeta, item, cacheable, where, Clase, tipo, relacion, }, pagina = null) {
+            let tiempo;
+            // if (isDev) tiempo = moment();
+            try {
+                if (['general', 'ecommerce', 'ecreator'].includes(universo) &&
+                    !IdEmpresa) {
+                    IdEmpresa = await this.receptor.buscarEmpresa();
+                }
+                let nkey = `${universo ? universo : 'pro'}:${IdEmpresa}:${modelo}:${item.id}`;
+                let pkey = (id) => `${universo ? universo : 'pro'}:${IdEmpresa}:${planeta}:${id}`;
+                const { resultado, cache } = await (0, cachear_1.cachear)(cacheable, this.cacheManager, (0, keyInterface_1.transformarKey)({
+                    universo,
+                    IdEmpresa,
+                    tipo,
+                    fragmentos: [
+                        { nombre: modelo, id: item.id },
+                        { nombre: planeta },
+                    ],
+                }), (cache) => Promise.resolve(cache.map((n) => new Clase(JSON.parse(n)))), //Revisar
+                (resultado) => Promise.resolve(resultado.map((n) => n.get({ plain: true }))), //transformar
+                () => item.$get(planeta, { where: (0, formarwhere_1.formarWhere)(where) }), //Pedir
+                () => new Promise(async (resolve) => {
+                    try {
+                        let e = await this.cacheManager.store.hexists(nkey, planeta);
+                        if (e) {
+                            let ids = await this.cacheManager.store.hget(nkey, planeta);
+                            if (ids) {
+                                Promise.all(JSON.parse(ids).map((id) => this.cacheManager.store.hexists(pkey(id), 'item'))).then((exists) => {
+                                    if (!exists.includes(0)) {
+                                        Promise.all(JSON.parse(ids).map(async (id) => await this.cacheManager.store.hget(pkey(id), 'item'))).then(resolve);
+                                    }
+                                    else
+                                        resolve(undefined);
+                                });
+                            }
+                            else
+                                resolve(undefined);
+                        }
+                        else
+                            resolve(undefined);
+                    }
+                    catch (err) {
+                        console.log({ err });
+                    }
+                }), //observar
+                (__, resultado) => {
+                    return Promise.all(resultado.map((n) => this.cacheManager.store.hset(pkey(n.id), 'item', JSON.stringify(n)))).then(() => this.cacheManager.store.hset(nkey, planeta, JSON.stringify(resultado.map((n) => n.id))));
+                });
+                await (0, paginar_1.paginar)(this.cacheManager, IdEmpresa, pagina, planeta, resultado.map((n) => n.get({ plain: true })));
+                if (isDev)
+                    console.log(
+                    // moment().diff(moment(tiempo), 'milliseconds', true),
+                    'muchos', cache);
+                return resultado ? resultado : [];
+            }
+            catch (err) {
+                console.log(err);
+                log(chalk.red('muchos', { modelo, err }, '***********'));
+            }
+        }
+        async ligar({ universo, servicio, alias, IdPlaneta, IdModelo, tipo, planeta, through, borrarSSR, }) {
+            let IdEmpresa = null;
+            if (['general', 'ecommerce', 'ecreator'].includes(universo) &&
+                !IdEmpresa) {
+                IdEmpresa = await this.receptor.buscarEmpresa();
+            }
+            let crearKey = (planeta, id) => [
+                `${universo ? universo : 'pro'}:${IdEmpresa}:${planeta}:${id}`,
+                `${universo ? universo : 'pro'}:${IdEmpresa}:${planeta}:paginacion`,
+            ];
+            // debugger
+            return this.eliminarCache([
+                ...crearKey(modelo, IdModelo),
+                ...crearKey(planeta, IdPlaneta),
+            ], borrarSSR)
+                .then(() => servicio.findByPk(IdModelo))
+                .then((item) => {
+                return item.$add(alias, IdPlaneta, through ? { through } : null);
+            })
+                .then((response) => true)
+                .catch((err) => {
+                log(chalk.red('ligar', alias, err, '***********'));
+                return false;
+            });
+        }
+        async desligar({ universo, servicio, alias, IdPlaneta, IdModelo, tipo, planeta, borrarSSR, }) {
+            let IdEmpresa = null;
+            if (['general', 'ecommerce', 'ecreator'].includes(universo) &&
+                !IdEmpresa) {
+                IdEmpresa = await this.receptor.buscarEmpresa();
+            }
+            let crearKey = (planeta, id) => [
+                `${universo ? universo : 'pro'}:${IdEmpresa}:${planeta}:${id}`,
+                `${universo ? universo : 'pro'}:${IdEmpresa}:${planeta}:paginacion`,
+            ];
+            console.log('simoooon');
+            imprimir(`${modelo} ${IdModelo} ${tipo} desligar ${planeta} ${IdPlaneta}`);
+            return this.eliminarCache([
+                ...crearKey(modelo, IdModelo),
+                ...crearKey(planeta, IdPlaneta),
+            ], borrarSSR)
+                .then(() => servicio.findByPk(IdModelo))
+                .then((item) => item.$remove(alias, IdPlaneta))
+                .then(() => true)
+                .catch((err) => {
+                log(chalk.red('desligar', alias, err, '***********'));
+                return false;
+            });
+        }
+        async eliminarCache(items, borrarSSR = false) {
+            if (borrarSSR)
+                redisStore_1.clientSsr.flushdb();
+            log(chalk.red('SE ELIMINOOOO ALGOOO!!!!!!!!!!!!!!', items, borrarSSR));
+            return Promise.all(items.map(async (item) => this.cacheManager
+                .keys(`*${item}*`)
+                .then((keys) => Promise.all(keys.map((key) => this.cacheManager.del(key))))));
+        }
+        async arbol(universo, IdEmpresa, planeta, servicio, Clase, subnombre, IdPlaneta) {
+            if (['general', 'ecommerce', 'ecreator'].includes(universo) &&
+                !IdEmpresa) {
+                IdEmpresa = await this.receptor.buscarEmpresa();
+            }
+            const KEY = `${universo ?? 'pro'}:${IdEmpresa}:arbol:${subnombre.replace('sub', '')}`;
+            const cache = await this.cacheManager.get(KEY);
+            if (cache) {
+                const data = JSON.parse(cache);
+                if (Array.isArray(data)) {
+                    return data.map((item) => new Clase(item));
+                }
+            }
+            // let resultado;
+            const resultado = await servicio.findAll({
+                where: {
+                    [IdPlaneta]: null,
+                },
+                // include: [
+                // 	{
+                // 		model: Clase,
+                // 		as: subnombre,
+                // 		nested: true,
+                // 	},
+                // ],
+            });
+            await this.cacheManager.set(KEY, JSON.stringify(resultado));
+            return resultado;
+        }
+    };
+}

package/prototipos/baseService.d.ts

@@ -0,0 +1,93 @@
+import { Key } from './utils/keyInterface';
+export declare const redis_on = true;
+type Ctor = new (...a: any[]) => any;
+interface Peticion {
+    value: any;
+    key: Key;
+    Clase: Ctor;
+    repository: any;
+    options?: any;
+    pagina?: any;
+    cacheable?: boolean;
+    borrarSSR?: boolean;
+}
+export declare function BaseService(modelo: string): {
+    new <T extends {
+        cacheManager: any;
+        receptor: any;
+        buscarXid<Ctor>({ value: { id, cacheable }, key, Clase, repository, pagina, }: Peticion): Promise<Ctor>;
+        buscarTodos<Ctor>({ value, key, Clase, repository, pagina, cacheable, }: Peticion): Promise<Ctor[]>;
+        crear<Ctor>({ value, key, Clase, repository, borrarSSR, }: Peticion): Promise<Ctor>;
+        contar({ value, repository, key }: {
+            value: any;
+            repository: any;
+            key: any;
+        }): Promise<unknown>;
+        actualizar({ value, options, key, Clase, repository, borrarSSR, }: {
+            value: any;
+            options: any;
+            key: any;
+            Clase: any;
+            repository: any;
+            borrarSSR?: any;
+        }): Promise<unknown>;
+        reescribir({ value, options, repository }: {
+            value: any;
+            options: any;
+            repository: any;
+        }): Promise<unknown>;
+        destruir({ value, repository, borrarSSR, }: {
+            value: any;
+            repository: any;
+            borrarSSR?: any;
+        }): Promise<unknown>;
+        buscaryContar<Ctor>({ value, key, Clase, repository, pagina, }: Peticion): Promise<{
+            count: number;
+            rows: Ctor[];
+        }>;
+        buscarOcrear<Ctor>({ value, repository }: {
+            value: any;
+            repository: any;
+        }): Promise<Ctor>;
+        eliminarCache(items: string[], borrarSSR?: boolean): Promise<any[]>;
+    }>(cacheManager: any, receptor?: any): {
+        cacheManager: any;
+        receptor: any;
+        buscarXid<Ctor>({ value: { id, cacheable }, key, Clase, repository, pagina, }: Peticion): Promise<Ctor>;
+        buscarTodos<Ctor>({ value, key, Clase, repository, pagina, cacheable, }: Peticion): Promise<Ctor[]>;
+        crear<Ctor>({ value, key, Clase, repository, borrarSSR, }: Peticion): Promise<Ctor>;
+        contar({ value, repository, key }: {
+            value: any;
+            repository: any;
+            key: any;
+        }): Promise<unknown>;
+        actualizar({ value, options, key, Clase, repository, borrarSSR, }: {
+            value: any;
+            options: any;
+            key: any;
+            Clase: any;
+            repository: any;
+            borrarSSR?: any;
+        }): Promise<unknown>;
+        reescribir({ value, options, repository }: {
+            value: any;
+            options: any;
+            repository: any;
+        }): Promise<unknown>;
+        destruir({ value, repository, borrarSSR, }: {
+            value: any;
+            repository: any;
+            borrarSSR?: any;
+        }): Promise<unknown>;
+        buscaryContar<Ctor>({ value, key, Clase, repository, pagina, }: Peticion): Promise<{
+            count: number;
+            rows: Ctor[];
+        }>;
+        buscarOcrear<Ctor>({ value, repository }: {
+            value: any;
+            repository: any;
+        }): Promise<Ctor>;
+        eliminarCache(items: string[], borrarSSR?: boolean): Promise<any[]>;
+    };
+};
+export {};