ab-ecosystem-cpass 1.0.0 → 1.0.6

package/dist/types/inbox.d.ts

@@ -0,0 +1,391 @@
+import type { JsonObject } from './common';
+import type { Contact, ContactChatMetadata, ContactName, ContactProfile, ContactTag } from './audience';
+import type { ContactFilterEntry } from './contact-filter';
+/**
+ * Delivery state, shared by every channel kind. Providers report more than these
+ * -- email bounces, carrier rejections -- and each maps onto one of the five, so
+ * the inbox, the campaign reports and the billing logs all read one field. The
+ * provider's own wording survives in `error`.
+ */
+export type MessageStatus = 'received' | 'sent' | 'delivered' | 'read' | 'failed';
+/** `received` is the only inbound state, so direction is derived, not stored. */
+export type MessageDirection = 'inbound' | 'outbound';
+/** Who put the message on the wire, derived from the `sent_by_*` flags. */
+export type MessageSource = 'contact' | 'agent' | 'bot' | 'campaign' | 'api' | 'business_app';
+/**
+ * The message body, as the channel describes it.
+ *
+ * Open by design -- a WhatsApp interactive reply, an email part tree and an RCS
+ * card share no structure worth forcing into one schema. Only `type` is promised,
+ * and by convention the body for that kind sits under a key of the same name:
+ * `{ type: 'image', image: { id, link } }`.
+ *
+ * Narrow it yourself where you know the channel: `Message<MyWhatsAppContent>`.
+ */
+export interface MessageContent extends JsonObject {
+    type: string;
+}
+/** Per-status unix seconds. `0` means the message never reached that state. */
+export interface MessageReceipts {
+    sent: number;
+    read: number;
+    failed: number;
+    replied: number;
+    received: number;
+    delivered: number;
+}
+export interface Message<C extends MessageContent = MessageContent, X = JsonObject> {
+    id: string;
+    contact: string;
+    /** Channel it travelled over. Lives in the channels service, so an id only. */
+    channel: string;
+    content: C;
+    /** Provider context: the replied-to id, forwarding flags, the CTWA referral. */
+    context: X;
+    /** The contact's identity on this channel -- phone number, handle, address. */
+    identifier: string;
+    /**
+     * The provider's id (a `wamid` for WhatsApp), unique across the account. An
+     * outbound message carries its queue id here until the provider answers.
+     */
+    message_id: string;
+    status: MessageStatus;
+    /** Unix seconds as the provider reported it. Thread order is by this. */
+    timestamp: number;
+    direction: MessageDirection;
+    source: MessageSource;
+    sent_by_api: boolean;
+    sent_by_biz_app: boolean;
+    sent_by_campaign: boolean;
+    sent_by_bot: boolean;
+    agent: string | null;
+    receipts: MessageReceipts;
+    meta: {
+        bookmarked: boolean;
+        hide: boolean;
+    };
+    campaign: {
+        id: string | null;
+        cmid: number;
+    };
+    bot: {
+        id: string | null;
+        node: string;
+    };
+    error: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Media kinds whose bytes the platform fetches from the provider and re-hosts. */
+export type MediaContentType = 'image' | 'video' | 'audio' | 'document' | 'voice' | 'sticker';
+export interface ListMessagesPayload {
+    /** Contact whose thread to read. */
+    id: string;
+    /** Default 20, max 100. */
+    limit?: number;
+    /** `id` of the oldest message already held; older ones follow. */
+    last_message_id?: string;
+}
+export interface FetchMessagePayload {
+    /** The provider id, not the document id. */
+    message_id: string;
+}
+export interface SendMessagePayload {
+    channel: string;
+    contact: {
+        id: string;
+        identifier: string;
+    };
+    content: MessageContent;
+    context?: JsonObject;
+    /** Attribute to another member. Needs `live_chat.send.AS_OTHER`. */
+    agent?: string;
+}
+export interface DeleteMessagePayload {
+    /** Contact whose thread the message belongs to. */
+    id: string;
+    /** Either the document id or the provider id. */
+    message_id: string;
+}
+export interface RetryDownloadPayload {
+    /** The document id -- a retry targets a row the platform already stored. */
+    message_id: string;
+}
+export interface MessageDeleteResult {
+    success: boolean;
+    id: string;
+}
+/**
+ * The inbox's view of a contact: the chat-relevant projection, not the whole
+ * contact. Every chat event answers with this, so one shape updates the list row
+ * and the conversation header together.
+ */
+export interface Chat {
+    id: string;
+    name: ContactName;
+    profile: Record<string, ContactProfile>;
+    chat_metadata: ContactChatMetadata;
+    /** Unix seconds of the last inbound message. The list is ordered by this. */
+    last_seen: number;
+    /** Flow state. Open-ended on the stored schema, carried through as-is. */
+    bot: JsonObject;
+    /** Last-message preview, so a list of chats needs no thread reads. */
+    last_interaction_props: JsonObject;
+    agent: string | null;
+    team: string | null;
+    tags: ContactTag[];
+    /** Present on list rows; the chat header renders them. */
+    custom_field_hash?: JsonObject;
+}
+/**
+ * The inbox's own list filter. Every key is independent and omitting one means
+ * "don't care", so an empty filter is every live chat.
+ */
+export interface ChatListFilter {
+    /** `all` every chat, `me` the caller's own, `none` the unassigned queue. */
+    assignment?: 'all' | 'me' | 'none';
+    /** `unread` has unseen messages or a by-hand flag; `replied` is caught up. */
+    unread?: 'unread' | 'replied';
+    new?: 'new' | 'old';
+    /** `closed` covers closed and marked-done alike; `open` is neither. */
+    closed?: 'closed' | 'open';
+    archived?: 'archived' | 'unarchived';
+    /** `active_no_bot` is running with no flow attached. */
+    automation?: 'active' | 'paused' | 'active_no_bot';
+    block?: 'ic' | 'og' | 'api' | 'bot' | 'unblocked';
+    /** `active` means seen inside the last 24 hours -- the provider reply window. */
+    session?: 'active' | 'expired';
+}
+export interface ListChatsPayload {
+    filter?: ChatListFilter;
+    /** Conditions in the same DSL the contact list and segments use. */
+    conditions?: ContactFilterEntry[];
+    search?: string;
+    /** `last_seen` of the oldest row already held; omit for the first page. */
+    nextPage?: number;
+    /** Default 20, max 100. */
+    limit?: number;
+    department?: string;
+    team_member?: string;
+}
+export interface ChatList {
+    contacts: Chat[];
+    /**
+     * The filter after permission narrowing. A team member without the unassigned
+     * permission asking for `all` gets `me` back, so the UI can show what it got.
+     */
+    filter: ChatListFilter;
+    /** Send as `nextPage` for the following page; `null` at the end. */
+    nextPage: number | null;
+}
+/** Every action `chat.action` accepts. */
+export type ChatActionName = 'delete' | 'transfer' | 'bulk_transfer' | 'archive' | 'unarchive' | 'block' | 'mark_as_read' | 'mark_as_unread' | 'pause_automation' | 'resume_automation' | 'close' | 'done' | 'pause_timer' | 'update_tags';
+/** The blocked flags; send only the ones to change. */
+export interface ChatBlockUpdate {
+    incoming?: boolean;
+    outgoing?: boolean;
+    bot?: boolean;
+    api?: boolean;
+}
+/** `chat` names the target. `id` is accepted as an alias on every action. */
+interface ChatTarget {
+    chat?: string;
+    id?: string;
+}
+export type ChatActionPayload = (ChatTarget & {
+    action: 'delete';
+}) | (ChatTarget & {
+    action: 'transfer';
+    member: string;
+}) | (ChatTarget & {
+    action: 'archive';
+}) | (ChatTarget & {
+    action: 'unarchive';
+}) | (ChatTarget & {
+    action: 'block';
+    update: ChatBlockUpdate;
+}) | (ChatTarget & {
+    action: 'mark_as_read';
+}) | (ChatTarget & {
+    action: 'mark_as_unread';
+}) | (ChatTarget & {
+    action: 'pause_automation';
+}) | (ChatTarget & {
+    action: 'resume_automation';
+}) | (ChatTarget & {
+    action: 'close';
+}) | (ChatTarget & {
+    action: 'done';
+    isEnded?: boolean;
+}) | (ChatTarget & {
+    action: 'pause_timer';
+    duration: number;
+}) | (ChatTarget & {
+    action: 'update_tags';
+    tags: string[];
+}) | {
+    action: 'bulk_transfer';
+    /** Member to take chats from, or `UNASSIGN` for the unassigned queue. */
+    source: string | 'UNASSIGN';
+    /** Member or team to hand them to, or `UNASSIGN` to clear it. */
+    target: string | 'UNASSIGN';
+    target_type?: 'member' | 'department';
+};
+/** The envelope every chat action answers and broadcasts with. */
+export interface ChatActionResult {
+    action: ChatActionName;
+    id: string;
+    /** `null` for `delete`: the row has left the list, so there is nothing to draw. */
+    chat?: Chat | null;
+}
+export interface BulkTransferResult {
+    action: 'bulk_transfer';
+    count: number;
+    chats: ChatActionResult[];
+}
+export interface UpdateChatPayload {
+    id: string;
+    action: 'done' | 'archive';
+}
+/** `contact.update` answers with the metadata alone. */
+export interface UpdateChatResult {
+    id: string;
+    action: 'done' | 'archive';
+    chat_metadata?: ContactChatMetadata;
+}
+export interface AssignBotPayload {
+    chat: string;
+    channel: string;
+    bot: string;
+    node?: string;
+    /**
+     * `assign` attaches the flow and resumes automation. `trigger` hands the chat
+     * to the bot server, which decides where in the flow it belongs.
+     */
+    action?: 'assign' | 'trigger';
+}
+/** A click-to-WhatsApp referral: the ad payload behind a conversation. */
+/**
+ * A delivery state moved on a message already on screen.
+ *
+ * Its own push rather than another `message.received`, because a client updates
+ * the ticks in place and does not want to re-render the bubble. The row is the
+ * stored document as the sender service wrote it, so `_id` is a string and
+ * `receipts` carries the unix second each state was reached.
+ */
+export interface MessageStatusUpdate extends JsonObject {
+    /** The provider's message id -- what an echoed bubble's queue id is replaced by. */
+    message_id: string;
+    status: MessageStatus;
+    /** Owner the row belongs to. */
+    user: string;
+    contact?: string;
+    receipts?: Partial<MessageReceipts>;
+    /** Provider text when `status` is `failed`. */
+    error?: string;
+}
+/** Media kinds a chat message can carry. */
+export type MediaKind = 'image' | 'video' | 'audio' | 'voice' | 'sticker' | 'document';
+/**
+ * Per-kind ceilings, in bytes. WhatsApp's limits, enforced when the upload is
+ * requested rather than when the message is sent.
+ */
+export declare const MEDIA_LIMITS: Record<MediaKind, number>;
+/** What `POST /v1/audience/inbox/media/upload-url` takes. Metadata, not bytes. */
+export interface CreateMediaUploadPayload {
+    kind: MediaKind;
+    /** Only its extension and display name survive; the stored key is a uuid. */
+    filename: string;
+    content_type: string;
+    /** Exact byte length. Signed into the ticket, so the upload must match. */
+    size: number;
+}
+/** A presigned upload. `PUT` the bytes to `upload_url` with exactly `headers`. */
+export interface MediaUpload {
+    upload_url: string;
+    /** Every header the signature covers. Anything else fails the upload. */
+    headers: Record<string, string>;
+    /**
+     * Where the object is readable once the upload succeeds. Permanent -- only
+     * `upload_url` expires, and only if unused.
+     */
+    link: string;
+    key: string;
+    kind: MediaKind;
+    filename: string;
+    content_type: string;
+    size: number;
+    /** Unix seconds after which `upload_url` stops working. */
+    expires_at: number;
+    expires_in: number;
+}
+/**
+ * The bytes `sendMedia` can take.
+ *
+ * A browser `File` or `Blob`, or a description of bytes for Node, where neither
+ * exists. Structurally the same thing `crm.inboxMedia.upload()` accepts, declared
+ * here so the realtime entrypoint does not have to import the REST one.
+ */
+export type MediaFile = Blob | {
+    body: unknown;
+    filename: string;
+    contentType: string;
+    size: number;
+};
+/**
+ * Uploads a file and answers with its permanent link.
+ *
+ * Satisfied by `crm.inboxMedia.upload`. Declared as a function so the socket
+ * client takes a capability rather than a dependency on the REST client: an app
+ * that only ever sends a `link` pulls none of it in.
+ */
+export type MediaUploader = (file: MediaFile, options: {
+    kind: MediaKind;
+    filename?: string;
+}) => Promise<string>;
+/**
+ * What `sendMedia` takes: a chat, a kind, and either a link or a file.
+ *
+ * `link` and `file` are alternatives -- a link is sent as it is, a file is
+ * uploaded first and needs the `Inbox` to have been given an uploader.
+ */
+export interface SendMediaPayload {
+    channel: string;
+    contact: {
+        id: string;
+        identifier: string;
+    };
+    kind: MediaKind;
+    /** Already uploaded. Takes precedence over `file`. */
+    link?: string;
+    /** Uploaded before sending. Requires `uploadMedia` on the Inbox. */
+    file?: MediaFile;
+    /** Shown under the media. Ignored for a sticker, which takes none. */
+    caption?: string;
+    /** What the recipient sees for a document. Also names the uploaded object. */
+    filename?: string;
+    context?: JsonObject;
+    /** Attribute to another member. Needs `live_chat.send.AS_OTHER`. */
+    agent?: string;
+}
+export interface CtwaReferral {
+    id: string;
+    contact: string;
+    channel: string | null;
+    /** The provider's referral object. `payload.source_id` is the ad id. */
+    payload: JsonObject;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * When a contact was last seen on one channel. Providers only allow unprompted
+ * replies inside 24 hours of the last inbound message, and a contact reachable on
+ * several channels has one such window per channel.
+ */
+export interface ChatSession {
+    id: string;
+    channel: string;
+    last_seen: number;
+}
+/** Re-exported so a consumer importing `Chat` need not also reach for `Contact`. */
+export type { Contact };

package/dist/types/inbox.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MEDIA_LIMITS = void 0;
+/**
+ * Per-kind ceilings, in bytes. WhatsApp's limits, enforced when the upload is
+ * requested rather than when the message is sent.
+ */
+exports.MEDIA_LIMITS = {
+    image: 5 * 1024 * 1024,
+    video: 16 * 1024 * 1024,
+    audio: 16 * 1024 * 1024,
+    voice: 16 * 1024 * 1024,
+    sticker: 100 * 1024,
+    document: 100 * 1024 * 1024,
+};
+//# sourceMappingURL=inbox.js.map

package/dist/types/inbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbox.js","sourceRoot":"","sources":["../../src/types/inbox.ts"],"names":[],"mappings":";;;AAoTA;;;GAGG;AACU,QAAA,YAAY,GAA8B;IACrD,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,IAAI;IACtB,KAAK,EAAE,EAAE,GAAG,IAAI,GAAG,IAAI;IACvB,KAAK,EAAE,EAAE,GAAG,IAAI,GAAG,IAAI;IACvB,KAAK,EAAE,EAAE,GAAG,IAAI,GAAG,IAAI;IACvB,OAAO,EAAE,GAAG,GAAG,IAAI;IACnB,QAAQ,EAAE,GAAG,GAAG,IAAI,GAAG,IAAI;CAC5B,CAAC"}

package/dist/types/index.d.ts

@@ -2,3 +2,6 @@ export * from './common';
 export * from './contact-filter';
 export * from './audience';
 export * from './channels';
+export * from './inbox';
+export * from './scheduled-message';
+export * from './campaign';

package/dist/types/index.js

@@ -18,4 +18,9 @@ __exportStar(require("./common"), exports);
 __exportStar(require("./contact-filter"), exports);
 __exportStar(require("./audience"), exports);
 __exportStar(require("./channels"), exports);
+__exportStar(require("./inbox"), exports);
+// After './inbox': a scheduled message's body is a `MessageContent`.
+__exportStar(require("./scheduled-message"), exports);
+// After './contact-filter': a campaign's audience may be a list of its entries.
+__exportStar(require("./campaign"), exports);
 //# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,mDAAiC;AACjC,6CAA2B;AAC3B,6CAA2B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,mDAAiC;AACjC,6CAA2B;AAC3B,6CAA2B;AAC3B,0CAAwB;AACxB,qEAAqE;AACrE,sDAAoC;AACpC,gFAAgF;AAChF,6CAA2B"}

package/dist/types/scheduled-message.d.ts

@@ -0,0 +1,221 @@
+/**
+ * Scheduled messages: a send with a time, and optionally a condition checked
+ * immediately before it goes out.
+ *
+ * The condition is what makes a drip safe to set and forget. A sequence of five
+ * messages over two weeks is five rows; each one re-reads the contact a moment
+ * before sending and stands down if the contact no longer matches. So "stop
+ * messaging a lead once they convert" is a field on the contact changing, not a
+ * job anybody has to remember to cancel.
+ *
+ * Declared here rather than imported from `@crm/contracts` so the published
+ * package has no private dependencies; kept in step with the zod schemas.
+ */
+import type { ContactFilter } from './contact-filter';
+import type { IsoDate, JsonObject, ListQuery, ObjectId } from './common';
+import type { MessageContent } from './inbox';
+/** Units a schedule's spacing is expressed in. */
+export type ScheduleUnit = 'minutes' | 'hours' | 'days' | 'weeks' | 'months';
+/**
+ * Where one occurrence ended up.
+ *
+ * | Status | Meaning |
+ * | --- | --- |
+ * | `pending` | Waiting for its moment. The only status that can be rescheduled. |
+ * | `processing` | Claimed by the scheduler, mid-send. |
+ * | `sent` | Handed to the channel. Delivery is then a message status, not this. |
+ * | `skipped` | Its condition did not match. `result` says what was expected and what was found. |
+ * | `cancelled` | Stood down -- by a caller, or by an earlier occurrence failing its condition under `cancel_series`. |
+ * | `failed` | Could not be sent: the contact is gone, trashed, blocked for outbound, or has no channel identity. `result.reason` says which. |
+ */
+export type ScheduledMessageStatus = 'pending' | 'processing' | 'sent' | 'skipped' | 'failed' | 'cancelled';
+/**
+ * What a failed condition does to the rest of the series.
+ *
+ * - `skip` -- this occurrence only. Later ones still run and are checked again,
+ *   so a contact who leaves and re-enters the condition resumes receiving.
+ * - `cancel_series` -- this occurrence and every later one. The default for a
+ *   series, because a converted lead should drop out of the sequence for good
+ *   rather than re-enter it if someone edits their stage back.
+ */
+export type OnConditionFail = 'skip' | 'cancel_series';
+/** A step's distance from the series start. Cumulative, never relative to the previous step. */
+export interface ScheduleOffset {
+    value: number;
+    unit: ScheduleUnit;
+}
+/**
+ * One message in a sequence, with its own copy.
+ *
+ * `after` is measured from the series' `starts_at`, so editing one step's delay
+ * does not shift the steps behind it.
+ */
+export interface ScheduledMessageStep {
+    after: ScheduleOffset;
+    content: MessageContent;
+    context?: JsonObject;
+    /**
+     * Narrows this step beyond the series condition. Both must pass. Use it for a
+     * step that needs an extra guard -- a final discount offer only if the contact
+     * has not already bought -- and leave it out to inherit the series condition
+     * alone.
+     */
+    conditions?: ContactFilter | null;
+}
+/** Expands into evenly spaced occurrences, all carrying the same message. */
+export interface ScheduleRepeat {
+    /** Spacing between occurrences. Must be at least 1. */
+    every: number;
+    unit: ScheduleUnit;
+    /**
+     * Inclusive end. The last occurrence is the final one at or before this
+     * instant, so `starts_at` + `every: 3, unit: 'days'` + `until` two weeks out
+     * produces five sends, not four or six.
+     */
+    until: IsoDate;
+}
+/**
+ * Why an occurrence did not send, or how it did.
+ *
+ * Only the first failing condition is named: listing every one of them would be
+ * noise when the first already explains the skip.
+ */
+export interface ScheduledMessageResult {
+    /**
+     * `queued` | `condition_not_met` | `series_cancelled_by_condition` |
+     * `cancelled_by_user` | `contact_missing` | `contact_trashed` |
+     * `outgoing_blocked` | `no_channel_identity`
+     */
+    reason?: string;
+    /** For `condition_not_met`: which condition refused -- the series' or the step's. */
+    scope?: 'series' | 'step';
+    /** For `condition_not_met`: the first condition that failed, and what it wanted. */
+    field_id?: string;
+    condition?: string;
+    expected?: unknown;
+    /** For `series_cancelled_by_condition`: the occurrence whose condition failed. */
+    at_occurrence?: number;
+    /** Anything else the server recorded. */
+    error?: string;
+}
+export interface ScheduledMessage {
+    id: ObjectId;
+    /** The series this belongs to, or `null` for a one-off. */
+    series: ObjectId | null;
+    /** 1-based position in the series. `1` for a one-off. */
+    occurrence: number;
+    title: string;
+    contact: ObjectId;
+    /** Channel it will go out on. Lives in the channels service, so an id only. */
+    channel: ObjectId;
+    content: MessageContent;
+    context: JsonObject;
+    /** IANA zone the schedule was expressed in, e.g. `Asia/Kolkata`. */
+    timezone: string;
+    /** The resolved instant, always UTC. This is what the scheduler fires on. */
+    scheduled_at: IsoDate;
+    /** The same moment as wall-clock in `timezone`, with no offset -- what the user chose. */
+    scheduled_at_local: string;
+    /** The series condition. `null` means send unconditionally. */
+    conditions: ContactFilter | null;
+    /**
+     * This occurrence's own extra narrowing, from its step. Both this and
+     * `conditions` have to pass.
+     */
+    step_conditions: ContactFilter | null;
+    on_condition_fail: OnConditionFail;
+    status: ScheduledMessageStatus;
+    result: ScheduledMessageResult | null;
+    /** When the scheduler claimed it. */
+    processed_at: IsoDate | null;
+    /** When it reached a terminal status. */
+    completed_at: IsoDate | null;
+    createdAt: IsoDate;
+    updatedAt: IsoDate;
+}
+/** A series and the occurrences it expanded into. */
+export interface ScheduledMessageSeries {
+    series: ObjectId;
+    title: string;
+    contact: ObjectId;
+    channel: ObjectId;
+    timezone: string;
+    conditions: ContactFilter | null;
+    on_condition_fail: OnConditionFail;
+    /** In send order. One row per message, each independently cancellable. */
+    occurrences: ScheduledMessage[];
+}
+/** What every create shares. */
+interface ScheduledMessageBase {
+    /** Shown in the schedule list. Defaults to `'Untitled'`. */
+    title?: string;
+    channel: ObjectId;
+    contact: {
+        id: ObjectId;
+    };
+    /**
+     * IANA zone name -- `Asia/Kolkata`, `Europe/London`. Not an abbreviation and
+     * not an offset: `IST` and `+05:30` are rejected.
+     *
+     * Required. When the time below carries no offset it is read as wall-clock in
+     * this zone; when it does, the instant is already pinned and this is kept for
+     * display and for later edits.
+     */
+    timezone: string;
+    /**
+     * Checked against the contact immediately before each send. Omit to always
+     * send.
+     *
+     * Same DSL as `contacts.list({ filter })` and a saved `Segment` -- see the
+     * contact filter page. A custom field is addressed by its **slug**.
+     */
+    conditions?: ContactFilter | null;
+    /** Default `skip` for a one-off, `cancel_series` for a series. */
+    on_condition_fail?: OnConditionFail;
+}
+/** One message, one time. */
+export interface CreateScheduledMessageInput extends ScheduledMessageBase {
+    /**
+     * `2026-10-15T10:00:00` is 10:00 in `timezone`. `2026-10-15T04:30:00Z` is that
+     * instant regardless of it. Must be in the future.
+     */
+    scheduled_at: IsoDate;
+    content: MessageContent;
+    context?: JsonObject;
+}
+/** A sequence with different copy per step. */
+export interface CreateScheduledSeriesInput extends ScheduledMessageBase {
+    /** The first step's moment; every `after` is measured from here. */
+    starts_at: IsoDate;
+    /** 1..365 steps, in any order -- they are sorted by `after` before expansion. */
+    steps: ScheduledMessageStep[];
+}
+/** A sequence repeating one message on a fixed cadence. */
+export interface CreateRepeatingScheduleInput extends ScheduledMessageBase {
+    starts_at: IsoDate;
+    repeat: ScheduleRepeat;
+    content: MessageContent;
+    context?: JsonObject;
+}
+/** Moves a `pending` occurrence. Anything else is a 409. */
+export interface RescheduleMessageInput {
+    scheduled_at: IsoDate;
+    /** Re-reads `scheduled_at` in a different zone. Defaults to the one already stored. */
+    timezone?: string;
+    title?: string;
+}
+export interface ListScheduledMessagesQuery extends ListQuery {
+    /** Everything queued for one contact. */
+    contact?: ObjectId;
+    /** One drip's occurrences. */
+    series?: ObjectId;
+    status?: ScheduledMessageStatus;
+    channel?: ObjectId;
+}
+/** What `cancelSeries` answers with. */
+export interface CancelSeriesResult {
+    series: ObjectId;
+    /** How many `pending` occurrences were stood down. Already-sent ones are untouched. */
+    cancelled: number;
+}
+export {};

package/dist/types/scheduled-message.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Scheduled messages: a send with a time, and optionally a condition checked
+ * immediately before it goes out.
+ *
+ * The condition is what makes a drip safe to set and forget. A sequence of five
+ * messages over two weeks is five rows; each one re-reads the contact a moment
+ * before sending and stands down if the contact no longer matches. So "stop
+ * messaging a lead once they convert" is a field on the contact changing, not a
+ * job anybody has to remember to cancel.
+ *
+ * Declared here rather than imported from `@crm/contracts` so the published
+ * package has no private dependencies; kept in step with the zod schemas.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=scheduled-message.js.map

package/dist/types/scheduled-message.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduled-message.js","sourceRoot":"","sources":["../../src/types/scheduled-message.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG"}