@remit/data-ports 0.0.1

package/package.json

@@ -0,0 +1,54 @@
+{
+	"name": "@remit/data-ports",
+	"version": "0.0.1",
+	"type": "module",
+	"main": "src/index.ts",
+	"types": "src/index.ts",
+	"exports": {
+		".": {
+			"types": "./src/index.ts",
+			"default": "./src/index.ts"
+		},
+		"./conformance": {
+			"types": "./src/conformance/index.ts",
+			"default": "./src/conformance/index.ts"
+		},
+		"./errors": {
+			"types": "./src/errors.ts",
+			"default": "./src/errors.ts"
+		},
+		"./id": {
+			"types": "./src/id.ts",
+			"default": "./src/id.ts"
+		},
+		"./account-settings": {
+			"types": "./src/account-settings.ts",
+			"default": "./src/account-settings.ts"
+		},
+		"./wellknown": {
+			"types": "./src/wellknown.ts",
+			"default": "./src/wellknown.ts"
+		}
+	},
+	"scripts": {
+		"test:typecheck": "tsgo --noEmit"
+	},
+	"dependencies": {
+		"@remit/domain-enums": "*",
+		"short-uuid": "*",
+		"uuid": "*",
+		"zod": "*"
+	},
+	"devDependencies": {
+		"@remit/api-zod-schemas": "*"
+	},
+	"license": "MIT",
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/remit-mail/remit.git",
+		"directory": "packages/data-ports"
+	}
+}

package/src/account-settings.ts

@@ -0,0 +1,192 @@
+import { AccountSettingName } from "@remit/domain-enums";
+import { z } from "zod";
+
+export type AccountSettingNameValue =
+	(typeof AccountSettingName)[keyof typeof AccountSettingName];
+
+/**
+ * Per-`kind` value schemas, one per variant of the `AccountSettingValue`
+ * discriminated union in TypeSpec (`AccountSetting.tsp`). Authored here because
+ * the registry is the binding authority for what a value must satisfy — these
+ * are the contract every read and write is validated against.
+ */
+export const BooleanSettingSchema = z.object({
+	kind: z.literal("Boolean"),
+	value: z.boolean(),
+});
+export const StringSettingSchema = z.object({
+	kind: z.literal("String"),
+	value: z.string(),
+});
+export const NumberSettingSchema = z.object({
+	kind: z.literal("Number"),
+	value: z.number(),
+});
+export const StringListSettingSchema = z.object({
+	kind: z.literal("StringList"),
+	value: z.array(z.string()),
+});
+export const MapSettingSchema = z.object({
+	kind: z.literal("Map"),
+	value: z.record(z.string(), z.string()),
+});
+/**
+ * MutedFlag-valued setting. The value is a rich mute object (`MutedFlag` in
+ * TypeSpec / `@remit/api-openapi-types`): a boolean plus audit metadata. The
+ * schema is authored here — generated packages ship only `.d.ts` for this shape,
+ * so the registry owns the runtime contract a relocated mute flag is validated
+ * against (RFC 032 lesson from the signature slice).
+ */
+export const MutedFlagSettingSchema = z.object({
+	kind: z.literal("MutedFlag"),
+	value: z.object({
+		value: z.boolean(),
+		setAt: z.number(),
+		setBy: z.string().optional(),
+		expiresAt: z.number().optional(),
+		reason: z.string().optional(),
+	}),
+});
+
+/**
+ * RFC 032 Tier 1 registry: binds each setting `name` to the zod schema its
+ * `value` must satisfy. The discriminated union (`kind`) types the shape on the
+ * wire; this registry binds a name to one concrete shape, so a read or write of
+ * a given setting is validated against exactly the variant it requires.
+ *
+ * Adding a setting key is a deliberate change: extend the `AccountSettingName`
+ * enum in TypeSpec and add an entry here — never an ad-hoc, unvalidated value.
+ */
+export const accountSettingRegistry = {
+	[AccountSettingName.Theme]: StringSettingSchema,
+	[AccountSettingName.Density]: StringSettingSchema,
+	[AccountSettingName.DefaultComposerFormat]: StringSettingSchema,
+	[AccountSettingName.PinnedFolders]: StringListSettingSchema,
+	[AccountSettingName.AccountSignaturePlainText]: StringSettingSchema,
+	[AccountSettingName.AccountSignatureHtml]: StringSettingSchema,
+	[AccountSettingName.AccountDisplayName]: StringSettingSchema,
+	[AccountSettingName.AccountMuted]: MutedFlagSettingSchema,
+	[AccountSettingName.MailboxDisplayName]: StringSettingSchema,
+	[AccountSettingName.MailboxMuted]: MutedFlagSettingSchema,
+	[AccountSettingName.FolderRoleAppointment]: StringSettingSchema,
+	/**
+	 * Deprecated tombstone: superseded by `FolderRoleAppointment` (RFC 032
+	 * exclusive-folder-appointment, #976). Kept only so `baseSettingName`
+	 * recognises leftover `MailboxRole#<mailboxId>` rows written by the #963/#964
+	 * backfill instead of throwing `Unknown account setting name`; the read-side
+	 * groupers (`groupAccountOverrides`, `groupMailboxOverrides`,
+	 * `groupFolderAppointmentsByAccount`) already skip any base they don't
+	 * explicitly handle, so a `MailboxRole` row is ignored, not surfaced. Do not
+	 * write new rows under this name. Remove once the row-deletion migration ships.
+	 */
+	[AccountSettingName.MailboxRole]: StringSettingSchema,
+} as const satisfies Record<AccountSettingNameValue, z.ZodTypeAny>;
+
+export type AccountSettingRegistry = typeof accountSettingRegistry;
+
+export type AccountSettingValueFor<N extends AccountSettingNameValue> = z.infer<
+	AccountSettingRegistry[N]
+>;
+
+/**
+ * Separator between a setting's base enum member and its per-target suffix in a
+ * composite stored name (e.g. `AccountSignaturePlainText#<accountId>`). Some
+ * settings are per-account, but `AccountSetting` is keyed per accountConfigId, so
+ * the stored `name` encodes the target after this separator. The registry still
+ * validates by the base member; readers filter by the suffix.
+ */
+export const SETTING_NAME_SEPARATOR = "#";
+
+/**
+ * A persisted setting `name`. Either a plain closed-enum member or a composite
+ * `<base>#<suffix>` for a per-target setting. Always a `string` whose first
+ * segment is a known base member.
+ */
+export type StoredSettingName = string;
+
+/** Compose the stored name for a per-target setting (e.g. one signature per account). */
+export function composeSettingName(
+	base: AccountSettingNameValue,
+	target: string,
+): StoredSettingName {
+	return `${base}${SETTING_NAME_SEPARATOR}${target}`;
+}
+
+const isAccountSettingNameValue = (
+	value: string,
+): value is AccountSettingNameValue =>
+	Object.hasOwn(accountSettingRegistry, value);
+
+/**
+ * Derive the base enum member from a stored name. Strips the `#<suffix>` from a
+ * composite name; returns a plain name unchanged. Throws when the base segment
+ * is not a registered setting (let-it-crash — an unknown key is a programmer
+ * error, never an ad-hoc column).
+ */
+export function baseSettingName(
+	name: StoredSettingName,
+): AccountSettingNameValue {
+	const base = name.split(SETTING_NAME_SEPARATOR)[0] ?? "";
+	if (!isAccountSettingNameValue(base)) {
+		throw new Error(`Unknown account setting name: ${name}`);
+	}
+	return base;
+}
+
+/**
+ * Every value shape the registry can hold. Useful where a value is handled
+ * generically (e.g. the persisted `value` attribute) rather than per-name.
+ */
+export type AnyAccountSettingValue = z.infer<
+	| typeof BooleanSettingSchema
+	| typeof StringSettingSchema
+	| typeof NumberSettingSchema
+	| typeof StringListSettingSchema
+	| typeof MapSettingSchema
+	| typeof MutedFlagSettingSchema
+>;
+
+/**
+ * Parse-and-narrow a value against the schema registered for `name`. Accepts a
+ * plain enum member or a composite `<base>#<suffix>` name; validation resolves
+ * to the base member's schema. Throws a ZodError on mismatch (let-it-crash);
+ * returns the value typed to the variant the name requires.
+ */
+export function parseAccountSettingValue<N extends AccountSettingNameValue>(
+	name: N,
+	value: unknown,
+): AccountSettingValueFor<N>;
+export function parseAccountSettingValue(
+	name: StoredSettingName,
+	value: unknown,
+): AnyAccountSettingValue;
+export function parseAccountSettingValue(
+	name: StoredSettingName,
+	value: unknown,
+): AnyAccountSettingValue {
+	const schema = accountSettingRegistry[baseSettingName(name)];
+	return schema.parse(value) as AnyAccountSettingValue;
+}
+
+/**
+ * Non-throwing variant: returns the zod SafeParse result so a caller with a
+ * recovery path can branch on `success`. Accepts composite names like above.
+ */
+export function safeParseAccountSettingValue<N extends AccountSettingNameValue>(
+	name: N,
+	value: unknown,
+): z.SafeParseReturnType<unknown, AccountSettingValueFor<N>>;
+export function safeParseAccountSettingValue(
+	name: StoredSettingName,
+	value: unknown,
+): z.SafeParseReturnType<unknown, AnyAccountSettingValue>;
+export function safeParseAccountSettingValue(
+	name: StoredSettingName,
+	value: unknown,
+): z.SafeParseReturnType<unknown, AnyAccountSettingValue> {
+	const schema = accountSettingRegistry[baseSettingName(name)];
+	return schema.safeParse(value) as z.SafeParseReturnType<
+		unknown,
+		AnyAccountSettingValue
+	>;
+}

package/src/conformance/harness.ts

@@ -0,0 +1,12 @@
+/**
+ * A backend's binding for a conformance suite: how to build the repository
+ * under test, how to tear its backing store down, and the two behaviours the
+ * suite cannot express portably — id minting and not-found detection, both of
+ * which differ per implementation.
+ */
+export interface RepositoryConformanceHarness<TRepo> {
+	createRepository(): Promise<TRepo>;
+	teardown(): Promise<void>;
+	makeId(): string;
+	isNotFoundError(error: unknown): boolean;
+}

package/src/conformance/index.ts

@@ -0,0 +1,2 @@
+export type { RepositoryConformanceHarness } from "./harness.js";
+export { labelRepositoryConformance } from "./label.js";

package/src/conformance/label.ts

@@ -0,0 +1,95 @@
+import assert from "node:assert/strict";
+import { after, before, describe, test } from "node:test";
+import { LabelColor } from "@remit/domain-enums";
+import type { ILabelRepository } from "../interfaces/label.js";
+import type { RepositoryConformanceHarness } from "./harness.js";
+
+export function labelRepositoryConformance(
+	harness: RepositoryConformanceHarness<ILabelRepository>,
+): void {
+	describe("ILabelRepository conformance", () => {
+		let repo: ILabelRepository;
+
+		before(async () => {
+			repo = await harness.createRepository();
+		});
+
+		after(() => harness.teardown());
+
+		test("create derives normalizedName and defaults color", async () => {
+			const accountConfigId = harness.makeId();
+
+			const label = await repo.create({
+				accountConfigId,
+				name: "  Receipts  ",
+			});
+
+			assert.equal(label.name, "  Receipts  ");
+			assert.equal(label.normalizedName, "receipts");
+			assert.equal(label.color, LabelColor.Default);
+		});
+
+		test("get throws a not-found error for a missing label", async () => {
+			await assert.rejects(
+				repo.get(harness.makeId(), harness.makeId()),
+				(error) => harness.isNotFoundError(error),
+			);
+		});
+
+		test("update re-derives normalizedName when the name changes", async () => {
+			const accountConfigId = harness.makeId();
+			const label = await repo.create({ accountConfigId, name: "Old Name" });
+
+			const updated = await repo.update(accountConfigId, label.labelId, {
+				name: "New Name",
+			});
+
+			assert.equal(updated.name, "New Name");
+			assert.equal(updated.normalizedName, "new name");
+		});
+
+		test("update throws a not-found error for a missing label", async () => {
+			await assert.rejects(
+				repo.update(harness.makeId(), harness.makeId(), { name: "x" }),
+				(error) => harness.isNotFoundError(error),
+			);
+		});
+
+		test("listByAccountConfig scopes to the account", async () => {
+			const accountConfigId = harness.makeId();
+			const other = harness.makeId();
+
+			const mine = await repo.create({ accountConfigId, name: "Mine" });
+			await repo.create({ accountConfigId: other, name: "Foreign" });
+
+			const labels = await repo.listByAccountConfig(accountConfigId);
+			assert.equal(labels.length, 1);
+			assert.equal(labels[0]?.labelId, mine.labelId);
+		});
+
+		test("findByNormalizedName dedupes case- and whitespace-insensitively", async () => {
+			const accountConfigId = harness.makeId();
+			const label = await repo.create({ accountConfigId, name: "Work" });
+
+			const found = await repo.findByNormalizedName(accountConfigId, "WORK");
+			assert.equal(found?.labelId, label.labelId);
+
+			const missing = await repo.findByNormalizedName(
+				accountConfigId,
+				"nonexistent",
+			);
+			assert.equal(missing, null);
+		});
+
+		test("delete removes the row", async () => {
+			const accountConfigId = harness.makeId();
+			const label = await repo.create({ accountConfigId, name: "Gone" });
+
+			await repo.delete(accountConfigId, label.labelId);
+
+			await assert.rejects(repo.get(accountConfigId, label.labelId), (error) =>
+				harness.isNotFoundError(error),
+			);
+		});
+	});
+}

package/src/errors.ts

@@ -0,0 +1,75 @@
+export class HTTPError extends Error {
+	public statusCode = 500;
+}
+
+export class BadRequestError extends HTTPError {
+	name = "BadRequestError";
+	public statusCode = 400;
+}
+
+export class ClientError extends HTTPError {
+	name = "ClientError";
+	public statusCode = 401;
+}
+
+export class ForbiddenError extends HTTPError {
+	name = "ForbiddenError";
+	public statusCode = 403;
+}
+
+export class NotFoundError extends HTTPError {
+	name = "NotFoundError";
+	public statusCode = 404;
+}
+
+export class ConflictError extends HTTPError {
+	name = "ConflictError";
+	public statusCode = 409;
+}
+
+/**
+ * A message exists but its body could not be fetched/parsed after every
+ * body-sync retry was spent (issue #1270 / epic #1281 invariant 3). This is
+ * distinct from `NotFoundError`: the message is real, but its content is
+ * permanently unavailable — the client must show an explicit, actionable
+ * error instead of retrying (no 202, no silent skip).
+ */
+export class UnrecoverableBodyError extends HTTPError {
+	name = "UnrecoverableBodyError";
+	public statusCode = 422;
+}
+
+export class CreateFailedConflictError extends ConflictError {
+	public statusCode = 409;
+	name = "CreateFailedConflictError";
+	constructor(resourceType: string, params: unknown) {
+		super(
+			`${resourceType} with properties "${JSON.stringify(params)}" already exists.`,
+		);
+	}
+}
+
+export class UnhandledError extends HTTPError {
+	name = "UnhandledError";
+	public statusCode = 500;
+	readonly cause: Error | undefined;
+
+	constructor(message: string, cause?: Error) {
+		super(message);
+		this.message = message;
+		if (cause) this.cause = cause;
+	}
+
+	toJSON() {
+		return {
+			message: this.message,
+			cause: this.cause?.message,
+			stack: this.cause?.stack || this.stack,
+		};
+	}
+}
+
+export class InternalServerError extends UnhandledError {
+	name = "InternalServerError";
+	public statusCode = 500;
+}

package/src/id.ts

@@ -0,0 +1,105 @@
+import shortUuid from "short-uuid";
+import { v5 as uuidv5 } from "uuid";
+import type { MessageIdSource } from "./types.js";
+
+const translator = shortUuid.createTranslator(shortUuid.constants.uuid25Base36);
+
+export const base36uuid = (): string => translator.generate();
+
+export const fromUUID = (uuid: string): string => translator.fromUUID(uuid);
+
+export const toUUID = (shortId: string): string => translator.toUUID(shortId);
+
+export const generateUuidv5 = (name: string, namespace: string): string =>
+	uuidv5(name, namespace);
+
+export const base36uuidv5 = (name: string, namespace: string): string =>
+	translator.fromUUID(uuidv5(name, namespace));
+
+export const REMIT_NAMESPACE = "9e89694d-214b-4d9b-99f5-214b4d9b99f5";
+
+export const deriveAddressId = (
+	accountConfigId: string,
+	email: string,
+): string =>
+	base36uuidv5(
+		`address:${accountConfigId}:${email.toLowerCase()}`,
+		REMIT_NAMESPACE,
+	);
+
+export const deriveEnvelopeAddressId = (
+	messageId: string,
+	role: string,
+	order: number,
+): string =>
+	base36uuidv5(
+		`envelopeaddress:${messageId}:${role}:${order}`,
+		REMIT_NAMESPACE,
+	);
+
+export const isValidMessageId = (messageId: string | undefined): boolean => {
+	if (!messageId) return false;
+	const trimmed = messageId.trim();
+	return trimmed !== "" && trimmed !== "<>";
+};
+
+export const normalizeMessageIdHeader = (source: MessageIdSource): string => {
+	if (isValidMessageId(source.messageId)) {
+		return source.messageId as string;
+	}
+
+	const parts = [
+		"generated",
+		source.mailboxId,
+		source.uid.toString(),
+		source.date || "",
+		source.subject || "",
+		source.fromMailbox || "",
+		source.fromHost || "",
+	];
+
+	return parts.join(":");
+};
+
+export const deriveMessageId = (
+	accountId: string,
+	messageIdHeader: string,
+): string =>
+	base36uuidv5(`message:${accountId}:${messageIdHeader}`, REMIT_NAMESPACE);
+
+export const deriveMessageIdFromSource = (
+	accountId: string,
+	source: MessageIdSource,
+): string => deriveMessageId(accountId, normalizeMessageIdHeader(source));
+
+export const deriveThreadId = (
+	accountId: string,
+	rootMessageIdHeader: string,
+): string =>
+	base36uuidv5(
+		`thread:${accountId}:${rootMessageIdHeader.toLowerCase()}`,
+		REMIT_NAMESPACE,
+	);
+
+export const deriveEnvelopeId = (messageId: string): string =>
+	base36uuidv5(`envelope:${messageId}`, REMIT_NAMESPACE);
+
+/**
+ * Canonical IMAP path for the root MIME node. BODYSTRUCTURE leaves the
+ * root's `part` blank; we assign "0" so it has a stable, unambiguous key
+ * across the codebase (BodyPart row id, S3 key, seed scripts).
+ */
+export const ROOT_PART_PATH = "0";
+
+export const deriveBodyPartId = (messageId: string, partPath: string): string =>
+	base36uuidv5(`bodypart:${messageId}:${partPath}`, REMIT_NAMESPACE);
+
+export const deriveBodyPartParameterId = (
+	messageId: string,
+	partPath: string,
+	parameterName: string,
+): string =>
+	base36uuidv5(
+		`bodypartparam:${messageId}:${partPath}:${parameterName.toLowerCase()}`,
+		REMIT_NAMESPACE,
+	);

package/src/index.ts

@@ -0,0 +1,102 @@
+export type { IAccountRepository } from "./interfaces/account.js";
+export type { IAccountConfigRepository } from "./interfaces/account-config.js";
+export type { IAccountExportRequestRepository } from "./interfaces/account-export-request.js";
+export type { IAccountSettingRepository } from "./interfaces/account-setting.js";
+export type { IAddressRepository } from "./interfaces/address.js";
+export type { IEnvelopeRepository } from "./interfaces/envelope.js";
+export type { IFilterRepository } from "./interfaces/filter.js";
+export type { IFilterAnchorRepository } from "./interfaces/filter-anchor.js";
+export type { ILabelRepository } from "./interfaces/label.js";
+export type { IMailboxRepository } from "./interfaces/mailbox.js";
+export type { IMailboxLockRepository } from "./interfaces/mailbox-lock.js";
+export type { IMailboxSpecialUseRepository } from "./interfaces/mailbox-special-use.js";
+export type { IMessageRepository } from "./interfaces/message.js";
+export type { IMessageFlagRepository } from "./interfaces/message-flag.js";
+export type { IMessageFlagPushRepository } from "./interfaces/message-flag-push.js";
+export type { IMessageLabelRepository } from "./interfaces/message-label.js";
+export type { IMessagePlacementMoveRepository } from "./interfaces/message-placement-move.js";
+export type { IOrganizeJobRequestRepository } from "./interfaces/organize-job-request.js";
+export type { IOutboxMessageRepository } from "./interfaces/outbox-message.js";
+export type { IThreadMessageRepository } from "./interfaces/thread-message.js";
+export type {
+	IUnitOfWork,
+	UnitOfWorkRepositories,
+} from "./interfaces/unit-of-work.js";
+export type {
+	AccountConfigDescription,
+	AccountConfigItem,
+	AccountDescription,
+	AccountExportRequestItem,
+	AccountItem,
+	AccountSchedulerPage,
+	AccountSettingItem,
+	AccountSettingValue,
+	AddressFlags,
+	AddressItem,
+	BodyPartContentItem,
+	BodyPartContentUpsertInput,
+	BodyPartItem,
+	BodyPartParameterItem,
+	BodyPartParameterUpsertInput,
+	BodyPartStorageItem,
+	BodyPartUpsertInput,
+	CreateAccountConfigInput,
+	CreateAccountExportRequestInput,
+	CreateAccountInput,
+	CreateAddressInput,
+	CreateEnvelopeAddressInput,
+	CreateEnvelopeInput,
+	CreateFilterAnchorInput,
+	CreateFilterInput,
+	CreateLabelInput,
+	CreateMailboxInput,
+	CreateMessageFlagInput,
+	CreateMessageInput,
+	CreateMessageLabelInput,
+	CreateOrganizeJobRequestInput,
+	CreateOutboxMessageInput,
+	CreateThreadMessageInput,
+	EnvelopeAddressItem,
+	EnvelopeItem,
+	FilterAnchorItem,
+	FilterItem,
+	FlagsMergePatch,
+	LabelItem,
+	ListOptions,
+	MailboxItem,
+	MailboxLockItem,
+	MailboxSpecialUseItem,
+	MailboxSpecialUseValue,
+	MessageData,
+	MessageDescription,
+	MessageFlagItem,
+	MessageFlagPushItem,
+	MessageIdSource,
+	MessageItem,
+	MessageLabelItem,
+	MessagePlacementMoveItem,
+	MessageReferenceItem,
+	OrganizeJobRequestItem,
+	OutboxMessageItem,
+	PutMessageFlagPushInput,
+	PutMessagePlacementMoveInput,
+	RawMessageStorageItem,
+	ResultList,
+	SearchOptions,
+	ThreadMessageItem,
+	UpdateAccountConfigInput,
+	UpdateAccountExportRequestInput,
+	UpdateAccountInput,
+	UpdateAddressInput,
+	UpdateEnvelopeInput,
+	UpdateFilterInput,
+	UpdateLabelInput,
+	UpdateMailboxInput,
+	UpdateMessageInput,
+	UpdateMessageMoveInput,
+	UpdateOrganizeJobRequestInput,
+	UpdateOutboxMessageInput,
+	UpdateThreadMessageInput,
+	UpsertAccountSettingInput,
+	WithMailboxLockResult,
+} from "./types.js";

package/src/interfaces/account-config.ts

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

package/src/interfaces/account-export-request.ts

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