local-lite 0.0.4 → 0.0.6

package/dist/react/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SyncIndicator = exports.SyncInspector = void 0;
 exports.clearLiveQueryCache = clearLiveQueryCache;
 exports.useLiveQuery = useLiveQuery;
+exports.useLiveQueries = useLiveQueries;
 exports.useLiveRow = useLiveRow;
 exports.useLiveInfiniteQuery = useLiveInfiniteQuery;
 exports.useMutations = useMutations;
@@ -32,10 +33,14 @@ function areRowsEqual(a, b) {
     if (aObj.id !== undefined && bObj.id !== undefined && aObj.id !== bObj.id) {
         return false;
     }
-    if (aObj.updated_at !== undefined &&
-        bObj.updated_at !== undefined &&
-        aObj.updated_at !== bObj.updated_at) {
-        return false;
+    const aTs = aObj.updated_at ?? aObj.updatedAt;
+    const bTs = bObj.updated_at ?? bObj.updatedAt;
+    if (aObj.id !== undefined &&
+        bObj.id !== undefined &&
+        aObj.id === bObj.id &&
+        aTs !== undefined &&
+        bTs !== undefined) {
+        return aTs === bTs;
     }
     const aKeys = Object.keys(aObj);
     const bKeys = Object.keys(bObj);
@@ -75,9 +80,50 @@ function areRowArraysEqual(a, b) {
     }
     return true;
 }
-// In-memory query result cache to eliminate initial render latency and flickering
-const queryCache = new Map();
+const MAX_QUERY_CACHE_SIZE = 100;
+class LRUQueryCache {
+    map = new Map();
+    get(key) {
+        const val = this.map.get(key);
+        if (val !== undefined) {
+            this.map.delete(key);
+            this.map.set(key, val);
+        }
+        return val;
+    }
+    set(key, val) {
+        if (this.map.has(key)) {
+            this.map.delete(key);
+        }
+        else if (this.map.size >= MAX_QUERY_CACHE_SIZE) {
+            const oldestKey = this.map.keys().next().value;
+            if (oldestKey !== undefined) {
+                this.map.delete(oldestKey);
+            }
+        }
+        this.map.set(key, val);
+    }
+    has(key) {
+        return this.map.has(key);
+    }
+    delete(key) {
+        return this.map.delete(key);
+    }
+    clear() {
+        this.map.clear();
+    }
+}
+// In-memory query result cache capped with LRU eviction to prevent memory leaks
+const queryCache = new LRUQueryCache();
 const inFlightQueries = new Map();
+async function fetchDeduped(key, fn) {
+    let inFlight = inFlightQueries.get(key);
+    if (!inFlight) {
+        inFlight = fn().finally(() => inFlightQueries.delete(key));
+        inFlightQueries.set(key, inFlight);
+    }
+    return inFlight;
+}
 /**
  * Clears the in-memory live query cache.
  */
@@ -119,27 +165,14 @@ function useLiveQuery(client, tableName, queryOrOptions) {
         if (!client || !client.db)
             return;
         try {
-            // De-duplicate simultaneous identical in-flight queries
-            let inFlight = inFlightQueries.get(cacheKey);
-            if (!inFlight) {
-                inFlight = (async () => {
-                    const param = queryParamRef.current;
-                    if (typeof param === 'function') {
-                        return (await param(client)) || [];
-                    }
-                    else if (typeof param === 'object' && param !== null) {
-                        return await client.findMany(tableName, param);
-                    }
-                    else {
-                        return await client.findMany(tableName);
-                    }
-                })();
-                inFlightQueries.set(cacheKey, inFlight);
-                inFlight.finally(() => {
-                    inFlightQueries.delete(cacheKey);
-                });
-            }
-            const res = (await inFlight) || [];
+            const res = await fetchDeduped(cacheKey, async () => {
+                const param = queryParamRef.current;
+                if (typeof param === 'function')
+                    return (await param(client)) || [];
+                if (typeof param === 'object' && param !== null)
+                    return await client.findMany(tableName, param);
+                return await client.findMany(tableName);
+            });
             queryCache.set(cacheKey, res);
             setData((prev) => (areRowArraysEqual(prev, res) ? prev : res));
         }
@@ -171,6 +204,174 @@ function useLiveQuery(client, tableName, queryOrOptions) {
     }, [client, tableName, queryKey, refetch, scheduleRefetch]);
     return { data, refetch, loading };
 }
+function normalizeMultiQueries(input) {
+    const items = [];
+    if (Array.isArray(input)) {
+        for (const item of input) {
+            if (typeof item === 'string') {
+                items.push({
+                    key: item,
+                    table: item,
+                    queryKey: 'all',
+                    cacheKey: `${item}:all`,
+                });
+            }
+            else if (typeof item === 'object' && item !== null && item.table) {
+                const { table, ...options } = item;
+                const qKey = JSON.stringify(options);
+                items.push({
+                    key: table,
+                    table,
+                    queryKey: qKey,
+                    cacheKey: `${table}:${qKey}`,
+                    options,
+                });
+            }
+        }
+    }
+    else if (typeof input === 'object' && input !== null) {
+        for (const [key, spec] of Object.entries(input)) {
+            if (typeof spec === 'string') {
+                items.push({
+                    key,
+                    table: spec,
+                    queryKey: 'all',
+                    cacheKey: `${spec}:all`,
+                });
+            }
+            else if (typeof spec === 'function') {
+                items.push({
+                    key,
+                    table: key,
+                    queryKey: 'custom',
+                    cacheKey: `${key}:custom`,
+                    fn: spec,
+                });
+            }
+            else if (typeof spec === 'object' && spec !== null) {
+                const table = spec.table || key;
+                const options = { ...spec };
+                delete options.table;
+                const qKey = JSON.stringify(options);
+                items.push({
+                    key,
+                    table,
+                    queryKey: qKey,
+                    cacheKey: `${table}:${qKey}`,
+                    options,
+                });
+            }
+        }
+    }
+    return items;
+}
+/**
+ * Reactive multi-table live query hook that loads data from multiple tables concurrently.
+ *
+ * Benefits:
+ * - Parallel fetching: queries SQLite tables concurrently via Promise.all.
+ * - Single atomic React commit: coalesces multiple table results into a single state update,
+ *   preventing cascading re-renders and UI freezing.
+ * - Multi-table event coordination: listens to mutations across all requested tables,
+ *   coalescing updates so downstream calculations only run once.
+ * - Zero-latency cache read-through: returns instant cached rows on mount.
+ *
+ * Usage with dictionary:
+ * ```ts
+ * const { data, loading } = useLiveQueries(client, {
+ *   projects: 'projects',
+ *   tasks: { where: { project_id: '123' }, orderBy: 'created_at' },
+ *   tags: { table: 'labels' }
+ * });
+ * // data.projects, data.tasks, data.tags
+ * ```
+ *
+ * Usage with array:
+ * ```ts
+ * const { data, loading } = useLiveQueries(client, ['projects', 'tasks', 'tags']);
+ * // data.projects, data.tasks, data.tags
+ * ```
+ */
+function useLiveQueries(client, queries) {
+    const signature = (0, react_1.useMemo)(() => {
+        return JSON.stringify(queries, (_, val) => (typeof val === 'function' ? 'fn' : val));
+    }, [queries]);
+    const items = (0, react_1.useMemo)(() => normalizeMultiQueries(queries), [signature]);
+    const [data, setData] = (0, react_1.useState)(() => {
+        const initial = {};
+        for (const item of items) {
+            const cached = queryCache.get(item.cacheKey);
+            initial[item.key] = cached ? cached : [];
+        }
+        return initial;
+    });
+    const [loading, setLoading] = (0, react_1.useState)(() => {
+        if (items.length === 0)
+            return false;
+        for (const item of items) {
+            if (!queryCache.has(item.cacheKey))
+                return true;
+        }
+        return false;
+    });
+    const refetch = (0, react_1.useCallback)(async () => {
+        if (!client || !client.db || items.length === 0)
+            return;
+        try {
+            const results = await Promise.all(items.map(async (item) => {
+                try {
+                    const rows = await fetchDeduped(item.cacheKey, async () => {
+                        if (item.fn)
+                            return (await item.fn(client)) || [];
+                        if (item.options)
+                            return await client.findMany(item.table, item.options);
+                        return await client.findMany(item.table);
+                    });
+                    queryCache.set(item.cacheKey, rows);
+                    return { key: item.key, rows };
+                }
+                catch (err) {
+                    const msg = String(err?.message || err || '');
+                    if (msg.includes('no such column') || msg.includes('no such table')) {
+                        return { key: item.key, rows: [] };
+                    }
+                    console.error(`Error in useLiveQueries("${item.table}"):`, err);
+                    return { key: item.key, rows: [] };
+                }
+            }));
+            setData((prev) => {
+                let changed = false;
+                const next = { ...prev };
+                for (const res of results) {
+                    if (!areRowArraysEqual(prev[res.key], res.rows)) {
+                        next[res.key] = res.rows;
+                        changed = true;
+                    }
+                }
+                return changed ? next : prev;
+            });
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [client, items]);
+    const scheduleRefetch = (0, runner_js_1.useCoalescedRunner)(refetch);
+    (0, react_1.useEffect)(() => {
+        if (!client || !client.db || items.length === 0)
+            return;
+        refetch();
+        const tables = Array.from(new Set(items.map((i) => i.table).filter(Boolean)));
+        const unsubs = tables.map((tbl) => client.events.on(tbl, () => {
+            scheduleRefetch();
+        }));
+        return () => {
+            for (const unsub of unsubs) {
+                unsub();
+            }
+        };
+    }, [client, signature, refetch, scheduleRefetch]);
+    return { data, loading, refetch };
+}
 /**
  * Reactive hook to query a single record by primary key with 0ms cache read-through.
  * Automatically re-renders only when this specific row or table changes.
@@ -191,13 +392,10 @@ function useLiveRow(client, tableName, rowId, options) {
             return;
         }
         try {
-            let inFlight = inFlightQueries.get(cacheKey);
-            if (!inFlight) {
-                inFlight = client.findById(tableName, rowId, options).then((r) => (r ? [r] : []));
-                inFlightQueries.set(cacheKey, inFlight);
-                inFlight.finally(() => inFlightQueries.delete(cacheKey));
-            }
-            const res = await inFlight;
+            const res = await fetchDeduped(cacheKey, async () => {
+                const r = await client.findById(tableName, rowId, options);
+                return r ? [r] : [];
+            });
             const row = res.length > 0 ? res[0] : null;
             if (row) {
                 queryCache.set(cacheKey, [row]);

package/dist/react/status.d.ts

@@ -13,6 +13,11 @@ export interface UseSyncStatusResult {
 /**
  * Consolidated hook that tracks real-time sync connectivity, sync worker activity
  * (pushing/pulling/syncing), and pending items in the local SQLite outbox queue.
+ *
+ * Performance notes:
+ * - sync:status events update isOnline/isPushing/isPulling/pendingCount in-place (no DB query).
+ * - The 50-record outbox fetch (pendingRecords) only runs on mount and on explicit refresh().
+ * - sync:push / sync:pull only trigger a lightweight pendingCount update via sync:status.
  */
 export declare function useSyncStatus(client: LocalFirstClient | null | undefined): UseSyncStatusResult;
 /**

package/dist/react/status.js

@@ -7,6 +7,11 @@ const runner_js_1 = require("./runner.js");
 /**
  * Consolidated hook that tracks real-time sync connectivity, sync worker activity
  * (pushing/pulling/syncing), and pending items in the local SQLite outbox queue.
+ *
+ * Performance notes:
+ * - sync:status events update isOnline/isPushing/isPulling/pendingCount in-place (no DB query).
+ * - The 50-record outbox fetch (pendingRecords) only runs on mount and on explicit refresh().
+ * - sync:push / sync:pull only trigger a lightweight pendingCount update via sync:status.
  */
 function useSyncStatus(client) {
     const [isOnline, setIsOnline] = (0, react_1.useState)(true);
@@ -44,33 +49,36 @@ function useSyncStatus(client) {
             // Ignored if client is stopping or tables initializing
         }
     }, [client]);
-    const scheduleRefresh = (0, runner_js_1.useCoalescedRunner)(refresh);
     (0, react_1.useEffect)(() => {
         if (!client || !client.db)
             return;
+        // Initial full fetch on mount
         refresh();
+        // sync:status fires after every push/pull cycle — update scalar fields directly,
+        // no DB round-trip needed. pendingCount comes from the event payload.
         const unsubStatus = client.events.on('sync:status', (e) => {
             setIsOnline(e.isOnline);
             setIsPushing(e.isPushing);
             setIsPulling(e.isPulling);
             setPendingCount(e.pendingCount);
         });
-        const unsubOutbox = client.events.on('sync_outbox', () => {
-            scheduleRefresh();
-        });
-        const unsubPush = client.events.on('sync:push', () => {
-            scheduleRefresh();
-        });
-        const unsubPull = client.events.on('sync:pull', () => {
-            scheduleRefresh();
+        // Only refresh lastSyncedAt after a completed pull (lightweight meta query only)
+        const unsubPull = client.events.on('sync:pull', async (e) => {
+            if (e?.success) {
+                try {
+                    const ts = await client.getLastSyncedAt().catch(() => null);
+                    if (ts !== null && ts !== undefined) {
+                        setLastSyncedAt(ts > 0 ? ts : null);
+                    }
+                }
+                catch { /* ignored */ }
+            }
         });
         return () => {
             unsubStatus();
-            unsubOutbox();
-            unsubPush();
             unsubPull();
         };
-    }, [client, refresh, scheduleRefresh]);
+    }, [client, refresh]);
     return {
         isOnline,
         isPushing,

package/dist/schema/generator.d.ts

@@ -0,0 +1,49 @@
+export interface SchemaIndexDefinition {
+    table: string;
+    columns: string[];
+    isOneToOne: boolean;
+    sql: string;
+    referencedRelation?: string;
+    referencedColumns?: string[];
+    comment?: string;
+}
+export interface GenerateSchemaIndexesOptions {
+    /**
+     * Path to the Supabase database.types.ts file.
+     */
+    typesPath?: string;
+    /**
+     * Raw string content of the database.types.ts file.
+     */
+    typesContent?: string;
+    /**
+     * Target path where the generated TypeScript file should be written.
+     */
+    outputPath?: string;
+    /**
+     * Whether to also generate composite sync indexes for tables with business_id and deleted.
+     * Default: true
+     */
+    includeBusinessSyncIndexes?: boolean;
+}
+export interface GenerateSchemaIndexesResult {
+    indexes: SchemaIndexDefinition[];
+    code: string;
+    written: boolean;
+    outputPath?: string;
+}
+/**
+ * Parses raw Supabase database.types.ts content and extracts foreign-key index definitions.
+ */
+export declare function parseSchemaIndexes(content: string, options?: {
+    includeBusinessSyncIndexes?: boolean;
+}): SchemaIndexDefinition[];
+/**
+ * Generates TypeScript source code containing index definitions and an applicator helper.
+ */
+export declare function formatSchemaIndexesCode(indexes: SchemaIndexDefinition[]): string;
+/**
+ * Core generator function.
+ * Accepts the path or content of database.types.ts and generates schema indexes.
+ */
+export declare function generateSchemaIndexes(typesPathOrOptions: string | GenerateSchemaIndexesOptions, maybeOutputPath?: string): Promise<GenerateSchemaIndexesResult>;

package/dist/schema/generator.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSchemaIndexes = parseSchemaIndexes;
+exports.formatSchemaIndexesCode = formatSchemaIndexesCode;
+exports.generateSchemaIndexes = generateSchemaIndexes;
+async function getNodeModules() {
+    try {
+        const fsModName = 'node:fs';
+        const pathModName = 'node:path';
+        const fsMod = await import(/* @vite-ignore */ fsModName);
+        const pathMod = await import(/* @vite-ignore */ pathModName);
+        return {
+            fs: (fsMod.default || fsMod),
+            path: (pathMod.default || pathMod),
+        };
+    }
+    catch {
+        const req = typeof require !== 'undefined' ? require : null;
+        if (req) {
+            return {
+                fs: req('fs'),
+                path: req('path'),
+            };
+        }
+        throw new Error('Node.js filesystem (fs) and path modules are not available in this environment.');
+    }
+}
+/**
+ * Parses raw Supabase database.types.ts content and extracts foreign-key index definitions.
+ */
+function parseSchemaIndexes(content, options = {}) {
+    const lines = content.split(/\r?\n/);
+    const includeBusiness = options.includeBusinessSyncIndexes ?? true;
+    let currentTable = null;
+    let inRow = false;
+    let inRelationships = false;
+    let relLines = [];
+    const tableColumns = new Map();
+    const relationships = [];
+    for (const line of lines) {
+        // Detect table definition: "      <table_name>: {"
+        const tableMatch = line.match(/^\s{6}([a-z0-9_]+):\s*\{/);
+        if (tableMatch && !['Row', 'Insert', 'Update'].includes(tableMatch[1])) {
+            currentTable = tableMatch[1];
+            if (!tableColumns.has(currentTable)) {
+                tableColumns.set(currentTable, new Set());
+            }
+        }
+        // Track column names in Row: { ... }
+        if (line.includes('Row: {')) {
+            inRow = true;
+            continue;
+        }
+        if (inRow) {
+            if (line.trim() === '};' || line.trim() === '}') {
+                inRow = false;
+            }
+            else if (currentTable) {
+                const colMatch = line.match(/^\s{10}([a-z0-9_]+):/);
+                if (colMatch) {
+                    tableColumns.get(currentTable)?.add(colMatch[1]);
+                }
+            }
+        }
+        // Skip empty relationships
+        if (line.includes('Relationships: [];') || line.includes('Relationships: []')) {
+            continue;
+        }
+        if (line.includes('Relationships: [')) {
+            inRelationships = true;
+            relLines = [];
+            continue;
+        }
+        if (inRelationships) {
+            if (line.trim() === '];' || line.trim() === ']') {
+                inRelationships = false;
+                if (currentTable) {
+                    const block = relLines.join('\n');
+                    const itemRegex = /foreignKeyName:\s*['"]([^'"]+)['"][\s\S]*?columns:\s*\[([^\]]+)\][\s\S]*?isOneToOne:\s*(true|false)[\s\S]*?referencedRelation:\s*['"]([^'"]+)['"](?:[\s\S]*?referencedColumns:\s*\[([^\]]+)\])?/g;
+                    const matches = [...block.matchAll(itemRegex)];
+                    for (const m of matches) {
+                        const columns = m[2].split(',').map(c => c.trim().replace(/['"]/g, ''));
+                        const isOneToOne = m[3] === 'true';
+                        const referencedRelation = m[4];
+                        const referencedColumns = m[5]
+                            ? m[5].split(',').map(c => c.trim().replace(/['"]/g, ''))
+                            : undefined;
+                        const isUnique = isOneToOne ? 'UNIQUE ' : '';
+                        const colSql = columns.map(c => `"${c}"`).join(', ');
+                        const colSlug = columns.join('_');
+                        const indexName = `idx_${currentTable}_${colSlug}`;
+                        relationships.push({
+                            table: currentTable,
+                            columns,
+                            isOneToOne,
+                            referencedRelation,
+                            referencedColumns,
+                            sql: `CREATE ${isUnique}INDEX IF NOT EXISTS "${indexName}" ON "${currentTable}" (${colSql});`,
+                            comment: referencedRelation
+                                ? `References ${referencedRelation}${referencedColumns ? `(${referencedColumns.join(', ')})` : ''}`
+                                : undefined,
+                        });
+                    }
+                }
+                continue;
+            }
+            relLines.push(line);
+        }
+    }
+    // Optionally append composite business sync indexes
+    if (includeBusiness) {
+        for (const [table, cols] of tableColumns.entries()) {
+            if (cols.has('business_id') && cols.has('deleted')) {
+                const idxName = `idx_${table}_biz_del`;
+                if (!relationships.some(r => r.table === table &&
+                    r.columns.length === 2 &&
+                    r.columns.includes('business_id') &&
+                    r.columns.includes('deleted'))) {
+                    relationships.push({
+                        table,
+                        columns: ['business_id', 'deleted'],
+                        isOneToOne: false,
+                        sql: `CREATE INDEX IF NOT EXISTS "${idxName}" ON "${table}" ("business_id", "deleted");`,
+                        comment: 'Composite business partition index for zero-latency local queries',
+                    });
+                }
+            }
+        }
+    }
+    return relationships;
+}
+/**
+ * Generates TypeScript source code containing index definitions and an applicator helper.
+ */
+function formatSchemaIndexesCode(indexes) {
+    const sqlStatements = indexes.map(i => i.sql).join('\n');
+    return `/**
+ * AUTO-GENERATED FILE - DO NOT EDIT MANUALLY.
+ * Generated by local-lite schema index generator.
+ */
+
+/**
+ * SQLite index statements extracted from Supabase database schema.
+ * Total indexes: ${indexes.length}
+ */
+export const SCHEMA_INDEXES: readonly string[] = \`
+${sqlStatements}
+\`.trim().split('\\n');
+
+/**
+ * Applies all schema indexes into SQLite to ensure zero-latency local reads.
+ * Executes each statement safely, ignoring errors if tables are not yet created.
+ */
+export async function ensureSchemaIndexes(db: {
+  execute: (query: string, params?: any[]) => Promise<any>;
+}): Promise<void> {
+  for (const sql of SCHEMA_INDEXES) {
+    try {
+      await db.execute(sql);
+    } catch {
+      // Safe fallback if table has not been created yet
+    }
+  }
+}
+`;
+}
+/**
+ * Core generator function.
+ * Accepts the path or content of database.types.ts and generates schema indexes.
+ */
+async function generateSchemaIndexes(typesPathOrOptions, maybeOutputPath) {
+    const options = typeof typesPathOrOptions === 'string'
+        ? { typesPath: typesPathOrOptions, outputPath: maybeOutputPath }
+        : typesPathOrOptions;
+    let content = options.typesContent;
+    if (!content && options.typesPath) {
+        const { fs, path } = await getNodeModules();
+        const resolvedPath = path.resolve(options.typesPath);
+        if (!fs.existsSync(resolvedPath)) {
+            throw new Error(`Types file not found at: ${resolvedPath}`);
+        }
+        content = fs.readFileSync(resolvedPath, 'utf8');
+    }
+    if (!content) {
+        throw new Error('Either typesPath or typesContent must be provided to generateSchemaIndexes.');
+    }
+    const indexes = parseSchemaIndexes(content, {
+        includeBusinessSyncIndexes: options.includeBusinessSyncIndexes,
+    });
+    const code = formatSchemaIndexesCode(indexes);
+    let written = false;
+    let resolvedOutputPath;
+    if (options.outputPath) {
+        const { fs, path } = await getNodeModules();
+        resolvedOutputPath = path.resolve(options.outputPath);
+        const parentDir = path.dirname(resolvedOutputPath);
+        if (!fs.existsSync(parentDir)) {
+            fs.mkdirSync(parentDir, { recursive: true });
+        }
+        fs.writeFileSync(resolvedOutputPath, code, 'utf8');
+        written = true;
+    }
+    return {
+        indexes,
+        code,
+        written,
+        outputPath: resolvedOutputPath,
+    };
+}

package/dist/schema/index.d.ts

@@ -0,0 +1 @@
+export * from './generator.js';

package/dist/schema/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./generator.js"), exports);

package/dist/utils/uuid.d.ts

@@ -1,7 +1,7 @@
 import { v4 as uuidv4 } from 'uuid';
 /**
  * Generates an RFC4122 v4 compliant UUID.
- * Uses native crypto.randomUUID() when supported, with uuid.v4 fallback.
+ * Uses native crypto.randomUUID() when available (detected once at import), with uuid.v4 fallback.
  */
 export declare function generateUUID(): string;
 export { uuidv4 };