@vanzxy/baileys 2.0.0

package/lib/Utils/stickerpack.js

@@ -0,0 +1,275 @@
+/**
+ * Vanz@Add --- ported from Bail-master addons/stickerpack.ts.
+ *
+ * Adds support for building/sending WhatsApp Sticker Pack messages.
+ *
+ * Exports:
+ *   - convertToWebP() — converts a Buffer, URL string, or Stream into a WebP
+ *     sticker buffer (passthrough if already WebP), sharp → @napi-rs/image
+ *     fallback chain, 512x512 'inside' fit, quality 80.
+ *   - generateStickerPackId() — generates a random pack ID
+ *   - buildStickerPackProto() — builds the proto-level payload for a StickerPackMessage
+ *   - STICKER_PACK_MESSAGE_TYPE — the message type string 'sticker_pack'
+ *   - prepareStickerPackMessageItsliaaa() — full ZIP-build + upload + thumbnail
+ *     pipeline for a ready-to-send stickerPackMessage.
+ *
+ * NOTE: source imported isWebPBuffer/isAnimatedWebP from its own
+ * from-messages.ts, which is not part of this fork's port. Reimplemented
+ * below as small standalone binary-sniffing helpers (RIFF/WEBP header +
+ * ANIM chunk check) so this file has no external dependency on that addon.
+ */
+import { Boom } from '@hapi/boom';
+import { zip } from 'fflate';
+import { promises as fsPromises } from 'fs';
+import { proto } from '../../WAProto/index.js';
+import { sha256 } from './crypto.js';
+import { generateMessageIDV2, unixTimestampSeconds } from './generics.js';
+import { encryptedStream, getImageProcessingLibrary, getStream, toBuffer } from './messages-media.js';
+/** True if `buffer` starts with a RIFF....WEBP container header. */
+export const isWebPBuffer = (buffer) => {
+    return (buffer.length > 12 &&
+        buffer.toString('ascii', 0, 4) === 'RIFF' &&
+        buffer.toString('ascii', 8, 12) === 'WEBP');
+};
+/** True if a WebP buffer contains an ANIM chunk (animated sticker). */
+export const isAnimatedWebP = (buffer) => {
+    return isWebPBuffer(buffer) && buffer.includes(Buffer.from('ANIM', 'ascii'));
+};
+/**
+ * Convert a Buffer, URL string, or Stream into a WebP sticker buffer.
+ * If the input is already a valid WebP, it's returned untouched (and
+ * `isAnimated` reflects whether it's an animated WebP).
+ */
+export const convertToWebP = async (input) => {
+    const { stream } = await getStream(input);
+    const buffer = await toBuffer(stream);
+    if (isWebPBuffer(buffer)) {
+        return { buffer, isAnimated: isAnimatedWebP(buffer) };
+    }
+    const lib = await getImageProcessingLibrary();
+    const hasSharp = 'sharp' in lib && !!lib.sharp?.default;
+    const hasImage = 'image' in lib && !!lib.image?.Transformer;
+    if (!hasSharp && !hasImage) {
+        throw new Boom('No image processing library (sharp or @napi-rs/image) available for converting sticker to WebP.');
+    }
+    let webpBuffer;
+    if (hasSharp) {
+        webpBuffer = await lib.sharp
+            .default(buffer)
+            .resize(512, 512, { fit: 'inside' })
+            .webp({ quality: 80 })
+            .toBuffer();
+    }
+    else {
+        webpBuffer = await new lib.image.Transformer(buffer).resize(512, 512).webp(80);
+    }
+    return { buffer: webpBuffer, isAnimated: false };
+};
+/** Generate a random sticker pack ID (16 hex chars). */
+export const generateStickerPackId = () => {
+    const arr = new Uint8Array(8);
+    for (let i = 0; i < 8; i++)
+        arr[i] = Math.floor(Math.random() * 256);
+    return Array.from(arr)
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+};
+/** Build the proto-level stickerPackMessage payload (name/publisher/packId/description only). */
+export const buildStickerPackProto = (pack) => ({
+    name: pack.name,
+    publisher: pack.publisher,
+    packId: pack.packId ?? generateStickerPackId(),
+    description: pack.description ?? ''
+});
+/** stickerPack message type marker — for use with getMediaType()-style dispatch. */
+export const STICKER_PACK_MESSAGE_TYPE = 'sticker_pack';
+const ITSL_CONCURRENCY_LIMIT = 15;
+/**
+ * Build a complete, ready-to-send stickerPackMessage (ZIP built, encrypted,
+ * and uploaded) — full pipeline: per-sticker WebP conversion (15-way
+ * concurrency batching), 1MB per-sticker size limit, 60-sticker pack limit,
+ * cover→trayIcon-in-ZIP, and a separate 252×252 JPEG thumbnail upload.
+ */
+export const prepareStickerPackMessageItsliaaa = async (message, options) => {
+    // Vanz@Fix (bug 62): packId was never destructured here, so a caller-supplied
+    // pack ID was silently dropped and a fresh one always generated below.
+    const { cover, stickers = [], name = '📦 Sticker Pack', publisher = 'GitHub: itsliaaa', description = '🏷️ itsliaaa/baileys', packId } = message;
+    if (stickers.length > 60) {
+        throw new Boom('Sticker pack exceeds the maximum limit of 60 stickers', { statusCode: 400 });
+    }
+    if (stickers.length === 0) {
+        throw new Boom('Sticker pack must contain at least one sticker', { statusCode: 400 });
+    }
+    if (!cover) {
+        throw new Boom('Sticker pack must contain a cover', { statusCode: 400 });
+    }
+    const { logger } = options;
+    // Media caching (keyed by concatenated sticker URLs, if all stickers are URL-based)
+    let cacheableKey = false;
+    if (stickers.length && options.mediaCache) {
+        const urls = [];
+        for (const s of stickers) {
+            const data = s.data;
+            if (typeof data === 'object' && data?.url)
+                urls.push(data.url);
+        }
+        if (urls.length > 0)
+            cacheableKey = 'sticker:' + urls.join('@');
+    }
+    if (cacheableKey) {
+        const mediaBuff = await options.mediaCache.get(cacheableKey);
+        if (mediaBuff) {
+            logger?.debug({ cacheableKey }, 'got media cache hit');
+            return proto.Message.StickerPackMessage.decode(mediaBuff);
+        }
+    }
+    const lib = await getImageProcessingLibrary();
+    const hasSharp = 'sharp' in lib && !!lib.sharp?.default;
+    const hasImage = 'image' in lib && !!lib.image?.Transformer;
+    if (!hasSharp && !hasImage) {
+        throw new Boom('No image processing library (sharp or @napi-rs/image) available for converting sticker to WebP.');
+    }
+    const stickerPackIdValue = packId ?? generateMessageIDV2();
+    const stickerData = {};
+    const stickerMetadata = new Array(stickers.length);
+    for (let i = 0; i < stickers.length; i += ITSL_CONCURRENCY_LIMIT) {
+        const chunkEnd = Math.min(i + ITSL_CONCURRENCY_LIMIT, stickers.length);
+        const promises = [];
+        for (let j = i; j < chunkEnd; j++) {
+            promises.push((async (index) => {
+                const sticker = stickers[index];
+                const { stream } = await getStream(sticker.data);
+                const buffer = await toBuffer(stream);
+                let webpBuffer;
+                let isAnimated = false;
+                if (isWebPBuffer(buffer)) {
+                    webpBuffer = buffer;
+                    isAnimated = isAnimatedWebP(buffer);
+                }
+                else if (hasSharp) {
+                    webpBuffer = await lib.sharp
+                        .default(buffer)
+                        .resize(512, 512, { fit: 'inside' })
+                        .webp({ quality: 80 })
+                        .toBuffer();
+                }
+                else {
+                    webpBuffer = await new lib.image.Transformer(buffer).resize(512, 512).webp(80);
+                }
+                if (webpBuffer.length > 1024 * 1024) {
+                    throw new Boom(`Sticker at index ${index} exceeds the 1MB size limit`, { statusCode: 400 });
+                }
+                const hash = sha256(webpBuffer).toString('base64').replace(/\//g, '-');
+                const fileName = `${hash}.webp`;
+                stickerData[fileName] = [new Uint8Array(webpBuffer), { level: 0 }];
+                stickerMetadata[index] = {
+                    fileName,
+                    mimetype: 'image/webp',
+                    isAnimated,
+                    emojis: sticker.emojis || ['✨'],
+                    accessibilityLabel: sticker.accessibilityLabel || '‎'
+                };
+            })(j));
+        }
+        await Promise.all(promises);
+    }
+    const trayIconFileName = `${stickerPackIdValue}.webp`;
+    const { stream: coverStream } = await getStream(cover);
+    const coverBuffer = await toBuffer(coverStream);
+    let coverWebpBuffer;
+    if (isWebPBuffer(coverBuffer)) {
+        coverWebpBuffer = coverBuffer;
+    }
+    else if (hasSharp) {
+        coverWebpBuffer = await lib.sharp
+            .default(coverBuffer)
+            .resize(512, 512, { fit: 'inside' })
+            .webp({ quality: 80 })
+            .toBuffer();
+    }
+    else {
+        coverWebpBuffer = await new lib.image.Transformer(coverBuffer).resize(512, 512).webp(80);
+    }
+    stickerData[trayIconFileName] = [new Uint8Array(coverWebpBuffer), { level: 0 }];
+    const zipBuffer = await new Promise((resolve, reject) => {
+        zip(stickerData, (error, data) => (error ? reject(error) : resolve(Buffer.from(data))));
+    });
+    const stickerPackUpload = await encryptedStream(zipBuffer, 'sticker-pack', { logger, opts: options.options });
+    let stickerPackUploadResult;
+    try {
+        stickerPackUploadResult = await options.upload(stickerPackUpload.encFilePath, {
+            fileEncSha256B64: stickerPackUpload.fileEncSha256.toString('base64'),
+            mediaType: 'sticker-pack',
+            timeoutMs: options.mediaUploadTimeoutMs
+        });
+    }
+    finally {
+        fsPromises.unlink(stickerPackUpload.encFilePath).catch(() => logger?.warn('failed to remove tmp file'));
+    }
+    const obj = {
+        name,
+        publisher,
+        stickerPackId: stickerPackIdValue,
+        packDescription: description,
+        stickerPackOrigin: proto.Message.StickerPackMessage.StickerPackOrigin.USER_CREATED,
+        stickerPackSize: zipBuffer.length,
+        stickers: stickerMetadata,
+        fileSha256: stickerPackUpload.fileSha256,
+        fileEncSha256: stickerPackUpload.fileEncSha256,
+        mediaKey: stickerPackUpload.mediaKey,
+        directPath: stickerPackUploadResult.directPath,
+        fileLength: stickerPackUpload.fileLength,
+        mediaKeyTimestamp: unixTimestampSeconds(),
+        trayIconFileName
+    };
+    try {
+        let thumbnailBuffer;
+        if (hasSharp) {
+            thumbnailBuffer = await lib.sharp.default(coverBuffer).resize(252, 252).jpeg().toBuffer();
+        }
+        else {
+            // hasImage is guaranteed here since hasSharp||hasImage is enforced above.
+            // Vanz@Fix (bug 63): removed a jimp fallback branch that could never be
+            // reached (the earlier guard already requires sharp or image), and which
+            // main sticker/cover conversion above doesn't support anyway — it was
+            // dead code presenting a false sense of a jimp-only code path.
+            thumbnailBuffer = await new lib.image.Transformer(coverBuffer).resize(252, 252).jpeg();
+        }
+        if (!thumbnailBuffer || thumbnailBuffer.length === 0) {
+            throw new Error('Failed to generate thumbnail buffer');
+        }
+        const thumbUpload = await encryptedStream(thumbnailBuffer, 'thumbnail-sticker-pack', {
+            logger,
+            opts: options.options,
+            mediaKey: stickerPackUpload.mediaKey
+        });
+        let thumbUploadResult;
+        try {
+            thumbUploadResult = await options.upload(thumbUpload.encFilePath, {
+                fileEncSha256B64: thumbUpload.fileEncSha256.toString('base64'),
+                mediaType: 'thumbnail-sticker-pack',
+                timeoutMs: options.mediaUploadTimeoutMs
+            });
+        }
+        finally {
+            fsPromises.unlink(thumbUpload.encFilePath).catch(() => logger?.warn('failed to remove tmp file'));
+        }
+        Object.assign(obj, {
+            thumbnailDirectPath: thumbUploadResult.directPath,
+            thumbnailSha256: thumbUpload.fileSha256,
+            thumbnailEncSha256: thumbUpload.fileEncSha256,
+            thumbnailHeight: 252,
+            thumbnailWidth: 252,
+            imageDataHash: sha256(thumbnailBuffer).toString('base64')
+        });
+    }
+    catch (error) {
+        logger?.warn(`Thumbnail generation failed: ${error}`);
+    }
+    if (cacheableKey) {
+        logger?.debug({ cacheableKey }, 'set cache (background)');
+        options.mediaCache.set(cacheableKey, Buffer.from(proto.Message.StickerPackMessage.encode(obj).finish()));
+    }
+    return proto.Message.StickerPackMessage.fromObject(obj);
+};
+//# sourceMappingURL=stickerpack.js.map

package/lib/Utils/sync-action-utils.d.ts

@@ -0,0 +1,2 @@
+export function processContactAction(action: any, id: any, logger: any): any[];
+export function emitSyncActionResults(ev: any, results: any): void;

package/lib/Utils/sync-action-utils.js

@@ -0,0 +1,49 @@
+import { proto } from '../../WAProto/index.js';
+import { isLidUser, isPnUser } from '../WABinary/index.js';
+/**
+ * Process contactAction and return events to emit.
+ * Pure function - no side effects.
+ */
+export const processContactAction = (action, id, logger) => {
+    const results = [];
+    if (!id) {
+        logger?.warn({ hasFullName: !!action.fullName, hasLidJid: !!action.lidJid, hasPnJid: !!action.pnJid }, 'contactAction sync: missing id in index');
+        return results;
+    }
+    const lidJid = action.lidJid;
+    const idIsPn = isPnUser(id);
+    // PN is in index[1], not in contactAction.pnJid which is usually null
+    const phoneNumber = idIsPn ? id : action.pnJid || undefined;
+    // Always emit contacts.upsert
+    results.push({
+        event: 'contacts.upsert',
+        data: [
+            {
+                id,
+                name: action.fullName || action.firstName || action.username || undefined,
+                username: action.username || undefined,
+                lid: lidJid || undefined,
+                phoneNumber
+            }
+        ]
+    });
+    // Emit lid-mapping.update if we have valid LID-PN pair
+    if (lidJid && isLidUser(lidJid) && idIsPn) {
+        results.push({
+            event: 'lid-mapping.update',
+            data: { lid: lidJid, pn: id }
+        });
+    }
+    return results;
+};
+export const emitSyncActionResults = (ev, results) => {
+    for (const result of results) {
+        if (result.event === 'contacts.upsert') {
+            ev.emit('contacts.upsert', result.data);
+        }
+        else {
+            ev.emit('lid-mapping.update', result.data);
+        }
+    }
+};
+//# sourceMappingURL=sync-action-utils.js.map

package/lib/Utils/tc-token-utils.d.ts

@@ -0,0 +1,29 @@
+/** Read the persisted tctoken JID index and return its entries (never contains the sentinel key itself). */
+export function readTcTokenIndex(keys: any): Promise<any[]>;
+/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the sentinel key. */
+export function buildMergedTcTokenIndexWrite(keys: any, addedJids: any): Promise<{
+    __index: {
+        token: any;
+    };
+}>;
+export function isTcTokenExpired(timestamp: any): boolean;
+export function shouldSendNewTcToken(senderTimestamp: any): boolean;
+/** Resolve JID to LID for tctoken storage (WA Web stores under LID) */
+export function resolveTcTokenJid(jid: any, getLIDForPN: any): Promise<any>;
+/** Resolve target JID for issuing privacy token based on AB prop 14303 */
+export function resolveIssuanceJid(jid: any, issueToLid: any, getLIDForPN: any, getPNForLID: any): Promise<any>;
+export function buildTcTokenFromJid({ authState, jid, baseContent, getLIDForPN }: {
+    authState: any;
+    jid: any;
+    baseContent?: never[] | undefined;
+    getLIDForPN: any;
+}): Promise<any[] | undefined>;
+export function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }: {
+    result: any;
+    fallbackJid: any;
+    keys: any;
+    getLIDForPN: any;
+    onNewJidStored: any;
+}): Promise<void>;
+/** Sentinel key under `tctoken` store holding a JSON array of tracked storage JIDs for cross-session pruning. */
+export const TC_TOKEN_INDEX_KEY: "__index";

package/lib/Utils/tc-token-utils.js

@@ -0,0 +1,163 @@
+import { getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidMetaAI, isLidUser, isPnUser, jidNormalizedUser } from '../WABinary/index.js';
+// Same phone-number pattern as WABinary's isJidBot, applied against the user
+// part so the check is invariant to @c.us ↔ @s.whatsapp.net normalization.
+const BOT_PHONE_REGEX = /^1313555\d{4}$|^131655500\d{2}$/;
+/**
+ * Mirrors WA Web's `Wid.isRegularUser()` (user ∧ ¬PSA ∧ ¬Bot). Used to gate tctoken
+ * storage against malformed notifications — WA Web filters server-side but we
+ * defend here for parity with `WAWebSetTcTokenChatAction.handleIncomingTcToken`.
+ * Works for both pre- and post-normalized JIDs (`@c.us` vs `@s.whatsapp.net`).
+ */
+function isRegularUser(jid) {
+    if (!jid)
+        return false;
+    const user = jid.split('@')[0] ?? '';
+    if (user === '0')
+        return false; // PSA
+    if (BOT_PHONE_REGEX.test(user))
+        return false; // Bot by phone pattern
+    if (isJidMetaAI(jid))
+        return false; // MetaAI (@bot server)
+    return !!(isPnUser(jid) || isLidUser(jid) || isHostedPnUser(jid) || isHostedLidUser(jid) || jid.endsWith('@c.us'));
+}
+const TC_TOKEN_BUCKET_DURATION = 604800; // 7 days
+const TC_TOKEN_NUM_BUCKETS = 4; // ~28-day rolling window
+/** Sentinel key under `tctoken` store holding a JSON array of tracked storage JIDs for cross-session pruning. */
+export const TC_TOKEN_INDEX_KEY = '__index';
+/** Read the persisted tctoken JID index and return its entries (never contains the sentinel key itself). */
+export async function readTcTokenIndex(keys) {
+    const data = await keys.get('tctoken', [TC_TOKEN_INDEX_KEY]);
+    const entry = data[TC_TOKEN_INDEX_KEY];
+    if (!entry?.token?.length)
+        return [];
+    try {
+        const parsed = JSON.parse(Buffer.from(entry.token).toString());
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((j) => typeof j === 'string' && j.length > 0 && j !== TC_TOKEN_INDEX_KEY);
+    }
+    catch {
+        return [];
+    }
+}
+/** Build a SignalDataSet fragment that writes the merged index (persisted ∪ added) under the sentinel key. */
+export async function buildMergedTcTokenIndexWrite(keys, addedJids) {
+    const persisted = await readTcTokenIndex(keys);
+    const merged = new Set(persisted);
+    for (const jid of addedJids) {
+        if (jid && jid !== TC_TOKEN_INDEX_KEY)
+            merged.add(jid);
+    }
+    return {
+        [TC_TOKEN_INDEX_KEY]: { token: Buffer.from(JSON.stringify([...merged])) }
+    };
+}
+// WA Web has separate sender/receiver AB props for these but they're identical today
+export function isTcTokenExpired(timestamp) {
+    if (timestamp === null || timestamp === undefined)
+        return true;
+    const ts = typeof timestamp === 'string' ? parseInt(timestamp) : timestamp;
+    if (isNaN(ts))
+        return true;
+    const now = Math.floor(Date.now() / 1000);
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
+    const cutoffBucket = currentBucket - (TC_TOKEN_NUM_BUCKETS - 1);
+    const cutoffTimestamp = cutoffBucket * TC_TOKEN_BUCKET_DURATION;
+    return ts < cutoffTimestamp;
+}
+export function shouldSendNewTcToken(senderTimestamp) {
+    if (senderTimestamp === undefined)
+        return true;
+    const now = Math.floor(Date.now() / 1000);
+    const currentBucket = Math.floor(now / TC_TOKEN_BUCKET_DURATION);
+    const senderBucket = Math.floor(senderTimestamp / TC_TOKEN_BUCKET_DURATION);
+    return currentBucket > senderBucket;
+}
+/** Resolve JID to LID for tctoken storage (WA Web stores under LID) */
+export async function resolveTcTokenJid(jid, getLIDForPN) {
+    if (isLidUser(jid))
+        return jid;
+    const lid = await getLIDForPN(jid);
+    return lid ?? jid;
+}
+/** Resolve target JID for issuing privacy token based on AB prop 14303 */
+export async function resolveIssuanceJid(jid, issueToLid, getLIDForPN, getPNForLID) {
+    if (issueToLid) {
+        if (isLidUser(jid))
+            return jid;
+        const lid = await getLIDForPN(jid);
+        return lid ?? jid;
+    }
+    if (!isLidUser(jid))
+        return jid;
+    if (getPNForLID) {
+        const pn = await getPNForLID(jid);
+        return pn ?? jid;
+    }
+    return jid;
+}
+export async function buildTcTokenFromJid({ authState, jid, baseContent = [], getLIDForPN }) {
+    try {
+        const storageJid = await resolveTcTokenJid(jid, getLIDForPN);
+        const tcTokenData = await authState.keys.get('tctoken', [storageJid]);
+        const entry = tcTokenData?.[storageJid];
+        const tcTokenBuffer = entry?.token;
+        if (!tcTokenBuffer?.length || isTcTokenExpired(entry?.timestamp)) {
+            if (tcTokenBuffer) {
+                // Preserve senderTimestamp so shouldSendNewTcToken() keeps its dedupe state
+                // after we drop the unusable peer token. Only wipe the record entirely when
+                // there's nothing worth keeping.
+                const cleared = entry?.senderTimestamp !== undefined
+                    ? { token: Buffer.alloc(0), senderTimestamp: entry.senderTimestamp }
+                    : null;
+                await authState.keys.set({ tctoken: { [storageJid]: cleared } });
+            }
+            return baseContent.length > 0 ? baseContent : undefined;
+        }
+        baseContent.push({
+            tag: 'tctoken',
+            attrs: {},
+            content: tcTokenBuffer
+        });
+        return baseContent;
+    }
+    catch (error) {
+        return baseContent.length > 0 ? baseContent : undefined;
+    }
+}
+export async function storeTcTokensFromIqResult({ result, fallbackJid, keys, getLIDForPN, onNewJidStored }) {
+    const tokensNode = getBinaryNodeChild(result, 'tokens');
+    if (!tokensNode)
+        return;
+    const tokenNodes = getBinaryNodeChildren(tokensNode, 'token');
+    for (const tokenNode of tokenNodes) {
+        if (tokenNode.attrs.type !== 'trusted_contact' || !(tokenNode.content instanceof Uint8Array)) {
+            continue;
+        }
+        // In notifications tokenNode.attrs.jid is your own device JID, not the sender's
+        const rawJid = jidNormalizedUser(fallbackJid || tokenNode.attrs.jid);
+        if (!isRegularUser(rawJid))
+            continue;
+        const storageJid = await resolveTcTokenJid(rawJid, getLIDForPN);
+        const existingTcData = await keys.get('tctoken', [storageJid]);
+        const existingEntry = existingTcData[storageJid];
+        const existingTs = existingEntry?.timestamp ? Number(existingEntry.timestamp) : 0;
+        const incomingTs = tokenNode.attrs.t ? Number(tokenNode.attrs.t) : 0;
+        // timestamp-less tokens would be immediately expired
+        if (!incomingTs)
+            continue;
+        if (existingTs > 0 && existingTs > incomingTs)
+            continue;
+        await keys.set({
+            tctoken: {
+                [storageJid]: {
+                    ...existingEntry,
+                    token: Buffer.from(tokenNode.content),
+                    timestamp: tokenNode.attrs.t
+                }
+            }
+        });
+        onNewJidStored?.(storageJid);
+    }
+}
+//# sourceMappingURL=tc-token-utils.js.map

package/lib/Utils/templates.d.ts

@@ -0,0 +1,76 @@
+export interface TemplateVariable {
+    name: string;
+    defaultValue?: string;
+    required: boolean;
+}
+export interface MessageTemplate {
+    id: string;
+    name: string;
+    content: string;
+    description?: string;
+    category?: string;
+    variables: TemplateVariable[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+export type TemplateData = Record<string, string | number | undefined | null>;
+export declare class TemplateManager {
+    private templates;
+    private generateId;
+    private extractVariables;
+    create(options: {
+        id?: string;
+        name: string;
+        content: string;
+        description?: string;
+        category?: string;
+    }): MessageTemplate;
+    get(id: string): MessageTemplate | undefined;
+    getByName(name: string): MessageTemplate | undefined;
+    getAll(): MessageTemplate[];
+    getByCategory(category: string): MessageTemplate[];
+    update(id: string, updates: Partial<MessageTemplate>): MessageTemplate | undefined;
+    delete(id: string): boolean;
+    renderContent(content: string, data?: TemplateData): string;
+    render(id: string, data?: TemplateData): string;
+    validate(id: string, data: TemplateData): {
+        valid: boolean;
+        missing: string[];
+    };
+    export(): string;
+    import(json: string, overwrite?: boolean): number;
+}
+export declare const PRESET_TEMPLATES: {
+    ORDER_CONFIRMATION: {
+        name: string;
+        category: string;
+        content: string;
+    };
+    WELCOME: {
+        name: string;
+        category: string;
+        content: string;
+    };
+    REMINDER: {
+        name: string;
+        category: string;
+        content: string;
+    };
+    SUPPORT_TICKET: {
+        name: string;
+        category: string;
+        content: string;
+    };
+    BIRTHDAY: {
+        name: string;
+        category: string;
+        content: string;
+    };
+    INVOICE: {
+        name: string;
+        category: string;
+        content: string;
+    };
+};
+export declare const createTemplateManager: (includePresets?: boolean) => TemplateManager;
+export declare const renderTemplate: (content: string, data?: TemplateData) => string;