@iann29/rastro 0.10.9 → 0.11.0

package/dist/component/metaLeads.d.ts

@@ -0,0 +1,681 @@
+import { type Infer } from "convex/values";
+import type { Id } from "./_generated/dataModel.js";
+import { type ActionCtx, type MutationCtx } from "./_generated/server.js";
+import { type MetaPageErrorCode } from "./leadAdsValidators.js";
+import { type MetaGraph } from "./metaGraph.js";
+/** Leads, forms and Pages one call or one read handles at most. */
+export declare const MAX_PAGES_PER_CONNECTION = 200;
+export declare const MAX_SITE_PAGES = 20;
+/** Forms the forms screen lists for a site, every Page together. */
+export declare const MAX_SITE_FORMS = 500;
+/**
+ * How often the reconciliation makes sure the app is still subscribed to a
+ * linked Page: the subscription is the Page's and the app's, shared by every
+ * host, so another host unlinking the Page (releases before this one did
+ * unsubscribe) or a Page admin may have taken it off.
+ */
+export declare const SUBSCRIPTION_CHECK_MS: number;
+/**
+ * A lead whose commit failed this many times, while later leads of its form
+ * came in, is skipped by the reconciliation (kept in `formLeadFailures`).
+ */
+export declare const MAX_LEAD_ATTEMPTS = 5;
+/**
+ * A link's stored `lastError` (`CODE: message`) as the code a screen reads;
+ * the message stays in the component. Anything unknown reads as Meta being
+ * unavailable, which passes by itself.
+ */
+export declare function pageErrorCode(lastError: string | null | undefined): MetaPageErrorCode | null;
+declare const sealedPageValidator: import("convex/values").VObject<{
+    leadsAllowed: boolean;
+    name: string;
+    pageId: string;
+    tasks: string[];
+    tokenCipher: string;
+    tokenIv: string;
+}, {
+    pageId: import("convex/values").VString<string, "required">;
+    name: import("convex/values").VString<string, "required">;
+    tasks: import("convex/values").VArray<string[], import("convex/values").VString<string, "required">, "required">;
+    leadsAllowed: import("convex/values").VBoolean<boolean, "required">;
+    tokenCipher: import("convex/values").VString<string, "required">;
+    tokenIv: import("convex/values").VString<string, "required">;
+}, "required", "leadsAllowed" | "name" | "pageId" | "tasks" | "tokenCipher" | "tokenIv">;
+/**
+ * The Pages a token acts for, each with its token sealed, for `savePages`.
+ * Never fails a login: a token without the Page permissions (a login with the
+ * old configuration) lists none, and anything Meta refuses here leaves the
+ * Pages already known (`complete: false`).
+ */
+export declare function readPages(client: MetaGraph, token: string): Promise<{
+    pages: Array<Infer<typeof sealedPageValidator>>;
+    complete: boolean;
+}>;
+/**
+ * Stores the Pages a connection's token listed, with their sealed tokens. A
+ * linked Page the listing leaves out (with `complete`) stops, saying why; a
+ * linked Page listed again (or with a fresh token) resumes. Ignored when the
+ * connection has another token by now (`tokenIv`).
+ */
+export declare const savePages: import("convex/server").RegisteredMutation<"internal", {
+    complete: boolean;
+    connectionId: import("convex/values").GenericId<"metaConnections">;
+    connectionTokenIv: string;
+    pages: {
+        leadsAllowed: boolean;
+        name: string;
+        pageId: string;
+        tasks: string[];
+        tokenCipher: string;
+        tokenIv: string;
+    }[];
+}, Promise<null>>;
+export declare const handlerRegistered: import("convex/server").RegisteredQuery<"internal", {}, Promise<boolean>>;
+/**
+ * Reads and stores the Pages a connection's token acts for, on a host that
+ * opted into Lead Ads (its form lead handler is registered). A host that did
+ * not makes no Pages read and keeps no Page token.
+ */
+export declare function syncOwnerPages(ctx: ActionCtx, client: MetaGraph, connection: {
+    connectionId: Id<"metaConnections">;
+    token: string;
+    tokenIv: string;
+}): Promise<void>;
+export declare const ownersToRead: import("convex/server").RegisteredQuery<"internal", {
+    after: number | null;
+}, Promise<{
+    connectionId: import("convex/values").GenericId<"metaConnections">;
+    creationTime: number;
+    tokenCipher: string;
+    tokenIv: string;
+    active: boolean;
+}[]>>;
+/**
+ * The host registered its form lead handler for the first time: the Pages of
+ * the owners already connected are read now, a batch of owners at a time,
+ * instead of at each owner's next login.
+ */
+export declare const readOwnersPages: import("convex/server").RegisteredAction<"internal", {
+    after: number | null;
+}, Promise<null>>;
+/**
+ * Meta refused the Page token sealed with `tokenIv`: the Page stops until a
+ * login lists it with a new one. A newer token (another IV) is left alone.
+ */
+export declare const markPageInvalid: import("convex/server").RegisteredMutation<"internal", {
+    message: string;
+    pageRowId: import("convex/values").GenericId<"metaPages">;
+    tokenIv: string;
+}, Promise<null>>;
+/** Forgets a removed connection's Pages and links, a batch at a time. */
+export declare function removeConnectionPages(ctx: MutationCtx, connectionId: Id<"metaConnections">, batch: number): Promise<boolean>;
+/**
+ * The owner's Pages as a screen shows them: whether Meta granted their
+ * leads, the site each feeds (whoever linked it, since a Page feeds one
+ * site) and whether this owner linked it. Never a token.
+ */
+export declare const pages: import("convex/server").RegisteredQuery<"public", {
+    ownerKey: string;
+}, Promise<{
+    pageId: string;
+    name: string;
+    tasks: string[];
+    leadsAllowed: boolean;
+    linkedSiteId: import("convex/values").GenericId<"sites"> | null;
+    own: boolean | null;
+    subscribedAt: number | null;
+    lastError: "HANDLER_FAILED" | "HANDLER_GAVE_UP" | "HANDLER_MISSING" | "META_PERMISSION_MISSING" | "META_RATE_LIMITED" | "META_TOKEN_INVALID" | "META_TRUNCATED" | "META_UNAVAILABLE" | "RUN_TIMEOUT" | "SECRETS_KEY_MISSING" | null;
+    handlerReady: boolean;
+}[]>>;
+/**
+ * The Pages linked to the sites, for the control plane's webhook routes, and
+ * whether this host's leadgen route takes forwards at all: `leadgenReady` (the
+ * component has `RASTRO_FEDERATION_AUDIENCE`), the `issuer` it checks them
+ * against and the `audience` it expects. The control plane routes a Page here
+ * only when it is ready, the issuer is its own and the audience is the one it
+ * signs forwards for (decision D1). `handlerReady` says whether the host
+ * registered its form lead handler: without it no Page is read, so a screen
+ * with no Pages names the host's setup instead of the Meta login.
+ */
+export declare const linkedPages: import("convex/server").RegisteredQuery<"public", {
+    siteIds: import("convex/values").GenericId<"sites">[];
+}, Promise<{
+    pages: {
+        pageId: string;
+        siteId: import("convex/values").GenericId<"sites">;
+    }[];
+    leadgenReady: boolean;
+    issuer: string;
+    audience: string | null;
+    handlerReady: boolean;
+}>>;
+export declare const prepareLink: import("convex/server").RegisteredQuery<"internal", {
+    onlyOwn: boolean;
+    ownerKey: string;
+    pageId: string;
+    siteId: import("convex/values").GenericId<"sites">;
+}, Promise<{
+    pageRowId: import("convex/values").GenericId<"metaPages">;
+    tokenCipher: string;
+    tokenIv: string;
+}>>;
+export declare const saveForms: import("convex/server").RegisteredMutation<"internal", {
+    complete: boolean;
+    forms: {
+        createdTime: number | null;
+        formId: string;
+        name: string;
+        questions: {
+            key: string;
+            label: string;
+            options?: {
+                key: string;
+                value: string;
+            }[] | undefined;
+            type: string;
+        }[];
+        status: string;
+        whatsappButton: boolean | null;
+    }[];
+    pageId: string;
+}, Promise<null>>;
+export declare const saveLink: import("convex/server").RegisteredMutation<"internal", {
+    forms: {
+        createdTime: number | null;
+        formId: string;
+        name: string;
+        questions: {
+            key: string;
+            label: string;
+            options?: {
+                key: string;
+                value: string;
+            }[] | undefined;
+            type: string;
+        }[];
+        status: string;
+        whatsappButton: boolean | null;
+    }[] | null;
+    onlyOwn: boolean;
+    ownerKey: string;
+    pageId: string;
+    reconcileFrom: number;
+    siteId: import("convex/values").GenericId<"sites">;
+    subscribedAt: number;
+}, Promise<null>>;
+/**
+ * Makes one of the owner's Pages feed the site's leads: subscribes the app to
+ * the Page's `leadgen` webhook with the Page's own token, reads its forms,
+ * records the link and starts the reconciliation. One Page feeds one site
+ * (`CONFLICT` otherwise). With `onlyOwn` (the federated path) a Page another
+ * owner linked to the site is a `CONFLICT` too; the host's own call moves it.
+ * `backfillDays` (0–30, host only) also brings the leads of the days before.
+ */
+export declare const linkPage: import("convex/server").RegisteredAction<"public", {
+    backfillDays?: number | undefined;
+    onlyOwn?: boolean | undefined;
+    ownerKey: string;
+    pageId: string;
+    siteId: import("convex/values").GenericId<"sites">;
+}, Promise<{
+    linked: boolean;
+    forms: number;
+}>>;
+/**
+ * Stops a Page feeding the site: forgets the link and so its reconciliation.
+ * The app's `leadgen` subscription stays on the Page: it is the Page's and
+ * the app's, shared by every host (one app, one dashboard webhook), so taking
+ * it off here would silence a host that links the Page now. The dashboard
+ * drops notifications for a Page no host claims. The site's form rules and
+ * the leads already in stay. With `ownerKey`, only that owner's link
+ * (another's is a `CONFLICT`). An action, like `linkPage`, for the callers
+ * that pair them.
+ */
+export declare const unlinkPage: import("convex/server").RegisteredAction<"public", {
+    ownerKey?: string | undefined;
+    pageId: string;
+    siteId: import("convex/values").GenericId<"sites">;
+}, Promise<{
+    unlinked: boolean;
+}>>;
+export declare const removeLink: import("convex/server").RegisteredMutation<"internal", {
+    ownerKey?: string | undefined;
+    pageId: string;
+    siteId: import("convex/values").GenericId<"sites">;
+}, Promise<{
+    unlinked: boolean;
+}>>;
+export declare const loadSitePageTokens: import("convex/server").RegisteredQuery<"internal", {
+    pageId?: string | undefined;
+    siteId: import("convex/values").GenericId<"sites">;
+}, Promise<{
+    pageId: string;
+    pageRowId: import("convex/values").GenericId<"metaPages">;
+    tokenCipher: string;
+    tokenIv: string;
+}[]>>;
+/**
+ * Reads the instant forms of the site's linked Pages (or one of them) from
+ * Meta again. New forms show up by themselves every reconciliation run; this
+ * is the screen's "refresh now".
+ */
+export declare const refreshForms: import("convex/server").RegisteredAction<"public", {
+    pageId?: string | undefined;
+    siteId: import("convex/values").GenericId<"sites">;
+}, Promise<{
+    pages: number;
+    forms: number;
+}>>;
+/**
+ * The Pages linked to the site and their forms, for the forms screen: each
+ * form's leads in the 30 UTC days up to `now` (and per day), its last lead,
+ * its rules and the end screen's WhatsApp button. With `ownerKey`, whether
+ * that owner linked each Page and may edit each form's rules (`own`).
+ */
+export declare const forms: import("convex/server").RegisteredQuery<"public", {
+    now?: number | undefined;
+    ownerKey?: string | undefined;
+    siteId: import("convex/values").GenericId<"sites">;
+}, Promise<{
+    pageId: string;
+    pageName: string;
+    leadsAllowed: boolean;
+    subscribedAt: number | null;
+    lastReconcileAt: number | null;
+    lastLeadAt: number | null;
+    lastError: "HANDLER_FAILED" | "HANDLER_GAVE_UP" | "HANDLER_MISSING" | "META_PERMISSION_MISSING" | "META_RATE_LIMITED" | "META_TOKEN_INVALID" | "META_TRUNCATED" | "META_UNAVAILABLE" | "RUN_TIMEOUT" | "SECRETS_KEY_MISSING" | null;
+    own?: boolean | undefined;
+    handlerReady: boolean;
+    forms: {
+        formId: string;
+        name: string;
+        status: string;
+        questions: {
+            key: string;
+            label: string;
+            options?: {
+                key: string;
+                value: string;
+            }[] | undefined;
+            type: string;
+        }[];
+        whatsappButton: boolean | null;
+        whatsappButtonConfirmed: boolean;
+        createdTime: number | null;
+        syncedAt: number;
+        leads30d: number | null;
+        daily: number[] | null;
+        lastLeadAt: number | null;
+        rules: {
+            configured: boolean;
+            count: number;
+            entryColumn: string | null;
+            own?: boolean | undefined;
+        };
+    }[];
+}[]>>;
+/**
+ * Where a site's form sends its leads: the rules in order (the first that
+ * matches decides; none → `entryColumn`, null for the host's own entry), and
+ * how the host makes the first contact. Replaces what was there; it decides
+ * the next leads only. With `ownerKey` and `onlyOwn` (the federated path), a
+ * Page or rules another owner set are a `CONFLICT`.
+ */
+export declare const setFormRules: import("convex/server").RegisteredMutation<"public", {
+    entryColumn: string | null;
+    firstContact: {
+        brakes?: {
+            businessHoursOnly: boolean;
+            maxPerHour: number;
+            waitMinutes: number;
+        } | undefined;
+        mode: "automatic" | "lead_starts" | "one_click";
+        text?: string | undefined;
+    };
+    formId: string;
+    onlyOwn?: boolean | undefined;
+    ownerKey?: string | undefined;
+    rules: {
+        answers: string[];
+        questionKey: string;
+        to: {
+            column: string;
+        } | {
+            discard: string;
+        };
+    }[];
+    siteId: import("convex/values").GenericId<"sites">;
+    whatsappButtonConfirmed?: boolean | undefined;
+}, Promise<null>>;
+/**
+ * A form's rules for the drawer, each with the leads it decided in the 30
+ * days up to `now` (null without `now`). A form never configured answers its
+ * defaults with `configured: false`.
+ */
+export declare const formRules: import("convex/server").RegisteredQuery<"public", {
+    formId: string;
+    now?: number | undefined;
+    ownerKey?: string | undefined;
+    siteId: import("convex/values").GenericId<"sites">;
+}, Promise<{
+    siteId: import("convex/values").GenericId<"sites">;
+    formId: string;
+    configured: boolean;
+    entryColumn: string | null;
+    rules: {
+        monthCount: number | null;
+        answers: string[];
+        questionKey: string;
+        to: {
+            column: string;
+        } | {
+            discard: string;
+        };
+    }[];
+    firstContact: {
+        brakes?: {
+            businessHoursOnly: boolean;
+            maxPerHour: number;
+            waitMinutes: number;
+        } | undefined;
+        mode: "automatic" | "lead_starts" | "one_click";
+        text?: string | undefined;
+    };
+    whatsappButtonConfirmed: boolean;
+    updatedAt: number | null;
+    own?: boolean | undefined;
+}>>;
+/**
+ * The form's leads of the 30 days up to `now` under a draft of its rules:
+ * how many each rule would decide, and where they would all go. Reads the
+ * choice answers Rastro keeps; never Meta.
+ */
+export declare const simulateFormRules: import("convex/server").RegisteredQuery<"public", {
+    entryColumn: string | null;
+    formId: string;
+    now: number;
+    rules: {
+        answers: string[];
+        questionKey: string;
+        to: {
+            column: string;
+        } | {
+            discard: string;
+        };
+    }[];
+    siteId: import("convex/values").GenericId<"sites">;
+}, Promise<{
+    total: number;
+    entry: number;
+    rules: number[];
+    columns: {
+        column: string;
+        leads: number;
+    }[];
+    discarded: {
+        reason: string;
+        leads: number;
+    }[];
+    partial: boolean;
+}>>;
+/**
+ * Sends a discarded lead back to the funnel: its decision is cleared (it
+ * goes to the host's entry) and the reason it had is kept as history. The
+ * host moves its card back itself. With `ownerKey`, only for a Page that
+ * owner linked.
+ */
+export declare const returnFormLead: import("convex/server").RegisteredMutation<"public", {
+    leadId: string;
+    ownerKey?: string | undefined;
+    siteId: import("convex/values").GenericId<"sites">;
+}, Promise<{
+    returned: boolean;
+}>>;
+/**
+ * Registers the host's form lead handler: a function handle to an internal
+ * mutation that receives each lead (see `formLeadPayloadValidator`). Safe to
+ * call again; `null` removes it, and leads then wait (not marked ingested)
+ * until a handler is back.
+ */
+export declare const setFormLeadHandler: import("convex/server").RegisteredMutation<"public", {
+    handle: string | null;
+}, Promise<null>>;
+/**
+ * What a failed commit says, safe for a log: a `ConvexError`'s `code` or the
+ * error's class name. Never the message: the host's handler had the lead's
+ * name, phone and e-mail in hand, and its message (or a validator's dump of
+ * the arguments) may carry them.
+ */
+export declare function failureCode(error: unknown): string;
+/**
+ * Counts one failed commit of a lead (its ids and the error's code, nothing
+ * else). Returns the attempts so far and whether the lead was already skipped.
+ */
+export declare const recordLeadFailure: import("convex/server").RegisteredMutation<"internal", {
+    code: string;
+    formId: string;
+    leadgenId: string;
+    pageId: string;
+}, Promise<{
+    attempts: number;
+    skipped: boolean;
+}>>;
+/** Marks leads the reconciliation gave up on, so they no longer hold it. */
+export declare const skipFailedLeads: import("convex/server").RegisteredMutation<"internal", {
+    leadgenIds: string[];
+}, Promise<null>>;
+export declare const commitFormLead: import("convex/server").RegisteredMutation<"internal", {
+    adId: string | null;
+    adsetId: string | null;
+    campaignId: string | null;
+    choices: {
+        answers: string[];
+        questionKey: string;
+    }[];
+    contact: {
+        email: string | null;
+        name: string | null;
+        phone: string | null;
+    };
+    formId: string;
+    freeAnswers: {
+        label: string;
+        questionKey: string;
+        value: string;
+    }[];
+    isOrganic: boolean;
+    leadgenId: string;
+    pageId: string;
+    platform: string | null;
+    receivedAt: number;
+}, Promise<{
+    status: "duplicate";
+    leadId: import("convex/values").GenericId<"leads">;
+} | {
+    status: "duplicate";
+    leadId: null;
+} | {
+    status: "unlinked";
+    leadId: null;
+} | {
+    status: "handler_missing";
+    leadId: null;
+} | {
+    status: "ingested";
+    leadId: Id<"leads">;
+}>>;
+export declare const loadIngestJob: import("convex/server").RegisteredQuery<"internal", {
+    leadgenId?: string | undefined;
+    pageId: string;
+}, Promise<{
+    status: "duplicate";
+    linkId?: undefined;
+    pageRowId?: undefined;
+    tokenCipher?: undefined;
+    tokenIv?: undefined;
+} | {
+    status: "unlinked";
+    linkId?: undefined;
+    pageRowId?: undefined;
+    tokenCipher?: undefined;
+    tokenIv?: undefined;
+} | {
+    status: "handler_missing";
+    linkId?: undefined;
+    pageRowId?: undefined;
+    tokenCipher?: undefined;
+    tokenIv?: undefined;
+} | {
+    status: "paused";
+    linkId?: undefined;
+    pageRowId?: undefined;
+    tokenCipher?: undefined;
+    tokenIv?: undefined;
+} | {
+    status: "ready";
+    linkId: import("convex/values").GenericId<"sitePages">;
+    pageRowId: import("convex/values").GenericId<"metaPages">;
+    tokenCipher: string;
+    tokenIv: string;
+}>>;
+export declare const formQuestions: import("convex/server").RegisteredQuery<"internal", {
+    formId: string;
+}, Promise<{
+    pageId: string;
+    questions: {
+        key: string;
+        label: string;
+        options?: {
+            key: string;
+            value: string;
+        }[] | undefined;
+        type: string;
+    }[];
+} | null>>;
+/**
+ * Brings one lead in, from Meta's webhook (forwarded by the control plane to
+ * `/rastro/meta/leadgen`). Idempotent on the leadgen id; a lead that cannot
+ * come in now (no handler, a stopped Page) is left for the reconciliation.
+ */
+export declare const ingestFormLead: import("convex/server").RegisteredAction<"internal", {
+    leadgenId: string;
+    pageId: string;
+}, Promise<{
+    status: string;
+}>>;
+/**
+ * The webhook's way in (http.ts): schedules the ingestion when the Page feeds
+ * a site here. Answers whether it did.
+ */
+export declare const scheduleLeadgen: import("convex/server").RegisteredMutation<"internal", {
+    leadgenId: string;
+    pageId: string;
+}, Promise<{
+    scheduled: boolean;
+}>>;
+/** Makes sure the chain runs by `at` (starts it, or pulls it earlier). */
+export declare function kickLeadsLoop(ctx: MutationCtx, at: number): Promise<void>;
+/** One link of the chain: hands the due Pages to fresh runs, moves on. */
+export declare const loop: import("convex/server").RegisteredMutation<"internal", {}, Promise<null>>;
+export declare const loadReconcileJob: import("convex/server").RegisteredQuery<"internal", {
+    linkId: import("convex/values").GenericId<"sitePages">;
+    runId: string;
+}, Promise<{
+    pageId: string;
+    reconcileFrom: number;
+    connectionActive: boolean;
+    handlerReady: boolean;
+    subscriptionDue: boolean;
+    page: {
+        pageRowId: import("convex/values").GenericId<"metaPages">;
+        tokenCipher: string;
+        tokenIv: string;
+        listed: boolean;
+        leadsAllowed: boolean;
+        invalid: boolean;
+    } | null;
+} | null>>;
+export declare const markSubscriptionChecked: import("convex/server").RegisteredMutation<"internal", {
+    at: number;
+    linkId: import("convex/values").GenericId<"sitePages">;
+    runId: string;
+}, Promise<null>>;
+/** The Page's active forms with where the run reads each from (seconds). */
+export declare const reconcileForms: import("convex/server").RegisteredQuery<"internal", {
+    linkId: import("convex/values").GenericId<"sitePages">;
+    runId: string;
+}, Promise<{
+    formId: string;
+    sinceSec: number;
+}[]>>;
+export declare const saveCursor: import("convex/server").RegisteredMutation<"internal", {
+    formId: string;
+    linkId: import("convex/values").GenericId<"sitePages">;
+    runId: string;
+    sec: number;
+}, Promise<{
+    stop: boolean;
+}>>;
+/** Records how a run ended and when the Page is read next. */
+export declare const finishReconcile: import("convex/server").RegisteredMutation<"internal", {
+    linkId: import("convex/values").GenericId<"sitePages">;
+    outcome: {
+        kind: "ok";
+        note: string | null;
+        regainMs: number | null;
+        usagePct: number;
+    } | {
+        kind: "connection" | "granted" | "key" | "other" | "permission" | "throttled" | "token";
+        message: string;
+        regainMs: number | null;
+    };
+    runId: string;
+    startedAt: number;
+}, Promise<null>>;
+/**
+ * One reconciliation run of a Page: its forms read again (new ones show up
+ * by themselves), then each active form's leads since its cursor, oldest
+ * first, in windows Meta lists completely (`reconcileForm`), through the
+ * same ingestion as the webhook. A lead that cannot come in now (the handler
+ * threw, or is missing) holds its form's cursor there, so it is read again
+ * next run, until it is given up on (MAX_LEAD_ATTEMPTS); leads already in
+ * are skipped by their leadgen id.
+ */
+export declare const reconcilePage: import("convex/server").RegisteredAction<"internal", {
+    linkId: import("convex/values").GenericId<"sitePages">;
+    runId: string;
+}, Promise<null>>;
+/**
+ * Per form, over the cohort days in the range: its leads, qualified, sales
+ * and revenue (from the lead rollups), and where its rules sent the leads
+ * (columns, the host's entry, discards by reason, the ones sent back).
+ */
+export declare const formsReport: import("convex/server").RegisteredQuery<"public", {
+    from: number;
+    siteIds: import("convex/values").GenericId<"sites">[];
+    to: number;
+}, Promise<{
+    forms: {
+        siteId: Id<"sites">;
+        pageId: string;
+        formId: string;
+        name: string | null;
+        leads: number;
+        qualified: number;
+        won: number;
+        revenueCents: number;
+        columns: {
+            column: string;
+            leads: number;
+        }[];
+        entry: number;
+        discarded: {
+            reason: string;
+            leads: number;
+        }[];
+        returned: number;
+    }[];
+    partial: boolean;
+}>>;
+export {};
+//# sourceMappingURL=metaLeads.d.ts.map

package/dist/component/metaLeads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metaLeads.d.ts","sourceRoot":"","sources":["../../src/component/metaLeads.ts"],"names":[],"mappings":"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"}