@remit/data-ports 0.0.1

package/src/interfaces/account-setting.ts

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

package/src/interfaces/account.ts

@@ -0,0 +1,40 @@
+import type {
+	AccountDescription,
+	AccountItem,
+	AccountSchedulerPage,
+	CreateAccountInput,
+	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?: string[],
+	): 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[]>;
+	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/src/interfaces/address.ts

@@ -0,0 +1,82 @@
+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>;
+	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[]>;
+	listByAccountConfig(input: {
+		accountConfigId: string;
+		normalizedCompound?: string;
+		cursor?: string;
+		limit?: number;
+	}): Promise<ResultList<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/src/interfaces/envelope.ts

@@ -0,0 +1,32 @@
+import type {
+	BodyPartContentUpsertInput,
+	BodyPartItem,
+	BodyPartUpsertInput,
+	CreateEnvelopeInput,
+	EnvelopeItem,
+	MessageData,
+	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>;
+	upsertBodyPartContents(
+		messageId: string,
+		contents: BodyPartContentUpsertInput[],
+	): Promise<void>;
+	getMessageData(messageId: string): Promise<MessageData>;
+	listBodyParts(messageId: string): Promise<BodyPartItem[]>;
+}

package/src/interfaces/filter-anchor.ts

@@ -0,0 +1,11 @@
+import type { CreateFilterAnchorInput, FilterAnchorItem } from "../types.js";
+
+export interface IFilterAnchorRepository {
+	put(input: CreateFilterAnchorInput): Promise<FilterAnchorItem>;
+	get(
+		accountConfigId: string,
+		filterId: string,
+	): Promise<FilterAnchorItem | null>;
+	listByAccountConfig(accountConfigId: string): Promise<FilterAnchorItem[]>;
+	delete(accountConfigId: string, filterId: string): Promise<void>;
+}

package/src/interfaces/filter.ts

@@ -0,0 +1,41 @@
+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/src/interfaces/label.ts

@@ -0,0 +1,21 @@
+import type {
+	CreateLabelInput,
+	LabelItem,
+	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[]>;
+	findByNormalizedName(
+		accountConfigId: string,
+		normalizedName: string,
+	): Promise<LabelItem | null>;
+}

package/src/interfaces/mailbox-lock.ts

@@ -0,0 +1,31 @@
+import type { MailboxLockItem, WithMailboxLockResult } from "../types.js";
+
+export interface IMailboxLockRepository {
+	tryAcquireLock(
+		mailboxId: string,
+		eventName: string,
+		accountId: string,
+		lockId: string,
+	): 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/src/interfaces/mailbox-special-use.ts

@@ -0,0 +1,33 @@
+import type {
+	MailboxSpecialUseItem,
+	MailboxSpecialUseValue,
+} from "../types.js";
+
+export interface IMailboxSpecialUseRepository {
+	create(
+		mailboxId: string,
+		specialUse: MailboxSpecialUseValue,
+	): Promise<MailboxSpecialUseItem>;
+	createMany(
+		mailboxId: string,
+		specialUses: MailboxSpecialUseValue[],
+	): Promise<MailboxSpecialUseItem[]>;
+	listByMailboxId(mailboxId: string): Promise<MailboxSpecialUseItem[]>;
+	deleteByMailboxId(mailboxId: string): Promise<number>;
+	findBySpecialUse(
+		accountId: string,
+		specialUse: MailboxSpecialUseValue,
+	): Promise<{ mailboxId: string; fullPath: string } | null>;
+	findInboxMailbox(
+		accountId: string,
+	): Promise<{ mailboxId: string; fullPath: string } | null>;
+	findTrashMailbox(
+		accountId: string,
+	): Promise<{ mailboxId: string; fullPath: string } | null>;
+	findArchiveMailbox(
+		accountId: string,
+	): Promise<{ mailboxId: string; fullPath: string } | null>;
+	findJunkMailbox(
+		accountId: string,
+	): Promise<{ mailboxId: string; fullPath: string } | null>;
+}

package/src/interfaces/mailbox.ts

@@ -0,0 +1,59 @@
+import type {
+	CreateMailboxInput,
+	MailboxItem,
+	ResultList,
+	UpdateMailboxInput,
+} from "../types.js";
+
+export interface IMailboxRepository {
+	create(input: CreateMailboxInput): Promise<MailboxItem>;
+	get(accountId: string, mailboxId: string): Promise<MailboxItem>;
+	get(accountId: string, mailboxIds: string[]): Promise<MailboxItem[]>;
+	/**
+	 * Resolve the owning accountId for a mailbox by its (globally unique) id,
+	 * without a tenant scope. Returns only the owner id (no row content); null
+	 * when the mailbox does not exist.
+	 *
+	 * The result is NOT a trusted tenant — it is derived from the row, so it must
+	 * never be fed back as the scope of a request-facing read. It has two uses:
+	 * pure system routing/indexing that has no tenant of its own (stream bridge,
+	 * search indexer), and ownership bootstrap where a request-facing caller
+	 * compares the resolved owner's accountConfigId against its OWN authenticated
+	 * accountConfigId to decide the caller may proceed.
+	 */
+	resolveAccountId(mailboxId: string): Promise<string | null>;
+	update(
+		accountId: string,
+		mailboxId: string,
+		input: UpdateMailboxInput,
+		remove?: string[],
+	): Promise<MailboxItem>;
+	delete(accountId: string, mailboxId: string): Promise<void>;
+	deleteMany(accountId: string, mailboxIds: string[]): Promise<void>;
+	listByAccount(
+		accountId: string,
+		options?: { limit?: number; continuationToken?: string },
+	): Promise<ResultList<MailboxItem>>;
+	listAllByAccount(accountId: string): Promise<MailboxItem[]>;
+	findByPath(accountId: string, fullPath: string): Promise<MailboxItem | null>;
+	getOrCreateByPath(
+		accountId: string,
+		fullPath: string,
+		defaults: Omit<CreateMailboxInput, "accountId" | "fullPath">,
+	): Promise<MailboxItem>;
+	findByPathPrefix(
+		accountId: string,
+		pathPrefix: string,
+		delimiter?: string,
+	): Promise<MailboxItem[]>;
+	findBySyncStatus(
+		accountId: string,
+		syncStatus: NonNullable<MailboxItem["syncStatus"]>,
+	): Promise<MailboxItem[]>;
+	renameChildPaths(
+		accountId: string,
+		oldPath: string,
+		newPath: string,
+		delimiter?: string,
+	): Promise<void>;
+}

package/src/interfaces/message-flag-push.ts

@@ -0,0 +1,17 @@
+import type { MessageFlagPushItem, PutMessageFlagPushInput } from "../types.js";
+
+export interface IMessageFlagPushRepository {
+	put(input: PutMessageFlagPushInput): Promise<MessageFlagPushItem>;
+	find(
+		messageId: string,
+		flagName: string,
+	): Promise<MessageFlagPushItem | null>;
+	updateState(
+		messageId: string,
+		flagName: string,
+		state: MessageFlagPushItem["state"],
+	): Promise<MessageFlagPushItem>;
+	delete(messageId: string, flagName: string): Promise<void>;
+	listByAccountId(accountId: string): Promise<MessageFlagPushItem[]>;
+	listByMailboxId(mailboxId: string): Promise<MessageFlagPushItem[]>;
+}

package/src/interfaces/message-flag.ts

@@ -0,0 +1,15 @@
+import type { CreateMessageFlagInput, MessageFlagItem } from "../types.js";
+
+export interface IMessageFlagRepository {
+	create(input: CreateMessageFlagInput): Promise<MessageFlagItem>;
+	get(messageFlagId: string): Promise<MessageFlagItem>;
+	get(messageFlagIds: string[]): Promise<MessageFlagItem[]>;
+	delete(messageFlagId: string): Promise<void>;
+	deleteMany(messageFlagIds: string[]): Promise<void>;
+	getFlags(messageId: string): Promise<MessageFlagItem[]>;
+	hasFlag(messageId: string, flagName: string): Promise<boolean>;
+	addFlag(messageId: string, flagName: string): Promise<MessageFlagItem>;
+	removeFlag(messageId: string, flagName: string): Promise<void>;
+	addFlags(messageId: string, flagNames: string[]): Promise<void>;
+	removeFlags(messageId: string, flagNames: string[]): Promise<void>;
+}

package/src/interfaces/message-label.ts

@@ -0,0 +1,11 @@
+import type { CreateMessageLabelInput, MessageLabelItem } from "../types.js";
+
+export interface IMessageLabelRepository {
+	apply(input: CreateMessageLabelInput): Promise<MessageLabelItem>;
+	remove(messageId: string, labelId: string): Promise<void>;
+	listByMessageId(messageId: string): Promise<MessageLabelItem[]>;
+	listByLabelId(
+		accountConfigId: string,
+		labelId: string,
+	): Promise<MessageLabelItem[]>;
+}

package/src/interfaces/message-placement-move.ts

@@ -0,0 +1,15 @@
+import type {
+	MessagePlacementMoveItem,
+	PutMessagePlacementMoveInput,
+} from "../types.js";
+
+export interface IMessagePlacementMoveRepository {
+	put(input: PutMessagePlacementMoveInput): Promise<MessagePlacementMoveItem>;
+	find(messageId: string): Promise<MessagePlacementMoveItem | null>;
+	updateState(
+		messageId: string,
+		state: MessagePlacementMoveItem["state"],
+	): Promise<MessagePlacementMoveItem>;
+	delete(messageId: string): Promise<void>;
+	listByAccountId(accountId: string): Promise<MessagePlacementMoveItem[]>;
+}

package/src/interfaces/message.ts

@@ -0,0 +1,40 @@
+import type {
+	CreateMessageInput,
+	MessageDescription,
+	MessageIdSource,
+	MessageItem,
+	ResultList,
+	UpdateMessageInput,
+	UpdateMessageMoveInput,
+} from "../types.js";
+
+export interface IMessageRepository {
+	create(input: CreateMessageInput): Promise<MessageItem>;
+	upsert(input: CreateMessageInput): Promise<MessageItem>;
+	upsertWithStatus(
+		input: CreateMessageInput,
+	): Promise<{ item: MessageItem; created: boolean }>;
+	get(messageId: string): Promise<MessageItem>;
+	get(messageIds: string[]): Promise<MessageItem[]>;
+	update(messageId: string, input: UpdateMessageInput): Promise<MessageItem>;
+	clearBodyStorageKey(messageId: string): Promise<MessageItem>;
+	delete(messageId: string): Promise<void>;
+	deleteMany(messageIds: string[]): Promise<void>;
+	listByMailbox(
+		mailboxId: string,
+		options?: { limit?: number; continuationToken?: string },
+	): Promise<ResultList<MessageItem>>;
+	listAllByMailbox(mailboxId: string): Promise<MessageItem[]>;
+	describe(messageId: string): Promise<MessageDescription>;
+	updateForMove(
+		messageId: string,
+		input: UpdateMessageMoveInput,
+	): Promise<MessageItem>;
+	updateUid(
+		messageId: string,
+		newUid: number,
+		newMailboxId: string,
+	): Promise<MessageItem>;
+}
+
+export type { MessageIdSource };

package/src/interfaces/organize-job-request.ts

@@ -0,0 +1,19 @@
+import type {
+	CreateOrganizeJobRequestInput,
+	OrganizeJobRequestItem,
+	ResultList,
+	UpdateOrganizeJobRequestInput,
+} from "../types.js";
+
+export interface IOrganizeJobRequestRepository {
+	create(input: CreateOrganizeJobRequestInput): Promise<OrganizeJobRequestItem>;
+	get(organizeJobId: string): Promise<OrganizeJobRequestItem>;
+	update(
+		organizeJobId: string,
+		input: UpdateOrganizeJobRequestInput,
+	): Promise<OrganizeJobRequestItem>;
+	listByAccountConfig(
+		accountConfigId: string,
+		options?: { limit?: number; continuationToken?: string },
+	): Promise<ResultList<OrganizeJobRequestItem>>;
+}

package/src/interfaces/outbox-message.ts

@@ -0,0 +1,51 @@
+import type {
+	CreateOutboxMessageInput,
+	OutboxMessageItem,
+	ResultList,
+	UpdateOutboxMessageInput,
+} from "../types.js";
+
+export interface IOutboxMessageRepository {
+	create(input: CreateOutboxMessageInput): Promise<OutboxMessageItem>;
+	/**
+	 * `mode: "read"` (default) throws NotFoundError on a foreign message so a
+	 * GET doesn't leak existence. `mode: "act"` throws ForbiddenError instead,
+	 * for action verbs (PATCH/POST/DELETE) where the caller has already named
+	 * the resource and the API contract says to explicitly deny rather than
+	 * feign 404 — see assertAccountOwnership / assertMessagesOwned.
+	 */
+	get(
+		accountConfigId: string,
+		outboxMessageId: string,
+		mode?: "read" | "act",
+	): Promise<OutboxMessageItem>;
+	get(
+		accountConfigId: string,
+		outboxMessageIds: string[],
+	): Promise<OutboxMessageItem[]>;
+	update(
+		accountConfigId: string,
+		outboxMessageId: string,
+		input: UpdateOutboxMessageInput,
+	): Promise<OutboxMessageItem>;
+	updateStatus(
+		accountConfigId: string,
+		outboxMessageId: string,
+		status: OutboxMessageItem["status"],
+	): Promise<OutboxMessageItem>;
+	markSent(
+		accountConfigId: string,
+		outboxMessageId: string,
+		fields: { sentAt: number; smtpMessageId?: string },
+	): Promise<OutboxMessageItem>;
+	delete(accountConfigId: string, outboxMessageId: string): Promise<void>;
+	deleteMany(
+		accountConfigId: string,
+		outboxMessageIds: string[],
+	): Promise<void>;
+	listByAccount(
+		accountId: string,
+		options?: { limit?: number; continuationToken?: string },
+	): Promise<ResultList<OutboxMessageItem>>;
+	listQueued(accountId: string): Promise<OutboxMessageItem[]>;
+}

package/src/interfaces/thread-message.ts

@@ -0,0 +1,122 @@
+import type {
+	CreateThreadMessageInput,
+	ResultList,
+	SearchOptions,
+	ThreadMessageItem,
+	UpdateThreadMessageInput,
+} from "../types.js";
+
+export interface IThreadMessageRepository {
+	create(input: CreateThreadMessageInput): Promise<ThreadMessageItem>;
+	get(
+		accountConfigId: string,
+		threadMessageId: string,
+	): Promise<ThreadMessageItem>;
+	get(
+		accountConfigId: string,
+		threadMessageIds: string[],
+	): Promise<ThreadMessageItem[]>;
+	update(
+		accountConfigId: string,
+		threadMessageId: string,
+		input: UpdateThreadMessageInput,
+		options?: {
+			composites?: {
+				sentDate?: number;
+				mailboxId?: string;
+				isRead?: boolean;
+				isDeleted?: boolean;
+				hasStars?: boolean;
+				hasAttachment?: boolean;
+			};
+		},
+	): Promise<ThreadMessageItem>;
+	delete(accountConfigId: string, threadMessageId: string): Promise<void>;
+	deleteMany(
+		keys: Array<{ accountConfigId: string; threadMessageId: string }>,
+	): Promise<void>;
+	listByAccount(
+		accountConfigId: string,
+		options?: { limit?: number; continuationToken?: string },
+	): Promise<ResultList<ThreadMessageItem>>;
+	listByDate(
+		accountConfigId: string,
+		options?: {
+			order?: "asc" | "desc";
+			limit?: number;
+			continuationToken?: string;
+			inboxMailboxIds?: Set<string>;
+			excludeDeleted?: boolean;
+		},
+	): Promise<ResultList<ThreadMessageItem>>;
+	listByThread(
+		threadId: string,
+		accountConfigId: string,
+		options?: {
+			order?: "asc" | "desc";
+			limit?: number;
+			continuationToken?: string;
+			mailboxId?: string;
+			excludeDeleted?: boolean;
+		},
+	): Promise<ResultList<ThreadMessageItem>>;
+	findByMessageId(
+		accountConfigId: string,
+		messageId: string,
+	): Promise<ThreadMessageItem | null>;
+	findAllByMessageId(
+		accountConfigId: string,
+		messageId: string,
+	): Promise<ThreadMessageItem[]>;
+	getByMessageId(
+		accountConfigId: string,
+		messageId: string,
+	): Promise<ThreadMessageItem>;
+	listByMailbox(
+		accountConfigId: string,
+		mailboxId: string,
+		options?: {
+			order?: "asc" | "desc";
+			limit?: number;
+			continuationToken?: string;
+			attributes?: string[];
+			excludeDeleted?: boolean;
+		},
+	): Promise<ResultList<ThreadMessageItem>>;
+	countByThread(accountConfigId: string, threadId: string): Promise<number>;
+	searchByMailbox(
+		accountConfigId: string,
+		mailboxId: string,
+		search: SearchOptions,
+		options?: {
+			order?: "asc" | "desc";
+			count?: number;
+			continuationToken?: string;
+			excludeDeleted?: boolean;
+		},
+	): Promise<ResultList<ThreadMessageItem>>;
+	searchByMailboxWindow(
+		accountConfigId: string,
+		mailboxId: string,
+		search: SearchOptions,
+		options?: {
+			order?: "asc" | "desc";
+			limit?: number;
+			continuationToken?: string;
+			attributes?: string[];
+			excludeDeleted?: boolean;
+		},
+	): Promise<ResultList<ThreadMessageItem>>;
+	countByMailbox(
+		accountConfigId: string,
+		mailboxId: string,
+		search: SearchOptions,
+		options?: {
+			limit?: number;
+			excludeDeleted?: boolean;
+			order?: "asc" | "desc";
+		},
+	): Promise<number>;
+	listAllByAccount(accountConfigId: string): Promise<ThreadMessageItem[]>;
+	deleteAllByAccount(accountConfigId: string): Promise<number>;
+}