@sincpro/mobile 0.1.0

package/dist/services/printer.service.js

@@ -0,0 +1,220 @@
+import { ReceiptExporterAdapter } from "../adapters/ReceiptExporter.adapter";
+import { SettingsRepository } from "../adapters/repositories/setting.repository";
+import { getPrinterDriver, hasPrinterDriver, setPrinterDriver, } from "../domain/print";
+import { loggerUseCases } from "../infrastructure/logger";
+import { UI_NOTIFICATION_EVENT } from "../infrastructure/ui/events";
+import { UIEventBus } from "../infrastructure/ui/UIEventBus";
+import { File } from "expo-file-system";
+import * as Print from "expo-print";
+import { bluetoothService } from "./bluetooth.service";
+class PrinterService {
+    bluetooth = bluetoothService;
+    cachedPrinter = null;
+    setDriver(driver) {
+        setPrinterDriver(driver);
+    }
+    hasDriver() {
+        return hasPrinterDriver();
+    }
+    getPairedDevices() {
+        return getPrinterDriver().getPairedDevices();
+    }
+    getPairedPrinters() {
+        return getPrinterDriver().getPairedPrinters();
+    }
+    isConnected() {
+        return getPrinterDriver().isConnected();
+    }
+    async connect(address, name) {
+        const hasPermissions = await this.bluetooth.ensurePermissionsForPrinter();
+        if (!hasPermissions) {
+            return false;
+        }
+        try {
+            await getPrinterDriver().connectBluetooth(address);
+            const printer = {
+                name,
+                address,
+                selectedAt: new Date().toISOString(),
+            };
+            await this.saveSelectedPrinter(printer);
+            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
+                type: "success",
+                text1: "Impresora conectada",
+                text2: `Conectado a ${name}`,
+            });
+            return true;
+        }
+        catch (error) {
+            loggerUseCases.error(`Failed to connect to printer: ${name}`, error);
+            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
+                type: "error",
+                text1: "Error de conexión",
+                text2: `No se pudo conectar a ${name}`,
+            });
+            return false;
+        }
+    }
+    async disconnect() {
+        try {
+            await getPrinterDriver().disconnect();
+            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
+                type: "info",
+                text1: "Desconectado",
+                text2: "Impresora desconectada",
+            });
+        }
+        catch (error) {
+            loggerUseCases.error("Error disconnecting from printer", error);
+        }
+    }
+    async getSelectedPrinter() {
+        if (this.cachedPrinter) {
+            return this.cachedPrinter;
+        }
+        const printer = await SettingsRepository.getSettingByName("common.selected_printer" /* ECommonSetting.SELECTED_PRINTER */);
+        this.cachedPrinter = printer;
+        return printer;
+    }
+    async saveSelectedPrinter(printer) {
+        await SettingsRepository.saveOneSetting("common.selected_printer" /* ECommonSetting.SELECTED_PRINTER */, printer);
+        this.cachedPrinter = printer;
+    }
+    async clearSelectedPrinter() {
+        await SettingsRepository.saveOneSetting("common.selected_printer" /* ECommonSetting.SELECTED_PRINTER */, null);
+        this.cachedPrinter = null;
+    }
+    async printTestPage() {
+        if (!this.isConnected()) {
+            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
+                type: "error",
+                text1: "Sin conexión",
+                text2: "Conecta una impresora primero",
+            });
+            return false;
+        }
+        try {
+            await getPrinterDriver().printText("=== PRUEBA DE IMPRESIÓN ===", {
+                alignment: "center",
+                bold: true,
+                fontSize: "large",
+            });
+            await getPrinterDriver().printText("Impresora configurada correctamente", {
+                alignment: "center",
+                fontSize: "medium",
+            });
+            await getPrinterDriver().printText(new Date().toLocaleString(), {
+                alignment: "center",
+                fontSize: "small",
+            });
+            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
+                type: "success",
+                text1: "Impresión exitosa",
+                text2: "Página de prueba impresa",
+            });
+            return true;
+        }
+        catch (error) {
+            loggerUseCases.error("Error printing test page", error);
+            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
+                type: "error",
+                text1: "Error de impresión",
+                text2: "No se pudo imprimir la página de prueba",
+            });
+            return false;
+        }
+    }
+    async printImageBase64(base64Data) {
+        const connected = await this.ensureConnected();
+        if (!connected)
+            return false;
+        try {
+            await getPrinterDriver().printImageBase64(base64Data);
+            return true;
+        }
+        catch (error) {
+            loggerUseCases.error("Error printing image", error);
+            return false;
+        }
+    }
+    async printFromView(viewRef) {
+        const connected = await this.ensureConnected();
+        if (!connected)
+            return false;
+        try {
+            const imageBase64 = await ReceiptExporterAdapter.captureAsImageBase64(viewRef);
+            if (!imageBase64) {
+                loggerUseCases.warn("Could not capture view for printing");
+                return false;
+            }
+            await getPrinterDriver().printImageBase64(imageBase64);
+            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
+                type: "success",
+                text1: "Impresión enviada",
+                text2: "Documento enviado a la impresora",
+            });
+            return true;
+        }
+        catch (error) {
+            loggerUseCases.error("Error printing from view", error);
+            return false;
+        }
+    }
+    async printHtml(html) {
+        const connected = await this.ensureConnected();
+        if (!connected)
+            return false;
+        try {
+            const pdfBase64 = await this.htmlToPdfBase64(html);
+            if (!pdfBase64) {
+                loggerUseCases.warn("Could not convert HTML to PDF");
+                return false;
+            }
+            loggerUseCases.info("PDF base64 length:", pdfBase64.length);
+            await getPrinterDriver().printPdfBase64(pdfBase64, 1);
+            return true;
+        }
+        catch (error) {
+            loggerUseCases.error("Error printing HTML", error);
+            return false;
+        }
+    }
+    async htmlToPdfBase64(html) {
+        try {
+            const THERMAL_WIDTH_PX = 576;
+            const THERMAL_HEIGHT_PX = 1500;
+            const { uri } = await Print.printToFileAsync({
+                html,
+                width: THERMAL_WIDTH_PX,
+                height: THERMAL_HEIGHT_PX,
+            });
+            if (!uri)
+                return null;
+            loggerUseCases.info("PDF generated at:", uri);
+            const file = new File(uri);
+            const pdfBase64 = await file.base64();
+            await file.delete();
+            return pdfBase64;
+        }
+        catch (error) {
+            loggerUseCases.error("Error converting HTML to PDF", error);
+            return null;
+        }
+    }
+    async ensureConnected() {
+        if (this.isConnected()) {
+            return true;
+        }
+        const printer = await this.getSelectedPrinter();
+        if (!printer) {
+            UIEventBus.emit(UI_NOTIFICATION_EVENT, {
+                type: "error",
+                text1: "Sin impresora",
+                text2: "Selecciona una impresora primero",
+            });
+            return false;
+        }
+        return this.connect(printer.address, printer.name);
+    }
+}
+export const printerService = new PrinterService();

package/dist/services/webview.service.d.ts

@@ -0,0 +1,17 @@
+import { type IAjaxInterceptedMessage, type IContentReadyMessage, type IInjectedScript, type IInjectionReadyMessage, type IPrintImageMessage, type IPrintRequestMessage, type TWebViewMessage } from "../domain/webview";
+declare class WebViewService {
+    private interceptors;
+    registerInterceptor(interceptor: IInjectedScript): void;
+    unregisterInterceptor(name: string): void;
+    getInterceptor(name: string): IInjectedScript | undefined;
+    getAllInterceptors(): IInjectedScript[];
+    combineScripts(scripts?: IInjectedScript[], additionalScript?: string): string;
+    parseMessage(rawData: string): TWebViewMessage | null;
+    isPrintRequest(msg: TWebViewMessage): msg is IPrintRequestMessage;
+    isPrintImage(msg: TWebViewMessage): msg is IPrintImageMessage;
+    isContentReady(msg: TWebViewMessage): msg is IContentReadyMessage;
+    isInjectionReady(msg: TWebViewMessage): msg is IInjectionReadyMessage;
+    isAjaxIntercepted(msg: TWebViewMessage): msg is IAjaxInterceptedMessage;
+}
+export declare const webViewService: WebViewService;
+export {};

package/dist/services/webview.service.js

@@ -0,0 +1,59 @@
+import { EWebViewMessageType, } from "../domain/webview";
+import { safeJsonParse } from "../tools/utils/serializer";
+class WebViewService {
+    interceptors = new Map();
+    registerInterceptor(interceptor) {
+        this.interceptors.set(interceptor.name, interceptor);
+    }
+    unregisterInterceptor(name) {
+        this.interceptors.delete(name);
+    }
+    getInterceptor(name) {
+        return this.interceptors.get(name);
+    }
+    getAllInterceptors() {
+        return Array.from(this.interceptors.values());
+    }
+    combineScripts(scripts, additionalScript) {
+        const parts = [];
+        if (scripts) {
+            for (const script of scripts) {
+                parts.push(script.script);
+            }
+        }
+        if (additionalScript) {
+            parts.push(additionalScript);
+        }
+        return parts.join("\n\n");
+    }
+    parseMessage(rawData) {
+        try {
+            const parsed = safeJsonParse(rawData);
+            if (!parsed || !parsed.type)
+                return null;
+            const validTypes = Object.values(EWebViewMessageType);
+            if (!validTypes.includes(parsed.type))
+                return null;
+            return parsed;
+        }
+        catch {
+            return null;
+        }
+    }
+    isPrintRequest(msg) {
+        return msg.type === EWebViewMessageType.PRINT_REQUEST;
+    }
+    isPrintImage(msg) {
+        return msg.type === EWebViewMessageType.PRINT_IMAGE;
+    }
+    isContentReady(msg) {
+        return msg.type === EWebViewMessageType.CONTENT_READY;
+    }
+    isInjectionReady(msg) {
+        return msg.type === EWebViewMessageType.INJECTION_READY;
+    }
+    isAjaxIntercepted(msg) {
+        return msg.type === EWebViewMessageType.AJAX_INTERCEPTED;
+    }
+}
+export const webViewService = new WebViewService();

package/dist/tools/utils/Initials.d.ts

@@ -0,0 +1 @@
+export declare const getUserInitials: (fullName: string, maxInitials?: number) => string;

package/dist/tools/utils/Initials.js

@@ -0,0 +1,12 @@
+export const getUserInitials = (fullName, maxInitials = 2) => {
+    if (!fullName || typeof fullName !== "string")
+        return "";
+    const words = fullName.trim().split(/\s+/).filter(Boolean);
+    if (words.length === 0)
+        return "";
+    const initials = words.length > 1 ? [words[0], words[words.length - 1]] : [words[0]];
+    return initials
+        .slice(0, maxInitials)
+        .map((word) => word.charAt(0).toUpperCase())
+        .join("");
+};

package/dist/tools/utils/collections.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Converts the input value into an array. If the value is already an array, it is returned as is.
+ * If the value is a Set, it is converted to an array. Otherwise, the value is wrapped in an array.
+ *
+ * @param value The value to convert. It can be a single item, an array, a Set, or undefined.
+ * @returns     An array containing the input value(s). If the input is undefined or null, an empty array is returned.
+ *
+ * @example
+ * // Single value: wrapped in an array
+ * const single = convertToArray(42);
+ * // single: [42]
+ *
+ * @example
+ * // Already an array: returned as-is
+ * const fromArray = convertToArray(['a', 'b', 'c']);
+ * // fromArray: ['a', 'b', 'c']
+ *
+ * @example
+ * // From a Set: converted to array
+ * const mySet = new Set<number>([1, 2, 3]);
+ * const fromSet = convertToArray(mySet);
+ * // fromSet: [1, 2, 3]
+ */
+export declare function convertToArray<T>(value: T | T[] | Set<T> | undefined): T[];
+type PropertyKey = string | number | symbol;
+type KeySelector<T, K extends PropertyKey> = keyof T | ((item: T) => K);
+/**
+ * Groups an array of items by a given property or key-selector function.
+ *
+ * @param array    The array of items to group.
+ * @param selector Either the name of a property on T, or a function that returns the key.
+ * @returns        A record where each key maps to an array of items sharing that key.
+ *
+ * @example
+ * interface Product { id: number; name: string; category: string; }
+ * const products: Product[] = [
+ *   { id: 1, name: 'Milk',   category: 'dairy' },
+ *   { id: 2, name: 'Cheese', category: 'dairy' },
+ *   { id: 3, name: 'Apple',  category: 'fruit' },
+ * ];
+ *
+ * // Group by property:
+ * const byCategory = groupBy(products, 'category');
+ * // { dairy: [ {…}, {…} ], fruit: [ {…} ] }
+ *
+ * // Group by function:
+ * const byFirstLetter = groupBy(products, p => p.name[0]);
+ * // { M: [ {…} ], C: [ {…} ], A: [ {…} ] }
+ */
+export declare function groupBy<T, K extends PropertyKey>(array: T[], selector: KeySelector<T, K>): Record<K, T[]>;
+/**
+ * Creates a lookup object where each key maps to the last item in the array
+ * that corresponds to that key. If multiple items share the same key,
+ * the last one wins.
+ *
+ * @param array     – The array of items to index.
+ * @param selector  – A property name of T, or a function that returns the key.
+ * @returns         A record where each key maps to a single item.
+ *
+ * @example
+ * interface User { id: number; name: string; }
+ * const users: User[] = [
+ *   { id: 1, name: 'Alice' },
+ *   { id: 2, name: 'Bob' },
+ *   { id: 1, name: 'Alicia' },
+ * ];
+ *
+ * // Index by property:
+ * const byId = keyBy(users, 'id');
+ * // byId === {
+ * //   1: { id: 1, name: 'Alicia' }, // last one wins
+ * //   2: { id: 2, name: 'Bob' }
+ * // }
+ *
+ * @example
+ * // Index by function:
+ * const byInitial = keyBy(users, u => u.name[0]);
+ * // byInitial === {
+ * //   A: { id: 1, name: 'Alicia' },
+ * //   B: { id: 2, name: 'Bob' }
+ * // }
+ */
+export declare function keyBy<T, K extends PropertyKey>(array: T[], selector: KeySelector<T, K>): Record<K, T>;
+/**
+ * Creates a lookup Map where each key maps to the last value
+ * produced by `valueSelector` for items in the array.
+ * If multiple items share the same key, the last one wins.
+ *
+ * @param array          – The array of items to index.
+ * @param keySelector    – A property name of T, or a function that returns the key.
+ * @param valueSelector  – A function that returns the value to store for each key.
+ * @returns              A Map where each key maps to a single value.
+ *
+ * @example
+ * interface User { id: number; name: string; }
+ * const users: User[] = [
+ *   { id: 1, name: 'Alice' },
+ *   { id: 2, name: 'Bob' },
+ *   { id: 1, name: 'Alicia' },
+ * ];
+ *
+ * // Map by property, valueSelector returns the user’s name:
+ * const nameMap = toMap(users, 'id', u => u.name);
+ * // nameMap.get(1) === 'Alicia'   // last one wins
+ * // nameMap.get(2) === 'Bob'
+ *
+ * @example
+ * interface MoveLine { id: number; product_id: number; quantity: number; }
+ * const moves: MoveLine[] = [
+ *   { id: 17, product_id: 842, quantity: 42 },
+ *   { id: 18, product_id: 838, quantity: 45 },
+ * ];
+ *
+ * // Map product_id → quantity:
+ * const qtyMap = toMap(moves, m => m.product_id, m => m.quantity);
+ * // qtyMap.get(842) === 42
+ * // qtyMap.get(838) === 45
+ */
+export declare function toMap<T, K extends PropertyKey, V>(array: T[], keySelector: KeySelector<T, K>, valueSelector: (item: T) => V): Map<K, V>;
+export {};

package/dist/tools/utils/collections.js

@@ -0,0 +1,158 @@
+/**
+ * Converts the input value into an array. If the value is already an array, it is returned as is.
+ * If the value is a Set, it is converted to an array. Otherwise, the value is wrapped in an array.
+ *
+ * @param value The value to convert. It can be a single item, an array, a Set, or undefined.
+ * @returns     An array containing the input value(s). If the input is undefined or null, an empty array is returned.
+ *
+ * @example
+ * // Single value: wrapped in an array
+ * const single = convertToArray(42);
+ * // single: [42]
+ *
+ * @example
+ * // Already an array: returned as-is
+ * const fromArray = convertToArray(['a', 'b', 'c']);
+ * // fromArray: ['a', 'b', 'c']
+ *
+ * @example
+ * // From a Set: converted to array
+ * const mySet = new Set<number>([1, 2, 3]);
+ * const fromSet = convertToArray(mySet);
+ * // fromSet: [1, 2, 3]
+ */
+export function convertToArray(value) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (value instanceof Set) {
+        return Array.from(value);
+    }
+    if (!Array.isArray(value)) {
+        return [value];
+    }
+    return value;
+}
+/**
+ * Groups an array of items by a given property or key-selector function.
+ *
+ * @param array    The array of items to group.
+ * @param selector Either the name of a property on T, or a function that returns the key.
+ * @returns        A record where each key maps to an array of items sharing that key.
+ *
+ * @example
+ * interface Product { id: number; name: string; category: string; }
+ * const products: Product[] = [
+ *   { id: 1, name: 'Milk',   category: 'dairy' },
+ *   { id: 2, name: 'Cheese', category: 'dairy' },
+ *   { id: 3, name: 'Apple',  category: 'fruit' },
+ * ];
+ *
+ * // Group by property:
+ * const byCategory = groupBy(products, 'category');
+ * // { dairy: [ {…}, {…} ], fruit: [ {…} ] }
+ *
+ * // Group by function:
+ * const byFirstLetter = groupBy(products, p => p.name[0]);
+ * // { M: [ {…} ], C: [ {…} ], A: [ {…} ] }
+ */
+export function groupBy(array, selector) {
+    const getKey = typeof selector === "function"
+        ? selector
+        : (item) => item[selector];
+    return array.reduce((groups, item) => {
+        const key = getKey(item);
+        if (!groups[key]) {
+            groups[key] = [];
+        }
+        groups[key].push(item);
+        return groups;
+    }, {});
+}
+/**
+ * Creates a lookup object where each key maps to the last item in the array
+ * that corresponds to that key. If multiple items share the same key,
+ * the last one wins.
+ *
+ * @param array     – The array of items to index.
+ * @param selector  – A property name of T, or a function that returns the key.
+ * @returns         A record where each key maps to a single item.
+ *
+ * @example
+ * interface User { id: number; name: string; }
+ * const users: User[] = [
+ *   { id: 1, name: 'Alice' },
+ *   { id: 2, name: 'Bob' },
+ *   { id: 1, name: 'Alicia' },
+ * ];
+ *
+ * // Index by property:
+ * const byId = keyBy(users, 'id');
+ * // byId === {
+ * //   1: { id: 1, name: 'Alicia' }, // last one wins
+ * //   2: { id: 2, name: 'Bob' }
+ * // }
+ *
+ * @example
+ * // Index by function:
+ * const byInitial = keyBy(users, u => u.name[0]);
+ * // byInitial === {
+ * //   A: { id: 1, name: 'Alicia' },
+ * //   B: { id: 2, name: 'Bob' }
+ * // }
+ */
+export function keyBy(array, selector) {
+    const getKey = typeof selector === "function"
+        ? selector
+        : (item) => item[selector];
+    return array.reduce((map, item) => {
+        const key = getKey(item);
+        map[key] = item;
+        return map;
+    }, {});
+}
+/**
+ * Creates a lookup Map where each key maps to the last value
+ * produced by `valueSelector` for items in the array.
+ * If multiple items share the same key, the last one wins.
+ *
+ * @param array          – The array of items to index.
+ * @param keySelector    – A property name of T, or a function that returns the key.
+ * @param valueSelector  – A function that returns the value to store for each key.
+ * @returns              A Map where each key maps to a single value.
+ *
+ * @example
+ * interface User { id: number; name: string; }
+ * const users: User[] = [
+ *   { id: 1, name: 'Alice' },
+ *   { id: 2, name: 'Bob' },
+ *   { id: 1, name: 'Alicia' },
+ * ];
+ *
+ * // Map by property, valueSelector returns the user’s name:
+ * const nameMap = toMap(users, 'id', u => u.name);
+ * // nameMap.get(1) === 'Alicia'   // last one wins
+ * // nameMap.get(2) === 'Bob'
+ *
+ * @example
+ * interface MoveLine { id: number; product_id: number; quantity: number; }
+ * const moves: MoveLine[] = [
+ *   { id: 17, product_id: 842, quantity: 42 },
+ *   { id: 18, product_id: 838, quantity: 45 },
+ * ];
+ *
+ * // Map product_id → quantity:
+ * const qtyMap = toMap(moves, m => m.product_id, m => m.quantity);
+ * // qtyMap.get(842) === 42
+ * // qtyMap.get(838) === 45
+ */
+export function toMap(array, keySelector, valueSelector) {
+    const getKey = (item) => typeof keySelector === "function"
+        ? keySelector(item)
+        : item[keySelector];
+    const map = new Map();
+    for (const item of array) {
+        map.set(getKey(item), valueSelector(item));
+    }
+    return map;
+}

package/dist/tools/utils/date.d.ts

@@ -0,0 +1,70 @@
+interface FormatDateOptions {
+    locale?: string | null;
+    showTime?: boolean;
+}
+/**
+ * Formatea una fecha en la zona horaria indicada respetando la granularidad de la entrada.
+ *
+ * Reglas de detección:
+ * 1. Si `input` es un string 'YYYY-MM-DD' (solo fecha) => se interpreta como medianoche (00:00:00)
+ *    en la zona horaria destino y se devuelve SOLO la parte de fecha (sin hora).
+ * 2. Si `input` incluye componente de tiempo (ISO completo o Date) => se convierte a la zona destino
+ *    y se muestra fecha + hora (HH:MM) salvo que se fuerce lo contrario mediante `options.showTime`.
+ * 3. Cuando `options.showTime` es `true` o `false` se sobre‑escribe la auto‑detección.
+ * 4. Si `timezone` es null/undefined o inválido se retorna la cadena "Error de formateo".
+ *
+ * Localización:
+ * - Usa el primer locale del dispositivo (`expo-localization`) como predeterminado.
+ * - Puedes forzar uno diferente con `options.locale` (ej: 'es-CR', 'en-US').
+ *
+ * Seguridad de zona horaria:
+ * - El parse de una fecha sin hora NO se hace en la zona local del dispositivo para luego convertir,
+ *   sino directamente en la zona destino para evitar corrimientos de día.
+ *
+ * Ejemplos:
+ * ```ts
+ * formatDate('2025-09-02', 'America/Costa_Rica');
+ * // => "2 de septiembre de 2025"
+ *
+ * formatDate('2025-09-02T18:30:00Z', 'America/Costa_Rica');
+ * // => "2 de septiembre de 2025, 12:30 p. m." (dependiendo del locale real)
+ *
+ * formatDate(new Date('2025-09-02T23:15:00Z'), 'Europe/Madrid');
+ * // => "3 de septiembre de 2025, 01:15" (cambio de día por zona +02)
+ *
+ * formatDate('2025-09-02', 'America/Costa_Rica', { showTime: true });
+ * // => "2 de septiembre de 2025, 12:00 a. m." (fuerza hora)
+ * ```
+ *
+ * @param input      Fecha (string ISO, 'YYYY-MM-DD' o instancia Date)
+ * @param timezone   Zona horaria IANA (ej: 'America/Costa_Rica', 'Asia/Tokyo'). Si es null/undefined usa Costa Rica
+ * @param options    Opcional: locale forzado y/o bandera para mostrar hora
+ * @returns          Cadena localizada o "Error de formateo" si no se puede procesar
+ */
+export declare function formatDate(input: string | Date, timezone: string | null | undefined, options?: FormatDateOptions): string;
+/**
+ * Formatea una fecha usando automáticamente el timezone por defecto (Costa Rica).
+ * Útil para casos donde no se tiene acceso al timezone del usuario.
+ *
+ * @param input      Fecha (string ISO, 'YYYY-MM-DD' o instancia Date)
+ * @param options    Opcional: locale forzado y/o bandera para mostrar hora
+ * @returns          Cadena localizada en timezone de Costa Rica
+ */
+export declare function formatDateWithDefaultTimezone(input: string | Date, options?: FormatDateOptions): string;
+/**
+ * Obtiene la fecha actual en formato YYYY-MM-DD en el timezone especificado.
+ * Útil para crear fechas de programación que respeten el timezone del usuario.
+ *
+ * @param timezone Zona horaria IANA. Si es null/undefined usa Costa Rica
+ * @returns Fecha actual en formato YYYY-MM-DD en el timezone especificado
+ */
+export declare function getCurrentDateInTimezone(timezone?: string | null): string;
+/**
+ * Obtiene la fecha y hora actual en formato ISO en el timezone especificado.
+ * Útil para timestamps que necesiten reflejar el timezone del usuario.
+ *
+ * @param timezone Zona horaria IANA. Si es null/undefined usa Costa Rica
+ * @returns Fecha actual en formato ISO en el timezone especificado
+ */
+export declare function getCurrentDateTimeInTimezone(timezone?: string | null): string;
+export {};