@aglyn/plugins-crm 1.0.0-beta.143

package/src/lib/model/next-activity.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { CrmNextActivityLink } from '@aglyn/aglyn';
+import type { CrmTaskRouteScope } from './task-routes';
+/**
+ * The contract between the console and the plugin's next-activity route
+ * (AGL-2661), the door a CLIENT-DIRECT task write uses to keep the records'
+ * `nextTaskAtMs` honest.
+ *
+ * The two task routes recompute it themselves. Every other task write —
+ * reopening, snoozing, deleting, the bulk bar's reassign — is a Firestore
+ * write from the browser, and a browser cannot recompute a denormalized
+ * figure it is not allowed to write consistently. So after such a write the
+ * surface tells this route which records the task named, and the route
+ * reads the tasks back and stores the answer. Best effort by design: the
+ * task write already happened, and a figure that did not move is what the
+ * Fields section's recompute exists for. The browser's side is
+ * `next-activity-api.ts`; this module is the contract both halves import.
+ *
+ * `all: true` is that recompute — the whole organization, every open task
+ * once — and is the Fields section's maintenance action.
+ */
+export declare const CRM_NEXT_ACTIVITY_ROUTE: "crm/next-activity";
+export declare const crmNextActivityRouteUrl: () => string;
+/** The most records one request recomputes — the bulk bar's own window. */
+export declare const CRM_NEXT_ACTIVITY_LINKS_MAX = 200;
+export type CrmNextActivityRequest = CrmTaskRouteScope & ({
+    links: CrmNextActivityLink[];
+    all?: false;
+} | {
+    all: true;
+    links?: undefined;
+});
+export interface CrmNextActivityResponse {
+    ok: true;
+    /** Records written. */
+    records: number;
+    /** Records a task named that no longer exist. */
+    missing: number;
+    /** The whole-org form only: how many open tasks it read, and whether it read them all. */
+    tasks?: number;
+    cleared?: number;
+    truncated?: boolean;
+}
+/** The links a task row carries, as the request names them. */
+export declare function nextActivityRequestLinks(tasks: readonly {
+    contactId?: string | null;
+    companyId?: string | null;
+    dealId?: string | null;
+}[]): CrmNextActivityLink[];

package/src/lib/model/next-activity.js

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * The contract between the console and the plugin's next-activity route
+ * (AGL-2661), the door a CLIENT-DIRECT task write uses to keep the records'
+ * `nextTaskAtMs` honest.
+ *
+ * The two task routes recompute it themselves. Every other task write —
+ * reopening, snoozing, deleting, the bulk bar's reassign — is a Firestore
+ * write from the browser, and a browser cannot recompute a denormalized
+ * figure it is not allowed to write consistently. So after such a write the
+ * surface tells this route which records the task named, and the route
+ * reads the tasks back and stores the answer. Best effort by design: the
+ * task write already happened, and a figure that did not move is what the
+ * Fields section's recompute exists for. The browser's side is
+ * `next-activity-api.ts`; this module is the contract both halves import.
+ *
+ * `all: true` is that recompute — the whole organization, every open task
+ * once — and is the Fields section's maintenance action.
+ */ export const CRM_NEXT_ACTIVITY_ROUTE = 'crm/next-activity';
+export const crmNextActivityRouteUrl = ()=>`/api/${CRM_NEXT_ACTIVITY_ROUTE}`;
+/** The most records one request recomputes — the bulk bar's own window. */ export const CRM_NEXT_ACTIVITY_LINKS_MAX = 200;
+/** The links a task row carries, as the request names them. */ export function nextActivityRequestLinks(tasks) {
+    return tasks.map((task)=>_extends({}, task.contactId ? {
+            contactId: task.contactId
+        } : {}, task.companyId ? {
+            companyId: task.companyId
+        } : {}, task.dealId ? {
+            dealId: task.dealId
+        } : {}));
+}
+
+//# sourceMappingURL=next-activity.js.map

package/src/lib/model/next-activity.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/crm/src/lib/model/next-activity.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { CrmNextActivityLink } from '@aglyn/aglyn'\nimport type { CrmTaskRouteScope } from './task-routes'\n\n/**\n * The contract between the console and the plugin's next-activity route\n * (AGL-2661), the door a CLIENT-DIRECT task write uses to keep the records'\n * `nextTaskAtMs` honest.\n *\n * The two task routes recompute it themselves. Every other task write —\n * reopening, snoozing, deleting, the bulk bar's reassign — is a Firestore\n * write from the browser, and a browser cannot recompute a denormalized\n * figure it is not allowed to write consistently. So after such a write the\n * surface tells this route which records the task named, and the route\n * reads the tasks back and stores the answer. Best effort by design: the\n * task write already happened, and a figure that did not move is what the\n * Fields section's recompute exists for. The browser's side is\n * `next-activity-api.ts`; this module is the contract both halves import.\n *\n * `all: true` is that recompute — the whole organization, every open task\n * once — and is the Fields section's maintenance action.\n */\nexport const CRM_NEXT_ACTIVITY_ROUTE = 'crm/next-activity' as const\n\nexport const crmNextActivityRouteUrl = (): string => `/api/${CRM_NEXT_ACTIVITY_ROUTE}`\n\n/** The most records one request recomputes — the bulk bar's own window. */\nexport const CRM_NEXT_ACTIVITY_LINKS_MAX = 200\n\nexport type CrmNextActivityRequest = CrmTaskRouteScope &\n  ({ links: CrmNextActivityLink[]; all?: false } | { all: true; links?: undefined })\n\nexport interface CrmNextActivityResponse {\n  ok: true\n  /** Records written. */\n  records: number\n  /** Records a task named that no longer exist. */\n  missing: number\n  /** The whole-org form only: how many open tasks it read, and whether it read them all. */\n  tasks?: number\n  cleared?: number\n  truncated?: boolean\n}\n\n/** The links a task row carries, as the request names them. */\nexport function nextActivityRequestLinks(\n  tasks: readonly { contactId?: string | null; companyId?: string | null; dealId?: string | null }[],\n): CrmNextActivityLink[] {\n  return tasks.map((task) => ({\n    ...(task.contactId ? { contactId: task.contactId } : {}),\n    ...(task.companyId ? { companyId: task.companyId } : {}),\n    ...(task.dealId ? { dealId: task.dealId } : {}),\n  }))\n}\n"],"names":["CRM_NEXT_ACTIVITY_ROUTE","crmNextActivityRouteUrl","CRM_NEXT_ACTIVITY_LINKS_MAX","nextActivityRequestLinks","tasks","map","task","contactId","companyId","dealId"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC;AAKD;;;;;;;;;;;;;;;;;CAiBC,GACD,OAAO,MAAMA,0BAA0B,oBAA4B;AAEnE,OAAO,MAAMC,0BAA0B,IAAc,CAAC,KAAK,EAAED,yBAAyB,CAAA;AAEtF,yEAAyE,GACzE,OAAO,MAAME,8BAA8B,IAAG;AAiB9C,6DAA6D,GAC7D,OAAO,SAASC,yBACdC,KAAkG;IAElG,OAAOA,MAAMC,GAAG,CAAC,CAACC,OAAU,aACtBA,KAAKC,SAAS,GAAG;YAAEA,WAAWD,KAAKC,SAAS;QAAC,IAAI,CAAC,GAClDD,KAAKE,SAAS,GAAG;YAAEA,WAAWF,KAAKE,SAAS;QAAC,IAAI,CAAC,GAClDF,KAAKG,MAAM,GAAG;YAAEA,QAAQH,KAAKG,MAAM;QAAC,IAAI,CAAC;AAEjD"}

package/src/lib/model/person-key-web.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * `personKey`, for a browser (AGL-2612).
+ *
+ * `person-key.ts` is THE derivation of the one address-keyed document id in
+ * this product — `sha256(normalizeContactEmail(email))` as full hex — and it
+ * is held out of the client barrel because `node:crypto` cannot ship to a
+ * published page. A console surface that wants to look a lead up by the
+ * address on a contact has the same derivation to make and no `node:crypto`
+ * to make it with, which left it reading the whole leads collection to find
+ * one document, or not looking at all.
+ *
+ * So this is the same derivation, to the byte, on WebCrypto: the same
+ * normalizer, the same digest, the same hex. Asynchronous because
+ * `crypto.subtle` is, and `null` for exactly the inputs the synchronous twin
+ * refuses — never a best-guess key, because a lookup keyed on a guess finds
+ * somebody else's record or nobody's and cannot tell which.
+ *
+ * The digest is spelled here rather than borrowed from the plugin manager's
+ * `sha256Hex`: that module imports this layer, and a helper reached back up
+ * through it would be a cycle for four lines.
+ *
+ * And `null`, rather than a throw, where there is no WebCrypto to run it —
+ * an insecure origin, a test DOM. A lookup that cannot be keyed is a lookup
+ * that finds nothing, which is the same answer the caller gets for an
+ * address that is not one, and the one it already handles.
+ */
+export declare function personKeyInBrowser(email: unknown): Promise<string | null>;

package/src/lib/model/person-key-web.js

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { normalizeContactEmail } from "@aglyn/aglyn/app-utils/contacts";
+/**
+ * `personKey`, for a browser (AGL-2612).
+ *
+ * `person-key.ts` is THE derivation of the one address-keyed document id in
+ * this product — `sha256(normalizeContactEmail(email))` as full hex — and it
+ * is held out of the client barrel because `node:crypto` cannot ship to a
+ * published page. A console surface that wants to look a lead up by the
+ * address on a contact has the same derivation to make and no `node:crypto`
+ * to make it with, which left it reading the whole leads collection to find
+ * one document, or not looking at all.
+ *
+ * So this is the same derivation, to the byte, on WebCrypto: the same
+ * normalizer, the same digest, the same hex. Asynchronous because
+ * `crypto.subtle` is, and `null` for exactly the inputs the synchronous twin
+ * refuses — never a best-guess key, because a lookup keyed on a guess finds
+ * somebody else's record or nobody's and cannot tell which.
+ *
+ * The digest is spelled here rather than borrowed from the plugin manager's
+ * `sha256Hex`: that module imports this layer, and a helper reached back up
+ * through it would be a cycle for four lines.
+ *
+ * And `null`, rather than a throw, where there is no WebCrypto to run it —
+ * an insecure origin, a test DOM. A lookup that cannot be keyed is a lookup
+ * that finds nothing, which is the same answer the caller gets for an
+ * address that is not one, and the one it already handles.
+ */ export async function personKeyInBrowser(email) {
+    var _globalThis_crypto;
+    const normalized = normalizeContactEmail(email);
+    if (!normalized) return null;
+    const subtle = (_globalThis_crypto = globalThis.crypto) == null ? void 0 : _globalThis_crypto.subtle;
+    if (!subtle) return null;
+    const digest = await subtle.digest('SHA-256', new TextEncoder().encode(normalized));
+    return Array.from(new Uint8Array(digest)).map((byte)=>byte.toString(16).padStart(2, '0')).join('');
+}
+
+//# sourceMappingURL=person-key-web.js.map

package/src/lib/model/person-key-web.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/crm/src/lib/model/person-key-web.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { normalizeContactEmail } from '@aglyn/aglyn/app-utils/contacts'\n\n/**\n * `personKey`, for a browser (AGL-2612).\n *\n * `person-key.ts` is THE derivation of the one address-keyed document id in\n * this product — `sha256(normalizeContactEmail(email))` as full hex — and it\n * is held out of the client barrel because `node:crypto` cannot ship to a\n * published page. A console surface that wants to look a lead up by the\n * address on a contact has the same derivation to make and no `node:crypto`\n * to make it with, which left it reading the whole leads collection to find\n * one document, or not looking at all.\n *\n * So this is the same derivation, to the byte, on WebCrypto: the same\n * normalizer, the same digest, the same hex. Asynchronous because\n * `crypto.subtle` is, and `null` for exactly the inputs the synchronous twin\n * refuses — never a best-guess key, because a lookup keyed on a guess finds\n * somebody else's record or nobody's and cannot tell which.\n *\n * The digest is spelled here rather than borrowed from the plugin manager's\n * `sha256Hex`: that module imports this layer, and a helper reached back up\n * through it would be a cycle for four lines.\n *\n * And `null`, rather than a throw, where there is no WebCrypto to run it —\n * an insecure origin, a test DOM. A lookup that cannot be keyed is a lookup\n * that finds nothing, which is the same answer the caller gets for an\n * address that is not one, and the one it already handles.\n */\nexport async function personKeyInBrowser(\n  email: unknown,\n): Promise<string | null> {\n  const normalized = normalizeContactEmail(email)\n  if (!normalized) return null\n  const subtle = globalThis.crypto?.subtle\n  if (!subtle) return null\n  const digest = await subtle.digest(\n    'SHA-256',\n    new TextEncoder().encode(normalized),\n  )\n  return Array.from(new Uint8Array(digest))\n    .map((byte) => byte.toString(16).padStart(2, '0'))\n    .join('')\n}\n"],"names":["normalizeContactEmail","personKeyInBrowser","email","globalThis","normalized","subtle","crypto","digest","TextEncoder","encode","Array","from","Uint8Array","map","byte","toString","padStart","join"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED,SAASA,qBAAqB,QAAQ,kCAAiC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;CAyBC,GACD,OAAO,eAAeC,mBACpBC,KAAc;QAICC;IAFf,MAAMC,aAAaJ,sBAAsBE;IACzC,IAAI,CAACE,YAAY,OAAO;IACxB,MAAMC,UAASF,qBAAAA,WAAWG,MAAM,qBAAjBH,mBAAmBE,MAAM;IACxC,IAAI,CAACA,QAAQ,OAAO;IACpB,MAAME,SAAS,MAAMF,OAAOE,MAAM,CAChC,WACA,IAAIC,cAAcC,MAAM,CAACL;IAE3B,OAAOM,MAAMC,IAAI,CAAC,IAAIC,WAAWL,SAC9BM,GAAG,CAAC,CAACC,OAASA,KAAKC,QAAQ,CAAC,IAAIC,QAAQ,CAAC,GAAG,MAC5CC,IAAI,CAAC;AACV"}

package/src/lib/model/record-facts.d.ts

@@ -0,0 +1,282 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { type ConsentGroup, type ContactFieldDefinition, type ContactInteraction, type CrmActivity, type CrmCompany, type CrmDeal, type CrmPipeline, type CrmTask } from '@aglyn/aglyn/server';
+/**
+ * WHAT THE CRM TELLS ANOTHER PLUGIN ABOUT ONE OF ITS RECORDS (AGL-2917).
+ *
+ * The facts a reader on the core's record-facts seam reports: one contact,
+ * company, deal or lead as a person on the team sees it, and the fields a
+ * spreadsheet import may fill. The server half reads the documents and
+ * applies who may see them (`server/record-facts.ts`); this half decides
+ * which of their fields leave the CRM at all, so the list below is the whole
+ * of what a caller — an assistant summarizing a record, an automation
+ * deciding on one — can pass on.
+ *
+ * ## What never leaves
+ *
+ * No email address, phone number or postal address of anyone; no marketing
+ * consent; no custom field VALUE; no team member's name or id; no document
+ * id of any record; no file; no order or payment detail beyond a count. A
+ * logged email carries its subject and a cut of its body, never the address
+ * it went to or came from. An import catalog carries field keys, labels and
+ * types, never a row of the file.
+ *
+ * Every text a person wrote into a record — a name, a job title, a tag, notes,
+ * a logged activity, a capture's summary, a task's or a deal's title, a
+ * reason — is reported as written, except that an email address or a phone
+ * number inside it is replaced by a placeholder first ({@link crmFactProse}):
+ * an import that put an address in the name column leaves no address behind.
+ * What the workspace configured — pipeline, stage and field names — and a
+ * company's domain are reported as they are. A postal address typed into a
+ * note is not recognized and leaves as typed.
+ *
+ * ## Stable bytes
+ *
+ * Every builder writes its keys in one order, dates as UTC calendar days and
+ * money as a currency code and a fixed-point amount, so the same records read
+ * twice report the same facts — a caller may key a cache on them, and one
+ * that does sees a change exactly when something it was told has changed.
+ */
+/** The records a reader is registered for, by the seam's resource name. */
+export declare const CRM_RECORD_FACTS_RESOURCES: {
+    readonly contact: "crm.contact";
+    readonly company: "crm.company";
+    readonly deal: "crm.deal";
+    readonly lead: "crm.lead";
+};
+export type CrmRecordFactsKind = keyof typeof CRM_RECORD_FACTS_RESOURCES;
+/** The import catalogs, read by collection name as the record id. */
+export declare const CRM_IMPORT_FACTS_RESOURCE = "crm.import";
+export declare const CRM_IMPORT_FACTS_COLLECTIONS: readonly ["contacts", "companies", "deals", "leads"];
+export type CrmImportFactsCollection = (typeof CRM_IMPORT_FACTS_COLLECTIONS)[number];
+export declare function isCrmImportFactsCollection(value: unknown): value is CrmImportFactsCollection;
+/** Newest timeline entries reported for a record. */
+export declare const CRM_FACTS_TIMELINE_MAX = 12;
+/** Open tasks reported for a record. */
+export declare const CRM_FACTS_TASKS_MAX = 8;
+/** Deals reported for a contact or a company. */
+export declare const CRM_FACTS_DEALS_MAX = 5;
+/** Tags reported for a record. */
+export declare const CRM_FACTS_TAGS_MAX = 10;
+/** How much of a logged activity's text, or a platform capture's summary, is reported. */
+export declare const CRM_FACTS_TEXT_MAX = 280;
+/** How much of a record's notes is reported. */
+export declare const CRM_FACTS_NOTES_MAX = 600;
+/** How long a name, a title or a subject may run. */
+export declare const CRM_FACTS_LABEL_MAX = 120;
+/** Custom fields an import catalog reports. */
+export declare const CRM_FACTS_CUSTOM_FIELDS_MAX = 40;
+/** One thing that happened, as a record's timeline reports it. */
+export interface CrmTimelineFact {
+    /** The UTC day it happened, `YYYY-MM-DD`. */
+    on: string;
+    /** What happened: a logged kind (Call, Email) or the capture it came through (Form, Booking). */
+    kind: string;
+    /** `outbound` or `inbound` for an email; absent otherwise. */
+    direction?: string;
+    subject?: string;
+    text?: string;
+    outcome?: string;
+    /** How far a sent email got: Sent, Delivered, Opened, Clicked, Bounced, Complained. */
+    delivery?: string;
+}
+/** One task still to do. */
+export interface CrmTaskFact {
+    title: string;
+    kind: string;
+    priority: string;
+    /** The UTC day it is due, or `null` for a task with no due date. */
+    due: string | null;
+    overdue: boolean;
+}
+/** One deal, as a contact's or a company's facts report it. */
+export interface CrmDealFact {
+    title: string;
+    stage: string;
+    status: string;
+    amount: string | null;
+    expectedClose: string | null;
+}
+export interface CrmContactFacts {
+    record: 'contact';
+    name: string;
+    jobTitle: string;
+    company: string;
+    lifecycleStage: string;
+    tags: string[];
+    /** The captures that met the person: Form, Booking, Customer. */
+    sources: string[];
+    orders: number;
+    lastPurchase: string | null;
+    since: string | null;
+    lastEmailEngagement: string | null;
+    notes: string;
+    timeline: CrmTimelineFact[];
+    openTasks: CrmTaskFact[];
+    deals: CrmDealFact[];
+}
+export interface CrmCompanyFacts {
+    record: 'company';
+    name: string;
+    domain: string;
+    industry: string;
+    tags: string[];
+    people: number;
+    since: string | null;
+    notes: string;
+    timeline: CrmTimelineFact[];
+    openTasks: CrmTaskFact[];
+    deals: CrmDealFact[];
+}
+/** One stage of a deal's pipeline, in order. */
+export interface CrmStageFact {
+    id: string;
+    name: string;
+    kind: 'open' | 'won' | 'lost';
+}
+export interface CrmDealFacts {
+    record: 'deal';
+    title: string;
+    pipeline: string;
+    stages: CrmStageFact[];
+    stageId: string;
+    stage: string;
+    status: string;
+    amount: string | null;
+    expectedClose: string | null;
+    inStageSince: string | null;
+    lostReason: string;
+    /** The name of the person the deal is with, as the deal copied it. */
+    contact: string;
+    company: string;
+    products: number;
+    since: string | null;
+    notes: string;
+    timeline: CrmTimelineFact[];
+    openTasks: CrmTaskFact[];
+}
+export interface CrmLeadFacts {
+    record: 'lead';
+    name: string;
+    status: string;
+    /** Where the lead was captured: Form, Booking, Sign-up, Import. */
+    sources: string[];
+    captures: number;
+    firstSeen: string | null;
+    lastSeen: string | null;
+    assigned: boolean;
+    converted: boolean;
+    unqualifiedReason: string;
+    notes: string;
+    timeline: CrmTimelineFact[];
+}
+export type CrmRecordFacts = CrmContactFacts | CrmCompanyFacts | CrmDealFacts | CrmLeadFacts;
+/** What a column of a file may hold, as an import field expects it. */
+export type CrmImportFieldType = 'email' | 'phone' | 'number' | 'date' | 'yes-no' | 'url' | 'text';
+/** One field an import may fill. */
+export interface CrmImportFieldFact {
+    /** The mapping target: a standard field's key, or `custom:<key>`. */
+    key: string;
+    label: string;
+    type: CrmImportFieldType;
+    required: boolean;
+}
+export interface CrmImportFacts {
+    record: 'import';
+    collection: CrmImportFactsCollection;
+    fields: CrmImportFieldFact[];
+}
+/** A value as trimmed, single-spaced text of at most `max` characters. */
+export declare function crmFactText(value: unknown, max: number): string;
+/** Epoch millis, a `Date` or a stored timestamp, as epoch millis; `null` for anything else. */
+export declare function crmFactMillis(value: unknown): number | null;
+/** A UTC calendar day, `YYYY-MM-DD`, or `null`. */
+export declare function crmFactDay(value: unknown): string | null;
+/** An amount as a currency code and a fixed-point figure: `USD 1250.00`. */
+export declare function crmFactMoney(cents: unknown, currency: unknown): string | null;
+export declare const CRM_FACTS_EMAIL_PLACEHOLDER = "[email address]";
+export declare const CRM_FACTS_PHONE_PLACEHOLDER = "[phone number]";
+/**
+ * Free text the team wrote, as {@link crmFactText} reports it, with every
+ * email address, and every run of ten digits or more that is not a list of
+ * days, replaced by a placeholder. The fields that hold an address or a number
+ * are never reported, and this keeps one typed into a note from leaving
+ * either. Replaced before the cut, so a cut never halves an address into
+ * something unrecognized.
+ */
+export declare function crmFactProse(value: unknown, max: number): string;
+/** A logged activity as a timeline entry. */
+export declare function crmActivityFact(activity: Partial<CrmActivity>): CrmTimelineFact | null;
+/** A capture the platform recorded on a contact, as a timeline entry. */
+export declare function crmInteractionFact(interaction: Partial<ContactInteraction>): CrmTimelineFact | null;
+/**
+ * Timeline entries newest first, at most {@link CRM_FACTS_TIMELINE_MAX}. A
+ * tie keeps the order the entries arrived in, so the same reads report the
+ * same list.
+ */
+export declare function crmTimelineFacts(entries: ReadonlyArray<{
+    atMs: unknown;
+    fact: CrmTimelineFact | null;
+}>): CrmTimelineFact[];
+/** The open tasks among `tasks`, soonest due first, undated last. */
+export declare function crmOpenTaskFacts(tasks: ReadonlyArray<Partial<CrmTask>>, nowMs: number): CrmTaskFact[];
+/** One deal, with its stage named by the pipeline it is in. */
+export declare function crmDealFact(deal: Partial<CrmDeal>, pipeline: CrmPipeline | null | undefined): CrmDealFact;
+/** Deals, open ones first, then most recently updated. */
+export declare function crmDealFacts(deals: ReadonlyArray<Partial<CrmDeal>>, pipelines: ReadonlyMap<string, CrmPipeline>): CrmDealFact[];
+export interface ContactFactsInput {
+    row: Record<string, unknown>;
+    /** The holder whose facet the person is read through. */
+    group: ConsentGroup;
+    activities: ReadonlyArray<Partial<CrmActivity>>;
+    tasks: ReadonlyArray<Partial<CrmTask>>;
+    deals: ReadonlyArray<Partial<CrmDeal>>;
+    pipelines: ReadonlyMap<string, CrmPipeline>;
+    nowMs: number;
+}
+export declare function contactFacts(input: ContactFactsInput): CrmContactFacts;
+export interface CompanyFactsInput {
+    company: Partial<CrmCompany>;
+    activities: ReadonlyArray<Partial<CrmActivity>>;
+    tasks: ReadonlyArray<Partial<CrmTask>>;
+    deals: ReadonlyArray<Partial<CrmDeal>>;
+    pipelines: ReadonlyMap<string, CrmPipeline>;
+    nowMs: number;
+}
+export declare function companyFacts(input: CompanyFactsInput): CrmCompanyFacts;
+export interface DealFactsInput {
+    deal: Partial<CrmDeal> & {
+        contactName?: unknown;
+        companyName?: unknown;
+    };
+    pipeline: CrmPipeline | null;
+    activities: ReadonlyArray<Partial<CrmActivity>>;
+    tasks: ReadonlyArray<Partial<CrmTask>>;
+    nowMs: number;
+}
+export declare function dealFacts(input: DealFactsInput): CrmDealFacts;
+export interface LeadFactsInput {
+    lead: Record<string, unknown>;
+    activities: ReadonlyArray<Partial<CrmActivity>>;
+}
+export declare function leadFacts(input: LeadFactsInput): CrmLeadFacts;
+/**
+ * The fields an import of `collection` may fill: the standard ones in the
+ * mapping menu's order, then the org's active custom fields for the record
+ * the collection holds, in their own order.
+ */
+export declare function importFacts(collection: CrmImportFactsCollection, customFields: ReadonlyArray<Partial<ContactFieldDefinition>>): CrmImportFacts;