@remit/data-ports 0.0.83 → 0.0.85

package/dist/types.d.ts

@@ -0,0 +1,491 @@
+import type { AccountConfigSchema, AccountSchema, AddressSchema, BodyPartParameterSchema, BodyPartSchema, BodyPartStorageSchema, CalendarCollectionSchema, CalendarEventIndexSchema, CalendarFeedTokenSchema, CalendarObjectSchema, CalendarSuggestionSchema, ConfigImportSchema, ConfigImportUnresolvedRefSchema, EnvelopeAddressSchema, EnvelopeSchema, FilterSchema, LabelSchema, MailboxLockSchema, MailboxSchema, MailboxSpecialUseEntrySchema, MailboxSpecialUseSchema, MessageFlagPushSchema, MessageFlagSchema, MessageLabelSchema, MessagePlacementMoveSchema, MessageRecordSchema, OrganizeJobRequestSchema, OutboxAttachmentSchema, OutboxMessageSchema, QuarantineSchema, RawMessageStorageSchema, SenderSignerStandingSchema, SyncWarningSchema, ThreadMessageSchema } from "@remit/api-zod-schemas";
+import type { ReferenceType } from "@remit/domain-enums";
+import type { z } from "zod";
+export type ResultList<T> = {
+    items: T[];
+    continuationToken: string | undefined;
+};
+/**
+ * Page shape for internal, non-API-facing pagination (e.g. the scheduled-sync
+ * tick paging through every account). `cursor` is a raw backend-native token —
+ * unlike `ResultList.continuationToken` it carries no salt/tamper check, since
+ * it never crosses a trust boundary. `null` means no further pages.
+ */
+export type AccountSchedulerPage = {
+    items: AccountItem[];
+    cursor: string | null;
+};
+export type ListOptions = {
+    limit?: number;
+    continuationToken?: string;
+};
+export type AccountItem = z.infer<typeof AccountSchema>;
+export type AccountConfigItem = z.infer<typeof AccountConfigSchema>;
+export type MailboxItem = z.infer<typeof MailboxSchema>;
+export type ThreadMessageItem = z.infer<typeof ThreadMessageSchema>;
+export type OutboxMessageItem = z.infer<typeof OutboxMessageSchema>;
+export type OutboxAttachmentItem = z.infer<typeof OutboxAttachmentSchema>;
+export type MessageItem = z.infer<typeof MessageRecordSchema>;
+export type MessageFlagItem = z.infer<typeof MessageFlagSchema>;
+export type BodyPartItem = z.infer<typeof BodyPartSchema>;
+export type MessageReferenceItem = {
+    messageReferenceId: string;
+    messageId: string;
+    envelopeId: string;
+    messageIdValue: string;
+    referenceType: string;
+    referenceOrder: number;
+    createdAt: number;
+    updatedAt: number;
+};
+export type MessageReferenceInput = Pick<MessageReferenceItem, "messageIdValue" | "referenceOrder"> & {
+    referenceType: (typeof ReferenceType)[keyof typeof ReferenceType];
+};
+export type EnvelopeAddressItem = z.infer<typeof EnvelopeAddressSchema>;
+export type BodyPartParameterItem = z.infer<typeof BodyPartParameterSchema>;
+export type RawMessageStorageItem = z.infer<typeof RawMessageStorageSchema>;
+export type BodyPartStorageItem = z.infer<typeof BodyPartStorageSchema>;
+export type EnvelopeItem = z.infer<typeof EnvelopeSchema>;
+export type MailboxLockItem = z.infer<typeof MailboxLockSchema>;
+export type MailboxSpecialUseItem = z.infer<typeof MailboxSpecialUseEntrySchema>;
+export type AddressItem = z.infer<typeof AddressSchema>;
+export type LabelItem = z.infer<typeof LabelSchema>;
+export type MessageLabelItem = z.infer<typeof MessageLabelSchema>;
+export type FilterItem = z.infer<typeof FilterSchema>;
+export type MessagePlacementMoveItem = z.infer<typeof MessagePlacementMoveSchema>;
+export type MessageFlagPushItem = z.infer<typeof MessageFlagPushSchema>;
+export type QuarantineItem = z.infer<typeof QuarantineSchema>;
+export type QuarantineMimeNodeItem = QuarantineItem["structure"][number];
+/**
+ * What a caller supplies to quarantine a message.
+ *
+ * `quarantineId` is absent on purpose. The column carries a random-id default
+ * (the house pattern for every entity here), so an input that merely allowed
+ * the id would let a writer omit it, take a fresh random one on every retry,
+ * and turn the idempotent write this record depends on into an accumulating
+ * pile of rows that the derived-id lookup never finds. The repository derives
+ * it from the four fields that name the message, which are all required here.
+ */
+export type QuarantineUpsertInput = Omit<QuarantineItem, "quarantineId" | "createdAt" | "updatedAt" | "structure"> & {
+    structure?: QuarantineMimeNodeItem[];
+};
+export type SyncWarningItem = z.infer<typeof SyncWarningSchema>;
+export type SyncWarningKey = Pick<SyncWarningItem, "accountConfigId" | "accountId" | "mailboxId" | "uidValidity" | "uid" | "stage">;
+export type MailboxSpecialUseValue = z.infer<typeof MailboxSpecialUseSchema>;
+export type AccountSettingValue = {
+    kind: "Boolean";
+    value: boolean;
+} | {
+    kind: "String";
+    value: string;
+} | {
+    kind: "Number";
+    value: number;
+} | {
+    kind: "StringList";
+    value: string[];
+} | {
+    kind: "Map";
+    value: Record<string, string>;
+} | {
+    kind: "MutedFlag";
+    value: {
+        value: boolean;
+        setAt: number;
+        setBy?: string;
+        expiresAt?: number;
+        reason?: string;
+    };
+};
+export type AccountSettingItem = {
+    accountSettingId: string;
+    accountConfigId: string;
+    name: string;
+    value: AccountSettingValue;
+    createdAt: number;
+    updatedAt: number;
+};
+export type AccountExportRequestItem = {
+    accountExportRequestId: string;
+    accountConfigId: string;
+    userId: string;
+    state: "Failed" | "Pending" | "Processing" | "Ready";
+    createdAt: number;
+    updatedAt: number;
+    expiresAt?: number;
+    objectKey?: string;
+    downloadUrl?: string;
+    errorMessage?: string;
+};
+export type AccountDescription = {
+    account: AccountItem[];
+    mailbox: MailboxItem[];
+};
+export type AccountConfigDescription = {
+    accountConfig: AccountConfigItem[];
+    account: AccountItem[];
+    address: AddressItem[];
+};
+export type MessageData = {
+    envelope: EnvelopeItem[];
+    messageReference: MessageReferenceItem[];
+    envelopeAddress: EnvelopeAddressItem[];
+    bodyPart: BodyPartItem[];
+    bodyPartParameter: BodyPartParameterItem[];
+    rawMessageStorage: RawMessageStorageItem[];
+    bodyPartStorage: BodyPartStorageItem[];
+};
+export type MessageDescription = {
+    message: MessageItem[];
+    messageFlag: MessageFlagItem[];
+    envelope: EnvelopeItem[];
+    messageReference: MessageReferenceItem[];
+    envelopeAddress: EnvelopeAddressItem[];
+    bodyPart: BodyPartItem[];
+    bodyPartParameter: BodyPartParameterItem[];
+    rawMessageStorage: RawMessageStorageItem[];
+    bodyPartStorage: BodyPartStorageItem[];
+};
+export type WithMailboxLockResult<T> = {
+    executed: boolean;
+    result?: T;
+};
+export type CreateAccountInput = Omit<AccountItem, "accountId" | "createdAt" | "updatedAt" | "authType" | "smtpEnabled" | "smtpHost" | "smtpPort" | "smtpTls" | "smtpStartTls" | "smtpUsername" | "syncedServices" | "grantedScopes"> & {
+    accountId?: string;
+    authType?: AccountItem["authType"];
+    syncedServices?: AccountItem["syncedServices"];
+    grantedScopes?: AccountItem["grantedScopes"];
+    smtpEnabled?: AccountItem["smtpEnabled"];
+    smtpHost?: AccountItem["smtpHost"];
+    smtpPort?: AccountItem["smtpPort"];
+    smtpTls?: AccountItem["smtpTls"];
+    smtpStartTls?: AccountItem["smtpStartTls"];
+    smtpUsername?: AccountItem["smtpUsername"];
+};
+export type UpdateAccountInput = Partial<Omit<CreateAccountInput, "accountId" | "accountConfigId">>;
+export type RemovableAccountField = "lastError" | "lastConnectedAt" | "lastSyncAt" | "syncPhase";
+export type CreateAccountConfigInput = Omit<AccountConfigItem, "accountConfigId" | "createdAt" | "updatedAt" | "state"> & {
+    accountConfigId?: string;
+    state?: AccountConfigItem["state"];
+};
+export type UpdateAccountConfigInput = Partial<Omit<CreateAccountConfigInput, "userId">>;
+export type CreateAccountExportRequestInput = Omit<AccountExportRequestItem, "accountExportRequestId" | "createdAt" | "updatedAt">;
+export type UpdateAccountExportRequestInput = Partial<Pick<AccountExportRequestItem, "state" | "expiresAt" | "errorMessage"> & {
+    objectKey?: string;
+}>;
+export type OrganizeJobRequestItem = z.infer<typeof OrganizeJobRequestSchema>;
+export type CreateOrganizeJobRequestInput = Omit<OrganizeJobRequestItem, "organizeJobId" | "createdAt" | "updatedAt" | "state" | "matchedCount" | "appliedCount" | "failedCount" | "errorMessage"> & {
+    state?: OrganizeJobRequestItem["state"];
+};
+export type UpdateOrganizeJobRequestInput = Partial<Pick<OrganizeJobRequestItem, "state" | "matchedCount" | "appliedCount" | "failedCount" | "errorMessage">>;
+export type ConfigImportItem = z.infer<typeof ConfigImportSchema>;
+export type ConfigImportUnresolvedRefItem = z.infer<typeof ConfigImportUnresolvedRefSchema>;
+export type CreateConfigImportInput = Omit<ConfigImportItem, "importId" | "createdAt" | "updatedAt" | "state" | "completedAt"> & {
+    state?: ConfigImportItem["state"];
+    completedAt?: ConfigImportItem["completedAt"];
+};
+export type UpdateConfigImportInput = Partial<Pick<ConfigImportItem, "state" | "unresolvedRefs" | "completedAt">>;
+export type UpsertAccountSettingInput = {
+    accountConfigId: string;
+    name: string;
+    value: AccountSettingValue;
+};
+export type AddressFlags = NonNullable<AddressItem["flags"]>;
+export type FlagsMergePatch = {
+    [K in keyof AddressFlags]?: AddressFlags[K] | null;
+};
+export type CreateAddressInput = Omit<AddressItem, "addressId" | "createdAt" | "updatedAt" | "flags" | "inboundCount" | "outboundCount" | "replyCount" | "lastInboundAt" | "lastReplyAt"> & {
+    addressId: string;
+    flags?: AddressFlags;
+    inboundCount?: AddressItem["inboundCount"];
+    outboundCount?: AddressItem["outboundCount"];
+    replyCount?: AddressItem["replyCount"];
+    lastInboundAt?: AddressItem["lastInboundAt"];
+    lastReplyAt?: AddressItem["lastReplyAt"];
+};
+export type UpdateAddressInput = Partial<Omit<CreateAddressInput, "accountConfigId">>;
+export type CreateEnvelopeAddressInput = Omit<EnvelopeAddressItem, "envelopeAddressId" | "createdAt" | "updatedAt">;
+export type CreateEnvelopeInput = Omit<EnvelopeItem, "envelopeId" | "createdAt" | "updatedAt"> & {
+    envelopeId: string;
+};
+export type UpdateEnvelopeInput = Partial<Omit<CreateEnvelopeInput, "messageId">>;
+export type BodyPartParameterUpsertInput = {
+    parameterName: string;
+    parameterValue: string;
+};
+export type BodyPartUpsertInput = {
+    partPath: string;
+    parentPartPath: string | null;
+    mediaType: BodyPartItem["mediaType"];
+    mediaSubtype: string;
+    contentId?: string;
+    contentDescription?: string;
+    transferEncoding: BodyPartItem["transferEncoding"];
+    sizeOctets: number;
+    lineCount?: number;
+    md5Hash?: string;
+    disposition?: BodyPartItem["disposition"];
+    dispositionFilename?: string;
+    language?: string;
+    location?: string;
+    isMultipart: boolean;
+    multipartSubtype?: BodyPartItem["multipartSubtype"];
+    parameters: BodyPartParameterUpsertInput[];
+};
+/**
+ * A mailbox row as an insert states it. `pendingPath` is absent: a create
+ * records no rename target (folder-rename-and-delete.md T1), and the transition
+ * is the only writer of it.
+ */
+export type CreateMailboxInput = Omit<MailboxItem, "mailboxId" | "createdAt" | "updatedAt" | "namespaceType" | "parentMailboxId" | "cursorState" | "syncStatus" | "pendingPath" | "syncFailureReason"> & {
+    namespaceType?: MailboxItem["namespaceType"];
+    parentMailboxId?: MailboxItem["parentMailboxId"];
+    /** Total per RFC 032 (defaults to `normal`) — optional at the input boundary, callers rarely set it explicitly. */
+    cursorState?: MailboxItem["cursorState"];
+    /** Total per D1 (defaults to `synced`) — the insert paths that record an intent say so; the sweep's discovery insert does not have to. */
+    syncStatus?: MailboxItem["syncStatus"];
+};
+export type CreateMailboxResult = {
+    outcome: "Created";
+    mailbox: MailboxItem;
+} | {
+    outcome: "PathTaken";
+};
+/**
+ * Everything about a mailbox that is not its mutation state.
+ *
+ * `syncStatus` and `pendingPath` are omitted rather than merely discouraged
+ * (docs/architecture/folder-rename-and-delete.md D3): where they are gone from
+ * the only general-purpose writer, a folder state written without a predicate
+ * is a type error rather than a convention someone has to remember. The two
+ * doors are `transition` and `transitionSubtree`, and they are the whole set.
+ */
+export type UpdateMailboxInput = Partial<Omit<CreateMailboxInput, "accountId" | "syncStatus">>;
+/**
+ * The state a mailbox transition expects to find, as the six states this design
+ * defines rather than as the four enum values
+ * (docs/architecture/folder-rename-and-delete.md D3). `from` becomes an
+ * `IN (…)` term; `wherePendingPath` becomes an equality or an `IS NULL` term,
+ * and is omitted only by a caller that genuinely does not care which of the two
+ * states sharing a `syncStatus` it is looking at.
+ */
+export type MailboxStatePredicate = {
+    from: readonly MailboxItem["syncStatus"][];
+    wherePendingPath?: string | null;
+};
+/**
+ * What a winning mailbox transition writes. `pendingPath` takes `null` to
+ * clear, and is only honoured at all when the state being written is one that
+ * may carry a rename target — a transition to `synced` or `deleting` drops it
+ * whatever the caller passes, which is what makes the invariant hold by
+ * construction rather than by convention.
+ */
+export type MailboxTransitionWrite = {
+    fullPath?: string;
+    pendingPath?: string | null;
+    syncFailureReason?: string;
+};
+export type MailboxTransitionIntent = MailboxStatePredicate & {
+    to: MailboxItem["syncStatus"];
+    set?: MailboxTransitionWrite;
+};
+/**
+ * A subtree intent recorded all-or-nothing (D6): every row of the subtree takes
+ * `newPath` in place of the named folder's path as its `pendingPath`. It
+ * carries no `wherePendingPath`: its accepted from-states are `synced` and the
+ * two failed variants, and both failed variants are legal starting points.
+ */
+export type MailboxSubtreeTransitionIntent = {
+    from: readonly MailboxItem["syncStatus"][];
+    to: MailboxItem["syncStatus"];
+    newPath: string;
+};
+export type CreateMessageInput = Omit<MessageItem, "messageId" | "createdAt" | "updatedAt" | "status" | "syncStatus" | "abandonedMutation" | "category" | "classificationState" | "authenticityVerdict" | "hasListUnsubscribe" | "movedByRemit"> & {
+    messageId: string;
+    status?: MessageItem["status"];
+    syncStatus?: MessageItem["syncStatus"];
+    abandonedMutation?: MessageItem["abandonedMutation"];
+    category?: MessageItem["category"];
+    classificationState?: MessageItem["classificationState"];
+    authenticityVerdict?: MessageItem["authenticityVerdict"];
+    hasListUnsubscribe?: MessageItem["hasListUnsubscribe"];
+    movedByRemit?: MessageItem["movedByRemit"];
+};
+/**
+ * Everything about a message that is not its placement.
+ *
+ * The six placement fields are omitted rather than merely discouraged
+ * (docs/architecture/imap-mutations.md R3): where they are gone from the only
+ * general-purpose writer, a placement written without a predicate is a type
+ * error rather than a convention someone has to remember. `transitionPlacement`,
+ * `repointIfPlacement` and the settle in `updateUid` are the doors, and they
+ * are the whole set.
+ */
+export type UpdateMessageInput = Partial<Omit<CreateMessageInput, "mailboxId" | "uid" | "status" | "syncStatus" | "abandonedMutation" | "originalMailboxId" | "originalUid">>;
+/**
+ * The placement a transition expects to find, as the caller read it
+ * (docs/architecture/imap-mutations.md R3). Every field named here becomes a
+ * term of the UPDATE's WHERE clause; what the caller did not read, it does not
+ * supply. `syncStatus` takes a set because several of the six placement states
+ * share one `status`.
+ */
+export type PlacementPredicate = {
+    status?: MessageItem["status"] | readonly MessageItem["status"][];
+    syncStatus?: MessageItem["syncStatus"] | readonly MessageItem["syncStatus"][];
+    mailboxId?: string;
+    uid?: number;
+};
+/**
+ * What a winning transition writes. `originalMailboxId` and `originalUid` take
+ * `null` to clear, which is how a settle spells a dropped pre-move pair.
+ */
+export type PlacementTransitionInput = {
+    status?: MessageItem["status"];
+    syncStatus?: MessageItem["syncStatus"];
+    abandonedMutation?: MessageItem["abandonedMutation"];
+    mailboxId?: string;
+    uid?: number;
+    originalMailboxId?: string | null;
+    originalUid?: number | null;
+};
+export type MessageIdSource = {
+    messageId?: string;
+    uid: number;
+    mailboxId: string;
+    date?: string;
+    subject?: string;
+    fromMailbox?: string;
+    fromHost?: string;
+};
+export type CreateMessageFlagInput = Omit<MessageFlagItem, "messageFlagId" | "createdAt" | "updatedAt">;
+export type PutMessagePlacementMoveInput = Omit<MessagePlacementMoveItem, "state" | "createdAt" | "updatedAt">;
+export type PutMessageFlagPushInput = Omit<MessageFlagPushItem, "state" | "createdAt" | "updatedAt">;
+export type CreateOutboxMessageInput = Omit<OutboxMessageItem, "outboxMessageId" | "createdAt" | "updatedAt" | "ccAddresses" | "bccAddresses" | "references" | "appendedUid"> & {
+    ccAddresses?: string[];
+    bccAddresses?: string[];
+    references?: string[];
+};
+export type UpdateOutboxMessageInput = Partial<Pick<OutboxMessageItem, "status" | "lastError" | "lastSmtpCode" | "sentAt" | "smtpMessageId" | "appendedUid" | "toAddresses" | "ccAddresses" | "bccAddresses" | "subject" | "textBody" | "htmlBody" | "inReplyTo" | "references">>;
+export type CreateThreadMessageInput = Omit<ThreadMessageItem, "threadMessageId" | "createdAt" | "updatedAt" | "star" | "category"> & {
+    star?: ThreadMessageItem["star"];
+    category?: ThreadMessageItem["category"];
+};
+export type UpdateThreadMessageInput = Partial<Omit<CreateThreadMessageInput, "accountConfigId" | "threadId" | "messageId">>;
+/**
+ * One substring criterion over a text column of a ThreadMessage row, named by
+ * the column it selects on rather than by whatever rule derived it. `sender`
+ * covers the From address and display name together, the same pair
+ * `SearchOptions.from` reads.
+ *
+ * Matching is accent- and case-insensitive substring, identical to the search
+ * predicates, so a term is a NARROWING a caller refines further in memory. It
+ * may return more than the criterion it stands for and never less — a term an
+ * implementation cannot evaluate faithfully is dropped, not approximated.
+ */
+export type ThreadMessageFieldTerm = {
+    field: "sender" | "subject" | "listId";
+    contains: string;
+};
+export type SearchOptions = {
+    query?: string;
+    subject?: string;
+    from?: string;
+    unread?: boolean;
+    starred?: boolean;
+    attachments?: boolean;
+    /**
+     * Whether the From address is muted, as a three-state filter: `false`
+     * excludes muted senders, `true` keeps only them, absent filters nothing.
+     *
+     * The one criterion here that is not a column on the ThreadMessage row —
+     * muting is a flag on the Address, reached through the row's `fromEmail` —
+     * and it is a predicate rather than a pass over a page for the same reason
+     * every other criterion is: a caller that hides muted mail while counting
+     * with it in states a number larger than the list it renders (#1137).
+     */
+    muted?: boolean;
+    /**
+     * Any-of set over the denormalized `category` column on the ThreadMessage
+     * row. An empty or absent set means no category filter. `uncategorized` is
+     * a member like any other — the column is NOT NULL with that default, so it
+     * names "no category" rather than standing for absence (issue #45). It
+     * matches mail the classifier has not reached and mail it declined to
+     * categorize alike; `Message.classificationState` is what separates those,
+     * and no read path filters on it (issue #331).
+     */
+    category?: ThreadMessageItem["category"][];
+};
+export type CreateLabelInput = Omit<LabelItem, "labelId" | "normalizedName" | "createdAt" | "updatedAt" | "color"> & {
+    color?: LabelItem["color"];
+};
+export type UpdateLabelInput = Partial<Pick<LabelItem, "name" | "normalizedName" | "color">>;
+export type CreateMessageLabelInput = Omit<MessageLabelItem, "messageLabelId" | "createdAt" | "updatedAt" | "appliedByFilterId"> & {
+    appliedByFilterId?: MessageLabelItem["appliedByFilterId"];
+};
+export type CreateFilterInput = Omit<FilterItem, "filterId" | "createdAt" | "updatedAt" | "state" | "disabledReason" | "ruleChangedAt" | "actionChangedAt" | "matchOperator" | "actionLabelId" | "actionMailboxId"> & {
+    state?: FilterItem["state"];
+    disabledReason?: FilterItem["disabledReason"];
+    matchOperator?: FilterItem["matchOperator"];
+    actionLabelId?: FilterItem["actionLabelId"];
+    actionMailboxId?: FilterItem["actionMailboxId"];
+};
+export type UpdateFilterInput = Partial<Omit<CreateFilterInput, "accountConfigId">>;
+export type CalendarCollectionItem = z.infer<typeof CalendarCollectionSchema>;
+export type CalendarObjectItem = z.infer<typeof CalendarObjectSchema>;
+export type CalendarEventIndexItem = z.infer<typeof CalendarEventIndexSchema>;
+export type CreateCalendarCollectionInput = Omit<CalendarCollectionItem, "calendarId" | "syncSequence" | "createdAt" | "updatedAt" | "color" | "componentSet" | "source" | "timezone" | "subscriptionUrl" | "subscriptionEnabled" | "subscriptionCheckedAt" | "subscriptionFetchedAt" | "subscriptionError"> & {
+    color?: CalendarCollectionItem["color"];
+    componentSet?: CalendarCollectionItem["componentSet"];
+    source?: CalendarCollectionItem["source"];
+    timezone?: CalendarCollectionItem["timezone"];
+    subscriptionUrl?: CalendarCollectionItem["subscriptionUrl"];
+    subscriptionEnabled?: CalendarCollectionItem["subscriptionEnabled"];
+};
+export type UpdateCalendarCollectionInput = Partial<Pick<CalendarCollectionItem, "displayName" | "color" | "timezone" | "subscriptionEnabled" | "subscriptionCheckedAt" | "subscriptionFetchedAt" | "subscriptionError">>;
+export type CalendarFeedTokenItem = z.infer<typeof CalendarFeedTokenSchema>;
+export type PutCalendarFeedTokenInput = Omit<CalendarFeedTokenItem, "feedTokenId" | "rotatedAt" | "createdAt" | "updatedAt">;
+/**
+ * A whole calendar resource. Every projected column is supplied together with
+ * the `icalData` it was projected from — the repository never derives one from
+ * the other, so the projection can only ever be produced by the one place that
+ * owns it (`@remit/calendar-service`) and can never drift from the bytes.
+ *
+ * `calendarObjectId` is derived from calendarId + resourceName, so this is an
+ * upsert: writing the same resource twice rewrites its own row.
+ */
+export type PutCalendarObjectInput = Omit<CalendarObjectItem, "calendarObjectId" | "createdAt" | "updatedAt">;
+/**
+ * One expanded occurrence. Written only as part of a full replacement of a
+ * resource's occurrences — there is no single-occurrence write, because a row
+ * here is never authoritative and never edited in place.
+ */
+export type CalendarOccurrenceInput = Omit<CalendarEventIndexItem, "calendarId" | "calendarObjectId" | "createdAt" | "updatedAt">;
+export type CalendarSuggestionItem = z.infer<typeof CalendarSuggestionSchema>;
+/**
+ * A whole suggestion, as the producer read it out of a message. Every field is
+ * derived from the message — nothing here is client-supplied — and
+ * `suggestionId` is derived from messageId + bodyPartId + icalUid, so this is
+ * an upsert: re-reading the same message rewrites its own row rather than
+ * stacking a second card on the message.
+ *
+ * `state` and `acceptedCalendarObjectId` are excluded: a producer only ever
+ * writes a `Pending` suggestion, and the two fields that record what a person
+ * decided move exclusively through `settle`, so a re-sync can never walk an
+ * answered card back to Pending. `supersededByMessageId` moves only through
+ * `supersedeIfPending`, with the state it explains.
+ */
+export type PutCalendarSuggestionInput = Omit<CalendarSuggestionItem, "suggestionId" | "state" | "acceptedCalendarObjectId" | "supersededByMessageId" | "createdAt" | "updatedAt">;
+export type SenderSignerStandingItem = z.infer<typeof SenderSignerStandingSchema>;
+/**
+ * One message observed arriving for a `(senderKey, signerDomain)` pair.
+ *
+ * `observedAt` is supplied rather than taken from the clock so a caller
+ * replaying a body-sync batch records the arrival's own time, and so the
+ * `firstSeenAt`-immutability contract is assertable without sleeping.
+ */
+export type ObserveSenderSignerStandingInput = {
+    accountConfigId: string;
+    senderKey: string;
+    signerDomain: string;
+    observedAt: number;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/update-manifest.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+export declare const SUMMARY_MAX_LENGTH = 140;
+export declare const UpdateManifestSchema: z.ZodObject<{
+    version: z.ZodString;
+    publishedAt: z.ZodString;
+    summary: z.ZodString;
+    releaseNotesUrl: z.ZodEffects<z.ZodString, string, string>;
+    registry: z.ZodString;
+    schemaVersion: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    summary: string;
+    version: string;
+    publishedAt: string;
+    releaseNotesUrl: string;
+    registry: string;
+    schemaVersion?: number | undefined;
+}, {
+    summary: string;
+    version: string;
+    publishedAt: string;
+    releaseNotesUrl: string;
+    registry: string;
+    schemaVersion?: number | undefined;
+}>;

package/dist/update-manifest.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export const SUMMARY_MAX_LENGTH = 140;
+export const UpdateManifestSchema = z.object({
+    version: z.string().regex(/^v\d+\.\d+\.\d+$/),
+    publishedAt: z.string().datetime(),
+    summary: z.string().min(1).max(SUMMARY_MAX_LENGTH),
+    releaseNotesUrl: z
+        .string()
+        .url()
+        .refine((url) => url.startsWith("https://"), {
+        message: "releaseNotesUrl must be an https:// URL",
+    }),
+    registry: z.string().min(1),
+    // The highest schema migration the release applies, as a count of the
+    // migrations shipped at that release. The updater compares it against the
+    // running instance's version to tell whether installing this release runs a
+    // migration. Optional so a manifest published before this field validates and
+    // reads as an unknown schema version rather than an error.
+    schemaVersion: z.number().int().nonnegative().optional(),
+});

package/dist/virtual-copy.d.ts

@@ -0,0 +1,8 @@
+import type { MailboxItem } from "./types.js";
+/**
+ * Whether this folder holds mail that also lives in a real folder. Such a
+ * folder is a view, not a filing location: seeing a message in it says nothing
+ * about where the message was filed, so it neither picks which duplicate a
+ * listing drops nor decides where a message lives.
+ */
+export declare const isVirtualCopyMailbox: (mailbox: MailboxItem) => boolean;

package/{src/virtual-copy.ts → dist/virtual-copy.js}

@@ -1,33 +1,28 @@
 import { MailboxSpecialUse } from "@remit/domain-enums";
-import type { MailboxItem } from "./types.js";
-
 /**
  * Special-use folders that hold a second copy of mail already reachable through
  * the folder it actually lives in — Gmail's All Mail, Starred and Important.
  */
-const VIRTUAL_COPY_SPECIAL_USE: readonly string[] = [
-	MailboxSpecialUse.All,
-	MailboxSpecialUse.Flagged,
-	MailboxSpecialUse.Important,
+const VIRTUAL_COPY_SPECIAL_USE = [
+    MailboxSpecialUse.All,
+    MailboxSpecialUse.Flagged,
+    MailboxSpecialUse.Important,
 ];
-
 /**
  * Well-known Gmail virtual paths, for servers that do not advertise the
  * special-use attribute. Whole path, never a prefix — a user's own
  * `Starred ideas` folder is real mail.
  */
-const VIRTUAL_COPY_FULL_PATHS: readonly string[] = [
-	"[gmail]/all mail",
-	"[gmail]/starred",
-	"[gmail]/important",
+const VIRTUAL_COPY_FULL_PATHS = [
+    "[gmail]/all mail",
+    "[gmail]/starred",
+    "[gmail]/important",
 ];
-
 /**
  * Whether this folder holds mail that also lives in a real folder. Such a
  * folder is a view, not a filing location: seeing a message in it says nothing
  * about where the message was filed, so it neither picks which duplicate a
  * listing drops nor decides where a message lives.
  */
-export const isVirtualCopyMailbox = (mailbox: MailboxItem): boolean =>
-	mailbox.specialUse?.some((use) => VIRTUAL_COPY_SPECIAL_USE.includes(use)) ===
-		true || VIRTUAL_COPY_FULL_PATHS.includes(mailbox.fullPath.toLowerCase());
+export const isVirtualCopyMailbox = (mailbox) => mailbox.specialUse?.some((use) => VIRTUAL_COPY_SPECIAL_USE.includes(use)) ===
+    true || VIRTUAL_COPY_FULL_PATHS.includes(mailbox.fullPath.toLowerCase());

package/dist/wellknown.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Wellknown promotion rule (issue #233).
+ *
+ * Pure predicate over an Address engagement snapshot. Returns `true` when
+ * the address should be auto-promoted to `flags.wellknown.value === true`.
+ *
+ * Three conjuncts:
+ *   1. `flags.wellknown.value` is not already `true` (idempotent).
+ *   2. Engagement threshold:
+ *      - `replyCount >= 1` always promotes (a real two-way conversation).
+ *      - `inboundCount >= 3` promotes ONLY for non-bulk senders. Bulk senders
+ *        (newsletters, marketing, automated, or List-Unsubscribe present) reach
+ *        high inbound counts by volume alone — that is not engagement. Only a
+ *        real reply from the user (`replyCount >= 1`) promotes a bulk sender.
+ *   3. `lastInboundAt` exists and is within the last 90 days
+ *      (keeps dormant senders from being promoted by stale counters).
+ *
+ * The body-sync inbound path always writes `lastInboundAt = now`, so the
+ * 90-day check trivially passes there. The SMTP reply path reads the
+ * existing `lastInboundAt` (the user is replying to an inbound, which
+ * implies a recent inbound, but we still gate on it explicitly).
+ */
+export declare const WELLKNOWN_INBOUND_THRESHOLD = 3;
+export declare const WELLKNOWN_REPLY_THRESHOLD = 1;
+export declare const WELLKNOWN_INBOUND_WINDOW_MS: number;
+export interface WellknownEngagementSnapshot {
+    inboundCount?: number;
+    replyCount?: number;
+    lastInboundAt?: number;
+    /**
+     * Whether this sender is a bulk/automated sender (newsletter, marketing,
+     * automated category, or List-Unsubscribe header present). Bulk senders
+     * can only be promoted via `replyCount >= 1`, not by inbound volume.
+     */
+    isBulk?: boolean;
+    flags?: {
+        wellknown?: {
+            value: boolean;
+        } | undefined;
+    };
+}
+export declare const shouldPromoteWellknown: (snapshot: WellknownEngagementSnapshot, now: number) => boolean;
+/**
+ * Returns true when the category or presence of List-Unsubscribe marks the
+ * sender as bulk, meaning they cannot be promoted by inbound volume alone.
+ */
+export declare function isBulkSender(category: string | undefined, hasListUnsubscribe: boolean): boolean;