limbo-component 1.0.0

package/dist/types/core/ConfigManager.d.ts

@@ -0,0 +1,294 @@
+export class ConfigManager {
+    globalConfig: {};
+    defaults: {
+        container: string;
+        mode: string;
+        modeUI: string;
+        features: string[];
+        ui: {
+            showActions: string[];
+            hideActions: any[];
+            theme: string;
+            language: string;
+            compactMode: boolean;
+            showTabs: boolean;
+            showPreview: boolean;
+        };
+        cropper: {
+            quality: number;
+            format: string;
+            aspectRatio: any;
+            lockAspectRatio: boolean;
+            allowedAspectRatios: {
+                label: string;
+                value: string;
+                ratio: number;
+            }[];
+            showFreeAspectRatio: boolean;
+        };
+        validation: {
+            maxSize: string;
+            formats: string[];
+            minWidth: any;
+            minHeight: any;
+            maxWidth: any;
+            maxHeight: any;
+        };
+        return: {
+            format: string;
+            autoAssign: boolean;
+            includeMetadata: boolean;
+        };
+        autoInputs: {
+            dataset: string;
+            buttonText: string;
+            buttonStyle: string;
+            buttonClass: string;
+            scanOnLoad: boolean;
+            observeChanges: boolean;
+        };
+        presets: {
+            aspects: {
+                name: string;
+                ratio: string;
+                label: string;
+            }[];
+            sizes: {
+                name: string;
+                width: number;
+                height: number;
+                fit: string;
+                label: string;
+            }[];
+            required: any[];
+            lockUserCrop: boolean;
+            allowArbitrary: boolean;
+            defaultAspect: string;
+            defaultSize: string;
+        };
+        modal: {
+            size: string;
+            title: string;
+            backdrop: boolean;
+            closeOnEscape: boolean;
+            closeOnBackdrop: boolean;
+            showCloseButton: boolean;
+        };
+        callbacks: {};
+        autoDestroy: boolean;
+        debug: boolean;
+        apiEndpoint: any;
+        auth: {
+            apiKey: any;
+            publicKey: any;
+            portal: any;
+            authMode: string;
+            tokenStorage: string;
+            autoRefresh: boolean;
+            refreshBuffer: number;
+        };
+        apiKey: any;
+    };
+    /**
+     * Establecer configuración global
+     */
+    setGlobal(config: any): this;
+    /**
+     * Obtener configuración global
+     */
+    getGlobal(): {};
+    /**
+     * Fusionar configuraciones con prioridad
+     * Orden: defaults < global < instance
+     */
+    merge(instanceConfig?: {}): {};
+    /**
+     * Fusión profunda de objetos
+     */
+    _deepMerge(...objects: any[]): {};
+    /**
+     * Establecer defaults personalizados
+     */
+    setDefaults(newDefaults: any): this;
+    /**
+     * Obtener defaults
+     */
+    getDefaults(): any;
+    /**
+     * Restablecer defaults a valores originales
+     */
+    resetDefaults(): this;
+    /**
+     * Obtener configuración específica por path
+     */
+    get(path: any, config?: any): any;
+    /**
+     * Establecer configuración específica por path
+     */
+    set(path: any, value: any): this;
+    /**
+     * Helper para obtener valor por path (ej: "ui.theme")
+     */
+    _getValueByPath(obj: any, path: any): any;
+    /**
+     * Helper para establecer valor por path
+     */
+    _setValueByPath(obj: any, path: any, value: any): void;
+    /**
+     * Obtener defaults originales (inmutable)
+     */
+    _getOriginalDefaults(): {
+        container: string;
+        mode: string;
+        modeUI: string;
+        features: string[];
+        ui: {
+            showActions: string[];
+            hideActions: any[];
+            theme: string;
+            language: string;
+            compactMode: boolean;
+            showTabs: boolean;
+            showPreview: boolean;
+        };
+        interaction: {
+            allowSelection: boolean;
+            allowCropping: boolean;
+            requiresCropping: boolean;
+            selectionMode: string;
+        };
+        cropper: {
+            quality: number;
+            format: string;
+            aspectRatio: any;
+            lockAspectRatio: boolean;
+            allowedAspectRatios: {
+                label: string;
+                value: string;
+                ratio: number;
+            }[];
+            showFreeAspectRatio: boolean;
+        };
+        validation: {
+            maxSize: string;
+            formats: string[];
+            minWidth: any;
+            minHeight: any;
+            maxWidth: any;
+            maxHeight: any;
+        };
+        return: {
+            format: string;
+            autoAssign: boolean;
+            includeMetadata: boolean;
+        };
+        autoInputs: {
+            dataset: string;
+            buttonText: string;
+            buttonStyle: string;
+            buttonClass: string;
+            scanOnLoad: boolean;
+            observeChanges: boolean;
+        };
+        modal: {
+            size: string;
+            title: string;
+            backdrop: boolean;
+            closeOnEscape: boolean;
+            closeOnBackdrop: boolean;
+            showCloseButton: boolean;
+        };
+        i18n: {
+            locale: string;
+            messages: {};
+            autoDetect: boolean;
+        };
+        theme: {
+            colors: {};
+            spacing: {};
+            typography: {};
+            borderRadius: {};
+            shadows: {};
+            customProperties: {};
+        };
+        callbacks: {};
+        autoDestroy: boolean;
+        debug: boolean;
+        apiEndpoint: any;
+        auth: {
+            apiKey: any;
+            publicKey: any;
+            portal: any;
+            authMode: string;
+            tokenStorage: string;
+            autoRefresh: boolean;
+            refreshBuffer: number;
+        };
+        apiKey: any;
+    };
+    /**
+     * Validar presets de configuración
+     */
+    _validatePresets(presets: any): any[];
+    /**
+     * Obtener preset por nombre
+     */
+    getPreset(config: any, name: any, type?: string): any;
+    /**
+     * Validar si un preset es requerido
+     */
+    isPresetRequired(config: any, presetName: any): any;
+    /**
+     * Obtener aspectos disponibles
+     */
+    getAvailableAspects(config: any): any;
+    /**
+     * Obtener tamaños disponibles
+     */
+    getAvailableSizes(config: any): any;
+    /**
+     * Crear instancia de i18n basada en configuración
+     */
+    createI18n(config: any): I18n;
+    /**
+     * Validar configuración
+     */
+    validate(config: any): {
+        isValid: boolean;
+        errors: any[];
+    };
+    /**
+     * Configurar autenticación JWT v2
+     * @param {string} apiKey - API Key para autenticación
+     * @param {string} publicKey - Public Key opcional para requests públicos
+     * @param {Object} options - Opciones adicionales de configuración JWT
+     */
+    setJWTAuth(apiKey: string, publicKey?: string, options?: any): this;
+    /**
+     * Obtener configuración de autenticación actual
+     */
+    getAuthConfig(mergedConfig?: any): {
+        authMode: any;
+        apiKey: any;
+        publicKey: any;
+        portal: any;
+        tokenStorage: any;
+        autoRefresh: boolean;
+        refreshBuffer: any;
+    };
+    /**
+     * Verificar si está usando autenticación JWT
+     */
+    isJWTMode(mergedConfig?: any): boolean;
+    /**
+     * Verificar si está usando modo legacy
+     */
+    isLegacyMode(mergedConfig?: any): boolean;
+    /**
+     * Migrar configuración legacy a JWT
+     * Helper para facilitar la migración gradual
+     */
+    migrateToJWT(legacyApiKey?: any): this;
+}
+import { I18n } from '../utils/i18n.js';
+//# sourceMappingURL=ConfigManager.d.ts.map

package/dist/types/core/ConfigManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigManager.d.ts","sourceRoot":"","sources":["../../../src/core/ConfigManager.js"],"names":[],"mappings":"AAOA;IAEI,iBAAsB;IACtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAmHC;IAGH;;OAEG;IACH,6BAGC;IAED;;OAEG;IACH,gBAEC;IAED;;;OAGG;IACH,+BASC;IAED;;OAEG;IACH,kCAkBC;IAED;;OAEG;IACH,oCAGC;IAED;;OAEG;IACH,mBAEC;IAED;;OAEG;IACH,sBAGC;IAED;;OAEG;IACH,kCAGC;IAED;;OAEG;IACH,iCAGC;IAED;;OAEG;IACH,0CAIC;IAED;;OAEG;IACH,uDAWC;IAED;;OAEG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2HC;IAED;;OAEG;IACH,sCAyCC;IAED;;OAEG;IACH,sDAQC;IAED;;OAEG;IACH,oDAGC;IAED;;OAEG;IACH,sCAGC;IAED;;OAEG;IACH,oCAGC;IAED;;OAEG;IACH,8BAcC;IAED;;OAEG;IACH;;;MA0CC;IAED;;;;;OAKG;IACH,mBAJW,MAAM,cACN,MAAM,uBAiBhB;IAED;;OAEG;IACH;;;;;;;;MAWC;IAED;;OAEG;IACH,uCAGC;IAED;;OAEG;IACH,0CAGC;IAED;;;OAGG;IACH,uCAYC;CACF;qBA5kBoB,kBAAkB"}

package/dist/types/core/EventManager.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 📡 GESTIÓN DE EVENTOS
+ * Responsabilidad única: Manejar todos los eventos del sistema
+ */
+export class EventManager {
+    listeners: Map<any, any>;
+    /**
+     * Emitir evento
+     */
+    emit(eventName: any, data?: {}): void;
+    /**
+     * Añadir listener interno
+     */
+    on(eventName: any, callback: any): () => void;
+    /**
+     * Remover listener
+     */
+    off(eventName: any, callback: any): void;
+    /**
+     * Limpiar todos los listeners
+     */
+    cleanup(): void;
+    /**
+     * Emitir evento DOM personalizado
+     */
+    _emitDOMEvent(eventName: any, data: any): void;
+    /**
+     * Ejecutar listeners internos
+     */
+    _executeListeners(eventName: any, data: any): void;
+    /**
+     * Obtener estadísticas de eventos
+     */
+    getStats(): {};
+}
+//# sourceMappingURL=EventManager.d.ts.map

package/dist/types/core/EventManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventManager.d.ts","sourceRoot":"","sources":["../../../src/core/EventManager.js"],"names":[],"mappings":"AACA;;;GAGG;AACH;IAEI,yBAA0B;IAG5B;;OAEG;IACH,sCAMC;IAED;;OAEG;IACH,8CAQC;IAED;;OAEG;IACH,yCAQC;IAED;;OAEG;IACH,gBAEC;IAED;;OAEG;IACH,+CAUC;IAED;;OAEG;IACH,mDAWC;IAED;;OAEG;IACH,eAMC;CACF"}

package/dist/types/core/InstanceManager.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 🏗️ GESTIÓN DE INSTANCIAS
+ * Responsabilidad única: Crear, gestionar y destruir instancias
+ */
+export class InstanceManager {
+    instances: Map<any, any>;
+    counter: number;
+    /**
+     * Crear nueva instancia
+     */
+    create(config: any, eventManager: any, modalManager: any): LimboInstance;
+    /**
+     * Obtener instancia por ID
+     */
+    get(instanceId: any): any;
+    /**
+     * Obtener todas las instancias
+     */
+    getAll(): any[];
+    /**
+     * Obtener instancias activas (montadas)
+     */
+    getActive(): any[];
+    /**
+     * Destruir instancia específica
+     */
+    destroy(instanceId: any): boolean;
+    /**
+     * Destruir todas las instancias
+     */
+    destroyAll(): void;
+    /**
+     * Cleanup de instancias huérfanas (contenedores eliminados del DOM)
+     */
+    cleanupOrphans(): number;
+    /**
+     * Estadísticas
+     */
+    getStats(): {
+        total: number;
+        active: number;
+        embed: number;
+        modal: number;
+        button: number;
+    };
+}
+import { LimboInstance } from './LimboInstance.js';
+//# sourceMappingURL=InstanceManager.d.ts.map

package/dist/types/core/InstanceManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstanceManager.d.ts","sourceRoot":"","sources":["../../../src/core/InstanceManager.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH;IAEI,yBAA0B;IAC1B,gBAAgB;IAGlB;;OAEG;IACH,yEAOC;IAED;;OAEG;IACH,0BAEC;IAED;;OAEG;IACH,gBAEC;IAED;;OAEG;IACH,mBAEC;IAED;;OAEG;IACH,kCAQC;IAED;;OAEG;IACH,mBAGC;IAED;;OAEG;IACH,yBAYC;IAED;;OAEG;IACH;;;;;;MASC;CACF;8BAhG6B,oBAAoB"}

package/dist/types/core/LimboCore.d.ts

@@ -0,0 +1,92 @@
+/**
+ * 🎯 NÚCLEO DE LIMBO - Gestión centralizada
+ * Responsabilidad única: Coordinar todo el sistema
+ */
+export class LimboCore {
+    config: ConfigManager;
+    instances: InstanceManager;
+    autoInputs: AutoInputManager;
+    events: EventManager;
+    modals: ModalManager;
+    theme: ThemeManager;
+    containerQueryDetector: import("../utils/ContainerQueryDetector.js").ContainerQueryDetector;
+    /**
+     * Configuración global
+     */
+    configure(options: any): ConfigManager;
+    /**
+     * Crear instancia manual
+     */
+    create(options: any): import("./LimboInstance.js").LimboInstance;
+    /**
+     * Configurar inputs automáticos
+     */
+    configureAutoInputs(options: any): AutoInputManager;
+    /**
+     * Configurar tema personalizado
+     */
+    setTheme(themeConfig: any): this;
+    /**
+     * Obtener tema actual
+     */
+    getTheme(): {
+        name: any;
+        theme: any;
+        isCustom: boolean;
+        variables: {};
+    };
+    /**
+     * Escanear y activar todos los inputs automáticos
+     */
+    scanAndActivate(selector?: any): {
+        found: number;
+        processed: number;
+        skipped: number;
+    };
+    /**
+     * Inicializar sistema de container queries para responsive dentro de modales
+     */
+    _initializeContainerQueries(): void;
+    /**
+     * Re-escanear elementos dinámicos
+     */
+    rescan(container?: Document): number;
+    /**
+     * Método legacy
+     */
+    init(options: any): import("./LimboInstance.js").LimboInstance;
+    /**
+     * Obtener instancias activas
+     */
+    getInstances(): any[];
+    /**
+     * Limpiar todo
+     */
+    destroy(): void;
+    _mapLegacyOptions(options: any): {
+        container: any;
+        mode: string;
+        features: string[];
+        apiKey: any;
+        prod: any;
+        url: any;
+    };
+    /**
+     * 🆕 Configurar listeners internos del sistema
+     */
+    _setupInternalListeners(): void;
+    /**
+     * 🆕 Manejar request de modal desde input automático
+     */
+    _handleAutoInputModalRequest({ config, callback }: {
+        config: any;
+        callback: any;
+    }): void;
+}
+import { ConfigManager } from './ConfigManager.js';
+import { InstanceManager } from './InstanceManager.js';
+import { AutoInputManager } from './AutoInputManager.js';
+import { EventManager } from './EventManager.js';
+import { ModalManager } from './ModalManager.js';
+import { ThemeManager } from '../utils/ThemeManager.js';
+//# sourceMappingURL=LimboCore.d.ts.map

package/dist/types/core/LimboCore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LimboCore.d.ts","sourceRoot":"","sources":["../../../src/core/LimboCore.js"],"names":[],"mappings":"AASA;;;GAGG;AACH;IAEI,sBAAiC;IACjC,2BAAsC;IACtC,6BAAwC;IACxC,qBAAgC;IAChC,qBAAgC;IAChC,oBAA+B;IAC/B,4FAAoD;IAMtD;;OAEG;IACH,uCAcC;IAED;;OAEG;IACH,iEAGC;IAED;;OAEG;IACH,oDAEC;IAED;;OAEG;IACH,iCAaC;IAED;;OAEG;IACH;;;;;MAEC;IAED;;OAEG;IACH;;;;MA0CC;IAED;;OAEG;IACH,oCAWC;IAED;;OAEG;IACH,qCAmBC;IAED;;OAEG;IACH,+DAGC;IAED;;OAEG;IACH,sBAEC;IAED;;OAEG;IACH,gBAKC;IAED;;;;;;;MASC;IAED;;OAEG;IACH,gCAKC;IAED;;OAEG;IACH;;;aAmBC;CACF;8BAlP6B,oBAAoB;gCAClB,sBAAsB;iCACrB,uBAAuB;6BAC3B,mBAAmB;6BACnB,mBAAmB;6BACnB,0BAA0B"}

package/dist/types/core/ModalManager.d.ts

@@ -0,0 +1,140 @@
+/**
+ * 🪟 GESTIÓN DE MODALES
+ * Responsabilidad única: Crear, mostrar y gestionar modales con accesibilidad
+ */
+export class ModalManager {
+    activeModals: Set<any>;
+    zIndexBase: number;
+    focusableSelectors: string;
+    initialized: boolean;
+    /**
+     * Crear y mostrar modal
+     */
+    createModal(config: any): Modal;
+    /**
+     * Cerrar modal específico
+     */
+    closeModal(modalId: any): boolean;
+    /**
+     * Cerrar todos los modales
+     */
+    closeAllModals(): void;
+    /**
+     * Obtener modal activo (último abierto)
+     */
+    getActiveModal(): any;
+    /**
+     * Obtener estadísticas
+     */
+    getStats(): {
+        active: number;
+        nextZIndex: number;
+    };
+    /**
+     * Generar ID único para modal
+     */
+    _generateModalId(): string;
+    /**
+     * Buscar modal por ID
+     */
+    _findModal(modalId: any): any;
+    /**
+     * Obtener siguiente z-index
+     */
+    _getNextZIndex(): number;
+    /**
+     * Remover modal del registro (llamado por Modal.destroy())
+     */
+    _removeModal(modal: any): void;
+    /**
+     * Manejar eventos de teclado globales
+     */
+    _handleGlobalKeydown(event: any): void;
+    /**
+     * Implementar tab trap para accesibilidad
+     */
+    _handleTabTrap(event: any, modal: any): void;
+    /**
+     * Inicializar listeners globales
+     */
+    _initGlobalListeners(): void;
+    globalKeydownHandler: (e: any) => void;
+    /**
+     * Cleanup
+     */
+    destroy(): void;
+}
+/**
+ * 🎭 CLASE MODAL INDIVIDUAL
+ * Representa un modal específico con su contenido y estado
+ */
+declare class Modal {
+    constructor(id: any, config: any, manager: any);
+    id: any;
+    config: any;
+    manager: any;
+    element: HTMLDivElement;
+    backdrop: HTMLDivElement;
+    isOpen: boolean;
+    previousFocus: Element;
+    /**
+     * Crear estructura del modal
+     */
+    _create(): void;
+    /**
+     * Crear backdrop
+     */
+    _createBackdrop(): void;
+    /**
+     * Crear estructura del modal
+     */
+    /**
+   * Crear modal principal
+   */
+    _createModal(): void;
+    /**
+     * Crear cabecera del modal
+     */
+    _createHeader(): void;
+    /**
+     * Crear cuerpo del modal
+     */
+    _createBody(): void;
+    /**
+     * Adjuntar eventos
+     */
+    _attachEvents(): void;
+    _originalBodyOverflow: string;
+    /**
+     * Abrir modal
+     */
+    open(): this;
+    /**
+     * Cerrar modal
+     */
+    close(): this;
+    /**
+     * Destruir modal
+     */
+    destroy(): void;
+    /**
+     * Obtener contenedor del cuerpo para React
+     */
+    getBodyContainer(): Element;
+    /**
+     * Obtener elementos focusables
+     */
+    getFocusableElements(): any[];
+    /**
+     * Getters
+     */
+    getId(): any;
+    isOpened(): boolean;
+    getConfig(): any;
+    /**
+     * Cleanup interno
+     */
+    _cleanup(): void;
+}
+export {};
+//# sourceMappingURL=ModalManager.d.ts.map

package/dist/types/core/ModalManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModalManager.d.ts","sourceRoot":"","sources":["../../../src/core/ModalManager.js"],"names":[],"mappings":"AACA;;;GAGG;AACH;IAEI,uBAA6B;IAC7B,mBAAuB;IACvB,2BAOY;IACZ,qBAAwB;IAK1B;;OAEG;IACH,gCAIC;IAED;;OAEG;IACH,kCAOC;IAED;;OAEG;IACH,uBAGC;IAED;;OAEG;IACH,sBAEC;IAED;;OAEG;IACH;;;MAKC;IAED;;OAEG;IACH,2BAEC;IAED;;OAEG;IACH,8BAEC;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,uCAcC;IAED;;OAEG;IACH,6CAoBC;IAED;;OAEG;IACH,6BAMC;IAHC,uCAA+D;IAKjE;;OAEG;IACH,gBASC;CACF;AAED;;;GAGG;AACH;IACE,gDAuBC;IAtBC,QAAY;IACZ,YAaC;IACD,aAAsB;IACtB,wBAAmB;IACnB,yBAAoB;IACpB,gBAAmB;IACnB,uBAAyB;IAK3B;;OAEG;IACH,gBAIC;IAED;;OAEG;IACH,wBAuBC;IAED;;OAEG;IACD;;KAEC;IACH,qBAwEC;IAED;;OAEG;IACH,sBA6EC;IAED;;OAEG;IACH,oBA0BC;IAED;;OAEG;IACH,sBAGC;IADC,8BAAyD;IAG3D;;OAEG;IACH,aA4DC;IAED;;OAEG;IACH,cAyCC;IAED;;OAEG;IACH,gBAQC;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,8BAEC;IAED;;OAEG;IACH,aAEC;IAED,oBAEC;IAED,iBAEC;IAED;;OAEG;IACH,iBAiBC;CACF"}

package/dist/types/hooks/useAiImage.d.ts

@@ -0,0 +1,10 @@
+export default function useAiImage(apiKey: any, prod?: boolean): {
+    generate: (params: any) => Promise<any>;
+    loading: boolean;
+    error: any;
+    image: any;
+    reset: () => void;
+    services: any[];
+    fetchServices: () => Promise<void>;
+};
+//# sourceMappingURL=useAiImage.d.ts.map

package/dist/types/hooks/useAiImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAiImage.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAiImage.js"],"names":[],"mappings":"AAGA;;;;;;;;EAyCC"}

package/dist/types/hooks/useAiServices.d.ts

@@ -0,0 +1,7 @@
+export default function useAiServices(apiKey: any, prod?: boolean): {
+    services: any[];
+    loading: boolean;
+    error: any;
+    invalidateCache: () => void;
+};
+//# sourceMappingURL=useAiServices.d.ts.map

package/dist/types/hooks/useAiServices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAiServices.d.ts","sourceRoot":"","sources":["../../../src/hooks/useAiServices.js"],"names":[],"mappings":"AAMA;;;;;EA4CC"}

package/dist/types/hooks/useContainerQuery.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Hook para detectar el tamaño del contenedor y aplicar estilos responsive
+ * dentro de modales o contenedores con tamaño limitado
+ *
+ * @param {Object} options - Configuración del hook
+ * @param {number} options.mobileBreakpoint - Breakpoint para móvil (default: 768)
+ * @param {number} options.tabletBreakpoint - Breakpoint para tablet (default: 1024)
+ * @param {boolean} options.observeResize - Si debe observar cambios de tamaño (default: true)
+ * @returns {Object} Estado responsive y referencia del elemento
+ */
+export function useContainerQuery(options?: {
+    mobileBreakpoint: number;
+    tabletBreakpoint: number;
+    observeResize: boolean;
+}): any;
+/**
+ * Hook simplificado solo para detección móvil dentro de contenedores
+ * @param {number} breakpoint - Breakpoint móvil (default: 768)
+ * @returns {Object} Estado móvil y referencia
+ */
+export function useContainerMobile(breakpoint?: number): any;
+/**
+ * Hook para obtener solo el ancho del contenedor
+ * @returns {Object} Ancho del contenedor y referencia
+ */
+export function useContainerWidth(): any;
+export default useContainerQuery;
+//# sourceMappingURL=useContainerQuery.d.ts.map

package/dist/types/hooks/useContainerQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useContainerQuery.d.ts","sourceRoot":"","sources":["../../../src/hooks/useContainerQuery.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,4CALG;IAAwB,gBAAgB,EAAhC,MAAM;IACU,gBAAgB,EAAhC,MAAM;IACW,aAAa,EAA9B,OAAO;CACf,OAyHF;AAED;;;;GAIG;AACH,gDAHW,MAAM,OAehB;AAED;;;GAGG;AACH,yCASC"}