@mohasinac/appkit 4.41.0 → 4.41.2

package/dist/features/messages/index.js

@@ -1,4 +0,0 @@
-export * from "./hooks/useConversations";
-export * from "./hooks/useConversation";
-export { CONVERSATIONS_COLLECTION, CONVERSATIONS_INDEXED_FIELDS, } from "./schemas/firestore";
-export { conversationPingPath, userConversationsPingPath, buildConversationPingPaths, } from "./realtime";

package/dist/features/messages/realtime.d.ts

@@ -1,32 +0,0 @@
-/**
- * Conversations realtime channel — shared between client hooks and server
- * routes. Lives in a non-`"use client"` module so server route handlers can
- * import the path builders without dragging the React hooks into a server
- * bundle.
- *
- * Strategy (D5 + VC7):
- *   - Firestore = canonical store; messages embedded in `conversations/{id}`.
- *   - RTDB = "ping" channel only — server writes Date.now() to two paths on
- *     every mutation, clients subscribe and refetch.
- *
- *     chats/{id}/lastUpdate              — single-conversation ping
- *     chats/user/{userId}/lastUpdate     — per-user fan-out ping
- *
- * Both ends import these constants instead of inlining the path strings.
- */
-/** RTDB path bumped on every write to a single conversation. */
-export declare function conversationPingPath(conversationId: string): string;
-/**
- * RTDB path bumped on every write across all of a user's conversations.
- * Subscribing to this is how the chat list / nav bell refresh without
- * subscribing to every individual conversation.
- */
-export declare function userConversationsPingPath(userId: string): string;
-/** All ping paths to bump on a single conversation write. */
-export interface ConversationPingTargets {
-    conversationId: string;
-    buyerId: string;
-    /** Resolved store-owner UID for the seller side; null when not known. */
-    sellerOwnerId: string | null;
-}
-export declare function buildConversationPingPaths(targets: ConversationPingTargets): string[];

package/dist/features/messages/realtime.js

@@ -1,39 +0,0 @@
-/**
- * Conversations realtime channel — shared between client hooks and server
- * routes. Lives in a non-`"use client"` module so server route handlers can
- * import the path builders without dragging the React hooks into a server
- * bundle.
- *
- * Strategy (D5 + VC7):
- *   - Firestore = canonical store; messages embedded in `conversations/{id}`.
- *   - RTDB = "ping" channel only — server writes Date.now() to two paths on
- *     every mutation, clients subscribe and refetch.
- *
- *     chats/{id}/lastUpdate              — single-conversation ping
- *     chats/user/{userId}/lastUpdate     — per-user fan-out ping
- *
- * Both ends import these constants instead of inlining the path strings.
- */
-const PING_KEY = "lastUpdate";
-/** RTDB path bumped on every write to a single conversation. */
-export function conversationPingPath(conversationId) {
-    return `chats/${conversationId}/${PING_KEY}`;
-}
-/**
- * RTDB path bumped on every write across all of a user's conversations.
- * Subscribing to this is how the chat list / nav bell refresh without
- * subscribing to every individual conversation.
- */
-export function userConversationsPingPath(userId) {
-    return `chats/user/${userId}/${PING_KEY}`;
-}
-export function buildConversationPingPaths(targets) {
-    const paths = [
-        conversationPingPath(targets.conversationId),
-        userConversationsPingPath(targets.buyerId),
-    ];
-    if (targets.sellerOwnerId) {
-        paths.push(userConversationsPingPath(targets.sellerOwnerId));
-    }
-    return paths;
-}

package/dist/features/messages/repository/conversations.repository.d.ts

@@ -1,71 +0,0 @@
-/**
- * ConversationsRepository — buyer↔seller messaging.
- *
- * One document per buyer×storeId×productId tuple. Messages are embedded in
- * the document as an array (good up to ~200 entries; migrate to subcollection
- * later if threads explode).
- *
- * All mutations are transactional so concurrent writes don't drop messages
- * or unread counters.
- */
-import { type ConversationDocument, type ConversationMessage } from "../schemas/firestore";
-export declare class ConversationFullError extends Error {
-    readonly code: "CONVERSATION_FULL";
-}
-export declare class ConversationsRepository {
-    private collection;
-    /**
-     * Find an existing buyer×store×product conversation or create a new one.
-     * Idempotent — safe to call on every "Contact Seller" click.
-     */
-    findOrCreateByContext(params: {
-        buyerId: string;
-        buyerDisplayName: string;
-        storeId: string;
-        storeName: string;
-        sellerDisplayName: string;
-        productId?: string;
-        productTitle?: string;
-    }): Promise<ConversationDocument>;
-    findById(id: string): Promise<ConversationDocument | null>;
-    listByBuyer(buyerId: string): Promise<ConversationDocument[]>;
-    listByStore(storeId: string): Promise<ConversationDocument[]>;
-    /**
-     * Conversation ids this user may subscribe to, for the RTDB `conversationIds`
-     * custom-token claim.
-     *
-     * 🛑 This claim previously had NO ISSUER ANYWHERE. The `chats/$conversationId`
-     * rule requires `auth.token.conversationIds[$conversationId] == true`, but
-     * `/api/realtime/token` only ever issued `chatIds`, built by
-     * `chatRepository.getChatIdsForUser()` over the **`chatRooms`** collection —
-     * a different collection with different document ids. So the buyer↔seller
-     * live-message channel was denied for every user, and both subscribing hooks
-     * swallowed the permission error (one into `setIsConnected(false)`, one into
-     * a literal `// ignore`). Messages only ever appeared for the sender, via an
-     * unrelated `refetch()` after send.
-     *
-     * `.select()` with no fields fetches ids only — the document bodies are not
-     * needed and this runs on every token issue.
-     *
-     * @param limit hard cap. Firebase custom claims are limited to 1000 BYTES
-     *   total; each entry costs roughly `"<20-char id>":true,` ≈ 28 bytes, so a
-     *   user in hundreds of conversations would make `createCustomToken` throw
-     *   and take the whole route down (see the route's own comment).
-     */
-    getConversationIdsForUser(userId: string, storeIds?: readonly string[], limit?: number): Promise<string[]>;
-    /**
-     * Append a message to a conversation in a transaction. Bumps the counterparty
-     * unread counter; updates lastMessage / lastMessageAt / updatedAt.
-     */
-    appendMessage(conversationId: string, msg: Omit<ConversationMessage, "id" | "sentAt" | "isRead"> & {
-        id?: string;
-        sentAt?: Date;
-    }): Promise<ConversationDocument>;
-    /**
-     * Zero out the unread counter for one party. Also flips `isRead` on the
-     * embedded messages sent by the other party so the seller side can see what
-     * the buyer has already read.
-     */
-    markRead(conversationId: string, role: "buyer" | "seller"): Promise<void>;
-}
-export declare const conversationsRepository: ConversationsRepository;

package/dist/features/messages/repository/conversations.repository.js

@@ -1,284 +0,0 @@
-/**
- * ConversationsRepository — buyer↔seller messaging.
- *
- * One document per buyer×storeId×productId tuple. Messages are embedded in
- * the document as an array (good up to ~200 entries; migrate to subcollection
- * later if threads explode).
- *
- * All mutations are transactional so concurrent writes don't drop messages
- * or unread counters.
- */
-import { getAdminDb } from "../../../providers/db-firebase";
-import { encryptPiiFields, decryptPiiFields } from "../../../security/pii-encrypt";
-import { CONVERSATION_PII_FIELDS } from "../../../security/pii-schemas";
-import { serverLogger } from "../../../monitoring";
-import { CONVERSATION_FIELDS } from "../../../constants/field-names";
-import { CONVERSATIONS_COLLECTION, } from "../schemas/firestore";
-function toDate(raw) {
-    if (raw instanceof Date)
-        return raw;
-    if (raw && typeof raw.toDate === "function") {
-        return raw.toDate();
-    }
-    if (typeof raw === "string" || typeof raw === "number")
-        return new Date(raw);
-    return new Date();
-}
-function normaliseMessage(raw) {
-    const r = (raw ?? {});
-    return {
-        id: String(r.id ?? ""),
-        senderId: String(r.senderId ?? ""),
-        senderRole: r.senderRole ?? "buyer",
-        body: String(r.body ?? ""),
-        isRead: r.isRead === true,
-        sentAt: toDate(r.sentAt),
-        attachments: Array.isArray(r.attachments)
-            ? r.attachments
-            : undefined,
-    };
-}
-function normaliseDoc(id, raw) {
-    // Decrypt here rather than at the six call sites: this is the one function
-    // every read path already goes through, so a new reader cannot forget it.
-    // `markRead` deliberately does NOT decrypt — it reads raw messages, flips
-    // isRead and writes them straight back, so ciphertext round-trips untouched.
-    const r = decryptPiiFields(raw, [...CONVERSATION_PII_FIELDS]);
-    return {
-        id,
-        buyerId: String(r.buyerId ?? ""),
-        buyerDisplayName: String(r.buyerDisplayName ?? ""),
-        storeId: String(r.storeId ?? ""),
-        storeName: String(r.storeName ?? ""),
-        sellerDisplayName: String(r.sellerDisplayName ?? ""),
-        productId: typeof r.productId === "string" ? r.productId : undefined,
-        productTitle: typeof r.productTitle === "string" ? r.productTitle : undefined,
-        messages: Array.isArray(r.messages) ? r.messages.map(normaliseMessage) : [],
-        lastMessage: String(r.lastMessage ?? ""),
-        lastMessageAt: toDate(r.lastMessageAt),
-        unreadBuyer: typeof r.unreadBuyer === "number" ? r.unreadBuyer : 0,
-        unreadSeller: typeof r.unreadSeller === "number" ? r.unreadSeller : 0,
-        status: r.status ?? "active",
-        createdAt: toDate(r.createdAt),
-        updatedAt: toDate(r.updatedAt),
-    };
-}
-export class ConversationFullError extends Error {
-    constructor() {
-        super(...arguments);
-        this.code = "CONVERSATION_FULL";
-    }
-}
-export class ConversationsRepository {
-    collection() {
-        return getAdminDb().collection(CONVERSATIONS_COLLECTION);
-    }
-    /**
-     * Find an existing buyer×store×product conversation or create a new one.
-     * Idempotent — safe to call on every "Contact Seller" click.
-     */
-    async findOrCreateByContext(params) {
-        const db = getAdminDb();
-        const coll = this.collection();
-        const { buyerId, storeId, productId } = params;
-        // Stable composite key: buyerId + storeId + (productId | "general")
-        const productKey = productId ?? "general";
-        const stableId = `conv-${buyerId}-${storeId}-${productKey}`;
-        const ref = coll.doc(stableId);
-        return db.runTransaction(async (tx) => {
-            const snap = await tx.get(ref);
-            if (snap.exists) {
-                return normaliseDoc(snap.id, snap.data() ?? {});
-            }
-            const now = new Date();
-            const newDoc = {
-                buyerId: params.buyerId,
-                buyerDisplayName: params.buyerDisplayName,
-                storeId: params.storeId,
-                storeName: params.storeName,
-                sellerDisplayName: params.sellerDisplayName,
-                productId: params.productId,
-                productTitle: params.productTitle,
-                messages: [],
-                lastMessage: "",
-                lastMessageAt: now,
-                unreadBuyer: 0,
-                unreadSeller: 0,
-                status: "active",
-                createdAt: now,
-                updatedAt: now,
-            };
-            const encryptedDoc = encryptPiiFields(newDoc, [...CONVERSATION_PII_FIELDS]);
-            tx.set(ref, encryptedDoc);
-            return normaliseDoc(stableId, encryptedDoc);
-        });
-    }
-    async findById(id) {
-        const snap = await this.collection().doc(id).get();
-        if (!snap.exists)
-            return null;
-        return normaliseDoc(snap.id, snap.data() ?? {});
-    }
-    async listByBuyer(buyerId) {
-        const snap = await this.collection()
-            .where(CONVERSATION_FIELDS.BUYER_ID, "==", buyerId)
-            .orderBy(CONVERSATION_FIELDS.LAST_MESSAGE_AT, "desc")
-            .get();
-        return snap.docs.map((d) => normaliseDoc(d.id, d.data()));
-    }
-    async listByStore(storeId) {
-        const snap = await this.collection()
-            .where(CONVERSATION_FIELDS.STORE_ID, "==", storeId)
-            .orderBy(CONVERSATION_FIELDS.LAST_MESSAGE_AT, "desc")
-            .get();
-        return snap.docs.map((d) => normaliseDoc(d.id, d.data()));
-    }
-    /**
-     * Conversation ids this user may subscribe to, for the RTDB `conversationIds`
-     * custom-token claim.
-     *
-     * 🛑 This claim previously had NO ISSUER ANYWHERE. The `chats/$conversationId`
-     * rule requires `auth.token.conversationIds[$conversationId] == true`, but
-     * `/api/realtime/token` only ever issued `chatIds`, built by
-     * `chatRepository.getChatIdsForUser()` over the **`chatRooms`** collection —
-     * a different collection with different document ids. So the buyer↔seller
-     * live-message channel was denied for every user, and both subscribing hooks
-     * swallowed the permission error (one into `setIsConnected(false)`, one into
-     * a literal `// ignore`). Messages only ever appeared for the sender, via an
-     * unrelated `refetch()` after send.
-     *
-     * `.select()` with no fields fetches ids only — the document bodies are not
-     * needed and this runs on every token issue.
-     *
-     * @param limit hard cap. Firebase custom claims are limited to 1000 BYTES
-     *   total; each entry costs roughly `"<20-char id>":true,` ≈ 28 bytes, so a
-     *   user in hundreds of conversations would make `createCustomToken` throw
-     *   and take the whole route down (see the route's own comment).
-     */
-    async getConversationIdsForUser(userId, storeIds = [], limit = 25) {
-        const queries = [
-            this.collection()
-                .where(CONVERSATION_FIELDS.BUYER_ID, "==", userId)
-                .orderBy(CONVERSATION_FIELDS.LAST_MESSAGE_AT, "desc")
-                .limit(limit)
-                .select()
-                .get(),
-            // Firestore `in` caps at 30 values; a seller with more stores than that
-            // is not a shape this app produces.
-            ...(storeIds.length > 0
-                ? [
-                    this.collection()
-                        .where(CONVERSATION_FIELDS.STORE_ID, "in", storeIds.slice(0, 30))
-                        .orderBy(CONVERSATION_FIELDS.LAST_MESSAGE_AT, "desc")
-                        .limit(limit)
-                        .select()
-                        .get(),
-                ]
-                : []),
-        ];
-        const snaps = await Promise.all(queries);
-        const ids = new Set();
-        for (const snap of snaps) {
-            for (const doc of snap.docs)
-                ids.add(doc.id);
-        }
-        // Most-recent-first is already the sort order; truncating here keeps the
-        // claim inside the byte budget when a user is both buyer and seller.
-        return [...ids].slice(0, limit);
-    }
-    /**
-     * Append a message to a conversation in a transaction. Bumps the counterparty
-     * unread counter; updates lastMessage / lastMessageAt / updatedAt.
-     */
-    async appendMessage(conversationId, msg) {
-        const db = getAdminDb();
-        const ref = this.collection().doc(conversationId);
-        try {
-            return await db.runTransaction(async (tx) => {
-                const snap = await tx.get(ref);
-                if (!snap.exists) {
-                    throw new Error("Conversation not found");
-                }
-                const data = snap.data() ?? {};
-                const existing = Array.isArray(data.messages)
-                    ? data.messages.map(normaliseMessage)
-                    : [];
-                const now = msg.sentAt ?? new Date();
-                const newMessage = {
-                    id: msg.id ?? `msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-                    senderId: msg.senderId,
-                    senderRole: msg.senderRole,
-                    body: msg.body,
-                    isRead: false,
-                    sentAt: now,
-                    attachments: msg.attachments,
-                };
-                const nextMessages = [...existing, newMessage];
-                const unreadBuyer = msg.senderRole === "seller"
-                    ? (typeof data.unreadBuyer === "number" ? data.unreadBuyer : 0) + 1
-                    : (typeof data.unreadBuyer === "number" ? data.unreadBuyer : 0);
-                const unreadSeller = msg.senderRole === "buyer"
-                    ? (typeof data.unreadSeller === "number" ? data.unreadSeller : 0) + 1
-                    : (typeof data.unreadSeller === "number" ? data.unreadSeller : 0);
-                const patch = {
-                    messages: nextMessages,
-                    lastMessage: msg.body,
-                    lastMessageAt: now,
-                    unreadBuyer,
-                    unreadSeller,
-                    updatedAt: now,
-                };
-                // Encrypt before the write; normaliseDoc decrypts on the way back out,
-                // so the caller still receives plaintext.
-                const encryptedPatch = encryptPiiFields(patch, [...CONVERSATION_PII_FIELDS]);
-                tx.update(ref, encryptedPatch);
-                return normaliseDoc(conversationId, { ...data, ...encryptedPatch });
-            });
-        }
-        catch (error) {
-            serverLogger.error("ConversationsRepository.appendMessage error", {
-                conversationId,
-                error,
-            });
-            throw error;
-        }
-    }
-    /**
-     * Zero out the unread counter for one party. Also flips `isRead` on the
-     * embedded messages sent by the other party so the seller side can see what
-     * the buyer has already read.
-     */
-    async markRead(conversationId, role) {
-        const db = getAdminDb();
-        const ref = this.collection().doc(conversationId);
-        try {
-            await db.runTransaction(async (tx) => {
-                const snap = await tx.get(ref);
-                if (!snap.exists)
-                    return;
-                const data = snap.data() ?? {};
-                const messages = Array.isArray(data.messages)
-                    ? data.messages.map(normaliseMessage)
-                    : [];
-                // role="buyer" means the buyer just opened the chat → mark all
-                // seller-sent messages read.
-                const otherRole = role === "buyer" ? "seller" : "buyer";
-                const nextMessages = messages.map((m) => m.senderRole === otherRole && !m.isRead ? { ...m, isRead: true } : m);
-                tx.update(ref, {
-                    messages: nextMessages,
-                    [role === "buyer" ? "unreadBuyer" : "unreadSeller"]: 0,
-                    updatedAt: new Date(),
-                });
-            });
-        }
-        catch (error) {
-            serverLogger.error("ConversationsRepository.markRead error", {
-                conversationId,
-                role,
-                error,
-            });
-            throw error;
-        }
-    }
-}
-export const conversationsRepository = new ConversationsRepository();

package/dist/features/messages/schemas/firestore.d.ts

@@ -1,34 +0,0 @@
-/**
- * Messages / Conversations Firestore Document Types & Constants
- *
- * Architecture: one `conversations` document per buyer↔seller pair on a product.
- * Messages are embedded as an array for seed purposes; production can migrate to
- * a subcollection when the thread exceeds ~200 messages.
- */
-import type { BaseDocument } from "../../../_internal/shared/types/base-document";
-export type ConversationMessage = {
-    id: string;
-    senderId: string;
-    senderRole: "buyer" | "seller";
-    body: string;
-    isRead: boolean;
-    sentAt: Date;
-    attachments?: string[];
-};
-export interface ConversationDocument extends BaseDocument {
-    buyerId: string;
-    buyerDisplayName: string;
-    storeId: string;
-    storeName: string;
-    sellerDisplayName: string;
-    productId?: string;
-    productTitle?: string;
-    messages: ConversationMessage[];
-    lastMessage: string;
-    lastMessageAt: Date;
-    unreadBuyer: number;
-    unreadSeller: number;
-    status: "active" | "archived" | "blocked";
-}
-export declare const CONVERSATIONS_COLLECTION: "conversations";
-export declare const CONVERSATIONS_INDEXED_FIELDS: readonly ["buyerId", "storeId", "productId", "status", "lastMessageAt", "createdAt"];

package/dist/features/messages/schemas/firestore.js

@@ -1,16 +0,0 @@
-/**
- * Messages / Conversations Firestore Document Types & Constants
- *
- * Architecture: one `conversations` document per buyer↔seller pair on a product.
- * Messages are embedded as an array for seed purposes; production can migrate to
- * a subcollection when the thread exceeds ~200 messages.
- */
-export const CONVERSATIONS_COLLECTION = "conversations";
-export const CONVERSATIONS_INDEXED_FIELDS = [
-    "buyerId",
-    "storeId",
-    "productId",
-    "status",
-    "lastMessageAt",
-    "createdAt",
-];

package/dist/features/messages/schemas/index.d.ts

@@ -1,177 +0,0 @@
-import { z } from "zod";
-export * from "./firestore";
-export declare const conversationMessageSenderRoleSchema: z.ZodEnum<["buyer", "seller"]>;
-export declare const conversationStatusSchema: z.ZodEnum<["active", "archived", "blocked"]>;
-export declare const conversationMessageSchema: z.ZodObject<{
-    id: z.ZodString;
-    senderId: z.ZodString;
-    senderRole: z.ZodEnum<["buyer", "seller"]>;
-    body: z.ZodString;
-    isRead: z.ZodBoolean;
-    sentAt: z.ZodUnion<[z.ZodDate, z.ZodString, z.ZodObject<{
-        toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-    }, z.ZodTypeAny, "passthrough">>]>;
-    attachments: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    body: string;
-    isRead: boolean;
-    senderId: string;
-    senderRole: "buyer" | "seller";
-    sentAt: string | Date | z.objectOutputType<{
-        toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-    }, z.ZodTypeAny, "passthrough">;
-    attachments?: string[] | undefined;
-}, {
-    id: string;
-    body: string;
-    isRead: boolean;
-    senderId: string;
-    senderRole: "buyer" | "seller";
-    sentAt: string | Date | z.objectInputType<{
-        toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-    }, z.ZodTypeAny, "passthrough">;
-    attachments?: string[] | undefined;
-}>;
-export declare const conversationFirestoreSchema: z.ZodObject<{
-    createdAt: z.ZodUnion<[z.ZodDate, z.ZodString, z.ZodObject<{
-        toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-    }, z.ZodTypeAny, "passthrough">>]>;
-    updatedAt: z.ZodUnion<[z.ZodDate, z.ZodString, z.ZodObject<{
-        toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-    }, z.ZodTypeAny, "passthrough">>]>;
-    id: z.ZodString;
-    buyerId: z.ZodString;
-    buyerDisplayName: z.ZodString;
-    storeId: z.ZodString;
-    storeName: z.ZodString;
-    sellerDisplayName: z.ZodString;
-    productId: z.ZodOptional<z.ZodString>;
-    productTitle: z.ZodOptional<z.ZodString>;
-    messages: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        senderId: z.ZodString;
-        senderRole: z.ZodEnum<["buyer", "seller"]>;
-        body: z.ZodString;
-        isRead: z.ZodBoolean;
-        sentAt: z.ZodUnion<[z.ZodDate, z.ZodString, z.ZodObject<{
-            toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-            toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-            toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-        }, z.ZodTypeAny, "passthrough">>]>;
-        attachments: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        id: string;
-        body: string;
-        isRead: boolean;
-        senderId: string;
-        senderRole: "buyer" | "seller";
-        sentAt: string | Date | z.objectOutputType<{
-            toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-        }, z.ZodTypeAny, "passthrough">;
-        attachments?: string[] | undefined;
-    }, {
-        id: string;
-        body: string;
-        isRead: boolean;
-        senderId: string;
-        senderRole: "buyer" | "seller";
-        sentAt: string | Date | z.objectInputType<{
-            toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-        }, z.ZodTypeAny, "passthrough">;
-        attachments?: string[] | undefined;
-    }>, "many">;
-    lastMessage: z.ZodString;
-    lastMessageAt: z.ZodUnion<[z.ZodDate, z.ZodString, z.ZodObject<{
-        toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-    }, z.ZodTypeAny, "passthrough">>]>;
-    unreadBuyer: z.ZodNumber;
-    unreadSeller: z.ZodNumber;
-    status: z.ZodEnum<["active", "archived", "blocked"]>;
-}, "strip", z.ZodTypeAny, {
-    status: "archived" | "active" | "blocked";
-    id: string;
-    createdAt: string | Date | z.objectOutputType<{
-        toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-    }, z.ZodTypeAny, "passthrough">;
-    updatedAt: string | Date | z.objectOutputType<{
-        toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-    }, z.ZodTypeAny, "passthrough">;
-    storeId: string;
-    storeName: string;
-    buyerId: string;
-    lastMessageAt: string | Date | z.objectOutputType<{
-        toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-    }, z.ZodTypeAny, "passthrough">;
-    lastMessage: string;
-    messages: {
-        id: string;
-        body: string;
-        isRead: boolean;
-        senderId: string;
-        senderRole: "buyer" | "seller";
-        sentAt: string | Date | z.objectOutputType<{
-            toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-        }, z.ZodTypeAny, "passthrough">;
-        attachments?: string[] | undefined;
-    }[];
-    buyerDisplayName: string;
-    sellerDisplayName: string;
-    unreadBuyer: number;
-    unreadSeller: number;
-    productId?: string | undefined;
-    productTitle?: string | undefined;
-}, {
-    status: "archived" | "active" | "blocked";
-    id: string;
-    createdAt: string | Date | z.objectInputType<{
-        toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-    }, z.ZodTypeAny, "passthrough">;
-    updatedAt: string | Date | z.objectInputType<{
-        toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-    }, z.ZodTypeAny, "passthrough">;
-    storeId: string;
-    storeName: string;
-    buyerId: string;
-    lastMessageAt: string | Date | z.objectInputType<{
-        toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-    }, z.ZodTypeAny, "passthrough">;
-    lastMessage: string;
-    messages: {
-        id: string;
-        body: string;
-        isRead: boolean;
-        senderId: string;
-        senderRole: "buyer" | "seller";
-        sentAt: string | Date | z.objectInputType<{
-            toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
-        }, z.ZodTypeAny, "passthrough">;
-        attachments?: string[] | undefined;
-    }[];
-    buyerDisplayName: string;
-    sellerDisplayName: string;
-    unreadBuyer: number;
-    unreadSeller: number;
-    productId?: string | undefined;
-    productTitle?: string | undefined;
-}>;
-export type ConversationFromSchema = z.infer<typeof conversationFirestoreSchema>;
-export type ConversationMessageFromSchema = z.infer<typeof conversationMessageSchema>;