@remit/data-ports 0.0.83 → 0.0.85

package/src/interfaces/address.ts

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

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

package/src/interfaces/calendar-event-index.ts

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

package/src/interfaces/calendar-feed-token.ts

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

package/src/interfaces/calendar-object.ts

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

package/src/interfaces/calendar-suggestion.ts

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

package/src/interfaces/calendar-unit-of-work.ts

@@ -1,47 +0,0 @@
-import type { ICalendarCollectionRepository } from "./calendar-collection.js";
-import type { ICalendarEventIndexRepository } from "./calendar-event-index.js";
-import type { ICalendarFeedTokenRepository } from "./calendar-feed-token.js";
-import type { ICalendarObjectRepository } from "./calendar-object.js";
-import type { ICalendarSuggestionRepository } from "./calendar-suggestion.js";
-
-/**
- * The repositories one calendar write set touches, bound to a single unit of
- * work.
- */
-export interface CalendarUnitOfWorkRepositories {
-	calendarCollection: ICalendarCollectionRepository;
-	calendarObject: ICalendarObjectRepository;
-	calendarEventIndex: ICalendarEventIndexRepository;
-	/**
-	 * Present so accepting a suggestion settles the card in the same unit that
-	 * writes the resource (issue #1033). The two are one fact: a card still
-	 * asking with the event already in the calendar, or a card marked accepted
-	 * with no event behind it, is a state nothing later can repair.
-	 */
-	calendarSuggestion: ICalendarSuggestionRepository;
-	/**
-	 * Present so removing a calendar takes its feed address with it (issue
-	 * #1067). A token row outliving its collection is a credential pointing at
-	 * nothing — it answers 404, but nobody can see it to revoke it, and a later
-	 * calendar under the same derived id would inherit it.
-	 */
-	calendarFeedToken: ICalendarFeedTokenRepository;
-}
-
-/**
- * Runs a calendar write set as one atomic unit (issue #15). Writing a resource
- * is three writes — the object, its replaced occurrence rows, and the
- * collection's sequence bump — and none of them is meaningful without the
- * others: an object with stale occurrences is a calendar showing events the
- * resource no longer has, and an object written without the bump is a change no
- * sync report will ever hand a client.
- *
- * A throw rolls the whole set back. Backends without cross-entity transactions
- * supply a pass-through implementation that runs the callback against the plain
- * repositories.
- */
-export interface ICalendarUnitOfWork {
-	transaction<T>(
-		fn: (repos: CalendarUnitOfWorkRepositories) => Promise<T>,
-	): Promise<T>;
-}

package/src/interfaces/config-import.ts

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

package/src/interfaces/envelope.ts

@@ -1,32 +0,0 @@
-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-transaction.ts

@@ -1,23 +0,0 @@
-import type {
-	CreateFilterAnchorInput,
-	CreateFilterInput,
-	FilterItem,
-} from "../types.js";
-
-/**
- * Atomically creates a `Filter` row and its optional sibling `FilterAnchor`
- * row (#351). Without this, the two writes ran sequentially: a failure on the
- * second left a `Filter` durably marked `hasAnchor: true` with no matching
- * `FilterAnchor` row — a filter that looks normal but silently matches
- * nothing, forever, with no repair path (the anchor message id is never
- * retained once `createFilterWithAnchor` returns).
- *
- * `anchor` omits `filterId` — it is not known until the `Filter` row is
- * created inside the same transaction.
- */
-export interface IFilterAnchorTransaction {
-	createWithAnchor(
-		filter: CreateFilterInput,
-		anchor: Omit<CreateFilterAnchorInput, "filterId"> | null,
-	): Promise<FilterItem>;
-}

package/src/interfaces/filter-anchor.ts

@@ -1,11 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

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

package/src/interfaces/mailbox-lock.ts

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