@rapidmx/activesync-plugin 1.0.0-beta.2

package/dist/types/commands/SearchCommand.d.ts

@@ -0,0 +1,60 @@
+import { type WbxmlElement } from "../codec/WbxmlElement.js";
+import type { EasCommandContext, EasCommandHandler } from "../EasCommandHandler.js";
+/**
+ * Handles EAS `Search` for the `GAL` and `Mailbox` stores - `DocumentLibrary` (the real spec's third store type)
+ * remains out of scope, matching `ItemOperationsCommand`'s identical scope decision; this library has no
+ * document-library model.
+ *
+ * **`GAL`**: this library's `Contact` records are also the source of truth for GAL lookups against a mailbox's
+ * own address book (see the architecture note on `Contact` itself). A simple case-insensitive substring match
+ * via `RepoUtils.find()` directly, not the heavier `SearchProvider` full-text index - GAL lookups are
+ * small-scale exact/prefix matching against a personal address book, not relevance-ranked full text over large
+ * content. Only `displayName`/`givenName`/`surname`/`company` are matched - `Contact.emails`/`phones` are
+ * embedded arrays of objects, which a plain per-field regex query can't reach into on either backend (confirmed:
+ * MongoDB's `$regex` against an array-of-objects field matches nothing useful, and this library's own
+ * query-injection guard rejects dot-notation field paths like `"emails.address"` outright) - a documented gap,
+ * not an oversight.
+ *
+ * **`Mailbox`**: real full-text search over the caller's own `Email` messages, backed by `restapi`'s
+ * `SearchProvider` (its own full-text index, kept eventually-consistent with the primary datastore via
+ * `SearchIndexJob` - a just-sent/just-received message may briefly not be findable yet). **Pragmatic subset**:
+ * only `Class` `Email` is supported (a `Query` naming any other class is rejected, matching the `GAL`-only
+ * precedent this file already established for search generally); only the common real-world `Query` shape -
+ * `Class`/`CollectionId`/`FreeText`, optionally grouped under one `And` - is parsed, not the full recursive
+ * `And`/`Or`/`EqualTo`/`GreaterThan`/`LessThan` boolean-tree grammar MS-ASCMD's schema allows for, so a
+ * multi-level nested query silently only sees the first `And` group's own direct children. Each match is
+ * re-verified for `READ` on its own current `folderUid` before being included - `SearchProvider`'s index is
+ * scoped by `mailboxUid` alone, not per-folder ACL, so this is the one place that check still has to happen
+ * per-result rather than once up front. `SearchResultPage` carries no total count (the underlying providers
+ * don't compute one cheaply over a relevance-ranked query), so `Total` here means "how many matches this
+ * request's own capped fetch actually returned" - a client requesting a `Range` past that cap sees fewer
+ * results than may really exist, a documented approximation rather than exact server-side paging.
+ *
+ * `contactClass`/`messageClass`/`emailAdapterClass` are supplied by the Mongo/SQL concrete subclasses.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare abstract class SearchCommand implements EasCommandHandler {
+    readonly command = "Search";
+    protected abstract contactClass: any;
+    protected abstract messageClass: any;
+    protected abstract emailAdapterClass: any;
+    private _objectFactory?;
+    private contactRepo?;
+    private messageRepo?;
+    private emailAdapter?;
+    private searchProvider?;
+    private aclUtils?;
+    private defaultRangeEnd;
+    private maxRangeEnd;
+    init(): Promise<void>;
+    handle(ctx: EasCommandContext): Promise<WbxmlElement | undefined>;
+    private handleGal;
+    private handleMailbox;
+    private contactToResult;
+    /** Reuses `EmailSyncAdapter.toApplicationData()`'s own field mapping (Subject/From/To/Cc/Bcc/DateReceived/
+     * Importance/Read/Flag/Body/ConversationId) for a Mailbox-store search hit's `Properties` - the same
+     * per-field shape `Sync` already renders for this message, rather than a second, parallel mapping that
+     * could drift out of sync with it. */
+    private messageToResult;
+}

package/dist/types/commands/SendMailCommand.d.ts

@@ -0,0 +1,10 @@
+import { ComposeMailCommand } from "./ComposeMailCommand.js";
+/**
+ * Handles EAS `SendMail`: relays a freshly composed message with no referenced original - see
+ * `ComposeMailCommand`'s own doc comment for the full shared implementation.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare abstract class SendMailCommand extends ComposeMailCommand {
+    readonly command = "SendMail";
+}

package/dist/types/commands/SettingsCommand.d.ts

@@ -0,0 +1,37 @@
+import { type WbxmlElement } from "../codec/WbxmlElement.js";
+import type { EasCommandContext, EasCommandHandler } from "../EasCommandHandler.js";
+/**
+ * Handles EAS `Settings`: the first-run/general-purpose device<->server settings exchange. This pragmatic
+ * subset supports the sub-elements every real client actually depends on:
+ *
+ * - `UserInformation`/`Get`: returns the mailbox's `primarySmtpAddress`/`aliasAddresses` as `EmailAddresses`.
+ * - `DeviceInformation`/`Set`: acknowledged with `Status 1` but not persisted anywhere - `DeviceSyncState` has
+ * no fields for a device's model/IMEI/OS/friendly name, and nothing else in this library currently consumes
+ * them. A real client only requires the acknowledgement to proceed past first-run setup, not that the values
+ * are retrievable later.
+ * - `Oof`/`Get` and `Oof`/`Set`: reads/writes `Mailbox.oofEnabled`/`oofMessage`/`oofStartTime`/`oofEndTime`.
+ * `StartTime`/`EndTime` use MS-ASDTYPE's plain `dateTime` type (`Date.prototype.toISOString()`), not Compact
+ * DateTime - confirmed against MS-ASSETTINGS directly, unlike `Calendar`/`Tasks`' timestamp fields (see
+ * `CompactDateTime.ts`'s own doc comment on that exact distinction). A single combined reply message is stored
+ * rather than the spec's three audience-specific `OofMessage` variants (internal/external-known/
+ * external-unknown) - matches this codebase's existing "one thing, not three" simplification precedent (e.g.
+ * `ContactsSyncAdapter`'s single-slot phone/email handling).
+ * - `RightsManagementInformation` is not implemented - deferred, matching this library's "pragmatic subset"
+ * precedent elsewhere (e.g. `ComposeMailCommand`'s own documented gaps).
+ *
+ * `mailboxClass` is supplied by the Mongo/SQL concrete subclasses.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare abstract class SettingsCommand implements EasCommandHandler {
+    readonly command = "Settings";
+    protected abstract mailboxClass: any;
+    private _objectFactory?;
+    private mailboxRepo?;
+    init(): Promise<void>;
+    handle(ctx: EasCommandContext): Promise<WbxmlElement | undefined>;
+    /** `OofState`: `0`=disabled, `1`=enabled indefinitely, `2`=time-based (only while now is within
+     * `StartTime`/`EndTime`). */
+    private getOof;
+    private setOof;
+}

package/dist/types/commands/SmartForwardCommand.d.ts

@@ -0,0 +1,17 @@
+import { ComposeMailCommand } from "./ComposeMailCommand.js";
+import type { EasCommandContext } from "../EasCommandHandler.js";
+import type { Message } from "@rapidmx/restapi";
+/**
+ * Handles EAS `SmartForward`: relays a freshly composed message threaded to (and referencing) the original via
+ * `<Source>`, then flips the original's `Forwarded` flag - see `ComposeMailCommand`'s own doc comment for the
+ * full shared implementation and this pragmatic subset's scope.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare abstract class SmartForwardCommand extends ComposeMailCommand {
+    readonly command = "SmartForward";
+    protected markOriginal(ctx: EasCommandContext, original: Message & {
+        uid: string;
+        version: number;
+    }): Promise<void>;
+}

package/dist/types/commands/SmartReplyCommand.d.ts

@@ -0,0 +1,17 @@
+import { ComposeMailCommand } from "./ComposeMailCommand.js";
+import type { EasCommandContext } from "../EasCommandHandler.js";
+import type { Message } from "@rapidmx/restapi";
+/**
+ * Handles EAS `SmartReply`: relays a freshly composed message threaded to (and referencing) the original via
+ * `<Source>`, then flips the original's `Answered` flag - see `ComposeMailCommand`'s own doc comment for the
+ * full shared implementation and this pragmatic subset's scope.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare abstract class SmartReplyCommand extends ComposeMailCommand {
+    readonly command = "SmartReply";
+    protected markOriginal(ctx: EasCommandContext, original: Message & {
+        uid: string;
+        version: number;
+    }): Promise<void>;
+}

package/dist/types/commands/SyncCommand.d.ts

@@ -0,0 +1,100 @@
+import { type RecoverableBaseEntity } from "@rapidrest/service-core";
+import { type WbxmlElement } from "../codec/WbxmlElement.js";
+import type { EasCommandContext, EasCommandHandler } from "../EasCommandHandler.js";
+/** Binds one MS-ASCMD `Class` value (`"Email"`, `"Contacts"`, ...) to the concrete entity class `SyncCommand`
+ * should build a `RepoUtils` for, and the adapter class that maps that entity to/from `ApplicationData`.
+ * Supplied by the Mongo/SQL concrete subclasses, one map entry per supported collection type.
+ *
+ * `adapterClass`, not a pre-built `adapter` instance: `SyncCommand.init()` instantiates each one itself via
+ * `ObjectFactory`, so an adapter can `@Inject` its own dependencies (`EmailSyncAdapter` needs `BlobStore` for a
+ * Draft's body) exactly like any other DI-managed class in this library - a bare `new EmailSyncAdapter()` has
+ * no way to satisfy that. */
+export interface SyncCollectionBinding<T extends RecoverableBaseEntity> {
+    entityClass: any;
+    adapterClass: any;
+}
+/**
+ * Handles EAS `Sync`: enumerates `Add`/`Change`/`Delete`s for a single folder's contents since the device's last
+ * `Sync` of that folder, using the same watermark-based cursor mechanism `FolderSyncCommand` uses (via
+ * `EasSyncKeyUtils`), scoped by `folderUid` instead of `mailboxUid`, and keyed per-folder in
+ * `DeviceSyncState.folderSyncKeys` (the `CollectionId` a client sends *is* the `folderUid` - this library never
+ * invents a separate collection identifier).
+ *
+ * **Multi-collection requests**: every `<Collection>` in a request's `<Collections>` is processed and gets its
+ * own `<Collection>` entry in the response, each with its own independent `SyncKey`/`Status` - a client
+ * syncing several folders in one round trip (the common case once the initial per-folder backlog is done)
+ * gets one response covering all of them. All per-collection `SyncKey`/remembered-`Class` writes for the whole
+ * request are batched into a single `persistDeviceSyncState` call after every collection has been processed
+ * (never one call per collection) - see `EasSyncKeyUtils.persistDeviceSyncState`'s own doc comment for why a
+ * second write to the same `DeviceSyncState` within one request must never be built off a stale copy.
+ *
+ * **`Class` is only required on a collection's first (`SyncKey "0"`) request**, per `[MS-ASCMD]` - once seen,
+ * it's remembered in `DeviceSyncState.folderCollectionClasses` (keyed by `folderUid`) so a later request may
+ * omit it; omitting it for a folder never previously synced still gets `Status 4` (nothing to fall back to).
+ *
+ * **Every `CollectionId` is ACL-checked against the caller before it's touched**: `processCollection()` requires
+ * `ACLAction.READ` on the folder before enumerating or accepting any Commands for it at all (a folder the caller
+ * can't read is reported the same as an unrecognized collection - Status `4` - rather than leaking whether it
+ * exists); `applyAdd`/`applyChange`/`applyDelete` additionally require `CREATE`/`UPDATE`/`DELETE` respectively,
+ * and `applyChange`/`applyDelete` re-verify the resolved item's own `folderUid` actually matches the collection
+ * being synced (treating a mismatch identically to "not found" - Status `8` - never revealing that the
+ * `ServerId` resolves to something real elsewhere). Without this, a client could supply any other mailbox's
+ * folder/item uid as its own `CollectionId`/`ServerId` and read or mutate that mailbox's data directly - the
+ * same ownership-verification-after-an-`ignoreACL`-lookup pattern `ItemOperationsCommand`/`MoveItemsCommand`
+ * already use, applied consistently here too.
+ *
+ * **Pragmatic subset, deliberately not the full MS-ASCMD `Sync` surface**:
+ * - **Client-originated `Add`/`Change`/`Delete` commands are accepted for every collection type**, including
+ * `Email` (a device creating/editing a Draft, or deleting a message locally - see `applyAdd`/`applyChange`/
+ * `applyDelete`). `[MS-ASCMD]` itself disallows `Add`/`Change` for any *non-draft* `Email` item - this library
+ * doesn't verify a Sync `Email` Add/Change actually targets the caller's own Drafts folder *specifically*
+ * (only that it's a folder the caller actually owns/can write to - see above), matching how Contacts/Calendar/
+ * Tasks folder targeting is equally unchecked beyond ownership elsewhere. A collection whose adapter has no
+ * `fromApplicationData` at all would get Status `6` for `Add`/`Change` instead, but every adapter today
+ * implements it. Per `[MS-ASCMD]`'s own "Add (Sync)"/"Status (Sync)" pages: `Add` always gets a `Responses`
+ * entry (it must report the assigned `ServerId`); `Change`/`Delete` only get one on **failure** - a silent
+ * success means "assume it worked."
+ * - Only a body preview is returned per item (see `EmailSyncAdapter`'s own doc comment) - full body content is
+ * fetched separately via `ItemOperationsCommand`. A Draft's `Email` Add/Change is plain-text-only, with no
+ * attachment support (mirrors `ComposeMailCommand`'s own already-documented attachment gap).
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare abstract class SyncCommand implements EasCommandHandler {
+    readonly command = "Sync";
+    protected abstract collectionBindings: Record<string, SyncCollectionBinding<any>>;
+    /** Supplied by the Mongo/SQL concrete subclasses so a client-originated `Add`'s `newEntityDefaults()` can
+     * be given the caller's own `Mailbox` (`EmailSyncAdapter` needs it for a new Draft's `from`) - same
+     * one-line-per-backend pattern `MeetingResponseCommand`/`SettingsCommand` already use. */
+    protected abstract mailboxClass: any;
+    private windowSize;
+    private _objectFactory?;
+    private aclUtils?;
+    private repos;
+    private adapters;
+    private mailboxRepo?;
+    init(): Promise<void>;
+    /** Resolves the caller's own `Mailbox` at most once per request, and only if actually needed - most `Sync`
+     * requests contain no client-originated `Add` at all, so most requests never pay this extra round trip. */
+    private mailboxLoader;
+    handle(ctx: EasCommandContext): Promise<WbxmlElement | undefined>;
+    /** Processes one `<Collection>` from the request into its own `<Collection>` response element, plus (when
+     * this round advanced anything) the `folderUid`/new `SyncKey`/remembered `Class` for `handle()` to fold
+     * into its single end-of-request `persistDeviceSyncState` call - this method itself never persists
+     * anything, so it's safe to call once per collection in a request without the write-batching hazard
+     * `EasSyncKeyUtils.persistDeviceSyncState`'s doc comment describes. */
+    private processCollection;
+    private itemToCommandElement;
+    /** One client-originated command's outcome: `response` is a `Responses/{Add,Change,Delete}` entry to
+     * include (per MS-ASCMD, always present for `Add`, only present on failure for `Change`/`Delete`);
+     * `writtenAt` is the resulting `dateModified` of whatever was actually written, used to advance the
+     * persisted watermark past this round's own writes (see `handle()`'s own comment on why). */
+    private addResponseElement;
+    private statusResponseElement;
+    private applyAdd;
+    private applyChange;
+    private applyDelete;
+    /** Builds one `<Collection>` response element - `handle()` collects one of these per request `<Collection>`
+     * and wraps the whole set in a single `<Sync><Collections>`. */
+    private collectionResponse;
+}

package/dist/types/commands/mongo/FolderSyncCommandMongo.d.ts

@@ -0,0 +1,8 @@
+import { FolderMongo } from "@rapidmx/restapi/mongo";
+import { FolderSyncCommand } from "../FolderSyncCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class FolderSyncCommandMongo extends FolderSyncCommand<FolderMongo> {
+    protected folderClass: any;
+}

package/dist/types/commands/mongo/GetItemEstimateCommandMongo.d.ts

@@ -0,0 +1,7 @@
+import { GetItemEstimateCommand, type EstimateCollectionBinding } from "../GetItemEstimateCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class GetItemEstimateCommandMongo extends GetItemEstimateCommand {
+    protected collectionBindings: Record<string, EstimateCollectionBinding>;
+}

package/dist/types/commands/mongo/ItemOperationsCommandMongo.d.ts

@@ -0,0 +1,9 @@
+import { ItemOperationsCommand } from "../ItemOperationsCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class ItemOperationsCommandMongo extends ItemOperationsCommand {
+    protected folderClass: any;
+    protected messageClass: any;
+    protected attachmentClass: any;
+}

package/dist/types/commands/mongo/MeetingResponseCommandMongo.d.ts

@@ -0,0 +1,8 @@
+import { MeetingResponseCommand } from "../MeetingResponseCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class MeetingResponseCommandMongo extends MeetingResponseCommand {
+    protected calendarEventClass: any;
+    protected mailboxClass: any;
+}

package/dist/types/commands/mongo/MoveItemsCommandMongo.d.ts

@@ -0,0 +1,8 @@
+import { MoveItemsCommand } from "../MoveItemsCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class MoveItemsCommandMongo extends MoveItemsCommand {
+    protected messageClass: any;
+    protected folderClass: any;
+}

package/dist/types/commands/mongo/ResolveRecipientsCommandMongo.d.ts

@@ -0,0 +1,7 @@
+import { ResolveRecipientsCommand } from "../ResolveRecipientsCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class ResolveRecipientsCommandMongo extends ResolveRecipientsCommand {
+    protected contactClass: any;
+}

package/dist/types/commands/mongo/SearchCommandMongo.d.ts

@@ -0,0 +1,9 @@
+import { SearchCommand } from "../SearchCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class SearchCommandMongo extends SearchCommand {
+    protected contactClass: any;
+    protected messageClass: any;
+    protected emailAdapterClass: any;
+}

package/dist/types/commands/mongo/SendMailCommandMongo.d.ts

@@ -0,0 +1,8 @@
+import { SendMailCommand } from "../SendMailCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class SendMailCommandMongo extends SendMailCommand {
+    protected folderClass: any;
+    protected messageClass: any;
+}

package/dist/types/commands/mongo/SettingsCommandMongo.d.ts

@@ -0,0 +1,7 @@
+import { SettingsCommand } from "../SettingsCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class SettingsCommandMongo extends SettingsCommand {
+    protected mailboxClass: any;
+}

package/dist/types/commands/mongo/SmartForwardCommandMongo.d.ts

@@ -0,0 +1,8 @@
+import { SmartForwardCommand } from "../SmartForwardCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class SmartForwardCommandMongo extends SmartForwardCommand {
+    protected folderClass: any;
+    protected messageClass: any;
+}

package/dist/types/commands/mongo/SmartReplyCommandMongo.d.ts

@@ -0,0 +1,8 @@
+import { SmartReplyCommand } from "../SmartReplyCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class SmartReplyCommandMongo extends SmartReplyCommand {
+    protected folderClass: any;
+    protected messageClass: any;
+}

package/dist/types/commands/mongo/SyncCommandMongo.d.ts

@@ -0,0 +1,8 @@
+import { SyncCommand, type SyncCollectionBinding } from "../SyncCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class SyncCommandMongo extends SyncCommand {
+    protected mailboxClass: any;
+    protected collectionBindings: Record<string, SyncCollectionBinding<any>>;
+}

package/dist/types/commands/mongo/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./FolderSyncCommandMongo.js";
+export * from "./SyncCommandMongo.js";
+export * from "./SendMailCommandMongo.js";
+export * from "./SmartForwardCommandMongo.js";
+export * from "./SmartReplyCommandMongo.js";
+export * from "./ItemOperationsCommandMongo.js";
+export * from "./SearchCommandMongo.js";
+export * from "./MeetingResponseCommandMongo.js";
+export * from "./SettingsCommandMongo.js";

package/dist/types/commands/sql/FolderSyncCommandSQL.d.ts

@@ -0,0 +1,8 @@
+import { FolderSQL } from "@rapidmx/restapi/sql";
+import { FolderSyncCommand } from "../FolderSyncCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class FolderSyncCommandSQL extends FolderSyncCommand<FolderSQL> {
+    protected folderClass: any;
+}

package/dist/types/commands/sql/GetItemEstimateCommandSQL.d.ts

@@ -0,0 +1,7 @@
+import { GetItemEstimateCommand, type EstimateCollectionBinding } from "../GetItemEstimateCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class GetItemEstimateCommandSQL extends GetItemEstimateCommand {
+    protected collectionBindings: Record<string, EstimateCollectionBinding>;
+}

package/dist/types/commands/sql/ItemOperationsCommandSQL.d.ts

@@ -0,0 +1,9 @@
+import { ItemOperationsCommand } from "../ItemOperationsCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class ItemOperationsCommandSQL extends ItemOperationsCommand {
+    protected folderClass: any;
+    protected messageClass: any;
+    protected attachmentClass: any;
+}

package/dist/types/commands/sql/MeetingResponseCommandSQL.d.ts

@@ -0,0 +1,8 @@
+import { MeetingResponseCommand } from "../MeetingResponseCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class MeetingResponseCommandSQL extends MeetingResponseCommand {
+    protected calendarEventClass: any;
+    protected mailboxClass: any;
+}

package/dist/types/commands/sql/MoveItemsCommandSQL.d.ts

@@ -0,0 +1,8 @@
+import { MoveItemsCommand } from "../MoveItemsCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class MoveItemsCommandSQL extends MoveItemsCommand {
+    protected messageClass: any;
+    protected folderClass: any;
+}

package/dist/types/commands/sql/ResolveRecipientsCommandSQL.d.ts

@@ -0,0 +1,7 @@
+import { ResolveRecipientsCommand } from "../ResolveRecipientsCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class ResolveRecipientsCommandSQL extends ResolveRecipientsCommand {
+    protected contactClass: any;
+}

package/dist/types/commands/sql/SearchCommandSQL.d.ts

@@ -0,0 +1,9 @@
+import { SearchCommand } from "../SearchCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class SearchCommandSQL extends SearchCommand {
+    protected contactClass: any;
+    protected messageClass: any;
+    protected emailAdapterClass: any;
+}

package/dist/types/commands/sql/SendMailCommandSQL.d.ts

@@ -0,0 +1,8 @@
+import { SendMailCommand } from "../SendMailCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class SendMailCommandSQL extends SendMailCommand {
+    protected folderClass: any;
+    protected messageClass: any;
+}

package/dist/types/commands/sql/SettingsCommandSQL.d.ts

@@ -0,0 +1,7 @@
+import { SettingsCommand } from "../SettingsCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class SettingsCommandSQL extends SettingsCommand {
+    protected mailboxClass: any;
+}

package/dist/types/commands/sql/SmartForwardCommandSQL.d.ts

@@ -0,0 +1,8 @@
+import { SmartForwardCommand } from "../SmartForwardCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class SmartForwardCommandSQL extends SmartForwardCommand {
+    protected folderClass: any;
+    protected messageClass: any;
+}

package/dist/types/commands/sql/SmartReplyCommandSQL.d.ts

@@ -0,0 +1,8 @@
+import { SmartReplyCommand } from "../SmartReplyCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class SmartReplyCommandSQL extends SmartReplyCommand {
+    protected folderClass: any;
+    protected messageClass: any;
+}

package/dist/types/commands/sql/SyncCommandSQL.d.ts

@@ -0,0 +1,8 @@
+import { SyncCommand, type SyncCollectionBinding } from "../SyncCommand.js";
+/**
+ * @author Jean-Philippe Steinmetz
+ */
+export declare class SyncCommandSQL extends SyncCommand {
+    protected mailboxClass: any;
+    protected collectionBindings: Record<string, SyncCollectionBinding<any>>;
+}

package/dist/types/commands/sql/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./FolderSyncCommandSQL.js";
+export * from "./SyncCommandSQL.js";
+export * from "./SendMailCommandSQL.js";
+export * from "./SmartForwardCommandSQL.js";
+export * from "./SmartReplyCommandSQL.js";
+export * from "./ItemOperationsCommandSQL.js";
+export * from "./SearchCommandSQL.js";
+export * from "./MeetingResponseCommandSQL.js";
+export * from "./SettingsCommandSQL.js";

package/dist/types/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Exchange ActiveSync protocol compatibility (Phase 2 of this library's roadmap): a WBXML codec, JWT-secured
+ * transport (`BaseEasRoute`, reusing the framework's existing `@Auth(["jwt"])` strategy - no EAS-specific auth
+ * code of its own), and the pragmatic command subset agreed in the architecture plan - `Provision`,
+ * `FolderSync`, `Sync` (`Email`/`Contacts`/`Calendar`/`Tasks`), `SendMail`/`SmartForward`/`SmartReply`,
+ * `ItemOperations`, `Ping`, `Search` (GAL), `MeetingResponse`, and `Settings`.
+ *
+ * This module exports only the backend-agnostic surface: the codec, the abstract route/command base classes,
+ * the shared sync-cursor/date-format utilities, and the `Sync` collection adapters. The concrete Mongo/SQL
+ * classes a deployment actually instantiates (`EasRouteMongo`/`EasRouteSQL` and each command's Mongo/SQL
+ * variant) are exported from this package's `./mongo`/`./sql` subpaths instead, alongside every other
+ * entity/route/job this library defines - see `MongoConnection`/`ConnectionManager` usage elsewhere in this
+ * library's own README for that convention.
+ *
+ * A deployment mounts EAS at the protocol's well-known path with a trivial one-line subclass, the same pattern
+ * `push/MailPushRoute.ts`'s doc comment describes for `BasePushRoute`:
+ * ```ts
+ * import { EasRouteMongo } from "@rapidrest/mail/mongo";
+ * import { RouteDecorators } from "@rapidrest/service-core";
+ * const { Route } = RouteDecorators;
+ *
+ * @Route("/Microsoft-Server-ActiveSync")
+ * export class MyEasRoute extends EasRouteMongo {}
+ * ```
+ */
+export * from "./codec/WbxmlCodePages.js";
+export * from "./codec/WbxmlElement.js";
+export * from "./codec/WbxmlEncoder.js";
+export * from "./codec/WbxmlDecoder.js";
+export * from "./BaseEasRoute.js";
+export * from "./BaseDeviceSyncStateRoute.js";
+export * from "./models/DeviceSyncState.js";
+export * from "./jobs/EasDeviceStateCleanupJob.js";
+export * from "./EasCommandHandler.js";
+export * from "./EasSyncKeyUtils.js";
+export * from "./CompactDateTime.js";
+export * from "./commands/ProvisionCommand.js";
+export * from "./commands/FolderSyncCommand.js";
+export * from "./commands/SyncCommand.js";
+export * from "./commands/ComposeMailCommand.js";
+export * from "./commands/SendMailCommand.js";
+export * from "./commands/SmartForwardCommand.js";
+export * from "./commands/SmartReplyCommand.js";
+export * from "./commands/PingCommand.js";
+export * from "./commands/ItemOperationsCommand.js";
+export * from "./commands/SearchCommand.js";
+export * from "./commands/MeetingResponseCommand.js";
+export * from "./commands/SettingsCommand.js";
+export * from "./adapters/EasCollectionSyncAdapter.js";
+export * from "./adapters/EmailSyncAdapter.js";
+export * from "./adapters/ContactsSyncAdapter.js";
+export * from "./adapters/CalendarSyncAdapter.js";
+export * from "./adapters/TasksSyncAdapter.js";

package/dist/types/jobs/EasDeviceStateCleanupJob.d.ts

@@ -0,0 +1,26 @@
+import { BackgroundService } from "@rapidrest/service-core";
+import { DeviceSyncState } from "../models/DeviceSyncState.js";
+/**
+ * Prunes `DeviceSyncState` rows for EAS devices that haven't synced in more than `device_ttl_days` days (or
+ * that have never successfully synced at all), keeping the collection from growing unbounded with abandoned
+ * device pairings.
+ *
+ * Concrete entity classes are supplied by the Mongo/SQL subclasses (`EasDeviceStateCleanupJobMongo`/
+ * `EasDeviceStateCleanupJobSQL`), following the same generic pattern `ScanQueueJob` uses.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export declare abstract class EasDeviceStateCleanupJob<D extends DeviceSyncState> extends BackgroundService {
+    protected abstract deviceSyncStateClass: any;
+    private _objectFactory?;
+    private deviceSyncStateRepo?;
+    private scheduleExpr;
+    private batchSize;
+    private deviceTtlDays;
+    private logger;
+    get schedule(): string | undefined;
+    init(): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void> | void;
+    run(): Promise<void>;
+}

package/dist/types/jobs/mongo/EasDeviceStateCleanupJobMongo.d.ts

@@ -0,0 +1,5 @@
+import { EasDeviceStateCleanupJob } from "../EasDeviceStateCleanupJob.js";
+import { DeviceSyncStateMongo } from "../../models/mongo/DeviceSyncStateMongo.js";
+export declare class EasDeviceStateCleanupJobMongo extends EasDeviceStateCleanupJob<DeviceSyncStateMongo> {
+    protected deviceSyncStateClass: any;
+}

package/dist/types/jobs/sql/EasDeviceStateCleanupJobSQL.d.ts

@@ -0,0 +1,5 @@
+import { EasDeviceStateCleanupJob } from "../EasDeviceStateCleanupJob.js";
+import { DeviceSyncStateSQL } from "../../models/sql/DeviceSyncStateSQL.js";
+export declare class EasDeviceStateCleanupJobSQL extends EasDeviceStateCleanupJob<DeviceSyncStateSQL> {
+    protected deviceSyncStateClass: any;
+}

package/dist/types/models/DeviceSyncState.d.ts

@@ -0,0 +1,30 @@
+import type { BaseEntity } from "@rapidrest/service-core";
+/**
+ * Tracks the EAS sync state of a single paired mobile device against a `Mailbox`.
+ *
+ * @author Jean-Philippe Steinmetz
+ */
+export interface DeviceSyncState extends BaseEntity {
+    mailboxUid: string;
+    deviceId: string;
+    deviceType: string;
+    /** The EAS provisioning policy key most recently acknowledged by the device. */
+    policyKey?: string;
+    /** The per-folder EAS `SyncKey` cursor, keyed by `Folder.uid`. */
+    folderSyncKeys: Record<string, string>;
+    /** The EAS `Class` (`"Email"`, `"Contacts"`, ...) most recently synced for a folder, keyed by `Folder.uid` -
+     * lets a `Sync` request omit `Class` after its first request for a collection, per [MS-ASCMD], without the
+     * server losing track of which entity type that collection holds. */
+    folderCollectionClasses: Record<string, string>;
+    lastSyncAt?: Date;
+    provisioned: boolean;
+    /** `true` once an administrator has requested this device be remotely wiped (MS-ASPROV `RemoteWipe`). Set
+     * back to `false` once the device acknowledges the wipe. */
+    remoteWipeRequested?: boolean;
+    /** `true` if the pending/most recent remote wipe request was scoped to this account only (vs. a full device
+     * wipe) - recorded for administrative record-keeping; the wire directive sent to the device is the same
+     * either way in this library's pragmatic subset. */
+    remoteWipeAccountOnly?: boolean;
+    /** When the device most recently acknowledged a remote wipe request. */
+    remoteWipeAcknowledgedAt?: Date;
+}