@remit/backend 0.0.145 → 0.0.147

package/dist/src/api.js

@@ -1,4 +1,5 @@
 import spec from "@remit/api-openapi-spec/openapi.json" with { type: "json" };
+import { requestValidators } from "@remit/api-openapi-spec/request-validators";
 import { redactCalendarFeedPath } from "@remit/calendar-service";
 import { logger } from "@remit/logger";
 import { OpenAPIBackend, } from "openapi-backend";
@@ -16,7 +17,24 @@ if (!isDocument(spec)) {
 }
 // Typed as a Document so importers do not see the JSON literal type.
 export const OpenAPISpec = spec;
-const api = new OpenAPIBackend({
+// ajv compiles a validator with `new Function`, which a Cloudflare Worker
+// refuses, so every init hands the router the validators codegen compiled ahead
+// of time. A host may call init again; in quick mode it builds the validator
+// before its first await, so the validators land before any request does.
+class PrecompiledOpenAPIBackend extends OpenAPIBackend {
+    init() {
+        const initialized = super.init();
+        for (const { operationId } of this.router.getOperations()) {
+            if (!operationId || !Object.hasOwn(requestValidators, operationId)) {
+                throw new Error(`No precompiled request validator for ${operationId}; run npm run codegen`);
+            }
+            this.validator.requestValidators[operationId] =
+                requestValidators[operationId];
+        }
+        return initialized;
+    }
+}
+const api = new PrecompiledOpenAPIBackend({
     definition: OpenAPISpec,
     quick: true,
     // Coerce query/path params to their schema types. API Gateway delivers every

package/dist/src/handlers/account-oauth.d.ts

@@ -1,5 +1,6 @@
 import type { AccountService as AccountServiceName } from "@remit/api-openapi-types";
-import type { MicrosoftOAuthOperationIds, OperationHandler, PublicOperationHandler, PublicOperationIds } from "../types.js";
+import type { Context } from "openapi-backend";
+import type { HandlerContext, PublicOperationHandler } from "../types.js";
 export interface OAuthState {
     accountConfigId: string;
     nonce: string;
@@ -12,4 +13,8 @@ export declare function verifyState(state: string, clientSecret: string): Promis
 export declare function parseJwtClaims(token: string): Promise<Record<string, unknown> | null>;
 export declare function getWebOrigin(origins: readonly string[]): string;
 export declare const microsoftOAuthCallback: PublicOperationHandler<"sync">;
-export declare const MicrosoftOAuthOperations: Record<Exclude<MicrosoftOAuthOperationIds, PublicOperationIds>, OperationHandler<MicrosoftOAuthOperationIds, "sync">>;
+export declare const MicrosoftOAuthOperations: {
+    MicrosoftOAuthOperations_microsoftOAuthStart: (context: Context, ctx: HandlerContext) => Promise<{
+        authorizationUrl: string;
+    }>;
+};

package/dist/src/handlers/account.d.ts

@@ -1,7 +1,15 @@
+import type { AccountResponse, DeleteAccountResponse, TestConnectionResponse } from "@remit/api-openapi-types";
+import type { Context } from "openapi-backend";
 import type { RemitClient } from "../service/data-client.js";
-import type { AccountDetailOperationIds, AccountOperationIds, OperationHandler } from "../types.js";
+import type { HandlerContext } from "../types.js";
 import { assertNotOAuthCreate, assertPasswordProvided, toAccountResponse } from "./account-guards.js";
 export { assertNotOAuthCreate, assertPasswordProvided, toAccountResponse };
 export declare const triggerAccountSyncSafe: (client: RemitClient<"sync">, accountId: string) => Promise<void>;
-export declare const AccountOperations: Record<AccountOperationIds, OperationHandler<AccountOperationIds, "sync" | "accountFanout">>;
-export declare const AccountDetailOperations: Record<AccountDetailOperationIds, OperationHandler<AccountDetailOperationIds, "sync" | "accountFanout">>;
+export declare const AccountOperations: {
+    AccountOperations_createAccount: (context: Context, ctx: HandlerContext<"sync">) => Promise<AccountResponse>;
+    AccountOperations_testConnection: (context: Context, ctx: HandlerContext) => Promise<TestConnectionResponse>;
+};
+export declare const AccountDetailOperations: {
+    AccountDetailOperations_updateAccount: (context: Context, ctx: HandlerContext) => Promise<AccountResponse>;
+    AccountDetailOperations_deleteAccount: (context: Context, ctx: HandlerContext<"accountFanout">) => Promise<DeleteAccountResponse>;
+};

package/dist/src/handlers/address.d.ts

@@ -1,6 +1,7 @@
 import type { AddressResponse, UpdateAddressInput } from "@remit/api-openapi-types";
 import type { AddressFlags, AddressItem, FlagsMergePatch } from "@remit/data-ports";
-import type { AddressDetailOperationIds, AddressOperationIds, OperationHandler } from "../types.js";
+import type { Context } from "openapi-backend";
+import type { HandlerContext } from "../types.js";
 export declare const toAddressResponse: (item: AddressItem) => AddressResponse;
 /**
  * Translate the wire-format `UpdateAddressInput` into a service-level
@@ -31,5 +32,12 @@ export declare const buildFlagsPatch: (input: UpdateAddressInput | undefined) =>
  * one standing on the Address.
  */
 export declare const backApplyCategoryFlag: (patch: FlagsMergePatch) => NonNullable<AddressFlags["category"]> | undefined;
-export declare const AddressOperations: Record<AddressOperationIds, OperationHandler<AddressOperationIds, "accountFanout">>;
-export declare const AddressDetailOperations: Record<AddressDetailOperationIds, OperationHandler<AddressDetailOperationIds, "accountFanout">>;
+export declare const AddressOperations: {
+    AddressOperations_searchAddresses: (context: Context, ctx: HandlerContext) => Promise<{
+        items: import("@remit/api-openapi-types").Components.Schemas.AddressResponse[];
+        continuationToken: string | undefined;
+    }>;
+};
+export declare const AddressDetailOperations: {
+    AddressDetailOperations_updateAddress: (context: Context, ctx: HandlerContext<"accountFanout">) => Promise<import("@remit/api-openapi-types").Components.Schemas.AddressResponse>;
+};

package/dist/src/handlers/config.d.ts

@@ -1,7 +1,10 @@
+import type { ConfigDescriptionResponse, ConfigImportReport } from "@remit/api-openapi-types";
+import type { ReaderConfigDocument } from "@remit/config-format";
 import type { FifoQueueProducer } from "@remit/data-ports";
 import { type StoredCredentialFields } from "@remit/mailbox-service/account-credentials";
+import type { Context } from "openapi-backend";
 import { type SyncMailboxesEvent } from "../service/trigger-sync.js";
-import type { ConfigOperationIds, OperationHandler } from "../types.js";
+import type { HandlerContext } from "../types.js";
 type StructuredLog = (fields: Record<string, unknown>, message: string) => void;
 interface ConfigSyncTriggerDeps {
     queue: FifoQueueProducer<SyncMailboxesEvent>;
@@ -39,5 +42,12 @@ interface ConfigSyncTriggerDeps {
 export declare const triggerConfigLoadSyncs: (accountConfigId: string, accounts: ReadonlyArray<{
     accountId: string;
 } & StoredCredentialFields>, deps: ConfigSyncTriggerDeps) => Promise<void>;
-export declare const ConfigOperations: Record<ConfigOperationIds, OperationHandler<ConfigOperationIds, "sync">>;
+export declare const ConfigOperations: {
+    ConfigOperations_getConfig: (_context: Context, ctx: HandlerContext<"sync">) => Promise<ConfigDescriptionResponse>;
+    ConfigOperations_exportConfig: (_context: Context, ctx: HandlerContext) => Promise<{
+        schemaVersion: number;
+        document: ReaderConfigDocument;
+    }>;
+    ConfigOperations_importConfig: (context: Context, ctx: HandlerContext) => Promise<ConfigImportReport>;
+};
 export {};

package/dist/src/handlers/filter.d.ts

@@ -1,3 +1,16 @@
-import type { FilterDetailOperationIds, FilterOperationIds, OperationHandler } from "../types.js";
-export declare const FilterOperations: Record<FilterOperationIds, OperationHandler<FilterOperationIds, "accountFanout">>;
-export declare const FilterDetailOperations: Record<FilterDetailOperationIds, OperationHandler<FilterDetailOperationIds, "accountFanout">>;
+import type { CreateFilterResponse } from "@remit/api-openapi-types";
+import type { HandlerContext } from "../types.js";
+export declare const FilterOperations: {
+    FilterOperations_listFilters: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext) => Promise<{
+        items: import("@remit/api-openapi-types").Components.Schemas.FilterResponse[];
+        continuationToken: string | undefined;
+    }>;
+    FilterOperations_createFilter: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"accountFanout">) => Promise<CreateFilterResponse>;
+};
+export declare const FilterDetailOperations: {
+    FilterDetailOperations_getFilter: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext) => Promise<import("@remit/api-openapi-types").Components.Schemas.FilterResponse>;
+    FilterDetailOperations_updateFilter: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext) => Promise<import("@remit/api-openapi-types").Components.Schemas.FilterResponse>;
+    FilterDetailOperations_deleteFilter: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext) => Promise<{
+        statusCode: number;
+    }>;
+};

package/dist/src/handlers/index.d.ts

@@ -6,33 +6,117 @@ export declare const handlers: {
     CalendarSuggestionActionOperations_reopenCalendarSuggestion: OperationHandler<import("../types.js").CalendarSuggestionActionOperationIds>;
     MessageCalendarSuggestionOperations_listMessageCalendarSuggestions: OperationHandler<"MessageCalendarSuggestionOperations_listMessageCalendarSuggestions">;
     CalendarSuggestionOperations_listCalendarSuggestions: OperationHandler<"CalendarSuggestionOperations_listCalendarSuggestions">;
-    AddressDetailOperations_updateAddress: OperationHandler<"AddressDetailOperations_updateAddress", "accountFanout">;
-    AddressOperations_searchAddresses: OperationHandler<"AddressOperations_searchAddresses", "accountFanout">;
-    OutboxAttachmentOperations_completeOutboxAttachment: OperationHandler<"OutboxAttachmentOperations_completeOutboxAttachment", "smtp">;
-    OutboxDetailOperations_getOutboxMessage: OperationHandler<import("../types.js").OutboxDetailOperationIds, "smtp">;
-    OutboxDetailOperations_updateOutboxMessage: OperationHandler<import("../types.js").OutboxDetailOperationIds, "smtp">;
-    OutboxDetailOperations_deleteOutboxMessage: OperationHandler<import("../types.js").OutboxDetailOperationIds, "smtp">;
-    OutboxDetailOperations_mintOutboxAttachment: OperationHandler<import("../types.js").OutboxDetailOperationIds, "smtp">;
-    OutboxDetailOperations_sendOutboxMessage: OperationHandler<import("../types.js").OutboxDetailOperationIds, "smtp">;
-    OutboxOperations_createOutboxMessage: OperationHandler<import("../types.js").OutboxOperationIds, "smtp">;
-    OutboxOperations_listOutboxMessages: OperationHandler<import("../types.js").OutboxOperationIds, "smtp">;
-    MessageBulkOperations_copyMessages: OperationHandler<import("../types.js").MessageBulkOperationIds, "body" | "sync" | "messageManagement">;
-    MessageBulkOperations_deleteMessages: OperationHandler<import("../types.js").MessageBulkOperationIds, "body" | "sync" | "messageManagement">;
-    MessageBulkOperations_updateFlags: OperationHandler<import("../types.js").MessageBulkOperationIds, "body" | "sync" | "messageManagement">;
-    MessageBulkOperations_updateMessageLabels: OperationHandler<import("../types.js").MessageBulkOperationIds, "body" | "sync" | "messageManagement">;
-    MessageBulkOperations_moveMessages: OperationHandler<import("../types.js").MessageBulkOperationIds, "body" | "sync" | "messageManagement">;
-    MessageBulkOperations_notSpam: OperationHandler<import("../types.js").MessageBulkOperationIds, "body" | "sync" | "messageManagement">;
-    MessageBulkOperations_reportSpam: OperationHandler<import("../types.js").MessageBulkOperationIds, "body" | "sync" | "messageManagement">;
-    MessageOperations_describeMessage: OperationHandler<import("../types.js").MessageOperationIds, "body" | "sync" | "messageManagement">;
-    MessageOperations_updateMessageFlags: OperationHandler<import("../types.js").MessageOperationIds, "body" | "sync" | "messageManagement">;
-    MessageOperations_getRawMessage: OperationHandler<import("../types.js").MessageOperationIds, "body" | "sync" | "messageManagement">;
+    AddressDetailOperations_updateAddress: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"accountFanout">) => Promise<import("@remit/api-openapi-types").Components.Schemas.AddressResponse>;
+    AddressOperations_searchAddresses: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<{
+        items: import("@remit/api-openapi-types").Components.Schemas.AddressResponse[];
+        continuationToken: string | undefined;
+    }>;
+    OutboxAttachmentOperations_completeOutboxAttachment: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").OutboxAttachmentResponse | import("./outbox-attachment.js").RejectionResponse>;
+    OutboxDetailOperations_getOutboxMessage: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").OutboxMessageResponse>;
+    OutboxDetailOperations_updateOutboxMessage: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"smtp">) => Promise<import("@remit/api-openapi-types").OutboxMessageResponse>;
+    OutboxDetailOperations_deleteOutboxMessage: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"smtp">) => Promise<{
+        statusCode: number;
+    }>;
+    OutboxDetailOperations_sendOutboxMessage: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"smtp">) => Promise<import("@remit/api-openapi-types").OutboxMessageResponse>;
+    OutboxDetailOperations_mintOutboxAttachment: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").MintOutboxAttachmentResponse | import("./outbox-attachment.js").RejectionResponse>;
+    OutboxOperations_createOutboxMessage: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"smtp">) => Promise<import("@remit/api-openapi-types").OutboxMessageResponse>;
+    OutboxOperations_listOutboxMessages: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<{
+        items: never[];
+        continuationToken: null;
+    } | {
+        items: import("@remit/api-openapi-types").Components.Schemas.OutboxMessageResponse[];
+        continuationToken: string | undefined;
+    }>;
+    MessageBulkOperations_updateFlags: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<{
+        successCount: number;
+        failureCount: number;
+    }>;
+    MessageBulkOperations_deleteMessages: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<{
+        successCount: number;
+        failureCount: number;
+    }>;
+    MessageBulkOperations_moveMessages: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<{
+        successCount: number;
+        failureCount: number;
+    }>;
+    MessageBulkOperations_copyMessages: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<{
+        successCount: number;
+        failureCount: number;
+    }>;
+    MessageBulkOperations_updateMessageLabels: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext) => Promise<{
+        successCount: number;
+        failureCount: number;
+    }>;
+    MessageBulkOperations_reportSpam: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<import("./message.js").SpamReportBulkOutcome>;
+    MessageBulkOperations_notSpam: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<import("./message.js").SpamReportBulkOutcome>;
+    MessageOperations_describeMessage: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"sync" | "messageManagement" | "body">) => Promise<{
+        message: {
+            spamReport?: {
+                reportedAt: number;
+            } | undefined;
+            labels?: {
+                labelId: string;
+                name: string;
+                color: "Default" | "Red" | "Orange" | "Yellow" | "Green" | "Teal" | "Blue" | "Purple" | "Gray";
+            }[] | undefined;
+            autoMoved?: import("@remit/api-openapi-types").Components.Schemas.AutoMovedInfo | undefined;
+            messageId: string;
+            mailboxId: string;
+            uid: number;
+            rfc822Size: number;
+            internalDate: number;
+            messageIdHeader: string | undefined;
+            authenticity: {
+                fromDomain: string;
+                dkimMismatch: boolean;
+                dkimDomain?: string | undefined;
+                displayNameCorrespondence?: "Corresponds" | "Lookalike" | "ForeignAddress" | "Unrelated" | "NoClaim" | undefined;
+                offDomainLinkDomains?: string[] | undefined;
+                signerDomain?: string | undefined;
+                envelopeDomain?: string | undefined;
+                signerMessageCount?: number | undefined;
+                signerFirstSeenAt?: number | undefined;
+            } | undefined;
+            status: "active" | "deleting" | "deleted" | "moving";
+            syncStatus: "failed" | "synced" | "pending" | "abandoned";
+            abandonedMutation: "none" | "move" | "delete" | "copy";
+        };
+        envelope: import("@remit/api-openapi-types").Components.Schemas.EnvelopeResponse;
+        flags: string[];
+        bodyParts: import("@remit/api-openapi-types").Components.Schemas.BodyPartResponse[];
+        references: {
+            messageIdValue: string;
+            referenceType: string;
+            referenceOrder: number;
+        }[];
+    }>;
+    MessageOperations_getRawMessage: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"sync" | "messageManagement">) => Promise<{
+        raw: string;
+    }>;
+    MessageOperations_updateMessageFlags: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<{
+        messageId: string;
+        isRead: boolean;
+        isStarred: boolean;
+    }>;
     ThreadOperations_listThreads: OperationHandler<import("../types.js").ThreadOperationIds>;
     ThreadOperations_searchThreads: OperationHandler<import("../types.js").ThreadOperationIds>;
     UnifiedThreadOperations_listAllThreads: OperationHandler<"UnifiedThreadOperations_listAllThreads">;
     ThreadDetailOperations_listThreadMessages: OperationHandler<"ThreadDetailOperations_listThreadMessages">;
-    SyncOperations_triggerSync: OperationHandler<import("../types.js").SyncOperationIds, "sync">;
-    SyncOperations_getSyncStatus: OperationHandler<import("../types.js").SyncOperationIds, "sync">;
-    TrashOperations_emptyTrash: OperationHandler<"TrashOperations_emptyTrash", "sync">;
+    SyncOperations_triggerSync: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<{
+        triggered: boolean;
+        message: string;
+    }>;
+    SyncOperations_getSyncStatus: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext) => Promise<{
+        accountId: string;
+        syncPhase: "error" | "idle" | "discovering_mailboxes" | "syncing_inbox" | "syncing_others" | "complete" | undefined;
+        mailboxCountTotal: number | undefined;
+        mailboxCountSynced: number | undefined;
+        lastSyncAt: number | undefined;
+        mailboxes: import("./sync-progress.js").MailboxSyncProgress[];
+    }>;
+    TrashOperations_emptyTrash: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<{
+        deletedCount: number;
+    }>;
     CalendarFreeBusyOperations_listCalendarFreeBusy: OperationHandler<"CalendarFreeBusyOperations_listCalendarFreeBusy">;
     CalendarEventDetailOperations_getCalendarEvent: OperationHandler<import("../types.js").CalendarEventDetailOperationIds>;
     CalendarEventDetailOperations_updateCalendarEvent: OperationHandler<import("../types.js").CalendarEventDetailOperationIds>;
@@ -47,40 +131,55 @@ export declare const handlers: {
     CalendarDetailOperations_deleteCalendar: OperationHandler<import("../types.js").CalendarDetailOperationIds>;
     CalendarOperations_listCalendars: OperationHandler<import("../types.js").CalendarOperationIds>;
     CalendarOperations_createCalendar: OperationHandler<import("../types.js").CalendarOperationIds>;
-    OrganizeJobDetailOperations_getOrganizeJob: OperationHandler<"OrganizeJobDetailOperations_getOrganizeJob", "accountFanout">;
-    OrganizeOperations_createOrganizeJob: OperationHandler<import("../types.js").OrganizeOperationIds, "accountFanout">;
-    OrganizeOperations_previewOrganize: OperationHandler<import("../types.js").OrganizeOperationIds, "accountFanout">;
+    OrganizeJobDetailOperations_getOrganizeJob: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").OrganizeJobResponse>;
+    OrganizeOperations_createOrganizeJob: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"accountFanout">) => Promise<import("@remit/api-openapi-types").CreateOrganizeJobResponse>;
+    OrganizeOperations_previewOrganize: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").OrganizePreviewResponse>;
     LabelDetailOperations_getLabel: OperationHandler<import("../types.js").LabelDetailOperationIds>;
     LabelDetailOperations_updateLabel: OperationHandler<import("../types.js").LabelDetailOperationIds>;
     LabelDetailOperations_deleteLabel: OperationHandler<import("../types.js").LabelDetailOperationIds>;
     LabelOperations_listLabels: OperationHandler<import("../types.js").LabelOperationIds>;
     LabelOperations_createLabel: OperationHandler<import("../types.js").LabelOperationIds>;
-    FilterDetailOperations_getFilter: OperationHandler<import("../types.js").FilterDetailOperationIds, "accountFanout">;
-    FilterDetailOperations_updateFilter: OperationHandler<import("../types.js").FilterDetailOperationIds, "accountFanout">;
-    FilterDetailOperations_deleteFilter: OperationHandler<import("../types.js").FilterDetailOperationIds, "accountFanout">;
-    FilterOperations_listFilters: OperationHandler<import("../types.js").FilterOperationIds, "accountFanout">;
-    FilterOperations_createFilter: OperationHandler<import("../types.js").FilterOperationIds, "accountFanout">;
+    FilterDetailOperations_getFilter: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").Components.Schemas.FilterResponse>;
+    FilterDetailOperations_updateFilter: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").Components.Schemas.FilterResponse>;
+    FilterDetailOperations_deleteFilter: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext) => Promise<{
+        statusCode: number;
+    }>;
+    FilterOperations_listFilters: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext) => Promise<{
+        items: import("@remit/api-openapi-types").Components.Schemas.FilterResponse[];
+        continuationToken: string | undefined;
+    }>;
+    FilterOperations_createFilter: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"accountFanout">) => Promise<import("@remit/api-openapi-types").CreateFilterResponse>;
     FolderRoleOperations_appointFolderRole: OperationHandler<"FolderRoleOperations_appointFolderRole">;
-    MailboxDetailOperations_getMailbox: OperationHandler<import("../types.js").MailboxDetailOperationIds, "sync">;
-    MailboxDetailOperations_renameMailbox: OperationHandler<import("../types.js").MailboxDetailOperationIds, "sync">;
-    MailboxDetailOperations_deleteMailbox: OperationHandler<import("../types.js").MailboxDetailOperationIds, "sync">;
-    MailboxOperations_listMailboxes: OperationHandler<import("../types.js").MailboxOperationIds, "sync">;
-    MailboxOperations_createMailbox: OperationHandler<import("../types.js").MailboxOperationIds, "sync">;
-    MicrosoftOAuthOperations_microsoftOAuthStart: OperationHandler<import("../types.js").MicrosoftOAuthOperationIds, "sync">;
-    AccountDetailOperations_updateAccount: OperationHandler<import("../types.js").AccountDetailOperationIds, "sync" | "accountFanout">;
-    AccountDetailOperations_deleteAccount: OperationHandler<import("../types.js").AccountDetailOperationIds, "sync" | "accountFanout">;
-    AccountOperations_createAccount: OperationHandler<import("../types.js").AccountOperationIds, "sync" | "accountFanout">;
-    AccountOperations_testConnection: OperationHandler<import("../types.js").AccountOperationIds, "sync" | "accountFanout">;
+    MailboxDetailOperations_getMailbox: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").Components.Schemas.MailboxResponse>;
+    MailboxDetailOperations_renameMailbox: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<import("@remit/api-openapi-types").Components.Schemas.MailboxResponse>;
+    MailboxDetailOperations_deleteMailbox: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<{
+        statusCode: number;
+    }>;
+    MailboxOperations_listMailboxes: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext) => Promise<{
+        items: import("@remit/api-openapi-types").Components.Schemas.MailboxResponse[];
+        continuationToken: string | undefined;
+    }>;
+    MailboxOperations_createMailbox: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: import("../types.js").HandlerContext<"sync">) => Promise<import("@remit/api-openapi-types").Components.Schemas.MailboxResponse>;
+    MicrosoftOAuthOperations_microsoftOAuthStart: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<{
+        authorizationUrl: string;
+    }>;
+    AccountDetailOperations_updateAccount: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").AccountResponse>;
+    AccountDetailOperations_deleteAccount: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"accountFanout">) => Promise<import("@remit/api-openapi-types").DeleteAccountResponse>;
+    AccountOperations_createAccount: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"sync">) => Promise<import("@remit/api-openapi-types").AccountResponse>;
+    AccountOperations_testConnection: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").TestConnectionResponse>;
     SystemOperations_getSystemUpdate: OperationHandler<import("../types.js").SystemOperationIds>;
     SystemOperations_applySystemUpdate: OperationHandler<import("../types.js").SystemOperationIds>;
-    ConfigOperations_getConfig: OperationHandler<import("../types.js").ConfigOperationIds, "sync">;
-    ConfigOperations_exportConfig: OperationHandler<import("../types.js").ConfigOperationIds, "sync">;
-    ConfigOperations_importConfig: OperationHandler<import("../types.js").ConfigOperationIds, "sync">;
-    MeOperations_deleteMe: OperationHandler<import("../types.js").MeOperationIds, "accountFanout">;
-    MeOperations_createExport: OperationHandler<import("../types.js").MeOperationIds, "accountFanout">;
-    MeOperations_getExport: OperationHandler<import("../types.js").MeOperationIds, "accountFanout">;
-    MeOperations_listQuarantine: OperationHandler<import("../types.js").MeOperationIds, "accountFanout">;
-    MeOperations_listVipSuggestions: OperationHandler<import("../types.js").MeOperationIds, "accountFanout">;
+    ConfigOperations_getConfig: (_context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"sync">) => Promise<import("@remit/api-openapi-types").ConfigDescriptionResponse>;
+    ConfigOperations_exportConfig: (_context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<{
+        schemaVersion: number;
+        document: import("@remit/config-format").ReaderConfigDocument;
+    }>;
+    ConfigOperations_importConfig: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").ConfigImportReport>;
+    MeOperations_listVipSuggestions: (_context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").VipSuggestionsResponse>;
+    MeOperations_listQuarantine: (_context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").QuarantineListResponse>;
+    MeOperations_deleteMe: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"accountFanout">) => Promise<import("@remit/api-openapi-types").DeleteAccountConfigResponse>;
+    MeOperations_createExport: (_context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext<"accountFanout">) => Promise<import("@remit/api-openapi-types").CreateExportResponse>;
+    MeOperations_getExport: (context: import("openapi-backend").Context, ctx: import("../types.js").HandlerContext) => Promise<import("@remit/api-openapi-types").AccountExportRequestResponse>;
 };
 export declare const publicHandlers: {
     MicrosoftOAuthOperations_microsoftOAuthCallback: PublicOperationHandler<"sync">;

package/dist/src/handlers/mailbox.d.ts

@@ -1,7 +1,7 @@
 import type { RenameMailboxInput } from "@remit/api-openapi-types";
 import type { IAccountSettingRepository, MailboxItem } from "@remit/data-ports";
 import { type FolderPathDeps } from "@remit/mailbox-service";
-import type { MailboxDetailOperationIds, MailboxOperationIds, OperationHandler, TrashOperationIds } from "../types.js";
+import type { HandlerContext } from "../types.js";
 /**
  * The mute flag and the display-name override are user preferences that live
  * in per-mailbox AccountSetting rows (RFC 032), not on the Mailbox entity.
@@ -18,6 +18,22 @@ export type MailboxPatchClient = FolderPathDeps & {
     accountSetting: Pick<IAccountSettingRepository, "get" | "upsert" | "delete">;
 };
 export declare const applyMailboxPatch: (client: MailboxPatchClient, accountConfigId: string, mailboxId: string, accountId: string, body: RenameMailboxInput) => Promise<MailboxItem>;
-export declare const MailboxOperations: Record<MailboxOperationIds, OperationHandler<MailboxOperationIds, "sync">>;
-export declare const MailboxDetailOperations: Record<MailboxDetailOperationIds, OperationHandler<MailboxDetailOperationIds, "sync">>;
-export declare const TrashOperations: Record<TrashOperationIds, OperationHandler<TrashOperationIds, "sync">>;
+export declare const MailboxOperations: {
+    MailboxOperations_listMailboxes: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext) => Promise<{
+        items: import("@remit/api-openapi-types").Components.Schemas.MailboxResponse[];
+        continuationToken: string | undefined;
+    }>;
+    MailboxOperations_createMailbox: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<import("@remit/api-openapi-types").Components.Schemas.MailboxResponse>;
+};
+export declare const MailboxDetailOperations: {
+    MailboxDetailOperations_getMailbox: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext) => Promise<import("@remit/api-openapi-types").Components.Schemas.MailboxResponse>;
+    MailboxDetailOperations_renameMailbox: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<import("@remit/api-openapi-types").Components.Schemas.MailboxResponse>;
+    MailboxDetailOperations_deleteMailbox: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<{
+        statusCode: number;
+    }>;
+};
+export declare const TrashOperations: {
+    TrashOperations_emptyTrash: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<{
+        deletedCount: number;
+    }>;
+};

package/dist/src/handlers/me.d.ts

@@ -1,2 +1,10 @@
-import type { MeOperationIds, OperationHandler } from "../types.js";
-export declare const MeOperations: Record<MeOperationIds, OperationHandler<MeOperationIds, "accountFanout">>;
+import type { AccountExportRequestResponse, CreateExportResponse, DeleteAccountConfigResponse, QuarantineListResponse, VipSuggestionsResponse } from "@remit/api-openapi-types";
+import type { Context } from "openapi-backend";
+import type { HandlerContext } from "../types.js";
+export declare const MeOperations: {
+    MeOperations_listVipSuggestions: (_context: Context, ctx: HandlerContext) => Promise<VipSuggestionsResponse>;
+    MeOperations_listQuarantine: (_context: Context, ctx: HandlerContext) => Promise<QuarantineListResponse>;
+    MeOperations_deleteMe: (context: Context, ctx: HandlerContext<"accountFanout">) => Promise<DeleteAccountConfigResponse>;
+    MeOperations_createExport: (_context: Context, ctx: HandlerContext<"accountFanout">) => Promise<CreateExportResponse>;
+    MeOperations_getExport: (context: Context, ctx: HandlerContext) => Promise<AccountExportRequestResponse>;
+};

package/dist/src/handlers/message.d.ts

@@ -1,6 +1,7 @@
 import type { BodyPartResponse } from "@remit/api-openapi-types";
+import type { Context } from "openapi-backend";
 import { type ContentSigner } from "../derive/contentSignature.js";
-import type { MessageBulkOperationIds, MessageOperationIds, OperationHandler } from "../types.js";
+import type { HandlerContext } from "../types.js";
 export declare const isStorageNotFoundError: (error: unknown) => boolean;
 /**
  * Decode the raw `.eml` bytes into a string for inspection. RFC822/MIME
@@ -78,5 +79,78 @@ export declare const GENERIC_FAILURE_REASON = "This message could not be process
  * regardless of batch size.
  */
 export declare const settleSpamReportBulk: (messageIds: string[], run: (messageId: string) => Promise<void>) => Promise<SpamReportBulkOutcome>;
-export declare const MessageOperations: Record<MessageOperationIds, OperationHandler<MessageOperationIds, "sync" | "messageManagement" | "body">>;
-export declare const MessageBulkOperations: Record<MessageBulkOperationIds, OperationHandler<MessageBulkOperationIds, "sync" | "messageManagement" | "body">>;
+export declare const MessageOperations: {
+    MessageOperations_describeMessage: (context: Context, ctx: HandlerContext<"sync" | "messageManagement" | "body">) => Promise<{
+        message: {
+            spamReport?: {
+                reportedAt: number;
+            } | undefined;
+            labels?: {
+                labelId: string;
+                name: string;
+                color: "Default" | "Red" | "Orange" | "Yellow" | "Green" | "Teal" | "Blue" | "Purple" | "Gray";
+            }[] | undefined;
+            autoMoved?: import("@remit/api-openapi-types").Components.Schemas.AutoMovedInfo | undefined;
+            messageId: string;
+            mailboxId: string;
+            uid: number;
+            rfc822Size: number;
+            internalDate: number;
+            messageIdHeader: string | undefined;
+            authenticity: {
+                fromDomain: string;
+                dkimMismatch: boolean;
+                dkimDomain?: string | undefined;
+                displayNameCorrespondence?: "Corresponds" | "Lookalike" | "ForeignAddress" | "Unrelated" | "NoClaim" | undefined;
+                offDomainLinkDomains?: string[] | undefined;
+                signerDomain?: string | undefined;
+                envelopeDomain?: string | undefined;
+                signerMessageCount?: number | undefined;
+                signerFirstSeenAt?: number | undefined;
+            } | undefined;
+            status: "active" | "deleting" | "deleted" | "moving";
+            syncStatus: "failed" | "synced" | "pending" | "abandoned";
+            abandonedMutation: "none" | "move" | "delete" | "copy";
+        };
+        envelope: import("@remit/api-openapi-types").Components.Schemas.EnvelopeResponse;
+        flags: string[];
+        bodyParts: import("@remit/api-openapi-types").Components.Schemas.BodyPartResponse[];
+        references: {
+            messageIdValue: string;
+            referenceType: string;
+            referenceOrder: number;
+        }[];
+    }>;
+    MessageOperations_getRawMessage: (context: Context, ctx: HandlerContext<"sync" | "messageManagement">) => Promise<{
+        raw: string;
+    }>;
+    MessageOperations_updateMessageFlags: (context: Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<{
+        messageId: string;
+        isRead: boolean;
+        isStarred: boolean;
+    }>;
+};
+export declare const MessageBulkOperations: {
+    MessageBulkOperations_updateFlags: (context: Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<{
+        successCount: number;
+        failureCount: number;
+    }>;
+    MessageBulkOperations_deleteMessages: (context: Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<{
+        successCount: number;
+        failureCount: number;
+    }>;
+    MessageBulkOperations_moveMessages: (context: Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<{
+        successCount: number;
+        failureCount: number;
+    }>;
+    MessageBulkOperations_copyMessages: (context: Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<{
+        successCount: number;
+        failureCount: number;
+    }>;
+    MessageBulkOperations_updateMessageLabels: (context: Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext) => Promise<{
+        successCount: number;
+        failureCount: number;
+    }>;
+    MessageBulkOperations_reportSpam: (context: Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<SpamReportBulkOutcome>;
+    MessageBulkOperations_notSpam: (context: Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<SpamReportBulkOutcome>;
+};

package/dist/src/handlers/organize.d.ts

@@ -1,10 +1,16 @@
-import type { OrganizeInput } from "@remit/api-openapi-types";
+import type { CreateOrganizeJobResponse, OrganizeInput, OrganizeJobResponse, OrganizePreviewResponse } from "@remit/api-openapi-types";
+import type { Context } from "openapi-backend";
 import { type OrganizePredicate } from "../service/organize.js";
-import type { OperationHandler, OrganizeJobDetailOperationIds, OrganizeOperationIds } from "../types.js";
+import type { HandlerContext } from "../types.js";
 /**
  * Normalize the request body into the flattened predicate the job row and the
  * matcher share.
  */
 export declare const predicateFromInput: (input: OrganizeInput) => OrganizePredicate;
-export declare const OrganizeOperations: Record<OrganizeOperationIds, OperationHandler<OrganizeOperationIds, "accountFanout">>;
-export declare const OrganizeJobDetailOperations: Record<OrganizeJobDetailOperationIds, OperationHandler<OrganizeJobDetailOperationIds, "accountFanout">>;
+export declare const OrganizeOperations: {
+    OrganizeOperations_createOrganizeJob: (context: Context, ctx: HandlerContext<"accountFanout">) => Promise<CreateOrganizeJobResponse>;
+    OrganizeOperations_previewOrganize: (context: Context, ctx: HandlerContext) => Promise<OrganizePreviewResponse>;
+};
+export declare const OrganizeJobDetailOperations: {
+    OrganizeJobDetailOperations_getOrganizeJob: (context: Context, ctx: HandlerContext) => Promise<OrganizeJobResponse>;
+};

package/dist/src/handlers/outbox-attachment.d.ts

@@ -4,7 +4,7 @@ import type { Context } from "openapi-backend";
 import type { ApiConfig } from "../config/api-config.js";
 import type { HandlerContext } from "../types.js";
 export declare const toOutboxAttachmentResponse: (config: ApiConfig) => (item: OutboxAttachmentItem) => OutboxAttachmentResponse;
-interface RejectionResponse {
+export interface RejectionResponse {
     statusCode: number;
     body: OutboxAttachmentRejection;
 }
@@ -22,4 +22,3 @@ export declare const mintOutboxAttachment: (context: Context, ctx: HandlerContex
  * how many there are is not evidence.
  */
 export declare const completeOutboxAttachment: (context: Context, ctx: HandlerContext) => Promise<OutboxAttachmentResponse | RejectionResponse>;
-export {};

package/dist/src/handlers/outbox.d.ts

@@ -1,4 +1,25 @@
-import type { OperationHandler, OutboxAttachmentOperationIds, OutboxDetailOperationIds, OutboxOperationIds } from "../types.js";
-export declare const OutboxOperations: Record<OutboxOperationIds, OperationHandler<OutboxOperationIds, "smtp">>;
-export declare const OutboxDetailOperations: Record<OutboxDetailOperationIds, OperationHandler<OutboxDetailOperationIds, "smtp">>;
-export declare const OutboxAttachmentOperations: Record<OutboxAttachmentOperationIds, OperationHandler<OutboxAttachmentOperationIds, "smtp">>;
+import type { OutboxMessageResponse } from "@remit/api-openapi-types";
+import type { Context } from "openapi-backend";
+import type { HandlerContext } from "../types.js";
+export declare const OutboxOperations: {
+    OutboxOperations_createOutboxMessage: (context: Context, ctx: HandlerContext<"smtp">) => Promise<OutboxMessageResponse>;
+    OutboxOperations_listOutboxMessages: (context: Context, ctx: HandlerContext) => Promise<{
+        items: never[];
+        continuationToken: null;
+    } | {
+        items: import("@remit/api-openapi-types").Components.Schemas.OutboxMessageResponse[];
+        continuationToken: string | undefined;
+    }>;
+};
+export declare const OutboxDetailOperations: {
+    OutboxDetailOperations_getOutboxMessage: (context: Context, ctx: HandlerContext) => Promise<OutboxMessageResponse>;
+    OutboxDetailOperations_updateOutboxMessage: (context: Context, ctx: HandlerContext<"smtp">) => Promise<OutboxMessageResponse>;
+    OutboxDetailOperations_deleteOutboxMessage: (context: Context, ctx: HandlerContext<"smtp">) => Promise<{
+        statusCode: number;
+    }>;
+    OutboxDetailOperations_sendOutboxMessage: (context: Context, ctx: HandlerContext<"smtp">) => Promise<OutboxMessageResponse>;
+    OutboxDetailOperations_mintOutboxAttachment: (context: Context, ctx: HandlerContext) => Promise<import("@remit/api-openapi-types").MintOutboxAttachmentResponse | import("./outbox-attachment.js").RejectionResponse>;
+};
+export declare const OutboxAttachmentOperations: {
+    OutboxAttachmentOperations_completeOutboxAttachment: (context: Context, ctx: HandlerContext) => Promise<import("@remit/api-openapi-types").OutboxAttachmentResponse | import("./outbox-attachment.js").RejectionResponse>;
+};

package/dist/src/handlers/sync.d.ts

@@ -1,7 +1,7 @@
 import type { FifoQueueProducer } from "@remit/data-ports";
 import { type FireAndForgetLogger } from "../service/fire-and-forget.js";
 import { type SyncMailboxesEvent } from "../service/trigger-sync.js";
-import type { OperationHandler, SyncOperationIds } from "../types.js";
+import type { HandlerContext } from "../types.js";
 interface SyncTriggerDeps {
     queue: FifoQueueProducer<SyncMailboxesEvent>;
     logger: FireAndForgetLogger & {
@@ -24,5 +24,18 @@ interface SyncTriggerDeps {
  * account-lookup / ownership failure still propagates and 500s as normal.
  */
 export declare const triggerSyncSafe: (accountId: string, accountConfigId: string, deps: SyncTriggerDeps) => Promise<void>;
-export declare const SyncOperations: Record<SyncOperationIds, OperationHandler<SyncOperationIds, "sync">>;
+export declare const SyncOperations: {
+    SyncOperations_triggerSync: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext<"sync">) => Promise<{
+        triggered: boolean;
+        message: string;
+    }>;
+    SyncOperations_getSyncStatus: (context: import("openapi-backend").Context<any, any, any, any, any, import("openapi-backend").Document>, ctx: HandlerContext) => Promise<{
+        accountId: string;
+        syncPhase: "error" | "idle" | "discovering_mailboxes" | "syncing_inbox" | "syncing_others" | "complete" | undefined;
+        mailboxCountTotal: number | undefined;
+        mailboxCountSynced: number | undefined;
+        lastSyncAt: number | undefined;
+        mailboxes: import("./sync-progress.js").MailboxSyncProgress[];
+    }>;
+};
 export {};

package/dist/src/service/create-remit-client.js

@@ -1,5 +1,5 @@
 import { logger } from "@remit/logger";
-import { BodySyncQueueService, BodySyncService, createConnection, FlagPushService, FlagQueueService, MailboxQueueService, MessageMoveService, OutboxAttachmentService, OutboxQueueService, PlacementMoveService, SpamReportService, SyncWarningService, } from "@remit/mailbox-service";
+import { BodySyncQueueService, BodySyncService, createConnection, FlagPushService, FlagQueueService, fifoMailboxManagement, MailboxQueueService, MessageMoveService, OutboxAttachmentService, OutboxQueueService, PlacementMoveService, SpamReportService, SyncWarningService, } from "@remit/mailbox-service";
 import { buildFilterConfig } from "@remit/mailbox-service/filter-config";
 import { deserializeEncryptedPayload, } from "@remit/secrets-service";
 const buildConnectionScope = (accountService, secretsService) => async (accountId) => {
@@ -131,7 +131,7 @@ export const composeSyncServices = (core, queues) => {
         }),
         mailboxQueue: new MailboxQueueService({
             mailboxService: core.mailbox,
-            queue: queues.sync,
+            enqueue: fifoMailboxManagement(queues.sync),
             logger,
         }),
         messageMove,

package/dist/src/service/queues.d.ts

@@ -5,7 +5,7 @@ export type SyncQueueEvent = SyncMailboxesEvent | FlagPushEvent | MailboxManagem
 export interface RemitClientQueues {
     sync: FifoQueueProducer<SyncQueueEvent>;
     accountFanout: QueueProducer<AccountFanoutEvent>;
-    smtp: FifoQueueProducer<SendMessageEvent>;
+    smtp: QueueProducer<SendMessageEvent>;
     messageManagement: QueueProducer<PlacementMovePushEvent>;
     body: QueueProducer<SyncMessageBodyEvent>;
 }

package/dist/src/service/shared-deps.js

@@ -1,6 +1,6 @@
 import { createCachedDataKeyProvider, createSecretsService, } from "@remit/secrets-service";
 import { createKmsDataKeyProvider, FAKE_KMS_KEY_ID, } from "@remit/secrets-service/kms";
-import { createQueueProducer } from "@remit/sqs-client/producer";
+import { createFifoQueueProducer, createStandardQueueProducer, } from "@remit/sqs-client/producer";
 import { createStorageService } from "@remit/storage-service/s3";
 import { env } from "expect-env";
 export const sqsQueueUrlsFromEnv = () => ({
@@ -11,11 +11,13 @@ export const sqsQueueUrlsFromEnv = () => ({
     body: env.SQS_QUEUE_URL_BODY,
 });
 export const sqsQueues = (urls) => ({
-    sync: createQueueProducer({ queueUrl: urls.sync }),
-    accountFanout: createQueueProducer({ queueUrl: urls.accountFanout }),
-    smtp: createQueueProducer({ queueUrl: urls.smtp }),
-    messageManagement: createQueueProducer({ queueUrl: urls.messageManagement }),
-    body: createQueueProducer({ queueUrl: urls.body }),
+    sync: createFifoQueueProducer({ queueUrl: urls.sync }),
+    accountFanout: createStandardQueueProducer({ queueUrl: urls.accountFanout }),
+    smtp: createStandardQueueProducer({ queueUrl: urls.smtp }),
+    messageManagement: createStandardQueueProducer({
+        queueUrl: urls.messageManagement,
+    }),
+    body: createStandardQueueProducer({ queueUrl: urls.body }),
 });
 export const buildSharedDeps = (queues) => ({
     storage: createStorageService(),

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remit/backend",
-	"version": "0.0.145",
+	"version": "0.0.147",
 	"description": "Remit Mail Inspector API backend",
 	"license": "MIT",
 	"author": "",
@@ -19,6 +19,10 @@
 			"types": "./dist/src/serve.d.ts",
 			"default": "./dist/src/serve.js"
 		},
+		"./handlers": {
+			"types": "./dist/src/handlers/index.d.ts",
+			"default": "./dist/src/handlers/index.js"
+		},
 		"./client": {
 			"types": "./dist/src/service/data-client.d.ts",
 			"default": "./dist/src/service/data-client.js"