@remit/data-ports 0.0.83 → 0.0.85

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+export { deriveFilterTtl } from "./filter-ttl.js";
+export type { IAccountRepository } from "./interfaces/account.js";
+export type { IAccountConfigRepository } from "./interfaces/account-config.js";
+export type { IAccountExportRequestRepository } from "./interfaces/account-export-request.js";
+export type { IAccountSettingRepository } from "./interfaces/account-setting.js";
+export type { IAddressRepository } from "./interfaces/address.js";
+export type { ICalendarCollectionRepository } from "./interfaces/calendar-collection.js";
+export type { ICalendarEventIndexRepository } from "./interfaces/calendar-event-index.js";
+export type { ICalendarFeedTokenRepository } from "./interfaces/calendar-feed-token.js";
+export type { ICalendarObjectRepository } from "./interfaces/calendar-object.js";
+export type { CalendarRepositories, CalendarWrite, DeleteCalendarCollectionWrite, DeleteCalendarObjectWrite, ICalendarStore, PutCalendarObjectWrite, ReprojectCalendarObjectWrite, SettleCalendarSuggestionWrite, UpdateCalendarCollectionWrite, } from "./interfaces/calendar-store.js";
+export type { ICalendarSuggestionRepository, SettleCalendarSuggestionInput, } from "./interfaces/calendar-suggestion.js";
+export type { IConfigImportRepository } from "./interfaces/config-import.js";
+export type { IEnvelopeRepository } from "./interfaces/envelope.js";
+export type { IFilterRepository } from "./interfaces/filter.js";
+export type { ILabelRepository } from "./interfaces/label.js";
+export type { IMailboxRepository } from "./interfaces/mailbox.js";
+export type { IMailboxLockRepository } from "./interfaces/mailbox-lock.js";
+export type { IMailboxSpecialUseRepository } from "./interfaces/mailbox-special-use.js";
+export type { IMessageRepository } from "./interfaces/message.js";
+export type { IMessageFlagRepository } from "./interfaces/message-flag.js";
+export type { IMessageFlagPushRepository } from "./interfaces/message-flag-push.js";
+export type { IMessageLabelRepository } from "./interfaces/message-label.js";
+export type { IMessagePlacementMoveRepository } from "./interfaces/message-placement-move.js";
+export type { IOrganizeJobRequestRepository } from "./interfaces/organize-job-request.js";
+export type { CreateOutboxAttachmentInput, IOutboxAttachmentRepository, OutboxAttachmentCap, ReserveOutboxAttachmentResult, } from "./interfaces/outbox-attachment.js";
+export { holdsRoom } from "./interfaces/outbox-attachment.js";
+export type { IOutboxMessageRepository } from "./interfaces/outbox-message.js";
+export { APPENDED_UID_NONE, APPENDED_UID_UNREPORTED, isSentCopyFiled, } from "./interfaces/outbox-message.js";
+export type { IQuarantineRepository } from "./interfaces/quarantine.js";
+export type { ISenderSignerStandingRepository } from "./interfaces/sender-signer-standing.js";
+export type { ISyncWarningRepository, SurfacedSyncWarnings, } from "./interfaces/sync-warning.js";
+export type { IThreadMessageRepository } from "./interfaces/thread-message.js";
+export type { MessageSettlementFields } from "./message-settlement.js";
+export { abandonedMutationOf, hasAbandonedDelete, hasAbandonedMove, } from "./message-settlement.js";
+export { FILTER_NO_ACTION, isSenderMuted, isSenderMuteFilter, } from "./sender-mute.js";
+export type { AccountConfigDescription, AccountConfigItem, AccountDescription, AccountExportRequestItem, AccountItem, AccountSchedulerPage, AccountSettingItem, AccountSettingValue, AddressFlags, AddressItem, BodyPartItem, BodyPartParameterItem, BodyPartParameterUpsertInput, BodyPartStorageItem, BodyPartUpsertInput, CalendarCollectionItem, CalendarEventIndexItem, CalendarFeedTokenItem, CalendarObjectItem, CalendarOccurrenceInput, CalendarSuggestionItem, ConfigImportItem, ConfigImportUnresolvedRefItem, CreateAccountConfigInput, CreateAccountExportRequestInput, CreateAccountInput, CreateAddressInput, CreateCalendarCollectionInput, CreateConfigImportInput, CreateEnvelopeAddressInput, CreateEnvelopeInput, CreateFilterInput, CreateLabelInput, CreateMailboxInput, CreateMailboxResult, CreateMessageFlagInput, CreateMessageInput, CreateMessageLabelInput, CreateOrganizeJobRequestInput, CreateOutboxMessageInput, CreateThreadMessageInput, EnvelopeAddressItem, EnvelopeItem, FilterItem, FlagsMergePatch, LabelItem, ListOptions, MailboxItem, MailboxLockItem, MailboxSpecialUseItem, MailboxSpecialUseValue, MailboxStatePredicate, MailboxSubtreeTransitionIntent, MailboxTransitionIntent, MailboxTransitionWrite, MessageData, MessageDescription, MessageFlagItem, MessageFlagPushItem, MessageIdSource, MessageItem, MessageLabelItem, MessagePlacementMoveItem, MessageReferenceInput, MessageReferenceItem, ObserveSenderSignerStandingInput, OrganizeJobRequestItem, OutboxAttachmentItem, OutboxMessageItem, PlacementPredicate, PlacementTransitionInput, PutCalendarFeedTokenInput, PutCalendarObjectInput, PutCalendarSuggestionInput, PutMessageFlagPushInput, PutMessagePlacementMoveInput, QuarantineItem, QuarantineMimeNodeItem, QuarantineUpsertInput, RawMessageStorageItem, RemovableAccountField, ResultList, SearchOptions, SenderSignerStandingItem, SyncWarningItem, SyncWarningKey, ThreadMessageFieldTerm, ThreadMessageItem, UpdateAccountConfigInput, UpdateAccountExportRequestInput, UpdateAccountInput, UpdateAddressInput, UpdateCalendarCollectionInput, UpdateConfigImportInput, UpdateEnvelopeInput, UpdateFilterInput, UpdateLabelInput, UpdateMailboxInput, UpdateMessageInput, UpdateOrganizeJobRequestInput, UpdateOutboxMessageInput, UpdateThreadMessageInput, UpsertAccountSettingInput, WithMailboxLockResult, } from "./types.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+export { deriveFilterTtl } from "./filter-ttl.js";
+export { holdsRoom } from "./interfaces/outbox-attachment.js";
+export { APPENDED_UID_NONE, APPENDED_UID_UNREPORTED, isSentCopyFiled, } from "./interfaces/outbox-message.js";
+export { abandonedMutationOf, hasAbandonedDelete, hasAbandonedMove, } from "./message-settlement.js";
+export { FILTER_NO_ACTION, isSenderMuted, isSenderMuteFilter, } from "./sender-mute.js";

package/dist/interfaces/account-config.d.ts

@@ -0,0 +1,15 @@
+import type { AccountConfigDescription, AccountConfigItem, CreateAccountConfigInput, ResultList, UpdateAccountConfigInput } from "../types.js";
+export interface IAccountConfigRepository {
+    create(input: CreateAccountConfigInput): Promise<AccountConfigItem>;
+    get(accountConfigId: string): Promise<AccountConfigItem>;
+    get(accountConfigIds: string[]): Promise<AccountConfigItem[]>;
+    update(accountConfigId: string, input: UpdateAccountConfigInput): Promise<AccountConfigItem>;
+    delete(accountConfigId: string): Promise<void>;
+    deleteMany(accountConfigIds: string[]): Promise<void>;
+    listByUser(userId: string, options?: {
+        limit?: number;
+        continuationToken?: string;
+    }): Promise<ResultList<AccountConfigItem>>;
+    describe(accountConfigId: string): Promise<AccountConfigDescription>;
+    listAll(): Promise<AccountConfigItem[]>;
+}

package/dist/interfaces/account-config.js

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

package/dist/interfaces/account-export-request.d.ts

@@ -0,0 +1,10 @@
+import type { AccountExportRequestItem, CreateAccountExportRequestInput, ResultList, UpdateAccountExportRequestInput } from "../types.js";
+export interface IAccountExportRequestRepository {
+    create(input: CreateAccountExportRequestInput): Promise<AccountExportRequestItem>;
+    get(accountExportRequestId: string): Promise<AccountExportRequestItem>;
+    update(accountExportRequestId: string, input: UpdateAccountExportRequestInput): Promise<AccountExportRequestItem>;
+    listByAccountConfig(accountConfigId: string, options?: {
+        limit?: number;
+        continuationToken?: string;
+    }): Promise<ResultList<AccountExportRequestItem>>;
+}

package/dist/interfaces/account-export-request.js

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

package/dist/interfaces/account-setting.d.ts

@@ -0,0 +1,8 @@
+import type { AccountSettingItem, UpsertAccountSettingInput } from "../types.js";
+export interface IAccountSettingRepository {
+    get(accountConfigId: string, name: string): Promise<AccountSettingItem | null>;
+    getMany(accountConfigIds: readonly string[], names: readonly string[]): Promise<AccountSettingItem[]>;
+    listByAccountConfig(accountConfigId: string): Promise<AccountSettingItem[]>;
+    upsert(input: UpsertAccountSettingInput): Promise<AccountSettingItem>;
+    delete(accountConfigId: string, name: string): Promise<void>;
+}

package/dist/interfaces/account-setting.js

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

package/dist/interfaces/account.d.ts

@@ -0,0 +1,29 @@
+import type { AccountDescription, AccountItem, AccountSchedulerPage, CreateAccountInput, RemovableAccountField, ResultList, UpdateAccountInput } from "../types.js";
+export interface IAccountRepository {
+    create(input: CreateAccountInput): Promise<AccountItem>;
+    get(accountId: string): Promise<AccountItem>;
+    get(accountIds: string[]): Promise<AccountItem[]>;
+    update(accountId: string, input: UpdateAccountInput, remove?: RemovableAccountField[]): Promise<AccountItem>;
+    markAuthenticated(accountId: string): Promise<AccountItem>;
+    delete(accountId: string): Promise<void>;
+    deleteMany(accountIds: string[]): Promise<void>;
+    list(accountConfigId: string, options?: {
+        limit?: number;
+        continuationToken?: string;
+    }): Promise<ResultList<AccountItem>>;
+    listAllByAccountConfig(accountConfigId: string): Promise<AccountItem[]>;
+    listMailSourcesByAccountConfig(accountConfigId: string): Promise<AccountItem[]>;
+    describe(accountId: string): Promise<AccountDescription>;
+    listAll(): Promise<AccountItem[]>;
+    incrementMailboxSynced(accountId: string): Promise<AccountItem>;
+    /**
+     * Page through every account system-wide, oldest-created first, for the
+     * scheduled-sync tick (#1247). Unlike `list()` this is not accountConfig
+     * scoped and the cursor is a raw backend-native token (no salt/tamper
+     * checking) — internal use only, never exposed over the API.
+     */
+    listAllAccountsPage(options?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<AccountSchedulerPage>;
+}

package/dist/interfaces/account.js

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

package/dist/interfaces/address.d.ts

@@ -0,0 +1,70 @@
+import type { JunkRoleMailboxes } from "../folder-role.js";
+import type { AddressItem, CreateAddressInput, CreateEnvelopeAddressInput, EnvelopeAddressItem, FlagsMergePatch, ResultList, UpdateAddressInput } from "../types.js";
+export interface IAddressRepository {
+    createAddress(input: CreateAddressInput): Promise<AddressItem>;
+    upsertAddress(input: CreateAddressInput): Promise<AddressItem>;
+    upsertCorrespondentAddress(input: CreateAddressInput): Promise<AddressItem>;
+    upsertJunkAddress(input: CreateAddressInput): Promise<AddressItem>;
+    /**
+     * `roles` covers every account under the message's config, resolved by the
+     * caller once per batch: this runs inside the per-message sync loop, and
+     * role resolution is deliberately uncached.
+     */
+    reconcileJunkOnlyForMessage(messageId: string, roles: JunkRoleMailboxes): Promise<void>;
+    getAddress(accountConfigId: string, addressId: string): Promise<AddressItem>;
+    getAddress(accountConfigId: string, addressIds: string[]): Promise<AddressItem[]>;
+    updateAddress(accountConfigId: string, addressId: string, input: UpdateAddressInput): Promise<AddressItem>;
+    mergeFlags(accountConfigId: string, addressId: string, patch: FlagsMergePatch): Promise<AddressItem>;
+    promoteWellknownByUser(accountConfigId: string, addressId: string, now: number): Promise<AddressItem>;
+    demoteSenderTrust(accountConfigId: string, addressId: string, now: number): Promise<AddressItem>;
+    deleteAddress(accountConfigId: string, addressId: string): Promise<void>;
+    incrementInboundCount(accountConfigId: string, addressId: string, now: number, isBulk?: boolean): Promise<void>;
+    incrementOutboundCount(accountConfigId: string, addressId: string, now: number): Promise<void>;
+    incrementReplyCount(accountConfigId: string, addressId: string, now: number): Promise<void>;
+    deleteManyAddresses(accountConfigId: string, addressIds: string[]): Promise<void>;
+    listSuggestedVips(input: {
+        accountConfigId: string;
+        limit?: number;
+    }): Promise<AddressItem[]>;
+    /**
+     * The account's addresses, most worth suggesting first: where the search term
+     * hit — the start of a value before the middle of one, and the display name
+     * before the local part, the domain and the whole address — then the account's
+     * standing for the sender, how much it corresponds with it, how recently, and
+     * the stored compound and id last so the order is total. Without a term every
+     * row scores the same match, so the remaining keys decide and the listing comes
+     * back by standing, correspondence and recency rather than alphabetically.
+     */
+    listByAccountConfig(input: {
+        accountConfigId: string;
+        /**
+         * Matched as a substring of the display name, the local part, the domain
+         * and the whole address, so `po`, `locatie`, `amsterdam`, `pocahondas.nl`
+         * and `amsterdam@pocahondas.nl` all resolve
+         * `Pocahondas locatie amsterdam <amsterdam@pocahondas.nl>`. A name outside
+         * ASCII (`Öz` for `Özcan Bakker`) resolves through the folded compound.
+         */
+        search?: string;
+        cursor?: string;
+        limit?: number;
+    }): Promise<ResultList<AddressItem>>;
+    /**
+     * Every address stored under the configuration, for a reader that must see
+     * the whole set: nothing is hidden, so a row the machine marked `junkOnly`
+     * still comes back with whatever the user decided about it. Ordered by
+     * `addressId`, which no write moves, so a page boundary cannot skip a row
+     * while message sync updates counts and timestamps underneath the read.
+     */
+    listAllByAccountConfigPage(input: {
+        accountConfigId: string;
+        cursor?: string;
+        limit?: number;
+    }): Promise<ResultList<AddressItem>>;
+    listAllByAccountConfig(accountConfigId: string): Promise<AddressItem[]>;
+    createEnvelopeAddress(input: CreateEnvelopeAddressInput): Promise<EnvelopeAddressItem>;
+    upsertEnvelopeAddress(input: CreateEnvelopeAddressInput): Promise<EnvelopeAddressItem>;
+    getEnvelopeAddress(envelopeAddressId: string): Promise<EnvelopeAddressItem>;
+    getEnvelopeAddress(envelopeAddressIds: string[]): Promise<EnvelopeAddressItem[]>;
+    deleteEnvelopeAddress(envelopeAddressId: string): Promise<void>;
+    deleteManyEnvelopeAddresses(envelopeAddressIds: string[]): Promise<void>;
+}

package/dist/interfaces/address.js

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

package/dist/interfaces/calendar-collection.d.ts

@@ -0,0 +1,38 @@
+import type { CalendarCollectionItem, CreateCalendarCollectionInput, UpdateCalendarCollectionInput } from "../types.js";
+export interface ICalendarCollectionRepository {
+    /**
+     * Writes the collection under its derived `calendarId`. Provisioning the
+     * same `(accountConfigId, urlSegment)` twice returns the existing row rather
+     * than a second one, so first-use provisioning is safe to run on every
+     * request without a prior read.
+     */
+    create(input: CreateCalendarCollectionInput): Promise<CalendarCollectionItem>;
+    /**
+     * Writes the collection, or answers `null` when its `urlSegment` is already
+     * taken in this account config.
+     *
+     * The distinction from `create` is who asked. Provisioning wants the row
+     * whoever got there first wrote; a person naming a calendar wants to be told
+     * the name is taken, and handing them somebody else's calendar instead is a
+     * silent merge of two things they meant to keep apart.
+     */
+    createExclusive(input: CreateCalendarCollectionInput): Promise<CalendarCollectionItem | null>;
+    get(accountConfigId: string, calendarId: string): Promise<CalendarCollectionItem>;
+    update(accountConfigId: string, calendarId: string, input: UpdateCalendarCollectionInput): Promise<CalendarCollectionItem>;
+    delete(accountConfigId: string, calendarId: string): Promise<void>;
+    listByAccountConfig(accountConfigId: string): Promise<CalendarCollectionItem[]>;
+    /**
+     * Every `Subscribed` collection whose refresh is on, across all account
+     * configs. The scheduled refresh walks this; a disabled subscription is
+     * absent, which is what stops its refresh.
+     */
+    listEnabledSubscriptions(): Promise<CalendarCollectionItem[]>;
+    findByUrlSegment(accountConfigId: string, urlSegment: string): Promise<CalendarCollectionItem | null>;
+    /**
+     * Advances the collection's change counter by one and returns the new value,
+     * which the caller stamps on the object it just wrote. Atomic with respect
+     * to concurrent writers: a read-then-write here would hand two writers the
+     * same sequence and lose one of them from every later sync report.
+     */
+    bumpSyncSequence(accountConfigId: string, calendarId: string): Promise<number>;
+}

package/dist/interfaces/calendar-collection.js

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

package/dist/interfaces/calendar-event-index.d.ts

@@ -0,0 +1,19 @@
+import type { CalendarEventIndexItem, CalendarOccurrenceInput } from "../types.js";
+export interface ICalendarEventIndexRepository {
+    /**
+     * Replaces every occurrence row of one resource with `occurrences`. Whole
+     * replacement rather than a merge: an edit that shortens a series must
+     * remove the occurrences it dropped, and a diff would leave them behind as
+     * events the calendar view still shows but the resource no longer has.
+     */
+    replaceForObject(calendarId: string, calendarObjectId: string, occurrences: CalendarOccurrenceInput[]): Promise<void>;
+    deleteForObject(calendarId: string, calendarObjectId: string): Promise<void>;
+    listForObject(calendarId: string, calendarObjectId: string): Promise<CalendarEventIndexItem[]>;
+    /**
+     * Occurrences starting within `[startAt, endAt)`, in start order — the
+     * calendar-view read. Bounded by start rather than by overlap: an
+     * occurrence that began before the window and runs into it is not returned,
+     * so a caller that must show those widens the window by its longest event.
+     */
+    listByStartRange(calendarId: string, startAt: string, endAt: string): Promise<CalendarEventIndexItem[]>;
+}

package/dist/interfaces/calendar-event-index.js

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

package/dist/interfaces/calendar-feed-token.d.ts

@@ -0,0 +1,31 @@
+import type { CalendarFeedTokenItem, PutCalendarFeedTokenInput } from "../types.js";
+export interface ICalendarFeedTokenRepository {
+    /**
+     * Mints the calendar's feed address, or replaces the token it already has.
+     *
+     * One statement, and an upsert on the derived `feedTokenId`: a calendar holds
+     * exactly one active address, so there is no state in which a revoked token
+     * still resolves alongside its replacement. `createdAt` survives a
+     * replacement — the feed is the same feed under a new secret — and
+     * `rotatedAt` is stamped only when a row was already there, so a caller can
+     * tell a fresh address from a rotated one without a prior read.
+     */
+    put(input: PutCalendarFeedTokenInput): Promise<CalendarFeedTokenItem>;
+    /**
+     * The address a calendar holds, or `null` when it has none. Scoped by account
+     * config: a management read is always somebody's, and an unscoped one would
+     * answer for a calendar the caller does not own.
+     */
+    findByCalendar(accountConfigId: string, calendarId: string): Promise<CalendarFeedTokenItem | null>;
+    /**
+     * The row a token hash names, or `null` when nothing answers to it.
+     *
+     * Deliberately unscoped, and the only read that is: a subscriber arrives with
+     * no session at all, so the hash is the whole lookup key and the row it finds
+     * is what names the owner. The caller still compares the stored hash against
+     * the presented one before serving anything.
+     */
+    findByTokenHash(tokenHash: string): Promise<CalendarFeedTokenItem | null>;
+    /** Revokes the calendar's address. Every subscribed client stops resolving. */
+    delete(accountConfigId: string, calendarId: string): Promise<void>;
+}

package/dist/interfaces/calendar-feed-token.js

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

package/dist/interfaces/calendar-object.d.ts

@@ -0,0 +1,36 @@
+import type { CalendarObjectItem, PutCalendarObjectInput } from "../types.js";
+export interface ICalendarObjectRepository {
+    put(input: PutCalendarObjectInput): Promise<CalendarObjectItem>;
+    get(calendarId: string, calendarObjectId: string): Promise<CalendarObjectItem>;
+    /**
+     * The resource under an id, or `null` when the collection does not hold it.
+     * `get` throws instead, which is right for a caller that already knows the
+     * resource exists; a request naming one is asking whether it does, and that
+     * is an answer rather than a fault.
+     */
+    find(calendarId: string, calendarObjectId: string): Promise<CalendarObjectItem | null>;
+    delete(calendarId: string, calendarObjectId: string): Promise<void>;
+    findByResourceName(calendarId: string, resourceName: string): Promise<CalendarObjectItem | null>;
+    /**
+     * The resource carrying an iCalendar UID, which is how a scheduling message
+     * or a calendar-query REPORT addresses an event — a client that has the UID
+     * generally does not have the resource name.
+     */
+    findByUid(calendarId: string, icalUid: string): Promise<CalendarObjectItem | null>;
+    listByUidPrefix(calendarId: string, prefix: string): Promise<CalendarObjectItem[]>;
+    listByCalendar(calendarId: string): Promise<CalendarObjectItem[]>;
+    /**
+     * The resources whose occurrence rows stop before `instant` — the series a
+     * range read has to expand for itself because the index does not reach that
+     * far. Narrow by construction: a resource that fits inside the expansion
+     * horizon carries no `expandedThrough` and never appears here, so a view of
+     * an ordinary calendar reads no iCalendar text at all.
+     */
+    listIncompleteExpansions(calendarId: string, instant: string): Promise<CalendarObjectItem[]>;
+    /**
+     * Everything written to the collection after `syncSequence`, in change
+     * order — the read behind a WebDAV-Sync report. Exclusive of the token
+     * itself, so replaying a token returns only what the client has not seen.
+     */
+    listChangedSince(calendarId: string, syncSequence: number): Promise<CalendarObjectItem[]>;
+}

package/dist/interfaces/calendar-object.js

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

package/dist/interfaces/calendar-store.d.ts

@@ -0,0 +1,93 @@
+import type { CalendarOccurrenceInput, PutCalendarObjectInput, UpdateCalendarCollectionInput } from "../types.js";
+import type { ICalendarCollectionRepository } from "./calendar-collection.js";
+import type { ICalendarEventIndexRepository } from "./calendar-event-index.js";
+import type { ICalendarFeedTokenRepository } from "./calendar-feed-token.js";
+import type { ICalendarObjectRepository } from "./calendar-object.js";
+import type { ICalendarSuggestionRepository, SettleCalendarSuggestionInput } from "./calendar-suggestion.js";
+/** The repositories a calendar write set reads before it commits. */
+export interface CalendarRepositories {
+    calendarCollection: ICalendarCollectionRepository;
+    calendarObject: ICalendarObjectRepository;
+    calendarEventIndex: ICalendarEventIndexRepository;
+    calendarSuggestion: ICalendarSuggestionRepository;
+    calendarFeedToken: ICalendarFeedTokenRepository;
+}
+/**
+ * Writes one resource: bumps the collection's sequence, stores the object at
+ * the bumped value and replaces its occurrence rows. The object's id derives
+ * from `(calendarId, resourceName)`, so the write needs no read of its own.
+ */
+export interface PutCalendarObjectWrite {
+    kind: "PutObject";
+    accountConfigId: string;
+    object: Omit<PutCalendarObjectInput, "syncSequence">;
+    occurrences: CalendarOccurrenceInput[];
+}
+/**
+ * Rewrites a resource that is already stored, the way a put does, but only
+ * while it is still the version that was read: a resource edited or deleted
+ * since stays as that edit left it.
+ * A collection whose timezone changed re-projects every resource this way.
+ */
+export interface ReprojectCalendarObjectWrite extends Omit<PutCalendarObjectWrite, "kind"> {
+    kind: "ReprojectObject";
+    /** The etag the resource carried when it was read; a later edit wins. */
+    readEtag: string;
+}
+/** Removes a resource with its occurrence rows, and bumps the sequence. */
+export interface DeleteCalendarObjectWrite {
+    kind: "DeleteObject";
+    accountConfigId: string;
+    calendarId: string;
+    calendarObjectId: string;
+}
+/**
+ * Settles a suggestion card. Present so accepting a suggestion settles the card
+ * in the same commit that writes the resource (issue #1033): a card still
+ * asking with the event already in the calendar, or a card marked accepted with
+ * no event behind it, is a state nothing later can repair.
+ */
+export interface SettleCalendarSuggestionWrite {
+    kind: "SettleSuggestion";
+    accountConfigId: string;
+    suggestionId: string;
+    settle: SettleCalendarSuggestionInput;
+}
+export interface UpdateCalendarCollectionWrite {
+    kind: "UpdateCollection";
+    accountConfigId: string;
+    calendarId: string;
+    patch: UpdateCalendarCollectionInput;
+}
+/**
+ * Removes a collection with every resource, occurrence and its feed address
+ * (issue #1067). A token row outliving its collection is a credential pointing
+ * at nothing: it answers 404, but nobody can see it to revoke it, and a later
+ * calendar under the same derived id would inherit it.
+ */
+export interface DeleteCalendarCollectionWrite {
+    kind: "DeleteCollection";
+    accountConfigId: string;
+    calendarId: string;
+}
+export type CalendarWrite = PutCalendarObjectWrite | ReprojectCalendarObjectWrite | DeleteCalendarObjectWrite | SettleCalendarSuggestionWrite | UpdateCalendarCollectionWrite | DeleteCalendarCollectionWrite;
+/**
+ * The calendar store (issue #15). Reads go through `repos`; a write set is a
+ * list of writes that `commit` applies in order: the calendar writes as one
+ * atomic batch, then the suggestion settlements, which live with the mail
+ * (#1420). A commit that fails between the two is repaired by repeating it,
+ * since every write in it converges on a rerun. Writing a
+ * resource is three writes — the object, its replaced occurrence rows and the
+ * collection's sequence bump — and none of them is meaningful without the
+ * others: an object with stale occurrences is a calendar showing events the
+ * resource no longer has, and an object written without the bump is a change
+ * no sync report will ever hand a client.
+ *
+ * Nothing inside a commit reads: every decision is made against what `repos`
+ * returned before it, and a write that a stale read would get wrong is keyed so
+ * that repeating or racing it converges (derived ids, upserts).
+ */
+export interface ICalendarStore {
+    readonly repos: CalendarRepositories;
+    commit(writes: readonly CalendarWrite[]): Promise<void>;
+}

package/dist/interfaces/calendar-store.js

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

package/dist/interfaces/calendar-suggestion.d.ts

@@ -0,0 +1,62 @@
+import type { CalendarSuggestionItem, PutCalendarSuggestionInput, ResultList } from "../types.js";
+/**
+ * The two fields that record what a person decided about a suggestion. They
+ * move together and only through {@link ICalendarSuggestionRepository.settle},
+ * so no producer write can walk an answered card back to `Pending`, and no
+ * state can name a calendar object that was never written.
+ *
+ * `acceptedCalendarObjectId` is `""` for every outcome but `Accepted` — the
+ * named absent state, never a missing attribute.
+ */
+export interface SettleCalendarSuggestionInput {
+    state: CalendarSuggestionItem["state"];
+    acceptedCalendarObjectId: string;
+}
+export interface ICalendarSuggestionRepository {
+    /**
+     * Writes the suggestion under its derived `suggestionId`. An upsert: the
+     * producer re-reading the same message rewrites the row it already wrote.
+     *
+     * Never touches `state` or `acceptedCalendarObjectId` on a row that already
+     * exists, so a re-sync of a message whose invitation the user accepted
+     * leaves the acceptance intact. A row it creates starts `Pending`.
+     */
+    put(input: PutCalendarSuggestionInput): Promise<CalendarSuggestionItem>;
+    get(accountConfigId: string, suggestionId: string): Promise<CalendarSuggestionItem>;
+    /** Every suggestion one message produced, superseded revisions included. */
+    listByMessage(accountConfigId: string, messageId: string): Promise<CalendarSuggestionItem[]>;
+    listByAcceptedCalendarObjects(accountConfigId: string, calendarObjectIds: string[]): Promise<CalendarSuggestionItem[]>;
+    /**
+     * The account's suggestions in one state, newest first. Also how the
+     * producer finds the revision a new message supersedes: only a `Pending`
+     * suggestion can be superseded, so the candidate set is this one.
+     */
+    listByState(accountConfigId: string, state: CalendarSuggestionItem["state"], options: {
+        endsAfter: string;
+        limit?: number;
+        continuationToken?: string;
+    }): Promise<ResultList<CalendarSuggestionItem>>;
+    /**
+     * Records the outcome of a person's decision. Returns the settled row.
+     */
+    settle(accountConfigId: string, suggestionId: string, input: SettleCalendarSuggestionInput): Promise<CalendarSuggestionItem>;
+    /**
+     * Retires a card as `Superseded`, but only while it is still `Pending`, and
+     * records the message whose revision retired it so the card can open that
+     * one. Returns the retired row, or `null` when the card had already been
+     * answered and nothing was written.
+     *
+     * A compare-and-set rather than a plain `settle` because the producer reads
+     * the pending set and writes to it in two steps, and a person can accept a
+     * card in between. An unconditional write there would overwrite their
+     * acceptance with `Superseded` and blank `acceptedCalendarObjectId`,
+     * severing the card from the event it put in their calendar.
+     */
+    supersedeIfPending(accountConfigId: string, suggestionId: string, supersededByMessageId: string): Promise<CalendarSuggestionItem | null>;
+    /**
+     * Points a card already `Superseded` at a later revision, so every retired
+     * revision of an event opens the newest one. Returns the updated row, or
+     * `null` when the card is not superseded and nothing was written.
+     */
+    repointSuperseded(accountConfigId: string, suggestionId: string, supersededByMessageId: string): Promise<CalendarSuggestionItem | null>;
+}

package/dist/interfaces/calendar-suggestion.js

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

package/dist/interfaces/config-import.d.ts

@@ -0,0 +1,8 @@
+import type { ConfigImportItem, CreateConfigImportInput, UpdateConfigImportInput } from "../types.js";
+export interface IConfigImportRepository {
+    create(input: CreateConfigImportInput): Promise<ConfigImportItem>;
+    get(importId: string): Promise<ConfigImportItem>;
+    update(importId: string, input: UpdateConfigImportInput): Promise<ConfigImportItem>;
+    /** Newest first, so the caller reads the import a person just ran. */
+    listByAccountConfig(accountConfigId: string): Promise<ConfigImportItem[]>;
+}

package/dist/interfaces/config-import.js

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

package/dist/interfaces/envelope.d.ts

@@ -0,0 +1,24 @@
+import type { BodyPartItem, BodyPartUpsertInput, CreateEnvelopeInput, EnvelopeItem, MessageData, MessageReferenceInput, UpdateEnvelopeInput } from "../types.js";
+export interface IEnvelopeRepository {
+    createEnvelope(input: CreateEnvelopeInput): Promise<EnvelopeItem>;
+    upsertEnvelope(input: CreateEnvelopeInput): Promise<EnvelopeItem>;
+    getEnvelope(envelopeId: string): Promise<EnvelopeItem>;
+    getEnvelope(envelopeIds: string[]): Promise<EnvelopeItem[]>;
+    updateEnvelope(envelopeId: string, input: UpdateEnvelopeInput): Promise<EnvelopeItem>;
+    deleteEnvelope(envelopeId: string): Promise<void>;
+    deleteManyEnvelopes(envelopeIds: string[]): Promise<void>;
+    upsertBodyParts(messageId: string, parts: BodyPartUpsertInput[]): Promise<void>;
+    replaceMessageReferences(messageId: string, references: MessageReferenceInput[]): Promise<void>;
+    getMessageData(messageId: string): Promise<MessageData>;
+    listBodyParts(messageId: string): Promise<BodyPartItem[]>;
+    /**
+     * Up to `limit` messages now in the folder that are queued to have their
+     * structure read again from the mail server.
+     */
+    listQueuedStructureRefetches(mailboxId: string, limit: number): Promise<Array<{
+        messageId: string;
+        uid: number;
+    }>>;
+    /** Take messages off that queue, once each. */
+    clearStructureRefetches(messageIds: string[]): Promise<void>;
+}

package/dist/interfaces/envelope.js

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

package/dist/interfaces/filter.d.ts

@@ -0,0 +1,28 @@
+import type { CreateFilterInput, FilterItem, ResultList, UpdateFilterInput } from "../types.js";
+export interface IFilterRepository {
+    create(input: CreateFilterInput): Promise<FilterItem>;
+    get(accountConfigId: string, filterId: string): Promise<FilterItem>;
+    update(accountConfigId: string, filterId: string, input: UpdateFilterInput): Promise<FilterItem>;
+    delete(accountConfigId: string, filterId: string): Promise<void>;
+    listByAccountConfig(accountConfigId: string): Promise<FilterItem[]>;
+    /**
+     * A single signed page of an account config's filters via the primary index —
+     * the settings-page/API list (RFC 034). Mirrors
+     * `IMailboxRepository.listByAccount`, so the API surface paginates identically
+     * to `listMailboxes`; `continuationToken` round-trips a backend-native cursor.
+     */
+    listPageByAccountConfig(accountConfigId: string, options?: {
+        limit?: number;
+        continuationToken?: string;
+    }): Promise<ResultList<FilterItem>>;
+    listByAccountAndState(accountConfigId: string, state: FilterItem["state"]): Promise<FilterItem[]>;
+    /**
+     * Lazily patch a Temporary filter read past its `expiresAt` to `Expired` and
+     * return the refreshed row (RFC 034 Decision 1.2). `expiresAt`/`now` are the
+     * source of truth for whether a filter is still active — `state` is only a
+     * cache of that comparison, refreshed here on whatever read touches the row
+     * next. A no-op (returns the item unchanged) for a Standing filter or one
+     * already Expired.
+     */
+    refreshExpiry(item: FilterItem): Promise<FilterItem>;
+}

package/dist/interfaces/filter.js

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

package/dist/interfaces/label.d.ts

@@ -0,0 +1,17 @@
+import type { CreateLabelInput, LabelItem, ResultList, UpdateLabelInput } from "../types.js";
+export interface ILabelRepository {
+    create(input: CreateLabelInput): Promise<LabelItem>;
+    get(accountConfigId: string, labelId: string): Promise<LabelItem>;
+    update(accountConfigId: string, labelId: string, input: UpdateLabelInput): Promise<LabelItem>;
+    delete(accountConfigId: string, labelId: string): Promise<void>;
+    listByAccountConfig(accountConfigId: string): Promise<LabelItem[]>;
+    /**
+     * A single signed page of an account config's labels (issue #26), mirroring
+     * `IFilterRepository.listPageByAccountConfig` — the settings-page/API list.
+     */
+    listPageByAccountConfig(accountConfigId: string, options?: {
+        limit?: number;
+        continuationToken?: string;
+    }): Promise<ResultList<LabelItem>>;
+    findByNormalizedName(accountConfigId: string, normalizedName: string): Promise<LabelItem | null>;
+}

package/dist/interfaces/label.js

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

package/dist/interfaces/mailbox-lock.d.ts

@@ -0,0 +1,12 @@
+import type { MailboxLockItem, WithMailboxLockResult } from "../types.js";
+export interface IMailboxLockRepository {
+    tryAcquireLock(mailboxId: string, eventName: string, accountId: string, lockId: string, ttlSeconds: number): Promise<boolean>;
+    releaseLock(accountId: string, mailboxId: string, eventName: string, lockId: string): Promise<void>;
+    withMailboxLock<T>(mailboxId: string, eventName: string, accountId: string, operation: () => Promise<T>, options?: {
+        lockId?: string;
+    }): Promise<WithMailboxLockResult<T>>;
+    get(accountId: string, mailboxId: string, eventName: string): Promise<MailboxLockItem | null>;
+    listAllLocks(): Promise<MailboxLockItem[]>;
+    listByAccount(accountId: string): Promise<MailboxLockItem[]>;
+    deleteByAccount(accountId: string): Promise<void>;
+}

package/dist/interfaces/mailbox-lock.js

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