@rapidmx/crm-plugin 0.1.0

package/dist/types/routes/sql/ScoringRuleRouteSQL.d.ts

@@ -0,0 +1,6 @@
+import type { CrmModelClasses } from "../../models/CrmModelClasses.js";
+import { BaseScoringRuleRoute } from "../BaseScoringRuleRoute.js";
+/** A workspace's lead scoring rules (`/api/mail/crm/scoring-rules`). */
+export declare class ScoringRuleRouteSQL extends BaseScoringRuleRoute {
+    protected classes: CrmModelClasses;
+}

package/dist/types/routes/sql/SegmentRouteSQL.d.ts

@@ -0,0 +1,6 @@
+import type { CrmModelClasses } from "../../models/CrmModelClasses.js";
+import { BaseSegmentRoute } from "../BaseSegmentRoute.js";
+/** A workspace's contact segments (`/api/mail/crm/segments`). */
+export declare class SegmentRouteSQL extends BaseSegmentRoute {
+    protected classes: CrmModelClasses;
+}

package/dist/types/routes/sql/SubscriptionRouteSQL.d.ts

@@ -0,0 +1,6 @@
+import type { CrmModelClasses } from "../../models/CrmModelClasses.js";
+import { BaseSubscriptionRoute } from "../BaseSubscriptionRoute.js";
+/** Contacts' subscriptions to mailing lists (`/api/mail/crm/subscriptions`). */
+export declare class SubscriptionRouteSQL extends BaseSubscriptionRoute {
+    protected classes: CrmModelClasses;
+}

package/dist/types/routes/sql/SuppressionRouteSQL.d.ts

@@ -0,0 +1,6 @@
+import type { CrmModelClasses } from "../../models/CrmModelClasses.js";
+import { BaseSuppressionRoute } from "../BaseSuppressionRoute.js";
+/** Addresses a workspace never sends marketing mail to (`/api/mail/crm/suppressions`). */
+export declare class SuppressionRouteSQL extends BaseSuppressionRoute {
+    protected classes: CrmModelClasses;
+}

package/dist/types/routes/sql/TaskRouteSQL.d.ts

@@ -0,0 +1,6 @@
+import type { CrmModelClasses } from "../../models/CrmModelClasses.js";
+import { BaseTaskRoute } from "../BaseTaskRoute.js";
+/** A workspace's tasks (`/api/mail/crm/tasks`). */
+export declare class TaskRouteSQL extends BaseTaskRoute {
+    protected classes: CrmModelClasses;
+}

package/dist/types/routes/sql/TemplateRouteSQL.d.ts

@@ -0,0 +1,6 @@
+import type { CrmModelClasses } from "../../models/CrmModelClasses.js";
+import { BaseTemplateRoute } from "../BaseTemplateRoute.js";
+/** A workspace's email templates (`/api/mail/crm/templates`). */
+export declare class TemplateRouteSQL extends BaseTemplateRoute {
+    protected classes: CrmModelClasses;
+}

package/dist/types/routes/sql/TimelineRouteSQL.d.ts

@@ -0,0 +1,6 @@
+import type { CrmModelClasses } from "../../models/CrmModelClasses.js";
+import { BaseTimelineRoute } from "../BaseTimelineRoute.js";
+/** Contact and company activity timelines (`/api/mail/crm/timeline`). */
+export declare class TimelineRouteSQL extends BaseTimelineRoute {
+    protected classes: CrmModelClasses;
+}

package/dist/types/routes/sql/TrackingRouteSQL.d.ts

@@ -0,0 +1,6 @@
+import type { CrmModelClasses } from "../../models/CrmModelClasses.js";
+import { BaseTrackingRoute } from "../BaseTrackingRoute.js";
+/** The anonymous open and click tracking endpoints of CRM email (`/api/mail/crm/t`). */
+export declare class TrackingRouteSQL extends BaseTrackingRoute {
+    protected classes: CrmModelClasses;
+}

package/dist/types/routes/sql/WebhookRouteSQL.d.ts

@@ -0,0 +1,6 @@
+import type { CrmModelClasses } from "../../models/CrmModelClasses.js";
+import { BaseWebhookRoute } from "../BaseWebhookRoute.js";
+/** A workspace's webhook endpoints (`/api/mail/crm/webhooks`). */
+export declare class WebhookRouteSQL extends BaseWebhookRoute {
+    protected classes: CrmModelClasses;
+}

package/dist/types/routes/sql/WorkspaceRouteSQL.d.ts

@@ -0,0 +1,6 @@
+import type { CrmModelClasses } from "../../models/CrmModelClasses.js";
+import { BaseWorkspaceRoute } from "../BaseWorkspaceRoute.js";
+/** CRM workspaces, their members and senders (`/api/mail/crm/workspaces`). */
+export declare class WorkspaceRouteSQL extends BaseWorkspaceRoute {
+    protected classes: CrmModelClasses;
+}

package/dist/types/scoring/Scoring.d.ts

@@ -0,0 +1,14 @@
+import type { CrmRepos } from "../models/CrmModelClasses.js";
+import { ScoringRule } from "../models/types.js";
+/** The most activity rows one rule reads per scoring, so a busy workspace's scoring stays bounded. */
+export declare const MAX_ACTIVITY_ROWS = 200000;
+/** How many times each contact did an activity rule's activity, within its window. Automatic opens and clicks don't count. */
+export declare function countActivity(repos: CrmRepos, workspaceUid: string, rule: ScoringRule, now?: Date): Promise<Map<string, number>>;
+/** The points one activity rule gives for `times` times: `points` each, limited to `maxPoints` either way. */
+export declare function activityPoints(rule: Pick<ScoringRule, "points" | "maxPoints">, times: number): number;
+/**
+ * Scores every contact of `workspaceUid` by its enabled `rules` and saves the scores that changed: each property rule's points for
+ * the contacts its filter matches, plus each activity rule's points for what the contact did. With no enabled rules every score
+ * goes back to 0. Returns how many contacts' scores changed.
+ */
+export declare function scoreWorkspace(repos: CrmRepos, workspaceUid: string, rules: ScoringRule[], now?: Date): Promise<number>;

package/dist/types/segments/Segments.d.ts

@@ -0,0 +1,46 @@
+import { FilterField, FilterNode } from "../filters/Filter.js";
+import type { CrmModelClasses, CrmRepos } from "../models/CrmModelClasses.js";
+import { Segment } from "../models/types.js";
+/** The `PropertyValue` key of segment membership: one row per member, `stringValue` = the segment's uid. */
+export declare const SEGMENTS_KEY = "segments";
+/** The most contacts one segment holds; a filter matching more keeps the first (by uid) and is marked `capped`. */
+export declare const MAX_SEGMENT_SIZE = 100000;
+/** How many rows one query of segments and scoring reads or changes (a setting only tests change). */
+export declare const PAGING: {
+    size: number;
+};
+/** The fields a contact filter may name in `workspaceUid`: with `segments`, unless the filter defines a segment. */
+export declare function contactFilterFields(repos: CrmRepos, workspaceUid: string, withSegments: boolean): Promise<Record<string, FilterField>>;
+/** `raw` as a segment's filter: a valid contact filter that doesn't name segments (a segment made of segments could loop). */
+export declare function readSegmentFilter(repos: CrmRepos, workspaceUid: string, raw: unknown): Promise<FilterNode>;
+/**
+ * The uids of the contacts of `workspaceUid` that `filter` (already validated) matches, in uid order - at most `cap`; `capped` when
+ * there were more.
+ */
+export declare function matchingContacts(repos: CrmRepos, workspaceUid: string, filter: FilterNode, cap?: number): Promise<{
+    uids: string[];
+    capped: boolean;
+}>;
+/** The uids of the current members of `segmentUid`. */
+export declare function segmentMembers(repos: CrmRepos, segmentUid: string): Promise<Set<string>>;
+/** Makes `uids` the members of `segment`: adds the new ones, removes the rest. Returns who entered and who left. */
+export declare function syncMembers(repos: CrmRepos, classes: CrmModelClasses, segment: Segment, uids: string[]): Promise<{
+    entered: string[];
+    left: string[];
+}>;
+/** A segment's refresh: the counts to store on it, and who entered and left. */
+export interface SegmentRefresh {
+    counts: {
+        memberCount: number;
+        capped: boolean;
+        refreshedAt: Date;
+    };
+    entered: string[];
+    left: string[];
+}
+/** Works a segment's members out from its filter and saves them. */
+export declare function refreshSegment(repos: CrmRepos, classes: CrmModelClasses, segment: Segment): Promise<SegmentRefresh>;
+/** Records `segment.entered` and `segment.left` events for who entered and left `segment`. */
+export declare function recordSegmentEvents(repos: CrmRepos, classes: CrmModelClasses, segment: Segment, entered: string[], left: string[], logger?: any): Promise<void>;
+/** Which of `contactUids` are in at least one of `segmentUids`. */
+export declare function inSegments(repos: CrmRepos, segmentUids: string[], contactUids: string[]): Promise<Set<string>>;

package/dist/types/sending/Audience.d.ts

@@ -0,0 +1,39 @@
+import type { CrmRepos } from "../models/CrmModelClasses.js";
+import { AbTest, CrmContact } from "../models/types.js";
+/**
+ * Who a campaign goes to: the subscribers of `listUids`, less those of `excludeListUids`; when `segmentUids` isn't empty, only those
+ * in one of those segments; and never those in `excludeSegmentUids`.
+ */
+export interface AudienceSpec {
+    workspaceUid: string;
+    listUids: string[];
+    excludeListUids: string[];
+    segmentUids?: string[];
+    excludeSegmentUids?: string[];
+}
+/** One page of an audience. */
+export interface AudiencePage {
+    /** The contacts of the page who may be mailed: subscribed, not excluded, active and not suppressed. */
+    contacts: CrmContact[];
+    /** Where the next page starts; `undefined` once the audience is done. */
+    nextCursor?: string;
+}
+/**
+ * One page of an audience, read through the lists' subscriptions in uid order after `cursor` (`pageSize` subscriptions a page, so
+ * the work of a page is bounded). A contact on several lists shows up once per list - callers de-duplicate (a campaign by its
+ * sends' unique `dedupeKey`).
+ */
+export declare function audiencePage(repos: CrmRepos, spec: AudienceSpec, cursor: string | undefined, pageSize: number): Promise<AudiencePage>;
+/** Which of `emails` the workspace has suppressed. */
+export declare function suppressedAmong(repos: CrmRepos, workspaceUid: string, emails: string[]): Promise<Set<string>>;
+/** How many distinct contacts an audience would reach, counting at most `cap` (then `capped`). */
+export declare function countAudience(repos: CrmRepos, spec: AudienceSpec, cap?: number): Promise<{
+    count: number;
+    capped: boolean;
+}>;
+/**
+ * The A/B variant a contact gets: `A` without a test; with one, `testPercent` of contacts (chosen by a hash of the campaign and
+ * contact, so the choice is stable however the audience is read) are spread evenly over the variants, and the rest get `""` - held
+ * for the winner.
+ */
+export declare function assignVariant(campaignUid: string, contactUid: string, abTest: AbTest | undefined): string;

package/dist/types/sending/CampaignRenderer.d.ts

@@ -0,0 +1,40 @@
+import type { CrmRepos } from "../models/CrmModelClasses.js";
+import { Campaign, CrmContact, OutboundSend } from "../models/types.js";
+/** What the renderer needs from its job. */
+export interface RendererSettings {
+    /** The public site, without a trailing slash. */
+    publicUrl: string;
+    /** The key tokens and tracked links are signed with. */
+    secret: string;
+    /** Send bounces to a per-message address (`verpAddress()`). */
+    verp: boolean;
+}
+/** One campaign message, ready for the mail transport. */
+export interface CampaignMessage {
+    raw: Buffer;
+    envelopeFrom: string;
+    /** The `Message-ID`, without angle brackets. */
+    messageId: string;
+    subject: string;
+}
+/** Why a message can't be rendered: its campaign's template or sender is gone. Not worth retrying. */
+export declare class UnrenderableError extends Error {
+}
+/**
+ * Renders campaign messages, one per recipient: the variant's template filled in for the contact, with its unsubscribe and
+ * preferences links (signed tokens), tracked links and the open image when the campaign tracks them, and the headers bulk mail
+ * needs - `List-Unsubscribe` with RFC 8058 one-click, `List-Id`, `Precedence: bulk` and a `Feedback-ID`. Templates, senders and
+ * workspaces are read once per renderer (one per dispatch run).
+ */
+export declare class CampaignRenderer {
+    private readonly repos;
+    private readonly settings;
+    private readonly templates;
+    private readonly records;
+    private readonly definitions;
+    constructor(repos: CrmRepos, settings: RendererSettings);
+    render(send: OutboundSend, campaign: Campaign, contact: CrmContact): Promise<CampaignMessage>;
+    private template;
+    private record;
+    private workspaceDefinitions;
+}

package/dist/types/sending/Engagement.d.ts

@@ -0,0 +1,50 @@
+import type { CrmModelClasses, CrmRepos } from "../models/CrmModelClasses.js";
+import { EngagementType, OutboundSend } from "../models/types.js";
+/** What an engagement event may say. */
+export interface EngagementData extends Record<string, unknown> {
+    /** An open or click that looked automatic (`isMachine()`). */
+    machine?: boolean;
+    /** A click's link. */
+    url?: string;
+    index?: number;
+    /** A bounce's `hard` or `soft`, and its enhanced status code. */
+    bounceType?: "hard" | "soft";
+    status?: string;
+}
+/**
+ * Records what happened to an outbound message: an `EngagementEvent`, the message's own counters and first-times (what campaign
+ * statistics count), and what follows for the contact:
+ * - An open, click or reply makes the contact engaged (`lastEngagedAt`) - an automatic open doesn't.
+ * - The first open, the first click, a reply, a bounce and a complaint go on the contact's timeline.
+ * - A hard bounce or a complaint suppresses the address and marks the contact `bounced` or `complained`, so nothing more is sent to it.
+ *
+ * Replies, complaints and unsubscribes count once per message; a hard bounce once (a soft one may be followed by a hard one).
+ */
+export declare class EngagementRecorder {
+    private readonly repos;
+    private readonly classes;
+    private readonly logger?;
+    constructor(repos: CrmRepos, classes: CrmModelClasses, logger?: any | undefined);
+    /** Records `type` for `send` (as of `at`) - see the class comment. Returns the send as updated, or `undefined` for an ignored repeat. */
+    record(send: OutboundSend, type: EngagementType, data?: EngagementData, at?: Date): Promise<OutboundSend | undefined>;
+    /**
+     * Applies `type` to the send's fields, retrying on version conflicts from a fresh read. `undefined` when it's a repeat that doesn't
+     * count (a second reply, complaint, unsubscribe or hard bounce).
+     */
+    private updateSend;
+    /** What `type` changes on `send`: `{}` for nothing, `undefined` for a repeat to ignore. */
+    private changesFor;
+    /** The contact-side consequences of an event - see the class comment. Failures are logged, not thrown: the event is recorded. */
+    private followUp;
+    private updateContact;
+    private suppress;
+    /** The timeline entry an event makes, if any: the first open, the first click, a reply, a bounce, a complaint. */
+    private timelineEntry;
+    /** How the timeline names what was sent: the campaign's name in quotes, or "an email". */
+    private sourceName;
+    /**
+     * Records the automation event of an engagement: every one but a failure, an automatic open or click, and a repeat open (only the
+     * first open a person makes is an event).
+     */
+    private recordEvent;
+}

package/dist/types/sending/Stats.d.ts

@@ -0,0 +1,17 @@
+import { RepoUtils } from "@rapidrest/service-core";
+import { CampaignCounts, CampaignStats, EngagementEvent, OutboundSend } from "../models/types.js";
+/** Counts with every number zero. */
+export declare function emptyCounts(): CampaignCounts;
+/** The counts of the sends of `sourceUid` (one variant's, when given). Cancelled sends aren't recipients. */
+export declare function countSends(repo: RepoUtils<OutboundSend>, sourceUid: string, variantId?: string): Promise<CampaignCounts>;
+/** A campaign's stats: the counts overall and, for an A/B test, per variant. */
+export declare function campaignStats(repo: RepoUtils<OutboundSend>, campaignUid: string, variantIds?: string[]): Promise<CampaignStats>;
+/** One link's clicks in a campaign. */
+export interface LinkClicks {
+    url: string;
+    clicks: number;
+    /** How many recipients clicked it. */
+    uniqueClicks: number;
+}
+/** A campaign's links by clicks, most first - from at most `maxEvents` click events. */
+export declare function linkClicks(repo: RepoUtils<EngagementEvent>, sourceUid: string, maxEvents?: number): Promise<LinkClicks[]>;

package/dist/types/sending/Tracking.d.ts

@@ -0,0 +1,39 @@
+/** A new outbound message token: 16 random bytes, base64url (22 characters). */
+export declare function newSendToken(): string;
+/** What a send token looks like, for refusing anything else before a database lookup. */
+export declare const SEND_TOKEN: RegExp;
+/**
+ * The path of a tracked link: `/t/c/<token>/<index>?u=<url>&s=<signature>`. The destination travels in the link (merge tags can make
+ * every recipient's different), signed so the redirect only ever goes where the email said - never an open redirect.
+ */
+export declare function clickPath(secret: string, token: string, index: number, url: string): string;
+/** Whether `signature` is `clickPath()`'s for this link. Compared in constant time. */
+export declare function verifyClick(secret: string, token: string, index: number, url: string, signature: unknown): boolean;
+/** A transparent 1x1 GIF, the open-tracking image. */
+export declare const TRACKING_PIXEL: Buffer;
+/** How soon after sending an open or click is taken as automatic (a server fetching everything on arrival). */
+export declare const MACHINE_WINDOW_MS = 2000;
+/**
+ * Whether an open or click looks automatic rather than a person's: a known scanner or previewer, no user agent, or within
+ * `MACHINE_WINDOW_MS` of sending. Apple Mail Privacy Protection and Gmail's image proxy fetch images for their users, so their opens
+ * count - but are never proof of reading.
+ */
+export declare function isMachine(userAgent: string | undefined, sentAt: Date | undefined, now?: Date): boolean;
+/**
+ * `html` with the `href` of each `http(s)` link replaced by `rewrite(url, index)` - `index` counting the rewritten links from 0 in
+ * order. Links in `keep` (the unsubscribe and preference links, which must work however tracking goes), `mailto:`/`tel:` links and
+ * anything else stay as they are. Returns the HTML and the URLs, in index order.
+ */
+export declare function trackLinks(html: string, rewrite: (url: string, index: number) => string, keep: ReadonlySet<string>): {
+    html: string;
+    urls: string[];
+};
+/** `html` with the open-tracking image `src` added at the end of its body. */
+export declare function addOpenPixel(html: string, src: string): string;
+/**
+ * The bounce address (VERP) of one message: `<local>+b-<token>@<domain>` of the sender's address, so a bounce comes back to the
+ * sender's mailbox (by plus-addressing) naming the message it is about. The plain address when that would be too long.
+ */
+export declare function verpAddress(fromAddress: string, token: string): string;
+/** The send token of a bounce address `verpAddress()` made, if `address` is one. */
+export declare function tokenFromVerp(address: string): string | undefined;

package/dist/types/sql.d.ts

@@ -0,0 +1,75 @@
+/**
+ * This plugin's `./sql` entry point: exactly the classes a server host loads for a SQL deployment - the CRM models, the routes
+ * mounted under `/api/mail/crm`, and the background jobs. Anything else exported here would be registered (and a job started) by
+ * the host too, so the abstract routes and utilities stay in the package root.
+ */
+export { WorkspaceSQL } from "./models/sql/WorkspaceSQL.js";
+export { WorkspaceMemberSQL } from "./models/sql/WorkspaceMemberSQL.js";
+export { WorkspaceSenderSQL } from "./models/sql/WorkspaceSenderSQL.js";
+export { CrmContactSQL } from "./models/sql/CrmContactSQL.js";
+export { CrmCompanySQL } from "./models/sql/CrmCompanySQL.js";
+export { PropertyDefinitionSQL } from "./models/sql/PropertyDefinitionSQL.js";
+export { PropertyValueSQL } from "./models/sql/PropertyValueSQL.js";
+export { CrmNoteSQL } from "./models/sql/CrmNoteSQL.js";
+export { CrmTaskSQL } from "./models/sql/CrmTaskSQL.js";
+export { TimelineEventSQL } from "./models/sql/TimelineEventSQL.js";
+export { CrmImportSQL } from "./models/sql/CrmImportSQL.js";
+export { MailingListSQL } from "./models/sql/MailingListSQL.js";
+export { SubscriptionSQL } from "./models/sql/SubscriptionSQL.js";
+export { SuppressionSQL } from "./models/sql/SuppressionSQL.js";
+export { CrmFormSQL } from "./models/sql/CrmFormSQL.js";
+export { CrmSettingSQL } from "./models/sql/CrmSettingSQL.js";
+export { EmailTemplateSQL } from "./models/sql/EmailTemplateSQL.js";
+export { SavedBlockSQL } from "./models/sql/SavedBlockSQL.js";
+export { CampaignSQL } from "./models/sql/CampaignSQL.js";
+export { OutboundSendSQL } from "./models/sql/OutboundSendSQL.js";
+export { EngagementEventSQL } from "./models/sql/EngagementEventSQL.js";
+export { SegmentSQL } from "./models/sql/SegmentSQL.js";
+export { ScoringRuleSQL } from "./models/sql/ScoringRuleSQL.js";
+export { AutomationSQL } from "./models/sql/AutomationSQL.js";
+export { AutomationVersionSQL } from "./models/sql/AutomationVersionSQL.js";
+export { EnrollmentSQL } from "./models/sql/EnrollmentSQL.js";
+export { CrmEventSQL } from "./models/sql/CrmEventSQL.js";
+export { PipelineSQL } from "./models/sql/PipelineSQL.js";
+export { DealSQL } from "./models/sql/DealSQL.js";
+export { WebhookEndpointSQL } from "./models/sql/WebhookEndpointSQL.js";
+export { WebhookDeliverySQL } from "./models/sql/WebhookDeliverySQL.js";
+export { ApiKeySQL } from "./models/sql/ApiKeySQL.js";
+export { WorkspaceRouteSQL } from "./routes/sql/WorkspaceRouteSQL.js";
+export { ContactRouteSQL } from "./routes/sql/ContactRouteSQL.js";
+export { CompanyRouteSQL } from "./routes/sql/CompanyRouteSQL.js";
+export { PropertyDefinitionRouteSQL } from "./routes/sql/PropertyDefinitionRouteSQL.js";
+export { NoteRouteSQL } from "./routes/sql/NoteRouteSQL.js";
+export { TaskRouteSQL } from "./routes/sql/TaskRouteSQL.js";
+export { TimelineRouteSQL } from "./routes/sql/TimelineRouteSQL.js";
+export { ImportRouteSQL } from "./routes/sql/ImportRouteSQL.js";
+export { ListRouteSQL } from "./routes/sql/ListRouteSQL.js";
+export { SubscriptionRouteSQL } from "./routes/sql/SubscriptionRouteSQL.js";
+export { SuppressionRouteSQL } from "./routes/sql/SuppressionRouteSQL.js";
+export { FormRouteSQL } from "./routes/sql/FormRouteSQL.js";
+export { PublicRouteSQL } from "./routes/sql/PublicRouteSQL.js";
+export { TemplateRouteSQL } from "./routes/sql/TemplateRouteSQL.js";
+export { SavedBlockRouteSQL } from "./routes/sql/SavedBlockRouteSQL.js";
+export { CampaignRouteSQL } from "./routes/sql/CampaignRouteSQL.js";
+export { TrackingRouteSQL } from "./routes/sql/TrackingRouteSQL.js";
+export { SegmentRouteSQL } from "./routes/sql/SegmentRouteSQL.js";
+export { ScoringRuleRouteSQL } from "./routes/sql/ScoringRuleRouteSQL.js";
+export { AutomationRouteSQL } from "./routes/sql/AutomationRouteSQL.js";
+export { PipelineRouteSQL } from "./routes/sql/PipelineRouteSQL.js";
+export { DealRouteSQL } from "./routes/sql/DealRouteSQL.js";
+export { AnalyticsRouteSQL } from "./routes/sql/AnalyticsRouteSQL.js";
+export { WebhookRouteSQL } from "./routes/sql/WebhookRouteSQL.js";
+export { ApiKeyRouteSQL } from "./routes/sql/ApiKeyRouteSQL.js";
+export { IntegrationRouteSQL } from "./routes/sql/IntegrationRouteSQL.js";
+export { CrmAdminRouteSQL } from "./routes/sql/CrmAdminRouteSQL.js";
+export { CrmImportJobSQL } from "./jobs/sql/CrmImportJobSQL.js";
+export { CampaignJobSQL } from "./jobs/sql/CampaignJobSQL.js";
+export { SendDispatchJobSQL } from "./jobs/sql/SendDispatchJobSQL.js";
+export { CrmMailEventJobSQL } from "./jobs/sql/CrmMailEventJobSQL.js";
+export { SegmentRefreshJobSQL } from "./jobs/sql/SegmentRefreshJobSQL.js";
+export { ScoringJobSQL } from "./jobs/sql/ScoringJobSQL.js";
+export { AutomationTriggerJobSQL } from "./jobs/sql/AutomationTriggerJobSQL.js";
+export { AutomationRunJobSQL } from "./jobs/sql/AutomationRunJobSQL.js";
+export { TaskReminderJobSQL } from "./jobs/sql/TaskReminderJobSQL.js";
+export { WebhookDeliveryJobSQL } from "./jobs/sql/WebhookDeliveryJobSQL.js";
+export { DateTriggerJobSQL } from "./jobs/sql/DateTriggerJobSQL.js";

package/dist/types/templates/Design.d.ts

@@ -0,0 +1,138 @@
+/** The look every part of a design falls back to. */
+export interface DesignTheme {
+    /** Around the email. */
+    backgroundColor: string;
+    /** Behind the content. */
+    contentBackgroundColor: string;
+    fontFamily: string;
+    textColor: string;
+    linkColor: string;
+    buttonColor: string;
+    buttonTextColor: string;
+    /** The content's width in pixels (480-800). */
+    width: number;
+}
+export type Align = "left" | "center" | "right";
+interface BlockBase {
+    /** Server-assigned when missing; stable across edits, so the editor can track blocks. */
+    id: string;
+    /** Padding around the block in pixels. */
+    padding?: number;
+}
+export interface TextBlock extends BlockBase {
+    type: "text";
+    /** Formatted text: paragraphs, bold, italics, underline, links, lists, line breaks - sanitized on save. */
+    html: string;
+    align?: Align;
+    fontSize?: number;
+    color?: string;
+}
+export interface HeadingBlock extends BlockBase {
+    type: "heading";
+    text: string;
+    level: 1 | 2 | 3;
+    align?: Align;
+    color?: string;
+}
+export interface ImageBlock extends BlockBase {
+    type: "image";
+    /** An https:// image. */
+    src: string;
+    alt: string;
+    /** Where clicking the image goes. */
+    href?: string;
+    /** In pixels; the column's width when unset. */
+    width?: number;
+    align?: Align;
+}
+export interface ButtonBlock extends BlockBase {
+    type: "button";
+    text: string;
+    href: string;
+    align?: Align;
+    backgroundColor?: string;
+    color?: string;
+    borderRadius?: number;
+}
+export interface DividerBlock extends BlockBase {
+    type: "divider";
+    color?: string;
+    thickness?: number;
+}
+export interface SpacerBlock extends BlockBase {
+    type: "spacer";
+    height: number;
+}
+export type SocialNetwork = "facebook" | "x" | "linkedin" | "instagram" | "youtube" | "github" | "web";
+export interface SocialBlock extends BlockBase {
+    type: "social";
+    links: {
+        network: SocialNetwork;
+        href: string;
+    }[];
+    align?: Align;
+}
+/** Hand-written HTML. Only workspace admins may add or change one; it is still sanitized. */
+export interface HtmlBlock extends BlockBase {
+    type: "html";
+    html: string;
+}
+/** The marketing footer: the workspace's name and postal address, and the unsubscribe and preferences links. */
+export interface FooterBlock extends BlockBase {
+    type: "footer";
+    /** Text above the links, e.g. why the reader gets the email. */
+    note?: string;
+    align?: Align;
+    color?: string;
+}
+export type DesignBlock = TextBlock | HeadingBlock | ImageBlock | ButtonBlock | DividerBlock | SpacerBlock | SocialBlock | HtmlBlock | FooterBlock;
+export type BlockType = DesignBlock["type"];
+export interface DesignColumn {
+    id: string;
+    blocks: DesignBlock[];
+}
+export interface DesignSection {
+    id: string;
+    backgroundColor?: string;
+    padding?: number;
+    /** 1 to 4 columns, side by side (stacked on a phone). */
+    columns: DesignColumn[];
+}
+/** An email design: a theme, and sections of columns of blocks. Stored as JSON on the template, rendered with MJML. */
+export interface TemplateDesign {
+    version: 1;
+    theme: DesignTheme;
+    sections: DesignSection[];
+}
+export declare const DEFAULT_THEME: DesignTheme;
+/** How big a design may get. */
+export declare const MAX_SECTIONS = 60;
+export declare const MAX_BLOCKS_PER_COLUMN = 40;
+export declare const MAX_BLOCKS = 400;
+export declare const MAX_DESIGN_BYTES: number;
+/** A new id for a design part. */
+export declare function newId(): string;
+/** What a design check needs to know. */
+export interface DesignCheck {
+    /** The caller may add or change hand-written HTML blocks. */
+    allowHtml: boolean;
+    /** The blocks of the design being replaced, by id: an HTML block unchanged from there is kept even when `allowHtml` is off. */
+    previous?: Map<string, DesignBlock>;
+    /** Makes a block's formatted text safe (`templates/Sanitize.ts`), and a hand-written HTML block's HTML. */
+    sanitizeText: (html: string) => string;
+    sanitizeHtml: (html: string) => string;
+}
+/** Every block of a design, in order. */
+export declare function designBlocks(design: TemplateDesign): DesignBlock[];
+/**
+ * A design from a request, checked and normalized: every part has an id (a missing or malformed one gets a new one), every value is
+ * within its limits, colours are colours, links are web, mail or phone links or merge tags, images are https, text is sanitized, and
+ * hand-written HTML only comes from someone allowed to write it. Undefined optional values are dropped. A bad design is a 400 naming
+ * the part at fault.
+ */
+export declare function validateDesign(raw: unknown, check: DesignCheck): TemplateDesign;
+/** Whether a design lets its reader unsubscribe: a footer block, or a link to `{{ links.unsubscribe }}` anywhere. */
+export declare function hasUnsubscribeLink(design: TemplateDesign): boolean;
+/** The design a new template starts from: a heading, a paragraph, a button and the footer. */
+export declare function starterDesign(): TemplateDesign;
+export {};

package/dist/types/templates/MergeContext.d.ts

@@ -0,0 +1,27 @@
+import { CrmCompany, CrmContact, PropertyDefinition, PropertyValue, Workspace, WorkspaceSender } from "../models/types.js";
+import { MergeContext } from "./Render.js";
+/** What a reader's merge context is made from. */
+export interface MergeSources {
+    workspace: Workspace;
+    contact: CrmContact;
+    contactValues?: Record<string, PropertyValue[]>;
+    contactDefinitions: PropertyDefinition[];
+    company?: CrmCompany;
+    companyValues?: Record<string, PropertyValue[]>;
+    companyDefinitions: PropertyDefinition[];
+    sender?: WorkspaceSender;
+    list?: {
+        name: string;
+    };
+    links: MergeContext["links"];
+}
+/**
+ * The merge context of one reader: their contact fields (`contact.first_name`, `contact.full_name`, `contact.properties.<key>`...), their
+ * company's (`company.name`...), the workspace's, the sender's, and the links to unsubscribe and manage preferences.
+ */
+export declare function buildMergeContext(sources: MergeSources): MergeContext;
+/** The merge tags a template can use, for the designer's merge tag picker. `properties.<key>` tags are added per workspace. */
+export declare const MERGE_TAGS: readonly {
+    tag: string;
+    label: string;
+}[];

package/dist/types/templates/Render.d.ts

@@ -0,0 +1,46 @@
+import { TemplateDesign } from "./Design.js";
+/** What a template's merge tags can read. Keys are snake_case, as merge tags are written (`{{ contact.first_name }}`). */
+export interface MergeContext {
+    contact: Record<string, unknown>;
+    company?: Record<string, unknown>;
+    workspace: {
+        name: string;
+        postal_address?: string;
+        website?: string;
+    };
+    sender?: {
+        name: string;
+        address: string;
+    };
+    list?: {
+        name: string;
+    };
+    links: {
+        unsubscribe: string;
+        preferences: string;
+        view_online?: string;
+    };
+}
+/** A rendered email. */
+export interface RenderedEmail {
+    subject: string;
+    /** A complete HTML document. */
+    html: string;
+    text: string;
+}
+/** A design as an MJML document; `preheader` becomes the inbox preview line. Merge tags are left in, for `renderEmail()`. */
+export declare function designToMjml(design: TemplateDesign, preheader?: string): string;
+/** The HTML of a design (before merge tags are filled in), from MJML. Throws a 400 for a design MJML can't lay out. */
+export declare function compileDesign(design: TemplateDesign, preheader?: string): Promise<string>;
+/**
+ * Checks that a subject and a compiled design parse as Liquid, so a template with a broken merge tag is refused when saved rather than
+ * when sent. A 400 names what's wrong.
+ */
+export declare function checkMergeTags(subject: string, compiledHtml: string): void;
+/**
+ * The email for one reader: the compiled design and the subject with their merge tags filled in from `context` (HTML-escaped in the
+ * body), and a plain-text part made from the result.
+ */
+export declare function renderEmail(compiledHtml: string, subject: string, context: MergeContext): Promise<RenderedEmail>;
+/** A made-up reader, for previews without a contact. */
+export declare function sampleContext(workspace: MergeContext["workspace"], sender?: MergeContext["sender"]): MergeContext;

package/dist/types/templates/Sanitize.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `html` with the quote and ampersand entities inside its merge and Liquid tags turned back into characters: `{{ x | default: 'a' }}`
+ * becomes `{{ x | default: 'a' }}`, which Liquid can parse. Nothing outside the tags changes, and `<`/`>` stay escaped everywhere.
+ */
+export declare function restoreMergeTags(html: string): string;
+/** Escapes text for HTML, except inside merge and Liquid tags (which only lose `<` and `>`, never valid in them). */
+export declare function escapeKeepingTags(text: string): string;
+/**
+ * The formatted text of a text block, made safe: the formatting the editor produces (paragraphs, bold, italics, underline,
+ * strike-through, links, lists, quotes, small headings, colour and alignment) and nothing else - no scripts, no styles beyond
+ * those, and links only to the web, mail, phones or merge tags. Merge tags stay usable (`restoreMergeTags()`).
+ */
+export declare function sanitizeText(html: string): string;
+/**
+ * A hand-written HTML block's HTML, made safe: layout and formatting HTML (tables, images, inline styles) is kept; scripts, forms,
+ * frames, event handlers and `javascript:` links are removed, and images must be https. Merge tags stay usable.
+ */
+export declare function sanitizeBlockHtml(html: string): string;