@vanzxy/baileys 1.6.2 → 1.6.4

package/lib/Utils/stickerpack.js

@@ -0,0 +1,276 @@
+/**
+ * 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) => {
+    const { cover, stickers = [], name = '📦 Sticker Pack', publisher = 'GitHub: itsliaaa', description = '🏷️ itsliaaa/baileys' } = 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;
+    const hasJimp = 'jimp' in lib && !!lib.jimp?.Jimp;
+    if (!hasSharp && !hasImage) {
+        throw new Boom('No image processing library (sharp or @napi-rs/image) available for converting sticker to WebP.');
+    }
+    const stickerPackIdValue = 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 if (hasImage) {
+            thumbnailBuffer = await new lib.image.Transformer(coverBuffer).resize(252, 252).jpeg();
+        }
+        else if (hasJimp) {
+            const jimpImage = await lib.jimp.Jimp.read(coverBuffer);
+            thumbnailBuffer = await jimpImage.resize({ w: 252, h: 252 }).getBuffer('image/jpeg');
+        }
+        else {
+            throw new Error('No image processing library available for thumbnail generation');
+        }
+        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/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;

package/lib/Utils/templates.js

@@ -0,0 +1,151 @@
+// Vanz@Add --- ported from Bail-master addons/templates.ts (type-only
+// annotations dropped; behavior unchanged).
+export class TemplateManager {
+    templates = new Map();
+    generateId() {
+        return `tpl_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+    extractVariables(content) {
+        const regex = /\{\{(\w+)(?::([^}]*))?\}\}/g;
+        const variables = [];
+        const seen = new Set();
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const name = match[1];
+            if (!name || seen.has(name))
+                continue;
+            seen.add(name);
+            variables.push({ name, defaultValue: match[2], required: !match[2] });
+        }
+        return variables;
+    }
+    create(options) {
+        const template = {
+            id: options.id ?? this.generateId(),
+            name: options.name,
+            content: options.content,
+            description: options.description,
+            category: options.category,
+            variables: this.extractVariables(options.content),
+            createdAt: new Date(),
+            updatedAt: new Date()
+        };
+        this.templates.set(template.id, template);
+        return template;
+    }
+    get(id) {
+        return this.templates.get(id);
+    }
+    getByName(name) {
+        return Array.from(this.templates.values()).find((t) => t.name === name);
+    }
+    getAll() {
+        return Array.from(this.templates.values());
+    }
+    getByCategory(category) {
+        return Array.from(this.templates.values()).filter((t) => t.category === category);
+    }
+    update(id, updates) {
+        const template = this.templates.get(id);
+        if (!template)
+            return undefined;
+        if (updates.content)
+            updates.variables = this.extractVariables(updates.content);
+        const updated = { ...template, ...updates, updatedAt: new Date() };
+        this.templates.set(id, updated);
+        return updated;
+    }
+    delete(id) {
+        return this.templates.delete(id);
+    }
+    renderContent(content, data = {}) {
+        return content.replace(/\{\{(\w+)(?::([^}]*))?\}\}/g, (match, name, defaultValue) => {
+            const value = data[name];
+            if (value !== undefined && value !== null)
+                return String(value);
+            if (defaultValue !== undefined)
+                return defaultValue;
+            return match;
+        });
+    }
+    render(id, data = {}) {
+        const template = this.templates.get(id);
+        if (!template)
+            throw new Error(`Template not found: ${id}`);
+        return this.renderContent(template.content, data);
+    }
+    validate(id, data) {
+        const template = this.templates.get(id);
+        if (!template)
+            throw new Error(`Template not found: ${id}`);
+        const missing = template.variables.filter((v) => v.required && !(v.name in data)).map((v) => v.name);
+        return { valid: missing.length === 0, missing };
+    }
+    export() {
+        return JSON.stringify(Array.from(this.templates.values()), null, 2);
+    }
+    import(json, overwrite = false) {
+        const templates = JSON.parse(json);
+        let imported = 0;
+        for (const t of templates) {
+            if (!overwrite && this.templates.has(t.id))
+                continue;
+            this.templates.set(t.id, { ...t, createdAt: new Date(t.createdAt), updatedAt: new Date(t.updatedAt) });
+            imported++;
+        }
+        return imported;
+    }
+}
+/** Ready-made templates covering common bot scenarios (order, welcome, reminder, etc). */
+export const PRESET_TEMPLATES = {
+    ORDER_CONFIRMATION: {
+        name: 'Order Confirmation',
+        category: 'order',
+        content: `✅ *Order Confirmed!*\n\nOrder ID: #{{orderId}}\nCustomer: {{customerName}}\nDate: {{orderDate}}\n\n📦 *Items:*\n{{items}}\n\n💰 *Total: {{total}}*\n\nThank you! 🙏`
+    },
+    WELCOME: {
+        name: 'Welcome Message',
+        category: 'greeting',
+        content: `👋 *Welcome, {{name}}!*\n\nThank you for joining {{companyName:us}}!\nNeed help? Reply to this message!`
+    },
+    REMINDER: {
+        name: 'Reminder',
+        category: 'notification',
+        content: `⏰ *Reminder*\n\nHi {{name}},\n\n📋 {{subject}}\n📅 Date: {{date}}\n🕐 Time: {{time}}\n📍 Location: {{location:TBD}}`
+    },
+    SUPPORT_TICKET: {
+        name: 'Support Ticket',
+        category: 'support',
+        content: `🎫 *Support Ticket Created*\n\nTicket #: {{ticketId}}\nSubject: {{subject}}\n\nHi {{name}},\n\nWe received your request! Response time: {{responseTime:24 hours}} 🙏`
+    },
+    BIRTHDAY: {
+        name: 'Birthday Wishes',
+        category: 'greeting',
+        content: `🎂 *Happy Birthday, {{name}}!* 🎉\n\nWishing you a wonderful day!\n\n🎁 Use code: {{code}} for {{discount:10}}% off! 🥳`
+    },
+    INVOICE: {
+        name: 'Invoice',
+        category: 'invoice',
+        content: `🧾 *Invoice {{invoiceNumber}}*\n\nBilled to: {{customerName}}\nInvoice date: {{invoiceDate}}\nDue date: {{dueDate:on receipt}}\n\n📋 *Items:*\n{{items}}\n\nSubtotal: {{subtotal}}\n💰 *Total: {{total}}*\n\nThank you for your business! 🙏`
+    }
+};
+export const createTemplateManager = (includePresets = true) => {
+    const manager = new TemplateManager();
+    if (includePresets) {
+        for (const [key, template] of Object.entries(PRESET_TEMPLATES)) {
+            manager.create({ ...template, id: key.toLowerCase() });
+        }
+    }
+    return manager;
+};
+export const renderTemplate = (content, data = {}) => {
+    return content.replace(/\{\{(\w+)(?::([^}]*))?\}\}/g, (match, name, defaultValue) => {
+        const value = data[name];
+        if (value !== undefined && value !== null)
+            return String(value);
+        if (defaultValue !== undefined)
+            return defaultValue;
+        return match;
+    });
+};
+//# sourceMappingURL=templates.js.map

package/lib/Utils/use-sqlite-auth-state.js

@@ -30,6 +30,33 @@ CREATE TABLE IF NOT EXISTS signal_keys (
 );
 CREATE INDEX IF NOT EXISTS signal_keys_type_idx ON signal_keys(type);
 `;
+// Vanz@Add 29-08-26 --- Migration tracking, ported in spirit from zapo-js's
+// wa_migrations pattern (packages/store-sqlite/src/migrations.ts). Each entry
+// is `{ id, sql }`; applied migrations are recorded by id in `wa_migrations`
+// so `db.exec(...)` schema changes are only ever run once per database file,
+// letting future releases evolve the schema without a manual ALTER step from
+// the user. Kept as an ordered array (not a folder of files) since the schema
+// here is a single flat file, unlike zapo's per-domain migration modules.
+const MIGRATIONS = [
+    { id: '0001_init', sql: CREATE_SCHEMA_SQL }
+];
+function ensureMigrationsTable(db) {
+    db.exec('CREATE TABLE IF NOT EXISTS wa_migrations (id TEXT PRIMARY KEY, applied_at INTEGER NOT NULL)');
+}
+function runMigrations(db) {
+    ensureMigrationsTable(db);
+    const applied = new Set(db.prepare('SELECT id FROM wa_migrations').all().map((r) => r.id));
+    const insertMigration = db.prepare('INSERT INTO wa_migrations (id, applied_at) VALUES (?, ?)');
+    for (const migration of MIGRATIONS) {
+        if (applied.has(migration.id))
+            continue;
+        const tx = db.transaction(() => {
+            db.exec(migration.sql);
+            insertMigration.run(migration.id, Date.now());
+        });
+        tx();
+    }
+}
 export async function useSqliteAuthState(opts) {
     let db;
     if (opts.database) {
@@ -43,7 +70,7 @@ export async function useSqliteAuthState(opts) {
     // what SQLite recommends for read-heavy workloads with sporadic writes.
     db.pragma('journal_mode = WAL');
     db.pragma('synchronous = NORMAL');
-    db.exec(CREATE_SCHEMA_SQL);
+    runMigrations(db);
     // Vanz@Fix (bug 8): periodic WAL checkpoint + cleanup old signal keys to prevent DB bloat.
     // Runs every 30 minutes. WAL checkpoint reclaims WAL file space; key cleanup removes stale session entries.
     const _walCleanupInterval = setInterval(() => {

package/lib/Utils/vcard.d.ts

@@ -0,0 +1,58 @@
+export interface ContactPhone {
+    number: string;
+    type?: string;
+    label?: string;
+}
+export interface ContactEmail {
+    email: string;
+    type?: string;
+}
+export interface ContactUrl {
+    url: string;
+    type?: string;
+}
+export interface ContactAddress {
+    street?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: string;
+    type?: string;
+}
+export interface ContactData {
+    fullName: string;
+    displayName?: string;
+    organization?: string;
+    title?: string;
+    phones?: ContactPhone[];
+    emails?: ContactEmail[];
+    urls?: ContactUrl[];
+    addresses?: ContactAddress[];
+    birthday?: string;
+    note?: string;
+}
+export declare const escapeVCard: (s: string) => string;
+export declare const formatPhone: (p: string) => string;
+export declare const generateVCard: (c: ContactData) => string;
+export declare const generateVCards: (contacts: ContactData[]) => string;
+export declare const parseVCard: (vcard: string) => Partial<ContactData>;
+export declare const createContactCard: (contact: ContactData) => {
+    contacts: {
+        displayName: string;
+        contacts: {
+            vcard: string;
+        }[];
+    };
+};
+export declare const createContactCards: (contacts: ContactData[]) => {
+    contacts: {
+        displayName: string;
+        contacts: {
+            vcard: string;
+        }[];
+    };
+};
+export declare const quickContact: (name: string, phone: string, options?: {
+    organization?: string;
+    email?: string;
+}) => ContactData;