@fer2809fl/baileys 7.0.2 → 7.0.5

package/lib/Utils/chat-utils.js

@@ -38,7 +38,7 @@ const to64BitNetworkOrder = (e) => {
     buff.writeUint32BE(e, 4);
     return buff;
 };
-const makeLtHashGenerator = ({ indexValueMap, hash }) => {
+export const makeLtHashGenerator = ({ indexValueMap, hash }) => {
     indexValueMap = { ...indexValueMap };
     const addBuffs = [];
     const subBuffs = [];
@@ -48,7 +48,10 @@ const makeLtHashGenerator = ({ indexValueMap, hash }) => {
             const prevOp = indexValueMap[indexMacBase64];
             if (operation === proto.SyncdMutation.SyncdOperation.REMOVE) {
                 if (!prevOp) {
-                    throw new Boom('tried remove, but no previous op', { data: { indexMac, valueMac } });
+                    // WA Web does not throw here — it logs a warning and skips the subtract.
+                    // The missing REMOVE will cause an LTHash mismatch, which is handled
+                    // by the MAC validation layer (snapshot recovery or retry).
+                    return;
                 }
                 // remove from index value mac, since this mutation is erased
                 delete indexValueMap[indexMacBase64];
@@ -80,10 +83,33 @@ const generatePatchMac = (snapshotMac, valueMacs, version, type, key) => {
     return hmacSign(total, key);
 };
 export const newLTHashState = () => ({ version: 0, hash: Buffer.alloc(128), indexValueMap: {} });
+export const ensureLTHashStateVersion = (state) => {
+    if (typeof state.version !== 'number' || isNaN(state.version)) {
+        state.version = 0;
+    }
+    return state;
+};
+export const MAX_SYNC_ATTEMPTS = 2;
+/**
+ * Check if an error is a missing app state sync key.
+ * WA Web treats these as "Blocked" (waits for key arrival), not fatal.
+ * In Baileys we retry with a snapshot which may use a different key.
+ */
+export const isMissingKeyError = (error) => {
+    return error?.data?.isMissingKey === true;
+};
+/**
+ * Determines if an app state sync error is unrecoverable.
+ * TypeError indicates a WASM crash; otherwise we give up after MAX_SYNC_ATTEMPTS.
+ * Missing keys are NOT checked here — they are handled separately as "Blocked".
+ */
+export const isAppStateSyncIrrecoverable = (error, attempts) => {
+    return attempts >= MAX_SYNC_ATTEMPTS || error?.name === 'TypeError';
+};
 export const encodeSyncdPatch = async ({ type, index, syncAction, apiVersion, operation }, myAppStateKeyId, state, getAppStateSyncKey) => {
     const key = !!myAppStateKeyId ? await getAppStateSyncKey(myAppStateKeyId) : undefined;
     if (!key) {
-        throw new Boom(`myAppStateKey ("${myAppStateKeyId}") not present`, { statusCode: 404 });
+        throw new Boom(`myAppStateKey ("${myAppStateKeyId}") not present`, { data: { isMissingKey: true } });
     }
     const encKeyId = Buffer.from(myAppStateKeyId, 'base64');
     state = { ...state, indexValueMap: { ...state.indexValueMap } };
@@ -139,17 +165,36 @@ export const decodeSyncdMutations = async (msgMutations, initialState, getAppSta
         // otherwise, if it's only a record -- it'll be a SET mutation
         const operation = 'operation' in msgMutation ? msgMutation.operation : proto.SyncdMutation.SyncdOperation.SET;
         const record = 'record' in msgMutation && !!msgMutation.record ? msgMutation.record : msgMutation;
-        const key = await getKey(record.keyId.id);
+        let key;
+        try {
+            key = await getKey(record.keyId.id);
+        }
+        catch (err) {
+            // Missing-key errors must propagate so the orchestrator can park the
+            // collection (Blocked) and retry when APP_STATE_SYNC_KEY_SHARE arrives.
+            // Other errors → individual record corruption, skip and keep going.
+            if (isMissingKeyError(err))
+                throw err;
+            continue;
+        }
         const content = record.value.blob;
         const encContent = content.subarray(0, -32);
         const ogValueMac = content.subarray(-32);
         if (validateMacs) {
             const contentHmac = generateMac(operation, encContent, record.keyId.id, key.valueMacKey);
             if (Buffer.compare(contentHmac, ogValueMac) !== 0) {
-                throw new Boom('HMAC content verification failed');
+                // HMAC verification failed — skip this record
+                continue;
             }
         }
-        const result = aesDecrypt(encContent, key.valueEncryptionKey);
+        let result;
+        try {
+            result = aesDecrypt(encContent, key.valueEncryptionKey);
+        }
+        catch {
+            // decrypt failed — skip this record instead of aborting
+            continue;
+        }
         const syncAction = proto.SyncActionData.decode(result);
         if (validateMacs) {
             const hmac = hmacSign(syncAction.index, key.indexKey);
@@ -175,8 +220,7 @@ export const decodeSyncdMutations = async (msgMutations, initialState, getAppSta
         const keyEnc = await getAppStateSyncKey(base64Key);
         if (!keyEnc) {
             throw new Boom(`failed to find key "${base64Key}" to decode mutation`, {
-                statusCode: 404,
-                data: { msgMutations }
+                data: { isMissingKey: true, msgMutations }
             });
         }
         const keys = mutationKeys(keyEnc.keyData);
@@ -189,7 +233,7 @@ export const decodeSyncdPatch = async (msg, name, initialState, getAppStateSyncK
         const base64Key = Buffer.from(msg.keyId.id).toString('base64');
         const mainKeyObj = await getAppStateSyncKey(base64Key);
         if (!mainKeyObj) {
-            throw new Boom(`failed to find key "${base64Key}" to decode patch`, { statusCode: 404, data: { msg } });
+            throw new Boom(`failed to find key "${base64Key}" to decode patch`, { data: { isMissingKey: true, msg } });
         }
         const mainKey = mutationKeys(mainKeyObj.keyData);
         const mutationmacs = msg.mutations.map(mutation => mutation.record.value.blob.slice(-32));
@@ -250,7 +294,7 @@ export const downloadExternalPatch = async (blob, options) => {
     const syncData = proto.SyncdMutations.decode(buffer);
     return syncData;
 };
-export const decodeSyncdSnapshot = async (name, snapshot, getAppStateSyncKey, minimumVersionNumber, validateMacs = true) => {
+export const decodeSyncdSnapshot = async (name, snapshot, getAppStateSyncKey, minimumVersionNumber, validateMacs = true, logger) => {
     const newState = newLTHashState();
     newState.version = toNumber(snapshot.version.version);
     const mutationMap = {};
@@ -267,12 +311,17 @@ export const decodeSyncdSnapshot = async (name, snapshot, getAppStateSyncKey, mi
         const base64Key = Buffer.from(snapshot.keyId.id).toString('base64');
         const keyEnc = await getAppStateSyncKey(base64Key);
         if (!keyEnc) {
-            throw new Boom(`failed to find key "${base64Key}" to decode mutation`);
+            throw new Boom(`failed to find key "${base64Key}" to decode mutation`, { data: { isMissingKey: true } });
         }
         const result = mutationKeys(keyEnc.keyData);
         const computedSnapshotMac = generateSnapshotMac(newState.hash, newState.version, name, result.snapshotMacKey);
         if (Buffer.compare(snapshot.mac, computedSnapshotMac) !== 0) {
-            throw new Boom(`failed to verify LTHash at ${newState.version} of ${name} from snapshot`);
+            // LTHash verification may fail when decodeSyncdMutations skipped undecryptable
+            // records (poisoned server-side snapshot); the aggregate client hash diverges
+            // from the server-computed mac. Fall through with a warning so the session stays
+            // alive with partial state, symmetric to how decodePatches handles its own
+            // LTHash mismatch a few lines below.
+            logger?.warn({ name, version: newState.version }, 'LTHash verification failed on snapshot, continuing with partial state');
         }
     }
     return {
@@ -297,24 +346,34 @@ export const decodePatches = async (name, syncds, initial, getAppStateSyncKey, o
         const patchVersion = toNumber(version.version);
         newState.version = patchVersion;
         const shouldMutate = typeof minimumVersionNumber === 'undefined' || patchVersion > minimumVersionNumber;
-        const decodeResult = await decodeSyncdPatch(syncd, name, newState, getAppStateSyncKey, shouldMutate
-            ? mutation => {
-                const index = mutation.syncAction.index?.toString();
-                mutationMap[index] = mutation;
-            }
-            : () => { }, true);
+        let decodeResult;
+        try {
+            decodeResult = await decodeSyncdPatch(syncd, name, newState, getAppStateSyncKey, shouldMutate
+                ? mutation => {
+                    const index = mutation.syncAction.index?.toString();
+                    mutationMap[index] = mutation;
+                }
+                : () => { }, validateMacs);
+        }
+        catch (err) {
+            if (isMissingKeyError(err))
+                throw err;
+            logger?.warn({ name, version: patchVersion, error: err.message }, 'failed to decode patch, skipping');
+            continue;
+        }
         newState.hash = decodeResult.hash;
         newState.indexValueMap = decodeResult.indexValueMap;
         if (validateMacs) {
             const base64Key = Buffer.from(keyId.id).toString('base64');
             const keyEnc = await getAppStateSyncKey(base64Key);
             if (!keyEnc) {
-                throw new Boom(`failed to find key "${base64Key}" to decode mutation`);
+                throw new Boom(`failed to find key "${base64Key}" to decode mutation`, { data: { isMissingKey: true } });
             }
             const result = mutationKeys(keyEnc.keyData);
             const computedSnapshotMac = generateSnapshotMac(newState.hash, newState.version, name, result.snapshotMacKey);
             if (Buffer.compare(snapshotMac, computedSnapshotMac) !== 0) {
-                throw new Boom(`failed to verify LTHash at ${newState.version} of ${name}`);
+                logger?.warn({ name, version: newState.version }, 'LTHash verification failed, skipping remaining patches');
+                break;
             }
         }
         // clear memory used up by the mutations
@@ -779,6 +838,7 @@ export const processSyncAction = (syncAction, ev, me, initialSyncOpts, logger) =
                     action.lidContactAction.firstName ||
                     action.lidContactAction.username ||
                     undefined,
+                username: action.lidContactAction.username || undefined,
                 lid: id,
                 phoneNumber: undefined
             }

package/lib/Utils/companion-reg-client-utils.d.ts

@@ -0,0 +1,17 @@
+import type { WABrowserDescription } from '../Types/index.js';
+export declare enum CompanionWebClientType {
+    UNKNOWN = 0,
+    CHROME = 1,
+    EDGE = 2,
+    FIREFOX = 3,
+    IE = 4,
+    OPERA = 5,
+    SAFARI = 6,
+    ELECTRON = 7,
+    UWP = 8,
+    OTHER_WEB_CLIENT = 9
+}
+export declare const getCompanionWebClientType: ([os, browserName]: WABrowserDescription) => CompanionWebClientType;
+export declare const getCompanionPlatformId: (browser: WABrowserDescription) => string;
+export declare const buildPairingQRData: (ref: string, noiseKeyB64: string, identityKeyB64: string, advB64: string, browser: WABrowserDescription) => string;
+//# sourceMappingURL=companion-reg-client-utils.d.ts.map

package/lib/Utils/companion-reg-client-utils.js

@@ -0,0 +1,35 @@
+export var CompanionWebClientType;
+(function (CompanionWebClientType) {
+    CompanionWebClientType[CompanionWebClientType["UNKNOWN"] = 0] = "UNKNOWN";
+    CompanionWebClientType[CompanionWebClientType["CHROME"] = 1] = "CHROME";
+    CompanionWebClientType[CompanionWebClientType["EDGE"] = 2] = "EDGE";
+    CompanionWebClientType[CompanionWebClientType["FIREFOX"] = 3] = "FIREFOX";
+    CompanionWebClientType[CompanionWebClientType["IE"] = 4] = "IE";
+    CompanionWebClientType[CompanionWebClientType["OPERA"] = 5] = "OPERA";
+    CompanionWebClientType[CompanionWebClientType["SAFARI"] = 6] = "SAFARI";
+    CompanionWebClientType[CompanionWebClientType["ELECTRON"] = 7] = "ELECTRON";
+    CompanionWebClientType[CompanionWebClientType["UWP"] = 8] = "UWP";
+    CompanionWebClientType[CompanionWebClientType["OTHER_WEB_CLIENT"] = 9] = "OTHER_WEB_CLIENT";
+})(CompanionWebClientType || (CompanionWebClientType = {}));
+const BROWSER_TO_COMPANION_WEB_CLIENT = {
+    Chrome: CompanionWebClientType.CHROME,
+    Edge: CompanionWebClientType.EDGE,
+    Firefox: CompanionWebClientType.FIREFOX,
+    IE: CompanionWebClientType.IE,
+    Opera: CompanionWebClientType.OPERA,
+    Safari: CompanionWebClientType.SAFARI
+};
+export const getCompanionWebClientType = ([os, browserName]) => {
+    if (browserName === 'Desktop') {
+        return os === 'Windows' ? CompanionWebClientType.UWP : CompanionWebClientType.ELECTRON;
+    }
+    return BROWSER_TO_COMPANION_WEB_CLIENT[browserName] || CompanionWebClientType.OTHER_WEB_CLIENT;
+};
+export const getCompanionPlatformId = (browser) => {
+    return getCompanionWebClientType(browser).toString();
+};
+export const buildPairingQRData = (ref, noiseKeyB64, identityKeyB64, advB64, browser) => {
+    return ('https://wa.me/settings/linked_devices#' +
+        [ref, noiseKeyB64, identityKeyB64, advB64, getCompanionPlatformId(browser)].join(','));
+};
+//# sourceMappingURL=companion-reg-client-utils.js.map

package/lib/Utils/enhanced-cache.d.ts

@@ -0,0 +1,40 @@
+export declare const CACHE_CONFIG: {
+    MEMORY: { MAX_SIZE: number; TTL: number; STALE_TTL: number };
+    SIGNAL: { MAX_SIZE: number; TTL: number };
+    GROUPS: { MAX_SIZE: number; TTL: number };
+    PROFILES: { MAX_SIZE: number; TTL: number };
+    PERSIST_INTERVAL: number;
+    PERSIST_ON_SIZE: number;
+};
+
+export declare class EnhancedCache<T = any> {
+    constructor(name: string, options?: { MAX_SIZE?: number; TTL?: number; STALE_TTL?: number; persistPath?: string });
+    get(key: string): T | undefined;
+    set(key: string, value: T, ttl?: number): void;
+    delete(key: string): void;
+    has(key: string): boolean;
+    getMany(keys: string[]): { found: Record<string, T>; missing: string[] };
+    setMany(entries: Record<string, T>): void;
+    load(): Promise<void>;
+    getStats(): {
+        hits: number;
+        misses: number;
+        sets: number;
+        deletes: number;
+        hitRate: string;
+        size: number;
+        hotCacheSize: number;
+        dirtyKeys: number;
+    };
+    clear(): void;
+    cleanup(): void;
+}
+
+export declare class CacheManager {
+    constructor(baseDir?: string, logger?: any);
+    loadAll(): Promise<void>;
+    getCache(name: 'signal' | 'groups' | 'profiles' | 'messages' | 'misc'): EnhancedCache;
+    getAllStats(): Record<string, ReturnType<EnhancedCache['getStats']>>;
+    clearAll(): void;
+    cleanup(): Promise<void>;
+}

package/lib/Utils/enhanced-cache.js

@@ -0,0 +1,242 @@
+import { LRUCache } from 'lru-cache';
+import { readFile, writeFile } from 'fs/promises';
+import { join } from 'path';
+
+const CACHE_CONFIG = {
+    MEMORY: {
+        MAX_SIZE: 10000,
+        TTL: 30 * 60 * 1000,
+        STALE_TTL: 5 * 60 * 1000
+    },
+    SIGNAL: {
+        MAX_SIZE: 5000,
+        TTL: 60 * 60 * 1000
+    },
+    GROUPS: {
+        MAX_SIZE: 500,
+        TTL: 15 * 60 * 1000
+    },
+    PROFILES: {
+        MAX_SIZE: 1000,
+        TTL: 60 * 60 * 1000
+    },
+    PERSIST_INTERVAL: 5 * 60 * 1000,
+    PERSIST_ON_SIZE: 100
+};
+
+class EnhancedCache {
+    constructor(name, options = {}) {
+        this.name = name;
+        this.options = { ...CACHE_CONFIG.MEMORY, ...options };
+        this.persistPath = options.persistPath;
+        this.dirty = new Set();
+        this.persistTimer = null;
+        this.stats = { hits: 0, misses: 0, sets: 0, deletes: 0 };
+        this.cache = new LRUCache({
+            max: this.options.MAX_SIZE,
+            ttl: this.options.TTL,
+            allowStale: true,
+            updateAgeOnGet: true,
+            updateAgeOnHas: true
+        });
+        this.hotCache = new Map();
+        this.hotCacheMaxSize = Math.floor(this.options.MAX_SIZE * 0.1);
+        this.accessCount = new Map();
+        if (this.persistPath) this._startPersistence();
+    }
+
+    get(key) {
+        if (this.hotCache.has(key)) {
+            this.stats.hits++;
+            this._trackAccess(key);
+            return this.hotCache.get(key);
+        }
+        const value = this.cache.get(key);
+        if (value !== undefined) {
+            this.stats.hits++;
+            this._trackAccess(key);
+            if (this._isHotKey(key)) this._addToHotCache(key, value);
+            return value;
+        }
+        this.stats.misses++;
+        return undefined;
+    }
+
+    set(key, value, ttl = undefined) {
+        this.cache.set(key, value, { ttl: ttl || this.options.TTL });
+        this.stats.sets++;
+        if (this.hotCache.has(key)) this.hotCache.set(key, value);
+        if (this.persistPath) {
+            this.dirty.add(key);
+            if (this.dirty.size >= CACHE_CONFIG.PERSIST_ON_SIZE) this._persist();
+        }
+    }
+
+    delete(key) {
+        this.cache.delete(key);
+        this.hotCache.delete(key);
+        this.accessCount.delete(key);
+        this.dirty.delete(key);
+        this.stats.deletes++;
+    }
+
+    has(key) {
+        return this.hotCache.has(key) || this.cache.has(key);
+    }
+
+    getMany(keys) {
+        const result = {};
+        const missing = [];
+        for (const key of keys) {
+            const value = this.get(key);
+            if (value !== undefined) result[key] = value;
+            else missing.push(key);
+        }
+        return { found: result, missing };
+    }
+
+    setMany(entries) {
+        for (const [key, value] of Object.entries(entries)) this.set(key, value);
+    }
+
+    _trackAccess(key) {
+        const count = (this.accessCount.get(key) || 0) + 1;
+        this.accessCount.set(key, count);
+        if (this.accessCount.size > this.options.MAX_SIZE) this._cleanupAccessCount();
+    }
+
+    _isHotKey(key) {
+        return (this.accessCount.get(key) || 0) >= 3;
+    }
+
+    _addToHotCache(key, value) {
+        if (this.hotCache.size >= this.hotCacheMaxSize) {
+            let minKey = null;
+            let minCount = Infinity;
+            for (const [k] of this.hotCache) {
+                const count = this.accessCount.get(k) || 0;
+                if (count < minCount) { minCount = count; minKey = k; }
+            }
+            if (minKey) this.hotCache.delete(minKey);
+        }
+        this.hotCache.set(key, value);
+    }
+
+    _cleanupAccessCount() {
+        const entries = [...this.accessCount.entries()];
+        entries.sort((a, b) => b[1] - a[1]);
+        this.accessCount.clear();
+        entries.slice(0, this.options.MAX_SIZE / 2).forEach(([k, v]) => {
+            this.accessCount.set(k, Math.floor(v / 2));
+        });
+    }
+
+    _startPersistence() {
+        this.persistTimer = setInterval(() => {
+            if (this.dirty.size > 0) this._persist();
+        }, CACHE_CONFIG.PERSIST_INTERVAL);
+    }
+
+    async _persist() {
+        if (!this.persistPath || this.dirty.size === 0) return;
+        try {
+            const data = {};
+            for (const key of this.dirty) {
+                const value = this.cache.get(key);
+                if (value !== undefined) data[key] = value;
+            }
+            const filePath = join(this.persistPath, `${this.name}-cache.json`);
+            let existing = {};
+            try {
+                const content = await readFile(filePath, 'utf8');
+                existing = JSON.parse(content);
+            } catch {}
+            const merged = { ...existing, ...data };
+            await writeFile(filePath, JSON.stringify(merged), 'utf8');
+            this.dirty.clear();
+        } catch (error) {
+            console.error('Cache persist error:', error);
+        }
+    }
+
+    async load() {
+        if (!this.persistPath) return;
+        try {
+            const filePath = join(this.persistPath, `${this.name}-cache.json`);
+            const content = await readFile(filePath, 'utf8');
+            const data = JSON.parse(content);
+            for (const [key, value] of Object.entries(data)) this.cache.set(key, value);
+        } catch {}
+    }
+
+    getStats() {
+        const hitRate = this.stats.hits / (this.stats.hits + this.stats.misses) || 0;
+        return {
+            ...this.stats,
+            hitRate: (hitRate * 100).toFixed(2) + '%',
+            size: this.cache.size,
+            hotCacheSize: this.hotCache.size,
+            dirtyKeys: this.dirty.size
+        };
+    }
+
+    clear() {
+        this.cache.clear();
+        this.hotCache.clear();
+        this.accessCount.clear();
+        this.dirty.clear();
+    }
+
+    cleanup() {
+        if (this.persistTimer) clearInterval(this.persistTimer);
+        this._persist();
+        this.clear();
+    }
+}
+
+class CacheManager {
+    constructor(baseDir, logger) {
+        this.baseDir = baseDir;
+        this.logger = logger;
+        this.caches = {
+            signal: new EnhancedCache('signal', { ...CACHE_CONFIG.SIGNAL, persistPath: baseDir }),
+            groups: new EnhancedCache('groups', { ...CACHE_CONFIG.GROUPS, persistPath: baseDir }),
+            profiles: new EnhancedCache('profiles', { ...CACHE_CONFIG.PROFILES, persistPath: baseDir }),
+            messages: new EnhancedCache('messages', CACHE_CONFIG.MEMORY),
+            misc: new EnhancedCache('misc', CACHE_CONFIG.MEMORY)
+        };
+    }
+
+    async loadAll() {
+        await Promise.all([
+            this.caches.signal.load(),
+            this.caches.groups.load(),
+            this.caches.profiles.load()
+        ]);
+        this.logger?.info('All caches loaded');
+    }
+
+    getCache(name) {
+        return this.caches[name];
+    }
+
+    getAllStats() {
+        const stats = {};
+        for (const [name, cache] of Object.entries(this.caches)) stats[name] = cache.getStats();
+        return stats;
+    }
+
+    clearAll() {
+        for (const cache of Object.values(this.caches)) cache.clear();
+    }
+
+    async cleanup() {
+        for (const cache of Object.values(this.caches)) cache.cleanup();
+    }
+}
+
+export {
+    CACHE_CONFIG,
+    EnhancedCache,
+    CacheManager
+};

package/lib/Utils/enhanced-logger.d.ts

@@ -0,0 +1,41 @@
+export declare const LOG_LEVELS: {
+    fatal: number; error: number; warn: number; info: number; debug: number; trace: number; silent: number;
+};
+export declare const COLORS: Record<string, string>;
+export declare const CATEGORY_ICONS: Record<string, string>;
+
+export type LogLevel = 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace';
+
+export declare class RyzeLogger {
+    constructor(options?: {
+        level?: LogLevel;
+        prettyPrint?: boolean;
+        category?: string;
+        colors?: boolean;
+        timestamps?: boolean;
+        filters?: string[];
+        maxHistory?: number;
+    });
+    fatal(messageOrData: string | object, data?: object): void;
+    error(messageOrData: string | object, data?: object): void;
+    warn(messageOrData: string | object, data?: object): void;
+    info(messageOrData: string | object, data?: object): void;
+    debug(messageOrData: string | object, data?: object): void;
+    trace(messageOrData: string | object, data?: object): void;
+    success(message: string, data?: object): void;
+    child(bindings: { class?: string; category?: string }): RyzeLogger;
+    setLevel(level: LogLevel): void;
+    addFilter(pattern: string): void;
+    removeFilter(pattern: string): void;
+    getHistory(options?: { level?: LogLevel; category?: string; since?: string | number | Date; limit?: number }): Array<{ timestamp: string; level: LogLevel; category: string; message: string; data: any }>;
+    clearHistory(): void;
+    exportLogs(format?: 'json' | 'text'): string;
+    time(label: string): { end: (message?: string) => number };
+    if(condition: boolean, level: LogLevel, message: string, data?: object): void;
+    throttle(key: string, message: string, data?: object, intervalMs?: number): void;
+}
+
+export declare function createLogger(options?: ConstructorParameters<typeof RyzeLogger>[0]): RyzeLogger;
+
+declare const defaultLogger: RyzeLogger;
+export default defaultLogger;