whale-code 6.4.0 → 6.5.0

package/dist/server/handlers/comms.js

@@ -1,6 +1,9 @@
 import { sanitizeFilterValue, escapeCSV, fillTemplate, groupBy } from "../lib/utils.js";
-import { generatePdfFromHtml } from "./browser.js";
 import { validateUrl } from "../lib/ssrf-guard.js";
+import { applyGenerationRules, generateCannabinoidData, applyCalculations, runValidation, generateFullPanelData, } from "../lib/pdf-renderer.js";
+import { renderLayoutToPdf, renderHtmlToPdf, renderLabelToPdf } from "../lib/react-pdf-layout.js";
+import { renderCOAToPdf } from "../lib/coa-renderer.js";
+import QRCode from "qrcode";
 const MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024; // 10MB per attachment
 const MAX_TOTAL_ATTACHMENT_BYTES = 25 * 1024 * 1024; // 25MB total
 const MAX_ATTACHMENT_COUNT = 10;
@@ -301,12 +304,12 @@ export async function handleDocuments(sb, args, storeId) {
             const storagePath = `${sid}/${fileName}`;
             let uploadBuffer;
             if (docType === "pdf") {
-                // PDF generation from HTML content via Playwright
+                // PDF generation from HTML content via React-PDF
                 const htmlContent = args.html || args.content;
                 if (!htmlContent)
                     return { success: false, error: "html or content (HTML string) is required for PDF documents" };
                 try {
-                    const pdfBuffer = await generatePdfFromHtml(htmlContent, {
+                    const pdfBuffer = await renderHtmlToPdf(htmlContent, {
                         format: args.format || "A4",
                         landscape: args.landscape || false,
                     });
@@ -530,10 +533,10 @@ export async function handleDocuments(sb, args, storeId) {
             return { success: true, data: { count: data?.length || 0, stores: data } };
         }
         case "list_profiles": {
-            const { data, error } = await sb.from("document_templates")
-                .select("id, name, description, document_type, headers, schema, created_at")
+            const { data, error } = await sb.from("document_profiles")
+                .select("id, name, category, sample_type, config, template_id, is_active, created_at")
                 .eq("is_active", true)
-                .or(`store_id.eq.${sid},store_id.is.null`)
+                .eq("owner_store_id", sid)
                 .order("name");
             if (error)
                 return { success: false, error: error.message };
@@ -541,10 +544,10 @@ export async function handleDocuments(sb, args, storeId) {
                 success: true,
                 data: {
                     count: data?.length || 0,
-                    profiles: (data || []).map(t => ({
-                        id: t.id, name: t.name, description: t.description,
-                        type: t.document_type, headers: t.headers,
-                        fields: t.schema?.length || 0,
+                    profiles: (data || []).map(p => ({
+                        id: p.id, name: p.name, category: p.category,
+                        sample_type: p.sample_type, template_id: p.template_id,
+                        has_config: Object.keys(p.config || {}).length > 0,
                     })),
                 },
             };
@@ -582,7 +585,437 @@ export async function handleDocuments(sb, args, storeId) {
             const succeeded = results.filter(r => !r.error).length;
             return { success: true, data: { total: items.length, succeeded, failed: items.length - succeeded, results } };
         }
+        // ================================================================
+        // PDF TEMPLATE SYSTEM — full layout rendering, calculations, profiles
+        // ================================================================
+        case "generate_pdf": {
+            const templateId = args.template_id;
+            const templateSlug = args.template_slug;
+            if (!templateId && !templateSlug)
+                return { success: false, error: "template_id or template_slug required" };
+            // 1. Load pdf_template
+            let tplQuery = sb.from("pdf_templates").select("*").eq("is_active", true);
+            if (templateId)
+                tplQuery = tplQuery.eq("id", templateId);
+            else
+                tplQuery = tplQuery.eq("slug", templateSlug);
+            tplQuery = tplQuery.or(`store_id.eq.${sid},store_id.is.null`);
+            const { data: tpl, error: tplErr } = await tplQuery.limit(1).single();
+            if (tplErr || !tpl)
+                return { success: false, error: `Template not found: ${templateId || templateSlug}` };
+            // 2. Optionally load document_profile + its client store
+            let profileConfig = {};
+            let profileConstants = {};
+            let profileClientData = {};
+            let resolvedClientStoreId = null;
+            if (args.profile_id) {
+                const { data: profile } = await sb.from("document_profiles")
+                    .select("*").eq("id", args.profile_id).eq("is_active", true).single();
+                if (profile) {
+                    const cfg = (profile.config || {});
+                    profileConfig = cfg;
+                    profileConstants = (cfg.constants || {});
+                    resolvedClientStoreId = profile.client_store_id || null;
+                    // Load client info from the profile's linked store
+                    if (profile.client_store_id) {
+                        const { data: clientStore } = await sb.from("stores")
+                            .select("store_name, legal_name, address, city, state, zip, distributor_license_number, phone, email")
+                            .eq("id", profile.client_store_id).single();
+                        if (clientStore) {
+                            profileClientData = {
+                                clientName: clientStore.legal_name || clientStore.store_name,
+                                clientAddress: [clientStore.address, clientStore.city, clientStore.state, clientStore.zip].filter(Boolean).join(", ") || null,
+                                licenseNumber: clientStore.distributor_license_number || null,
+                                clientPhone: clientStore.phone || null,
+                                clientEmail: clientStore.email || null,
+                            };
+                        }
+                    }
+                    // Use profile name as sampleName if not already set
+                    if (profile.name && !profileConstants.sampleName) {
+                        profileClientData.sampleName = profile.name;
+                    }
+                    if (profile.sample_type) {
+                        profileClientData.sampleType = profile.sample_type;
+                    }
+                    if (profile.default_size) {
+                        profileClientData.sampleSize = profile.default_size;
+                    }
+                }
+            }
+            // 3. Optionally load customer (via store_customer_profiles + platform_users) — overrides profile client
+            let clientData = {};
+            if (args.customer_id) {
+                const { data: rel } = await sb.from("user_creation_relationships")
+                    .select("id, store_id, platform_users!inner(first_name, last_name, email, phone)")
+                    .eq("id", args.customer_id).single();
+                if (rel) {
+                    const pu = rel.platform_users;
+                    const { data: prof } = await sb.from("store_customer_profiles")
+                        .select("street_address, city, state, postal_code, drivers_license_number, medical_card_number")
+                        .eq("relationship_id", rel.id).maybeSingle();
+                    clientData = {
+                        clientName: [pu.first_name, pu.last_name].filter(Boolean).join(" "),
+                        clientEmail: pu.email,
+                        clientPhone: pu.phone,
+                        clientAddress: prof ? [prof.street_address, prof.city, prof.state, prof.postal_code].filter(Boolean).join(", ") : null,
+                        clientLicense: prof?.drivers_license_number || null,
+                        clientMedicalCard: prof?.medical_card_number || null,
+                    };
+                }
+            }
+            // 4. Merge data: constants ← profile config ← profile client ← explicit client ← user data
+            const tplConstants = (tpl.constants || {});
+            const mergedConstants = { ...tplConstants, ...profileConstants };
+            const cannabinoidCfg = (profileConfig.cannabinoids ?? undefined);
+            const { cannabinoids: _cfgRanges, ...profileDataOnly } = profileConfig;
+            let mergedData = {
+                ...mergedConstants,
+                ...profileDataOnly,
+                ...profileClientData,
+                ...clientData,
+                ...(args.data || {}),
+                date: new Date().toISOString().slice(0, 10),
+                approvalDate: new Date().toISOString().slice(0, 10),
+            };
+            // 5. Apply generation rules — auto-fill sampleId, dates, etc.
+            mergedData = applyGenerationRules(tpl.generation_rules, mergedData);
+            // 6. Generate cannabinoid data if profile has cannabinoid config
+            if (cannabinoidCfg && !mergedData.cannabinoids) {
+                mergedData.cannabinoids = generateCannabinoidData(cannabinoidCfg, mergedConstants);
+            }
+            // 7. Apply calculations
+            mergedData = applyCalculations(tpl.calculations, mergedConstants, mergedData);
+            // Also run per-row calculations if cannabinoids exist
+            if (Array.isArray(mergedData.cannabinoids)) {
+                const rows = mergedData.cannabinoids;
+                for (const row of rows) {
+                    const rowCtx = { ...mergedConstants, ...row };
+                    const rowCalcs = (tpl.row_calculations || tpl.calculations);
+                    if (rowCalcs) {
+                        const computed = applyCalculations(rowCalcs, mergedConstants, rowCtx);
+                        Object.assign(row, computed);
+                    }
+                }
+            }
+            // 7b. Generate full panel data if requested (safety tests, pesticides, solvents)
+            if (mergedData.fullPanel && !mergedData.microbialResults) {
+                const tplConstants = (tpl.constants || {});
+                const fullPanel = generateFullPanelData(tplConstants);
+                mergedData.microbialResults = fullPanel.microbialResults;
+                mergedData.heavyMetalsResults = fullPanel.heavyMetalsResults;
+                mergedData.mycotoxinResults = fullPanel.mycotoxinResults;
+                mergedData.pesticidesCat1 = fullPanel.pesticidesCat1;
+                mergedData.pesticidesCat2 = fullPanel.pesticidesCat2;
+                mergedData.testsResidualSolvents = fullPanel.residualSolventsResults;
+                mergedData.totalPages = 5;
+                mergedData.complianceResults = mergedData.complianceResults || {
+                    heavyMetals: { status: "PASS" }, microbial: { status: "PASS" },
+                    pesticides: { status: "PASS" }, mycotoxins: { status: "PASS" },
+                    residualSolvents: { status: "PASS" },
+                };
+            }
+            // 7c. Generate QR code for COA templates — links to Quantix COA landing page
+            if (tpl.slug?.startsWith("cannabis-coa") && !mergedData.qrCodeDataUrl) {
+                const productSlug = (mergedData.sampleName || "certificate")
+                    .toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+                const coaUrl = `https://quantixanalytics.com/coa/${sid}/${productSlug}`;
+                try {
+                    mergedData.qrCodeDataUrl = await QRCode.toDataURL(coaUrl, { width: 120, margin: 1 });
+                }
+                catch { /* skip QR if generation fails */ }
+            }
+            // 8. Validate
+            const validationResults = runValidation(tpl.validation_rules, mergedData);
+            const errors = validationResults.filter(v => v.severity === "error" && !v.passed);
+            const warnings = validationResults.filter(v => v.severity === "warning" && !v.passed);
+            if (errors.length > 0 && !args.force) {
+                return {
+                    success: false,
+                    error: `Validation failed: ${errors.map(e => e.message).join("; ")}`,
+                    data: { errors, warnings },
+                };
+            }
+            // 9-10. Render PDF — all templates use React-PDF
+            let pdfBuffer;
+            try {
+                if (tpl.slug?.startsWith("cannabis-coa")) {
+                    // COA templates use dedicated renderer
+                    pdfBuffer = await renderCOAToPdf(mergedData);
+                }
+                else {
+                    // Detect label layout vs generic layout
+                    const layout = tpl.layout;
+                    const isLabel = layout?.version === 1 && Array.isArray(layout?.elements) && layout.elements[0]?.field;
+                    if (isLabel) {
+                        const items = Array.isArray(mergedData.items)
+                            ? mergedData.items
+                            : [mergedData];
+                        pdfBuffer = await renderLabelToPdf(layout, tpl.page_config, items);
+                    }
+                    else {
+                        pdfBuffer = await renderLayoutToPdf(tpl.layout, tpl.page_config, tpl.styles, mergedData);
+                    }
+                }
+            }
+            catch (err) {
+                return { success: false, error: `PDF generation failed: ${err instanceof Error ? err.message : String(err)}` };
+            }
+            // 11. Upload to Supabase storage
+            const sampleName = mergedData.sampleName || mergedData.productName || "";
+            const docName = args.name || (sampleName ? `${sampleName} COA` : fillTemplate(tpl.name || "Document", mergedData));
+            const safeName = docName.replace(/[^a-zA-Z0-9_\-]/g, "_");
+            const fileName = `${safeName}_${Date.now()}.pdf`;
+            const storagePath = `${sid}/${fileName}`;
+            const bucketName = "store-documents";
+            const { error: uploadErr } = await sb.storage
+                .from(bucketName)
+                .upload(storagePath, new Uint8Array(pdfBuffer), { contentType: "application/pdf", upsert: true });
+            if (uploadErr)
+                return { success: false, error: `Upload failed: ${uploadErr.message}` };
+            const { data: urlData } = sb.storage.from(bucketName).getPublicUrl(storagePath);
+            // 12. Build COA metadata for the Quantix landing page
+            const coaMetadata = {
+                size_bytes: pdfBuffer.length,
+                from_pdf_template: true,
+                template_version: tpl.version,
+            };
+            if (tpl.slug?.startsWith("cannabis-coa")) {
+                coaMetadata.sample_name = sampleName;
+                coaMetadata.sample_id = mergedData.sampleId || null;
+                coaMetadata.sample_type = mergedData.sampleType || mergedData.strain || null;
+                coaMetadata.sample_size = mergedData.sampleSize || null;
+                coaMetadata.batch_number = mergedData.batchId || null;
+                coaMetadata.lab_name = mergedData.labName || null;
+                coaMetadata.lab_contact = mergedData.labContact || null;
+                coaMetadata.lab_website = mergedData.labWebsite || null;
+                coaMetadata.lab_director = mergedData.labDirector || null;
+                coaMetadata.director_title = mergedData.directorTitle || null;
+                coaMetadata.logo_url = mergedData.logoUrl || null;
+                coaMetadata.signature_url = mergedData.signatureUrl || null;
+                coaMetadata.client_name = mergedData.clientName || null;
+                coaMetadata.client_address = mergedData.clientAddress || null;
+                coaMetadata.date_collected = mergedData.dateCollected || null;
+                coaMetadata.date_received = mergedData.dateReceived || null;
+                coaMetadata.date_tested = mergedData.dateTested || null;
+                coaMetadata.date_reported = mergedData.dateReported || null;
+                coaMetadata.status = "Pass";
+                coaMetadata.thc_total = mergedData.totalTHC || null;
+                coaMetadata.cbd_total = mergedData.totalCBD || null;
+                coaMetadata.cannabinoids_total = mergedData.totalCannabinoids || null;
+                coaMetadata.moisture = mergedData.moisture || null;
+                // Detailed cannabinoid data for the interactive landing page
+                const cannabinoids = mergedData.cannabinoids;
+                if (Array.isArray(cannabinoids)) {
+                    coaMetadata.cannabinoids = Object.fromEntries(cannabinoids.filter((c) => typeof c.percentWeight === "number" && c.percentWeight > 0)
+                        .map((c) => [c.name, c.percentWeight]));
+                    coaMetadata.cannabinoids_detailed = cannabinoids.map((c) => ({
+                        name: c.name, percent: c.percentWeight, mg_per_g: c.mgPerG, lod: c.lod, loq: c.loq, result: String(c.result ?? c.percentWeight),
+                    }));
+                }
+                // Safety test panels
+                if (mergedData.fullPanel) {
+                    coaMetadata.test_panels = {
+                        cannabinoids: true, microbial: true, heavy_metals: true,
+                        mycotoxins: true, pesticides: true, residual_solvents: true,
+                    };
+                    coaMetadata.safety_tests = {
+                        microbial: "Pass", heavy_metals: "Pass", mycotoxins: "Pass",
+                        pesticides: "Pass", residual_solvents: "Pass",
+                    };
+                }
+            }
+            // 13. Insert store_documents record
+            const { data: record, error: insertErr } = await sb.from("store_documents").insert({
+                store_id: sid,
+                document_type: tpl.document_type || "pdf",
+                file_name: fileName,
+                file_url: urlData.publicUrl,
+                file_size: pdfBuffer.length,
+                file_type: "application/pdf",
+                document_name: docName,
+                source_name: "PDF Template Engine",
+                document_date: new Date().toISOString().split("T")[0],
+                customer_id: args.customer_id || null,
+                client_store_id: resolvedClientStoreId,
+                data: { template_id: tpl.id, template_slug: tpl.slug, profile_id: args.profile_id || null },
+                metadata: coaMetadata,
+            }).select("id, document_name, file_url, created_at").single();
+            if (insertErr)
+                return { success: false, error: insertErr.message };
+            return {
+                success: true,
+                data: {
+                    id: record.id,
+                    name: record.document_name,
+                    url: record.file_url,
+                    template: tpl.name,
+                    size: pdfBuffer.length,
+                    warnings: warnings.map(w => w.message),
+                },
+            };
+        }
+        case "list_pdf_templates": {
+            let query = sb.from("pdf_templates")
+                .select("id, slug, name, description, document_type, version, created_at")
+                .eq("is_active", true)
+                .or(`store_id.eq.${sid},store_id.is.null`)
+                .order("name");
+            if (args.document_type)
+                query = query.eq("document_type", args.document_type);
+            if (args.limit)
+                query = query.limit(args.limit);
+            const { data, error } = await query;
+            if (error)
+                return { success: false, error: error.message };
+            return {
+                success: true,
+                data: {
+                    count: data?.length || 0,
+                    templates: (data || []).map(t => ({
+                        id: t.id, slug: t.slug, name: t.name,
+                        description: t.description, type: t.document_type, version: t.version,
+                    })),
+                },
+            };
+        }
+        case "list_document_profiles": {
+            let query = sb.from("document_profiles")
+                .select("id, name, category, sample_type, default_size, client_store_id, template_id, created_at")
+                .eq("is_active", true)
+                .eq("owner_store_id", sid)
+                .order("name");
+            if (args.template_id)
+                query = query.eq("template_id", args.template_id);
+            if (args.category)
+                query = query.eq("category", args.category);
+            if (args.limit)
+                query = query.limit(args.limit);
+            const { data, error } = await query;
+            if (error)
+                return { success: false, error: error.message };
+            return {
+                success: true,
+                data: {
+                    count: data?.length || 0,
+                    profiles: (data || []).map(p => ({
+                        id: p.id, name: p.name, category: p.category,
+                        sample_type: p.sample_type, default_size: p.default_size,
+                        client_store_id: p.client_store_id,
+                    })),
+                },
+            };
+        }
+        case "list_clients":
+        case "list_customers": {
+            let query = sb.from("v_store_customers")
+                .select("id, first_name, last_name, email, phone, loyalty_tier, total_orders, is_active, created_at")
+                .eq("store_id", sid)
+                .order("created_at", { ascending: false });
+            if (args.query) {
+                const term = `%${sanitizeFilterValue(String(args.query).trim())}%`;
+                query = query.or(`first_name.ilike.${term},last_name.ilike.${term},email.ilike.${term}`);
+            }
+            if (args.limit)
+                query = query.limit(args.limit);
+            const { data, error } = await query;
+            if (error)
+                return { success: false, error: error.message };
+            return {
+                success: true,
+                data: {
+                    count: data?.length || 0,
+                    customers: (data || []).map(c => ({
+                        id: c.id, name: [c.first_name, c.last_name].filter(Boolean).join(" "),
+                        email: c.email, phone: c.phone, loyalty_tier: c.loyalty_tier,
+                        total_orders: c.total_orders, is_active: c.is_active,
+                    })),
+                },
+            };
+        }
+        case "deliver_documents": {
+            // Batch-assign documents to a customer and optionally send notification email
+            const docIds = args.document_ids || (args.document_id ? [args.document_id] : []);
+            const customerId = args.customer_id;
+            if (!docIds.length)
+                return { success: false, error: "document_ids (array) or document_id (string) is required" };
+            if (!customerId)
+                return { success: false, error: "customer_id is required" };
+            // Verify customer belongs to this store
+            const { data: rel, error: relErr } = await sb.from("user_creation_relationships")
+                .select("id, store_id, platform_users!inner(first_name, last_name, email)")
+                .eq("id", customerId).eq("store_id", sid).single();
+            if (relErr || !rel)
+                return { success: false, error: "Customer not found for this store" };
+            const pu = rel.platform_users;
+            const customerEmail = pu.email;
+            const customerName = [pu.first_name, pu.last_name].filter(Boolean).join(" ");
+            // Assign all documents to the customer
+            const { error: updateErr } = await sb.from("store_documents")
+                .update({ customer_id: customerId })
+                .in("id", docIds)
+                .eq("store_id", sid);
+            if (updateErr)
+                return { success: false, error: `Failed to assign documents: ${updateErr.message}` };
+            // Get document names for the email
+            const { data: docs } = await sb.from("store_documents")
+                .select("id, document_name, file_url")
+                .in("id", docIds);
+            let emailSent = false;
+            if (!args.skip_email && customerEmail) {
+                const portalUrl = args.portal_url || null;
+                const docList = (docs || []).map(d => `<li><a href="${d.file_url}">${d.document_name || "Document"}</a></li>`).join("");
+                // Get store name for template
+                const { data: store } = await sb.from("stores").select("store_name").eq("id", sid).single();
+                const emailResult = await handleEmail(sb, {
+                    action: "send_template",
+                    to: customerEmail,
+                    template: "documents-delivered",
+                    template_data: {
+                        customer_name: customerName || "there",
+                        store_name: store?.store_name || "",
+                        document_count: String(docIds.length),
+                        document_list: docList,
+                        portal_url: portalUrl || "",
+                    },
+                }, storeId);
+                emailSent = emailResult.success;
+            }
+            return {
+                success: true,
+                data: {
+                    document_ids: docIds,
+                    customer_id: customerId,
+                    customer_email: customerEmail,
+                    email_sent: emailSent,
+                    count: docIds.length,
+                },
+            };
+        }
+        case "list_customer_documents": {
+            const customerId = args.customer_id;
+            if (!customerId)
+                return { success: false, error: "customer_id is required" };
+            let query = sb.from("store_documents")
+                .select("id, document_name, file_url, file_type, created_at, thumbnail_url, metadata, document_type")
+                .eq("store_id", sid)
+                .eq("customer_id", customerId)
+                .eq("is_active", true)
+                .order("created_at", { ascending: false });
+            if (args.limit)
+                query = query.limit(args.limit);
+            const { data, error } = await query;
+            if (error)
+                return { success: false, error: error.message };
+            return {
+                success: true,
+                data: {
+                    count: data?.length || 0,
+                    documents: data || [],
+                },
+            };
+        }
         default:
-            return { success: false, error: `Unknown documents action: ${action}. Valid: create, find, delete, create_template, list_templates, from_template, list_stores, list_profiles, generate` };
+            return { success: false, error: `Unknown documents action: ${action}. Valid: create, find, delete, create_template, list_templates, from_template, list_stores, list_profiles, generate, bulk_generate, generate_pdf, list_pdf_templates, list_document_profiles, list_customers, deliver_documents, list_customer_documents` };
     }
 }

package/dist/server/handlers/creations.js

@@ -55,7 +55,7 @@ const { products, store, categories } = useStore();
 Product shape:
 { id, name, sku, description, short_description, status, type,
   cost_price, wholesale_price, stock_quantity, featured,
-  field_values: { thca_percentage, strain_type, terpenes, effects, cbd_total, ... },
+  custom_fields: { thca_percentage, strain_type, terpenes, effects, cbd_total, ... },
   pricing_data: { mode, tiers: [{ label, quantity, unit, price }] },
   category: { id, name } }
 

package/dist/server/handlers/crm.d.ts

@@ -4,14 +4,12 @@ export declare function handleCustomers(sb: SupabaseClient, args: Record<string,
     error: string;
     count?: undefined;
     data?: undefined;
-    note?: undefined;
     linked?: undefined;
 } | {
     success: boolean;
     count: number;
     data: {
         id: any;
-        platform_user_id: any;
         first_name: any;
         last_name: any;
         email: any;
@@ -22,22 +20,30 @@ export declare function handleCustomers(sb: SupabaseClient, args: Record<string,
         total_orders: any;
         lifetime_value: any;
         is_active: any;
+        rfm_segment: any;
+        is_vip_customer: any;
+        is_at_risk: any;
+        is_churned: any;
+        reorder_due: any;
+        ai_churn_risk: any;
+        days_since_last_order: any;
+        engagement_score: any;
+        age_bracket: any;
         created_at: any;
     }[];
     error?: undefined;
-    note?: undefined;
     linked?: undefined;
 } | {
+    warning?: string | undefined;
+    note?: string | undefined;
     success: boolean;
-    data: any;
+    data: Record<string, unknown> | null;
     error?: undefined;
     count?: undefined;
-    note?: undefined;
     linked?: undefined;
 } | {
     success: boolean;
     data: any;
-    note: string;
     error?: undefined;
     count?: undefined;
     linked?: undefined;
@@ -57,7 +63,6 @@ export declare function handleCustomers(sb: SupabaseClient, args: Record<string,
         created_at: any;
     }[];
     error?: undefined;
-    note?: undefined;
     linked?: undefined;
 } | {
     success: boolean;
@@ -69,7 +74,48 @@ export declare function handleCustomers(sb: SupabaseClient, args: Record<string,
     error?: undefined;
     count?: undefined;
     data?: undefined;
-    note?: undefined;
+} | {
+    success: boolean;
+    count: number;
+    data: {
+        id: any;
+        points: any;
+        transaction_type: any;
+        reference_type: any;
+        reference_id: any;
+        description: any;
+        balance_before: any;
+        balance_after: any;
+        expires_at: any;
+        created_at: any;
+    }[];
+    error?: undefined;
+    linked?: undefined;
+} | {
+    success: boolean;
+    count: number;
+    data: {
+        id: any;
+        name: any;
+        ai_description: any;
+        type: any;
+        segment_rules: any;
+        filter_criteria: any;
+        customer_count: any;
+        is_active: any;
+        color: any;
+        icon: any;
+        targeting_tips: any;
+        created_at: any;
+    }[];
+    error?: undefined;
+    linked?: undefined;
+} | {
+    success: boolean;
+    count: number;
+    data: Record<string, unknown>[];
+    error?: undefined;
+    linked?: undefined;
 }>;
 export declare function handleOrders(sb: SupabaseClient, args: Record<string, unknown>, storeId?: string): Promise<{
     success: boolean;