@arcaelas/dynamite 1.0.17 → 1.0.18

package/src/utils/relations.d.ts

@@ -1,17 +1,39 @@
 /**
  * @file relations.ts
- * @descripcion Sistema de relaciones optimizado
+ * @description Sistema de carga de relaciones con batch loading
  * @autor Miguel Alejandro
  * @fecha 2025-01-28
  */
-/** Decorador @hasMany para relaciones 1:N */
-export declare const hasMany: (targetModel: () => any, foreignKey: string, localKey?: string) => (target: any, propertyKey: string) => void;
-/** Decorador @belongsTo para relaciones N:1 */
-export declare const belongsTo: (targetModel: () => any, localKey: string, foreignKey?: string) => (target: any, propertyKey: string) => void;
-/** Procesamiento optimizado de includes con batch loading transparente */
-export declare const processIncludes: (Model: any, items: any[], include: Record<string, any>, depth?: number) => Promise<any[]>;
-/** Separar opciones de query e include */
-export declare const separateQueryOptions: (options: Record<string, any>) => {
-    queryOptions: Record<string, any>;
-    includeOptions: Record<string, any> | undefined;
-};
+/**
+ * @description Opciones para include de relaciones
+ */
+interface IncludeOptions {
+    where?: Record<string, any>;
+    limit?: number;
+    offset?: number;
+    order?: 'asc' | 'desc';
+    include?: Record<string, IncludeOptions | boolean>;
+}
+/**
+ * @description Procesa includes recursivamente para cargar relaciones
+ * @param items Array de instancias a poblar
+ * @param include Objeto con relaciones a incluir
+ * @param TableClass Clase de la tabla actual
+ * @param depth Profundidad actual (máximo 10)
+ * @returns Items con relaciones pobladas
+ * @example
+ * ```typescript
+ * // Uso interno en Table.where()
+ * await processIncludes(users, {
+ *   posts: {
+ *     where: { published: true },
+ *     limit: 5,
+ *     include: {
+ *       comments: true
+ *     }
+ *   }
+ * }, User);
+ * ```
+ */
+export declare const processIncludes: (items: any[], include: Record<string, IncludeOptions | boolean>, TableClass: any, depth?: number) => Promise<any[]>;
+export {};

package/src/utils/relations.js

@@ -1,165 +1,141 @@
 "use strict";
 /**
  * @file relations.ts
- * @descripcion Sistema de relaciones optimizado
+ * @description Sistema de carga de relaciones con batch loading
  * @autor Miguel Alejandro
  * @fecha 2025-01-28
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.separateQueryOptions = exports.processIncludes = exports.belongsTo = exports.hasMany = void 0;
-const wrapper_1 = require("../core/wrapper");
-const naming_1 = require("./naming");
-// =============================================================================
-// DECORATORS
-// =============================================================================
-/** Decorador @hasMany para relaciones 1:N */
-const hasMany = (targetModel, foreignKey, localKey = "id") => (target, propertyKey) => {
-    (0, wrapper_1.ensureConfig)(target.constructor, (0, naming_1.toSnakePlural)(target.constructor.name)).relations.set(propertyKey, {
-        type: "hasMany",
-        targetModel,
-        foreignKey,
-        localKey,
-    });
-    Object.defineProperty(target, propertyKey, {
-        get() {
-            const cached = this[`_${propertyKey}`];
-            return cached !== undefined
-                ? cached
-                : (console.warn(`Relación ${propertyKey} no cargada. Use includes en la consulta.`),
-                    []);
-        },
-        configurable: true,
-        enumerable: false,
-    });
-};
-exports.hasMany = hasMany;
-/** Decorador @belongsTo para relaciones N:1 */
-const belongsTo = (targetModel, localKey, foreignKey = "id") => (target, propertyKey) => {
-    (0, wrapper_1.ensureConfig)(target.constructor, (0, naming_1.toSnakePlural)(target.constructor.name)).relations.set(propertyKey, {
-        type: "belongsTo",
-        targetModel,
-        localKey,
-        foreignKey,
-    });
-    Object.defineProperty(target, propertyKey, {
-        get() {
-            const cached = this[`_${propertyKey}`];
-            return cached !== undefined
-                ? cached
-                : (console.warn(`Relación ${propertyKey} no cargada. Use includes en la consulta.`),
-                    null);
-        },
-        configurable: true,
-        enumerable: false,
-    });
-};
-exports.belongsTo = belongsTo;
-// =============================================================================
-// FUNCTIONS
-// =============================================================================
-/** Batch loading para relaciones hasMany */
-const batchLoadHasMany = async (Model, items, relation, options = {}) => {
-    const { targetModel, foreignKey, localKey = "id" } = relation;
-    const parent_keys = items.map((item) => item[localKey]).filter(Boolean);
-    if (!parent_keys.length)
+exports.processIncludes = void 0;
+const decorator_1 = require("../core/decorator");
+/**
+ * @description Batch load para HasMany/HasOne
+ * Obtiene items relacionados donde foreignKey IN parent_ids
+ */
+const batchLoadHasMany = async (items, relation, options = {}) => {
+    const parent_ids = items.map(i => i[relation.localKey]).filter(Boolean);
+    if (!parent_ids.length)
         return new Map();
-    // Build query with relation options
-    let query = targetModel().where(foreignKey, "in", parent_keys);
-    // Apply additional filters if specified
+    // Obtener clase del modelo relacionado
+    const RelatedModel = relation.model();
+    // Query básico
+    let related = await RelatedModel.where(relation.foreignKey, 'in', parent_ids);
+    // Aplicar filtros adicionales
     if (options.where) {
-        const additionalFilters = Object.entries(options.where);
-        for (const [key, value] of additionalFilters) {
-            const currentResults = await query;
-            query = Promise.resolve(currentResults.filter((item) => item[key] === value));
-        }
+        related = related.filter((item) => Object.entries(options.where).every(([k, v]) => item[k] === v));
     }
-    const related_items = await query;
-    // TODO: Apply attributes selection
-    // For now, skip attributes filtering to ensure basic relations work
-    let processedItems = related_items;
-    // Apply other options like limit, order
-    let filteredItems = processedItems;
-    if (options.order === "DESC") {
-        filteredItems.sort((a, b) => b.id.localeCompare(a.id));
+    // Ordenar
+    if (options.order) {
+        related.sort((a, b) => {
+            const aId = String(a.id ?? '');
+            const bId = String(b.id ?? '');
+            return options.order === 'asc' ? aId.localeCompare(bId) : bId.localeCompare(aId);
+        });
     }
-    else if (options.order === "ASC") {
-        filteredItems.sort((a, b) => a.id.localeCompare(b.id));
+    // Agrupar por foreignKey
+    const grouped = new Map();
+    for (const item of related) {
+        const key = String(item[relation.foreignKey]);
+        if (!grouped.has(key))
+            grouped.set(key, []);
+        grouped.get(key).push(item);
     }
+    // Aplicar limit por grupo
     if (options.limit) {
-        filteredItems = filteredItems.slice(0, options.limit);
+        for (const [key, groupItems] of grouped) {
+            grouped.set(key, groupItems.slice(options.offset ?? 0, (options.offset ?? 0) + options.limit));
+        }
     }
-    const grouped = new Map();
-    filteredItems.forEach((item) => {
-        const key = item[foreignKey];
-        grouped.has(key) ? grouped.get(key).push(item) : grouped.set(key, [item]);
-    });
     return grouped;
 };
-/** Batch loading para relaciones belongsTo */
-const batchLoadBelongsTo = async (Model, items, relation, options = {}) => {
-    const { targetModel, localKey, foreignKey = "id" } = relation;
-    // Para BelongsTo: obtener valores de localKey (ej: category_id) de los items
-    const keys = items
-        .map((item) => (localKey ? item[localKey] : null))
-        .filter(Boolean);
-    if (!keys.length)
+/**
+ * @description Batch load para BelongsTo
+ * Obtiene items donde id IN local_keys
+ */
+const batchLoadBelongsTo = async (items, relation, _options = {}) => {
+    const local_keys = items.map(i => i[relation.localKey]).filter(Boolean);
+    if (!local_keys.length)
         return new Map();
-    // Buscar en targetModel donde foreignKey (ej: id) esté en los keys
-    const fetched_items = await targetModel().where(foreignKey, "in", keys);
-    // TODO: Apply attributes selection
-    // For now, skip attributes filtering to ensure basic relations work
-    let processedItems = fetched_items;
-    const results = new Map();
-    // Mapear por foreignKey para que coincida con localKey de los items
-    processedItems.forEach((item) => results.set(item[foreignKey], item));
-    return results;
+    const RelatedModel = relation.model();
+    const related = await RelatedModel.where(relation.foreignKey, 'in', local_keys);
+    const result = new Map();
+    for (const item of related) {
+        result.set(String(item[relation.foreignKey]), item);
+    }
+    return result;
 };
-/** Procesamiento optimizado de includes con batch loading transparente */
-const processIncludes = async (Model, items, include, depth = 0) => {
+/**
+ * @description Procesa includes recursivamente para cargar relaciones
+ * @param items Array de instancias a poblar
+ * @param include Objeto con relaciones a incluir
+ * @param TableClass Clase de la tabla actual
+ * @param depth Profundidad actual (máximo 10)
+ * @returns Items con relaciones pobladas
+ * @example
+ * ```typescript
+ * // Uso interno en Table.where()
+ * await processIncludes(users, {
+ *   posts: {
+ *     where: { published: true },
+ *     limit: 5,
+ *     include: {
+ *       comments: true
+ *     }
+ *   }
+ * }, User);
+ * ```
+ */
+const processIncludes = async (items, include, TableClass, depth = 0) => {
     if (!include || depth > 10 || !items.length)
         return items;
-    const meta = (0, wrapper_1.mustMeta)(Model);
-    const relation_promises = Object.entries(include).map(async ([relation_key, relation_options]) => {
-        const relation = meta.relations.get(relation_key);
-        if (!relation)
+    const schema = TableClass[decorator_1.SCHEMA];
+    if (!schema)
+        return items;
+    const promises = Object.entries(include).map(async ([relation_key, options]) => {
+        const column = schema.columns[relation_key];
+        if (!column?.store?.relation)
             return;
-        const related_data = relation.type === "hasMany"
-            ? await batchLoadHasMany(Model, items, relation, relation_options)
-            : await batchLoadBelongsTo(Model, items, relation, relation_options);
-        items.forEach((item) => {
-            let key;
-            if (relation.type === "hasMany") {
-                // Para HasMany: usar localKey (ej: "id") del item actual
-                key = item[relation.localKey || "id"];
-            }
-            else {
-                // Para BelongsTo: usar localKey (ej: "category_id") del item actual
-                key = relation.localKey ? item[relation.localKey] : null;
+        const relation = column.store.relation;
+        const opts = typeof options === 'boolean' ? {} : options;
+        // Batch load según tipo
+        let data;
+        if (relation.type === 'HasMany') {
+            data = await batchLoadHasMany(items, relation, opts);
+        }
+        else if (relation.type === 'HasOne') {
+            const hasMany = await batchLoadHasMany(items, relation, { ...opts, limit: 1 });
+            data = new Map();
+            for (const [k, v] of hasMany) {
+                data.set(k, v[0] ?? null);
             }
-            const related = related_data.get(key);
-            // Usar una propiedad temporal para evitar conflictos con getters
+        }
+        else {
+            // BelongsTo
+            data = await batchLoadBelongsTo(items, relation, opts);
+        }
+        // Asignar datos relacionados a cada item
+        for (const item of items) {
+            const key = String(item[relation.localKey]);
+            const value = relation.type === 'HasMany'
+                ? data.get(key) ?? []
+                : data.get(key) ?? null;
             Object.defineProperty(item, relation_key, {
-                value: relation.type === "hasMany" ? related || [] : related || null,
+                value,
                 writable: true,
                 enumerable: true,
-                configurable: true,
+                configurable: true
             });
-        });
-        if (relation_options?.include && related_data.size) {
-            const all_related = Array.from(related_data.values())
-                .flat()
-                .filter(Boolean);
-            await (0, exports.processIncludes)(relation.targetModel(), all_related, relation_options.include, depth + 1);
+        }
+        // Recursión para includes anidados
+        if (opts.include && data.size) {
+            const all_related = Array.from(data.values()).flat().filter(Boolean);
+            if (all_related.length) {
+                await (0, exports.processIncludes)(all_related, opts.include, relation.model(), depth + 1);
+            }
         }
     });
-    await Promise.all(relation_promises);
+    await Promise.all(promises);
     return items;
 };
 exports.processIncludes = processIncludes;
-/** Separar opciones de query e include */
-const separateQueryOptions = (options) => {
-    const { include, ...queryOptions } = options;
-    return { queryOptions, includeOptions: include };
-};
-exports.separateQueryOptions = separateQueryOptions;
 //# sourceMappingURL=relations.js.map

package/src/core/wrapper.d.ts

@@ -1,17 +0,0 @@
-/**
- * @file wrapper.ts
- * @descripcion Sistema de tipos y wrapper optimizado
- * @autor Miguel Alejandro
- * @fecha 2025-01-28
- */
-import type { Column, WrapperEntry } from "../@types/index";
-export type { BelongsTo, Column, CreationOptional, FilterableAttributes, HasMany, IncludeOptions, IncludeRelationOptions, InferAttributes, Mutate, NonAttribute, QueryOperator, QueryResult, Validate, WhereOptions, WhereOptionsWithoutWhere, WhereQueryOptions, WrapperEntry, } from "../@types/index";
-export declare const STORE: unique symbol;
-declare const wrapper: Map<Function, WrapperEntry>;
-/** Obtener o crear entrada wrapper para constructor */
-export declare const ensureConfig: (ctor: Function, table_name: string) => WrapperEntry;
-/** Obtener o crear configuración de columna para propiedad */
-export declare const ensureColumn: (entry: WrapperEntry, prop: string | symbol, column_name: string) => Column;
-/** Obtener metadatos requeridos (throws si no existen) */
-export declare const mustMeta: (ctor: Function) => WrapperEntry;
-export default wrapper;

package/src/core/wrapper.js

@@ -1,46 +0,0 @@
-"use strict";
-/**
- * @file wrapper.ts
- * @descripcion Sistema de tipos y wrapper optimizado
- * @autor Miguel Alejandro
- * @fecha 2025-01-28
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mustMeta = exports.ensureColumn = exports.ensureConfig = exports.STORE = void 0;
-exports.STORE = Symbol("dynamite:values");
-const wrapper = new Map();
-/** Obtener o crear entrada wrapper para constructor */
-const ensureConfig = (ctor, table_name) => {
-    const existing = wrapper.get(ctor);
-    if (existing)
-        return existing;
-    const entry = {
-        name: table_name,
-        columns: new Map(),
-        relations: new Map(),
-    };
-    wrapper.set(ctor, entry);
-    return entry;
-};
-exports.ensureConfig = ensureConfig;
-/** Obtener o crear configuración de columna para propiedad */
-const ensureColumn = (entry, prop, column_name) => {
-    const existing = entry.columns.get(prop);
-    if (existing)
-        return existing;
-    const column = { name: column_name, mutate: [], validate: [] };
-    entry.columns.set(prop, column);
-    return column;
-};
-exports.ensureColumn = ensureColumn;
-/** Obtener metadatos requeridos (throws si no existen) */
-const mustMeta = (ctor) => {
-    const meta = wrapper.get(ctor);
-    if (!meta) {
-        throw new Error(`Metadatos no encontrados para ${ctor.name}. ¿Usaste decoradores @Index, @PrimaryKey, etc.?`);
-    }
-    return meta;
-};
-exports.mustMeta = mustMeta;
-exports.default = wrapper;
-//# sourceMappingURL=wrapper.js.map

package/src/decorators/belongs_to.d.ts

@@ -1 +0,0 @@
-export default function BelongsTo(targetModel: () => any, localKey: string, foreignKey?: string): PropertyDecorator;

package/src/decorators/belongs_to.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = BelongsTo;
-const wrapper_1 = require("../core/wrapper");
-function BelongsTo(targetModel, localKey, foreignKey) {
-    return (target, prop) => {
-        const entry = (0, wrapper_1.ensureConfig)(target.constructor, target.constructor.name);
-        entry.relations.set(prop, {
-            type: "belongsTo",
-            targetModel,
-            foreignKey: foreignKey || "id",
-            localKey,
-        });
-        // Crear getter dinámico para la relación
-        Object.defineProperty(target, prop, {
-            get() {
-                return this[`_${prop.toString()}`] || null;
-            },
-            enumerable: true,
-            configurable: true,
-        });
-    };
-}
-//# sourceMappingURL=belongs_to.js.map

package/src/decorators/created_at.d.ts

@@ -1 +0,0 @@
-export default function CreatedAt(): PropertyDecorator;

package/src/decorators/created_at.js

@@ -1,11 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = CreatedAt;
-const default_1 = __importDefault(require("./default"));
-function CreatedAt() {
-    return (0, default_1.default)(() => new Date().toISOString());
-}
-//# sourceMappingURL=created_at.js.map

package/src/decorators/default.d.ts

@@ -1 +0,0 @@
-export default function Default(factory: any): PropertyDecorator;

package/src/decorators/default.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = Default;
-const wrapper_1 = require("../core/wrapper");
-const naming_1 = require("../utils/naming");
-function Default(factory) {
-    return (target, prop) => {
-        const ctor = target.constructor;
-        const entry = (0, wrapper_1.ensureConfig)(ctor, (0, naming_1.toSnakePlural)(ctor.name));
-        const column = (0, wrapper_1.ensureColumn)(entry, prop, String(prop));
-        if (column.default)
-            throw new Error(`@Default duplicado en '${String(prop)}'`);
-        column.default = typeof factory === "function" ? factory : () => factory;
-        !Object.getOwnPropertyDescriptor(ctor.prototype, prop)?.set &&
-            defineVirtual(ctor.prototype, column, prop);
-    };
-}
-function defineVirtual(proto, col, prop) {
-    Object.defineProperty(proto, prop, {
-        get() {
-            return (this[wrapper_1.STORE] ?? {})[prop];
-        },
-        set(val) {
-            const buf = (this[wrapper_1.STORE] ??= {});
-            val =
-                val === undefined && col.default !== undefined
-                    ? typeof col.default === "function"
-                        ? col.default()
-                        : col.default
-                    : val;
-            if (col.mutate)
-                for (const m of col.mutate)
-                    val = m(val);
-            if (col.validate) {
-                for (const v of col.validate) {
-                    const r = v(val);
-                    if (r !== true)
-                        throw new Error(typeof r === "string" ? r : "Validación fallida");
-                }
-            }
-            buf[prop] = val;
-        },
-        enumerable: true,
-        configurable: true,
-    });
-}
-//# sourceMappingURL=default.js.map

package/src/decorators/has_many.d.ts

@@ -1 +0,0 @@
-export default function HasMany(targetModel: () => any, foreignKey: string, localKey?: string): PropertyDecorator;

package/src/decorators/has_many.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = HasMany;
-const wrapper_1 = require("../core/wrapper");
-function HasMany(targetModel, foreignKey, localKey) {
-    return (target, prop) => {
-        const entry = (0, wrapper_1.ensureConfig)(target.constructor, target.constructor.name);
-        entry.relations.set(prop, {
-            type: "hasMany",
-            targetModel,
-            foreignKey,
-            localKey: localKey || "id",
-        });
-        // Crear getter dinámico para la relación
-        Object.defineProperty(target, prop, {
-            get() {
-                return this[`_${prop.toString()}`] || [];
-            },
-            enumerable: true,
-            configurable: true,
-        });
-    };
-}
-//# sourceMappingURL=has_many.js.map

package/src/decorators/index.d.ts

@@ -1,11 +0,0 @@
-/**
- * @file index.ts
- * @descripcion Decorador @Index para Partition Key
- * @autor Miguel Alejandro
- * @fecha 2025-01-27
- */
-/**
- * Decorador para marcar propiedad como Partition Key.
- * Configura la propiedad como índice principal para consultas.
- */
-export default function Index(): PropertyDecorator;

package/src/decorators/index.js

@@ -1,36 +0,0 @@
-"use strict";
-/**
- * @file index.ts
- * @descripcion Decorador @Index para Partition Key
- * @autor Miguel Alejandro
- * @fecha 2025-01-27
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = Index;
-const wrapper_1 = require("../core/wrapper");
-const naming_1 = require("../utils/naming");
-/**
- * Decorador para marcar propiedad como Partition Key.
- * Configura la propiedad como índice principal para consultas.
- */
-function Index() {
-    return (target, prop) => {
-        const ctor = target.constructor;
-        const tableName = (0, naming_1.toSnakePlural)(ctor.name);
-        const entry = (0, wrapper_1.ensureConfig)(ctor, tableName);
-        // Verificar si ya existe un índice primario
-        const existingIndex = [...entry.columns.values()].find((col) => col.index === true);
-        if (existingIndex && existingIndex.name !== String(prop)) {
-            throw new Error(`La tabla ${tableName} ya tiene definida una PartitionKey (${existingIndex.name}). ` +
-                `No se puede definir otra PartitionKey en '${String(prop)}'`);
-        }
-        // Obtener o crear la columna y marcar como índice
-        const column = (0, wrapper_1.ensureColumn)(entry, prop, String(prop));
-        column.index = true;
-        // Asegurar que la columna no sea nula por defecto
-        if (column.nullable === undefined) {
-            column.nullable = false;
-        }
-    };
-}
-//# sourceMappingURL=index.js.map

package/src/decorators/index_sort.d.ts

@@ -1,12 +0,0 @@
-/**
- * @file index_sort.ts
- * @descripcion Decorador @IndexSort para Sort Key
- * @autor Miguel Alejandro
- * @fecha 2025-01-27
- */
-/**
- * Decorador para marcar propiedad como Sort Key.
- * Configura la propiedad como clave de ordenación para consultas.
- * Requiere que exista una PartitionKey (@Index) definida previamente.
- */
-export default function IndexSort(): PropertyDecorator;

package/src/decorators/index_sort.js

@@ -1,43 +0,0 @@
-"use strict";
-/**
- * @file index_sort.ts
- * @descripcion Decorador @IndexSort para Sort Key
- * @autor Miguel Alejandro
- * @fecha 2025-01-27
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = IndexSort;
-const wrapper_1 = require("../core/wrapper");
-const naming_1 = require("../utils/naming");
-/**
- * Decorador para marcar propiedad como Sort Key.
- * Configura la propiedad como clave de ordenación para consultas.
- * Requiere que exista una PartitionKey (@Index) definida previamente.
- */
-function IndexSort() {
-    return (target, prop) => {
-        const ctor = target.constructor;
-        const tableName = (0, naming_1.toSnakePlural)(ctor.name);
-        const entry = (0, wrapper_1.ensureConfig)(ctor, tableName);
-        // Verificar que exista una PartitionKey definida
-        const hasPartitionKey = [...entry.columns.values()].some((col) => col.index === true);
-        if (!hasPartitionKey) {
-            throw new Error(`No se puede definir una SortKey en '${String(prop)}' sin una PartitionKey. ` +
-                `Asegúrate de marcar una propiedad con @Index primero.`);
-        }
-        // Verificar si ya existe una SortKey
-        const existingSortKey = [...entry.columns.values()].find((col) => col.indexSort === true);
-        if (existingSortKey && existingSortKey.name !== String(prop)) {
-            throw new Error(`La tabla ${tableName} ya tiene una SortKey definida (${existingSortKey.name}). ` +
-                `No se puede definir otra SortKey en '${String(prop)}'`);
-        }
-        // Obtener o crear la columna y marcar como índice de ordenación
-        const column = (0, wrapper_1.ensureColumn)(entry, prop, String(prop));
-        column.indexSort = true;
-        // Asegurar que la columna no sea nula por defecto
-        if (column.nullable === undefined) {
-            column.nullable = false;
-        }
-    };
-}
-//# sourceMappingURL=index_sort.js.map

package/src/decorators/mutate.d.ts

@@ -1,2 +0,0 @@
-import type { Mutate } from "../core/wrapper";
-export default function Mutate(fn: Mutate): PropertyDecorator;