@arcaelas/dynamite 1.0.14 → 1.0.17

package/src/utils/circular-detector.js

@@ -0,0 +1,212 @@
+"use strict";
+/**
+ * @file circular-detector.ts
+ * @description Detection and prevention of circular references in relations
+ * @author Miguel Alejandro
+ * @fecha 2025-08-31
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.circularDetector = exports.CircularTracker = exports.CircularReferenceError = exports.CircularReferenceDetector = void 0;
+class CircularReferenceDetector {
+    static { this.DEFAULT_CONFIG = {
+        maxDepth: 10,
+        maxIncludeDepth: 5,
+        trackingEnabled: true,
+    }; }
+    constructor(config) {
+        this.activePaths = new Set();
+        this.pathHistory = [];
+        this.config = { ...CircularReferenceDetector.DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Verificar si una ruta de inclusión es segura
+     */
+    validateIncludePath(modelName, includeOptions, currentDepth = 0, visitedModels = new Set()) {
+        // Verificar profundidad máxima
+        if (currentDepth > this.config.maxIncludeDepth) {
+            throw new CircularReferenceError(`Include depth exceeded limit of ${this.config.maxIncludeDepth} at model: ${modelName}`);
+        }
+        // Detectar referencia circular directa
+        if (visitedModels.has(modelName)) {
+            const path = Array.from(visitedModels).join(" -> ") + ` -> ${modelName}`;
+            throw new CircularReferenceError(`Circular reference detected in include path: ${path}`);
+        }
+        if (!includeOptions || typeof includeOptions !== "object") {
+            return;
+        }
+        const newVisited = new Set(visitedModels);
+        newVisited.add(modelName);
+        // Validar cada relación incluida
+        for (const [relationKey, relationOptions] of Object.entries(includeOptions)) {
+            if (this.config.trackingEnabled) {
+                this.pathHistory.push({
+                    modelName,
+                    relationKey,
+                    depth: currentDepth,
+                });
+            }
+            // Si la relación tiene sus propios includes, validar recursivamente
+            if (relationOptions &&
+                typeof relationOptions === "object" &&
+                "include" in relationOptions) {
+                // Aquí necesitaríamos obtener el modelo target de la relación
+                // Por simplicidad, usamos el relationKey como modelo (esto debería mejorar)
+                const targetModelName = this.inferTargetModelName(relationKey);
+                this.validateIncludePath(targetModelName, relationOptions.include, currentDepth + 1, newVisited);
+            }
+        }
+    }
+    /**
+     * Validar estructura de relaciones en tiempo de definición
+     */
+    validateRelationStructure(models, maxAllowedCycles = 0) {
+        const graph = this.buildRelationGraph(models);
+        const cycles = this.detectCycles(graph);
+        return {
+            isValid: cycles.length <= maxAllowedCycles,
+            cycles,
+            suggestions: this.generateSuggestions(cycles),
+        };
+    }
+    /**
+     * Construir grafo de relaciones
+     */
+    buildRelationGraph(models) {
+        const graph = new Map();
+        for (const [modelName, model] of models.entries()) {
+            const relations = [];
+            // Esto necesitaría acceso a los metadatos del modelo
+            // Por ahora simulamos la extracción de relaciones
+            const meta = model.getMeta?.();
+            if (meta?.relations) {
+                for (const [relationKey, relation] of meta.relations.entries()) {
+                    const targetModel = relation.targetModel?.()?.name || relationKey;
+                    relations.push(targetModel);
+                }
+            }
+            graph.set(modelName, relations);
+        }
+        return graph;
+    }
+    /**
+     * Detectar ciclos usando DFS
+     */
+    detectCycles(graph) {
+        const cycles = [];
+        const visited = new Set();
+        const recursionStack = new Set();
+        const dfs = (node, path) => {
+            if (recursionStack.has(node)) {
+                // Ciclo detectado
+                const cycleStart = path.indexOf(node);
+                const cycle = path.slice(cycleStart).concat(node);
+                cycles.push(cycle);
+                return;
+            }
+            if (visited.has(node)) {
+                return;
+            }
+            visited.add(node);
+            recursionStack.add(node);
+            path.push(node);
+            const neighbors = graph.get(node) || [];
+            for (const neighbor of neighbors) {
+                dfs(neighbor, [...path]);
+            }
+            recursionStack.delete(node);
+        };
+        for (const node of graph.keys()) {
+            if (!visited.has(node)) {
+                dfs(node, []);
+            }
+        }
+        return cycles;
+    }
+    /**
+     * Generar sugerencias para resolver ciclos
+     */
+    generateSuggestions(cycles) {
+        const suggestions = [];
+        for (const cycle of cycles) {
+            if (cycle.length === 2) {
+                suggestions.push(`Circular reference between ${cycle[0]} and ${cycle[1]}. Consider using lazy loading or removing one direction.`);
+            }
+            else {
+                suggestions.push(`Complex circular reference detected: ${cycle.join(" -> ")}. Consider breaking the cycle at the weakest relationship.`);
+            }
+        }
+        if (cycles.length > 0) {
+            suggestions.push("General: Use @NonAttribute for computed relationships or implement lazy loading to break cycles.");
+        }
+        return suggestions;
+    }
+    /**
+     * Inferir nombre del modelo target (simplificado)
+     */
+    inferTargetModelName(relationKey) {
+        // Conversión simple: posts -> Post, user -> User
+        return (relationKey.charAt(0).toUpperCase() +
+            relationKey.slice(1).replace(/s$/, ""));
+    }
+    /**
+     * Crear contexto de rastreo para includes anidados
+     */
+    createTrackingContext() {
+        return new CircularTracker(this.config.maxIncludeDepth);
+    }
+    /**
+     * Obtener historial de paths para debugging
+     */
+    getPathHistory() {
+        return [...this.pathHistory];
+    }
+    /**
+     * Limpiar historial
+     */
+    clearHistory() {
+        this.pathHistory = [];
+        this.activePaths.clear();
+    }
+}
+exports.CircularReferenceDetector = CircularReferenceDetector;
+/**
+ * Tracker específico para una operación de include
+ */
+class CircularTracker {
+    constructor(maxDepth) {
+        this.visitedModels = new Set();
+        this.currentPath = [];
+        this.maxDepth = maxDepth;
+    }
+    enter(modelName) {
+        if (this.currentPath.length >= this.maxDepth) {
+            throw new CircularReferenceError(`Maximum include depth ${this.maxDepth} exceeded at: ${modelName}`);
+        }
+        if (this.visitedModels.has(modelName)) {
+            const cyclePath = this.currentPath.join(" -> ") + ` -> ${modelName}`;
+            throw new CircularReferenceError(`Circular reference detected: ${cyclePath}`);
+        }
+        this.visitedModels.add(modelName);
+        this.currentPath.push(modelName);
+    }
+    exit(modelName) {
+        this.currentPath.pop();
+        this.visitedModels.delete(modelName);
+    }
+    getCurrentPath() {
+        return [...this.currentPath];
+    }
+}
+exports.CircularTracker = CircularTracker;
+class CircularReferenceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CircularReferenceError";
+    }
+}
+exports.CircularReferenceError = CircularReferenceError;
+// Instancia singleton
+const circularDetector = new CircularReferenceDetector();
+exports.circularDetector = circularDetector;
+exports.default = circularDetector;
+//# sourceMappingURL=circular-detector.js.map

package/src/utils/memory-manager.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @file memory-manager.ts
+ * @description Memory management and leak prevention
+ * @author Miguel Alejandro
+ * @fecha 2025-08-31
+ */
+declare class MemoryManager {
+    private static instance;
+    private cleanupTasks;
+    private maxCacheSize;
+    private maxCacheAge;
+    static getInstance(): MemoryManager;
+    /**
+     * Registrar una tarea de limpieza
+     */
+    registerCleanup(id: string, cleanup: () => void, intervalMs?: number): void;
+    /**
+     * Desregistrar y limpiar tarea
+     */
+    unregisterCleanup(id: string): void;
+    /**
+     * Limpiar cache con límites de tamaño y edad
+     */
+    cleanCache<T>(cache: Map<string, {
+        data: T;
+        expires: number;
+        created: number;
+    }>, maxSize?: number): void;
+    /**
+     * Monitorear uso de memoria
+     */
+    getMemoryUsage(): NodeJS.MemoryUsage;
+    /**
+     * Forzar garbage collection si está disponible
+     */
+    forceGC(): void;
+    /**
+     * Cleanup completo al shutdown
+     */
+    shutdown(): void;
+}
+export default MemoryManager;

package/src/utils/memory-manager.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * @file memory-manager.ts
+ * @description Memory management and leak prevention
+ * @author Miguel Alejandro
+ * @fecha 2025-08-31
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+class MemoryManager {
+    constructor() {
+        this.cleanupTasks = new Map();
+        this.maxCacheSize = 1000;
+        this.maxCacheAge = 300000; // 5 minutos
+    }
+    static getInstance() {
+        if (!MemoryManager.instance) {
+            MemoryManager.instance = new MemoryManager();
+        }
+        return MemoryManager.instance;
+    }
+    /**
+     * Registrar una tarea de limpieza
+     */
+    registerCleanup(id, cleanup, intervalMs) {
+        // Limpiar tarea previa si existe
+        this.unregisterCleanup(id);
+        const task = { id, cleanup };
+        if (intervalMs) {
+            task.interval = setInterval(() => {
+                try {
+                    cleanup();
+                }
+                catch (error) {
+                    console.warn(`Cleanup task ${id} failed:`, error);
+                }
+            }, intervalMs);
+        }
+        this.cleanupTasks.set(id, task);
+    }
+    /**
+     * Desregistrar y limpiar tarea
+     */
+    unregisterCleanup(id) {
+        const task = this.cleanupTasks.get(id);
+        if (task) {
+            if (task.interval) {
+                clearInterval(task.interval);
+            }
+            task.cleanup();
+            this.cleanupTasks.delete(id);
+        }
+    }
+    /**
+     * Limpiar cache con límites de tamaño y edad
+     */
+    cleanCache(cache, maxSize = this.maxCacheSize) {
+        const now = Date.now();
+        // Remover entradas expiradas
+        for (const [key, entry] of cache.entries()) {
+            if (entry.expires <= now || now - entry.created > this.maxCacheAge) {
+                cache.delete(key);
+            }
+        }
+        // Si aún excede el tamaño, remover las más antiguas
+        if (cache.size > maxSize) {
+            const entries = Array.from(cache.entries()).sort((a, b) => a[1].created - b[1].created);
+            const toRemove = entries.slice(0, cache.size - maxSize);
+            toRemove.forEach(([key]) => cache.delete(key));
+        }
+    }
+    /**
+     * Monitorear uso de memoria
+     */
+    getMemoryUsage() {
+        return process.memoryUsage();
+    }
+    /**
+     * Forzar garbage collection si está disponible
+     */
+    forceGC() {
+        if (global.gc) {
+            global.gc();
+        }
+    }
+    /**
+     * Cleanup completo al shutdown
+     */
+    shutdown() {
+        console.log("MemoryManager: Iniciando cleanup completo...");
+        for (const [id, task] of this.cleanupTasks.entries()) {
+            try {
+                this.unregisterCleanup(id);
+            }
+            catch (error) {
+                console.warn(`Error cleaning up task ${id}:`, error);
+            }
+        }
+        this.cleanupTasks.clear();
+        this.forceGC();
+    }
+}
+// Cleanup automático en shutdown
+process.on("SIGTERM", () => MemoryManager.getInstance().shutdown());
+process.on("SIGINT", () => MemoryManager.getInstance().shutdown());
+process.on("uncaughtException", () => MemoryManager.getInstance().shutdown());
+exports.default = MemoryManager;
+//# sourceMappingURL=memory-manager.js.map

package/src/utils/naming.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @file naming.ts
+ * @descripcion Utilidades de conversión de nombres
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-27
+ */
+/** Convierte nombre de clase a formato snake_case plural para tablas */
+export declare function toSnakePlural(input: string): string;

package/src/utils/naming.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * @file naming.ts
+ * @descripcion Utilidades de conversión de nombres
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-27
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSnakePlural = toSnakePlural;
+const pluralize_1 = __importDefault(require("pluralize"));
+/** Convierte nombre de clase a formato snake_case plural para tablas */
+function toSnakePlural(input) {
+    return (0, pluralize_1.default)(input.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase());
+}
+//# sourceMappingURL=naming.js.map

package/src/utils/projection.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @file projection.ts
+ * @description Selective field loading and projection optimization
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-27
+ */
+/** Build DynamoDB ProjectionExpression */
+export declare const buildProjection: (attributes?: string[], meta?: any) => string | undefined;
+/** Optimize attributes loading for relations */
+export declare const optimizeRelationAttributes: (include: any, baseAttributes?: string[]) => string[];
+/** Smart attribute selection for common patterns */
+export declare const getSmartAttributes: (Model: any, scenario: "list" | "detail" | "minimal") => string[];

package/src/utils/projection.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * @file projection.ts
+ * @description Selective field loading and projection optimization
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-27
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSmartAttributes = exports.optimizeRelationAttributes = exports.buildProjection = void 0;
+const wrapper_1 = require("../core/wrapper");
+/** Build DynamoDB ProjectionExpression */
+const buildProjection = (attributes, meta) => {
+    if (!attributes?.length || !meta)
+        return undefined;
+    // Validate attributes exist in model
+    const validAttributes = attributes.filter((attr) => meta.columns.has(attr) || meta.relations.has(attr));
+    return validAttributes.length ? validAttributes.join(", ") : undefined;
+};
+exports.buildProjection = buildProjection;
+/** Optimize attributes loading for relations */
+const optimizeRelationAttributes = (include, baseAttributes) => {
+    const attributes = new Set(baseAttributes || []);
+    // Add foreign keys needed for relations
+    Object.entries(include || {}).forEach(([relationKey, options]) => {
+        attributes.add(relationKey);
+        // Add foreign key fields
+        if (options?.foreignKey)
+            attributes.add(options.foreignKey);
+        if (options?.localKey)
+            attributes.add(options.localKey);
+    });
+    return Array.from(attributes);
+};
+exports.optimizeRelationAttributes = optimizeRelationAttributes;
+/** Smart attribute selection for common patterns */
+const getSmartAttributes = (Model, scenario) => {
+    const meta = (0, wrapper_1.mustMeta)(Model);
+    const columns = Array.from(meta.columns.keys());
+    switch (scenario) {
+        case "minimal":
+            return columns.filter((col) => meta.columns.get(col)?.primaryKey ||
+                ["id", "name", "title", "email"].includes(col));
+        case "list":
+            return columns.filter((col) => !["description", "content", "body", "metadata"].includes(col));
+        case "detail":
+        default:
+            return columns;
+    }
+};
+exports.getSmartAttributes = getSmartAttributes;
+//# sourceMappingURL=projection.js.map

package/src/utils/relations.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @file relations.ts
+ * @descripcion Sistema de relaciones optimizado
+ * @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;
+};

package/src/utils/relations.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * @file relations.ts
+ * @descripcion Sistema de relaciones optimizado
+ * @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)
+        return new Map();
+    // Build query with relation options
+    let query = targetModel().where(foreignKey, "in", parent_keys);
+    // Apply additional filters if specified
+    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));
+        }
+    }
+    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));
+    }
+    else if (options.order === "ASC") {
+        filteredItems.sort((a, b) => a.id.localeCompare(b.id));
+    }
+    if (options.limit) {
+        filteredItems = filteredItems.slice(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)
+        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;
+};
+/** Procesamiento optimizado de includes con batch loading transparente */
+const processIncludes = async (Model, items, include, 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)
+            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 related = related_data.get(key);
+            // Usar una propiedad temporal para evitar conflictos con getters
+            Object.defineProperty(item, relation_key, {
+                value: relation.type === "hasMany" ? related || [] : related || null,
+                writable: true,
+                enumerable: 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);
+        }
+    });
+    await Promise.all(relation_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/utils/security-validator.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @file security-validator.ts
+ * @description Security validation and NoSQL injection prevention
+ * @author Miguel Alejandro
+ * @fecha 2025-08-31
+ */
+import { QueryOperator } from "../@types/index";
+interface SecurityConfig {
+    maxStringLength: number;
+    maxArrayLength: number;
+    maxNestedDepth: number;
+    allowedOperators: QueryOperator[];
+    blockedPatterns: RegExp[];
+}
+declare class SecurityValidator {
+    private static readonly DEFAULT_CONFIG;
+    private config;
+    constructor(config?: Partial<SecurityConfig>);
+    /**
+     * Validar nombre de atributo/tabla
+     */
+    validateAttributeName(name: string): void;
+    /**
+     * Validar operador de query
+     */
+    validateOperator(operator: string): QueryOperator;
+    /**
+     * Validar valor de campo
+     */
+    validateValue(value: any, depth?: number): any;
+    /**
+     * Validar filtros de query completos
+     */
+    validateQueryFilters(filters: Record<string, any>): Record<string, any>;
+    /**
+     * Sanitizar string para DynamoDB
+     */
+    sanitizeString(input: string): string;
+    /**
+     * Validar tamaño de item para DynamoDB (límite 400KB)
+     */
+    validateItemSize(item: any): void;
+}
+declare class SecurityError extends Error {
+    constructor(message: string);
+}
+declare const securityValidator: SecurityValidator;
+export { SecurityError, SecurityValidator, securityValidator };
+export default securityValidator;