emdash 0.32.0 → 0.34.0

package/src/api/media-usage-write-fence.ts

@@ -0,0 +1,64 @@
+import type { Kysely } from "kysely";
+
+import { tableExists } from "../database/dialect-helpers.js";
+import type { Database } from "../database/types.js";
+import { apiError } from "./error.js";
+
+export interface MediaUsageActivationWriteFenceError {
+	code: "MEDIA_USAGE_ACTIVATION_IN_PROGRESS" | "MEDIA_USAGE_ACTIVATION_CHECK_FAILED";
+	message: string;
+	status: 503;
+}
+
+export class MediaUsageActivationWriteBlockedError extends Error {
+	constructor(
+		readonly code: MediaUsageActivationWriteFenceError["code"],
+		message: string,
+		readonly status: 503,
+	) {
+		super(message);
+		this.name = code;
+	}
+}
+
+export async function checkMediaUsageActivationWriteFence(
+	db: Kysely<Database>,
+): Promise<Response | null> {
+	const error = await findMediaUsageActivationWriteFenceError(db);
+	return error ? apiError(error.code, error.message, error.status) : null;
+}
+
+export async function assertMediaUsageActivationWriteAllowed(db: Kysely<Database>): Promise<void> {
+	const error = await findMediaUsageActivationWriteFenceError(db);
+	if (error) {
+		throw new MediaUsageActivationWriteBlockedError(error.code, error.message, error.status);
+	}
+}
+
+export async function findMediaUsageActivationWriteFenceError(
+	db: Kysely<Database>,
+): Promise<MediaUsageActivationWriteFenceError | null> {
+	if (!(await tableExists(db, "_emdash_media_usage_activation"))) return null;
+	try {
+		const row = await db
+			.selectFrom("_emdash_media_usage_activation")
+			.select("state")
+			.where("task_key", "=", "incremental_capture")
+			.executeTakeFirst();
+		if (row?.state === "activating") {
+			return {
+				code: "MEDIA_USAGE_ACTIVATION_IN_PROGRESS",
+				message: "Media usage activation is in progress",
+				status: 503,
+			};
+		}
+	} catch (error) {
+		console.error("[media-usage] Failed to check the activation write fence:", error);
+		return {
+			code: "MEDIA_USAGE_ACTIVATION_CHECK_FAILED",
+			message: "Unable to verify media usage activation state",
+			status: 503,
+		};
+	}
+	return null;
+}

package/src/api/openapi/document.ts

@@ -40,8 +40,17 @@ import {
 import {
 	mediaUsageDetailsQuery,
 	mediaUsageDetailsResponseSchema,
+	mediaUsageCollectionDeletionListQuery,
+	mediaUsageCollectionDeletionListResponseSchema,
+	mediaUsageCollectionDeletionRetryBody,
+	mediaUsageCollectionDeletionRetryResponseSchema,
 	mediaUsageRepairBody,
 	mediaUsageRepairResponseSchema,
+	mediaUsageWorkListQuery,
+	mediaUsageWorkListResponseSchema,
+	mediaUsageWorkRetryBody,
+	mediaUsageWorkRetryConflictSchema,
+	mediaUsageWorkRetryResponseSchema,
 } from "../schemas/media-usage.js";
 import {
 	DEFAULT_MAX_UPLOAD_SIZE,
@@ -88,6 +97,7 @@ import {
 	createCollectionBody,
 	createFieldBody,
 	fieldListResponseSchema,
+	collectionReorderBody,
 	fieldReorderBody,
 	fieldResponseSchema,
 	orphanedTableListResponseSchema,
@@ -112,11 +122,16 @@ import {
 import { settingsUpdateBody, siteSettingsSchema } from "../schemas/settings.js";
 import {
 	createTermBody,
+	reorderTermsBody,
+	taxonomyDefTranslationsSchema,
 	taxonomyListResponseSchema,
+	taxonomyResponseSchema,
 	termGetResponseSchema,
 	termListQuery,
 	termListResponseSchema,
+	termReorderResponseSchema,
 	termResponseSchema,
+	updateTaxonomyDefBody,
 	updateTermBody,
 } from "../schemas/taxonomies.js";
 import {
@@ -787,6 +802,102 @@ function buildMediaPaths(maxUploadSize: number) {
 				},
 			},
 		},
+		"/_emdash/api/admin/media-usage/work": {
+			get: {
+				operationId: "listMediaUsageWork",
+				summary: "List durable media usage work",
+				description:
+					"Returns one bounded cursor page of durable entry-indexing work for a current collection. Requires `schema:manage`; bearer tokens also require the `admin` scope. The response omits lease tokens, work versions, indexed content, media references, raw errors, and an exact backlog count.",
+				tags: ["Media"],
+				requestParams: { query: mediaUsageWorkListQuery },
+				responses: {
+					"200": {
+						description: "Bounded media usage work page",
+						content: {
+							[JSON_CONTENT]: { schema: successEnvelope(mediaUsageWorkListResponseSchema) },
+						},
+					},
+					...authErrors,
+					...standardErrors(400, 404, 500),
+				},
+			},
+		},
+		"/_emdash/api/admin/media-usage/work/retry": {
+			post: {
+				operationId: "retryMediaUsageWork",
+				summary: "Retry one durable media usage job",
+				description:
+					"Idempotently reopens or creates one entry-indexing job for a current immutable collection identity. Requires `schema:manage`; bearer tokens also require the `admin` scope. A live worker lease or a concurrent work change returns a stable conflict without exposing ownership tokens.",
+				tags: ["Media"],
+				requestBody: {
+					required: true,
+					content: { [JSON_CONTENT]: { schema: mediaUsageWorkRetryBody } },
+				},
+				responses: {
+					"200": {
+						description: "Current pending work state",
+						content: {
+							[JSON_CONTENT]: { schema: successEnvelope(mediaUsageWorkRetryResponseSchema) },
+						},
+					},
+					...authErrors,
+					...standardErrors(400, 404, 500),
+					"409": {
+						description: "The job has a live lease or changed concurrently",
+						content: { [JSON_CONTENT]: { schema: mediaUsageWorkRetryConflictSchema } },
+					},
+				},
+			},
+		},
+		"/_emdash/api/admin/media-usage/collection-deletions": {
+			get: {
+				operationId: "listMediaUsageCollectionDeletions",
+				summary: "List durable collection deletions",
+				description:
+					"Returns a bounded, redacted cursor page of collection deletion work. Requires `schema:manage`; bearer tokens also require the `admin` scope.",
+				tags: ["Media"],
+				requestParams: { query: mediaUsageCollectionDeletionListQuery },
+				responses: {
+					"200": {
+						description: "Bounded collection deletion page",
+						content: {
+							[JSON_CONTENT]: {
+								schema: successEnvelope(mediaUsageCollectionDeletionListResponseSchema),
+							},
+						},
+					},
+					...authErrors,
+					...standardErrors(400, 500),
+				},
+			},
+		},
+		"/_emdash/api/admin/media-usage/collection-deletions/retry": {
+			post: {
+				operationId: "retryMediaUsageCollectionDeletion",
+				summary: "Retry one collection deletion",
+				tags: ["Media"],
+				requestBody: {
+					required: true,
+					content: { [JSON_CONTENT]: { schema: mediaUsageCollectionDeletionRetryBody } },
+				},
+				responses: {
+					"200": {
+						description: "Pending collection deletion state",
+						content: {
+							[JSON_CONTENT]: {
+								schema: successEnvelope(mediaUsageCollectionDeletionRetryResponseSchema),
+							},
+						},
+					},
+					...authErrors,
+					...standardErrors(400, 404, 500),
+					"409": {
+						description: "The deletion has a live lease or changed concurrently",
+						content: { [JSON_CONTENT]: { schema: mediaUsageWorkRetryConflictSchema } },
+					},
+				},
+			},
+		},
 		"/_emdash/api/media/upload-url": {
 			post: {
 				operationId: "getMediaUploadUrl",
@@ -1062,6 +1173,28 @@ const schemaPaths = {
 			},
 		},
 	},
+	"/_emdash/api/schema/collections/reorder": {
+		post: {
+			operationId: "reorderCollections",
+			summary: "Reorder collections in the admin sidebar",
+			description:
+				"Sets the sidebar order. Collections omitted from the list lose their explicit position and fall back to alphabetical order after the ordered ones.",
+			tags: ["Schema"],
+			requestBody: { content: { [JSON_CONTENT]: { schema: collectionReorderBody } } },
+			responses: {
+				"200": {
+					description: "Reordered",
+					content: {
+						[JSON_CONTENT]: {
+							schema: successEnvelope(z.object({ success: z.literal(true) })),
+						},
+					},
+				},
+				...authErrors,
+				...standardErrors(400, 404, 500),
+			},
+		},
+	},
 	"/_emdash/api/schema/collections/{slug}/fields/reorder": {
 		post: {
 			operationId: "reorderFields",
@@ -1320,6 +1453,120 @@ const taxonomyPaths = {
 			},
 		},
 	},
+	"/_emdash/api/taxonomies/{name}": {
+		get: {
+			operationId: "getTaxonomy",
+			summary: "Get a taxonomy definition",
+			description:
+				"Definitions are per-locale; `locale` picks one, and without it the lowest-locale match is returned.",
+			tags: ["Taxonomies"],
+			requestParams: {
+				path: z.object({ name: z.string().meta({ description: "Taxonomy name" }) }),
+				query: z.object({
+					locale: z.string().optional().meta({ description: "Locale filter" }),
+				}),
+			},
+			responses: {
+				"200": {
+					description: "Taxonomy definition",
+					content: { [JSON_CONTENT]: { schema: successEnvelope(taxonomyResponseSchema) } },
+				},
+				...authErrors,
+				...standardErrors(400, 404, 500),
+			},
+		},
+		put: {
+			operationId: "updateTaxonomy",
+			summary: "Update a taxonomy definition",
+			description:
+				"Writes the single definition `name` + `locale` resolves to. `name` and `locale` cannot be changed — terms are keyed on `name`, and each locale is its own definition row.",
+			tags: ["Taxonomies"],
+			requestParams: {
+				path: z.object({ name: z.string().meta({ description: "Taxonomy name" }) }),
+				query: z.object({
+					locale: z.string().optional().meta({ description: "Locale of the definition to update" }),
+				}),
+			},
+			requestBody: { content: { [JSON_CONTENT]: { schema: updateTaxonomyDefBody } } },
+			responses: {
+				"200": {
+					description: "Updated taxonomy definition",
+					content: { [JSON_CONTENT]: { schema: successEnvelope(taxonomyResponseSchema) } },
+				},
+				...authErrors,
+				...standardErrors(400, 404, 500),
+			},
+		},
+		delete: {
+			operationId: "deleteTaxonomy",
+			summary: "Delete a taxonomy, its terms, and their content assignments",
+			description:
+				"Destructive and unscoped: every locale's definition goes, along with every term under the name and the assignments those terms hold. There is no locale parameter and no guard on a taxonomy that is still in use.",
+			tags: ["Taxonomies"],
+			requestParams: {
+				path: z.object({ name: z.string().meta({ description: "Taxonomy name" }) }),
+			},
+			responses: {
+				"200": {
+					description: "Deleted",
+					content: { [JSON_CONTENT]: { schema: successEnvelope(deleteResponseSchema) } },
+				},
+				...authErrors,
+				...standardErrors(404, 500),
+			},
+		},
+	},
+	"/_emdash/api/taxonomies/{name}/translations": {
+		get: {
+			operationId: "listTaxonomyTranslations",
+			summary: "List every locale variant of a taxonomy definition",
+			description:
+				"Create a translation with `POST /_emdash/api/taxonomies` and `translationOf` set to a definition id from this list.",
+			tags: ["Taxonomies"],
+			requestParams: {
+				path: z.object({ name: z.string().meta({ description: "Taxonomy name" }) }),
+				query: z.object({
+					locale: z
+						.string()
+						.optional()
+						.meta({ description: "Locale of the definition to resolve the group from" }),
+				}),
+			},
+			responses: {
+				"200": {
+					description: "Translations sharing a translation_group",
+					content: {
+						[JSON_CONTENT]: { schema: successEnvelope(taxonomyDefTranslationsSchema) },
+					},
+				},
+				...authErrors,
+				...standardErrors(400, 404, 500),
+			},
+		},
+	},
+	"/_emdash/api/taxonomies/{name}/reorder": {
+		post: {
+			operationId: "reorderTerms",
+			summary: "Set the manual order of one sibling group of terms",
+			description:
+				"`ids` names the terms to move, in the desired order, and may be a subset of the group — the listed terms are permuted within the positions they already occupy. A position belongs to a term across every locale, so there is no `locale` parameter. Ordering never reparents — use the term update endpoint to change a parent.",
+			tags: ["Taxonomies"],
+			requestParams: {
+				path: z.object({ name: z.string().meta({ description: "Taxonomy name" }) }),
+			},
+			requestBody: { content: { [JSON_CONTENT]: { schema: reorderTermsBody } } },
+			responses: {
+				"200": {
+					description: "The group in its new order",
+					content: {
+						[JSON_CONTENT]: { schema: successEnvelope(termReorderResponseSchema) },
+					},
+				},
+				...authErrors,
+				...standardErrors(400, 404, 500),
+			},
+		},
+	},
 	"/_emdash/api/taxonomies/{name}/terms": {
 		get: {
 			operationId: "listTerms",

package/src/api/public-url.ts

@@ -10,7 +10,7 @@
  */
 
 /** Minimal config shape — avoids importing the full EmDashConfig type tree. */
-interface SiteUrlConfig {
+export interface SiteUrlConfig {
 	siteUrl?: string;
 }
 
@@ -74,7 +74,19 @@ function getEnvSiteUrl(): string | undefined {
  * @returns Origin string, e.g. `"https://mysite.example.com"`
  */
 export function getPublicOrigin(url: URL, config?: SiteUrlConfig): string {
-	return config?.siteUrl || getEnvSiteUrl() || url.origin;
+	return getConfiguredOrigin(config) || url.origin;
+}
+
+/**
+ * Return the operator-configured public origin, if any.
+ *
+ * The first two steps of {@link getPublicOrigin}'s resolution —
+ * `config.siteUrl`, then the `EMDASH_SITE_URL`/`SITE_URL` env vars — without
+ * the request-URL fallback. For callers that have a more trustworthy fallback
+ * than the request (e.g. the stored setup origin used for outbound emails).
+ */
+export function getConfiguredOrigin(config?: SiteUrlConfig): string | undefined {
+	return config?.siteUrl || getEnvSiteUrl() || undefined;
 }
 
 /**

package/src/api/schemas/common.ts

@@ -1,5 +1,7 @@
 import { z } from "zod";
 
+import { LOCALE_CODE_PATTERN } from "../../i18n/config.js";
+
 // ---------------------------------------------------------------------------
 // Role level
 // ---------------------------------------------------------------------------
@@ -58,7 +60,7 @@ export const httpUrl = z
  * Validation is case-insensitive, but the value is preserved verbatim because the site config, stored
  * `locale` columns, and public query path all keep the raw BCP-47 casing.
  */
-export const localeCode = z.string().regex(/^[a-z]{2,3}(-[a-z0-9]{2,8})*$/i, "Invalid locale code");
+export const localeCode = z.string().regex(LOCALE_CODE_PATTERN, "Invalid locale code");
 
 /** Shared `?locale=xx` query shape for endpoints that filter by locale. */
 export const localeFilterQuery = z

package/src/api/schemas/content.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 
+import { SQL_BATCH_SIZE } from "../../utils/chunks.js";
 import { bylineSummarySchema, bylineCreditSchema, contentBylineInputSchema } from "./bylines.js";
 import { cursorPaginationQuery, httpUrl, localeCode } from "./common.js";
 
@@ -26,13 +27,115 @@ const contentDateBound = z
 	])
 	.optional();
 
+/**
+ * Byline ids for the content-list filter: either the literal `none` or a
+ * comma-separated list, parsed into an array.
+ *
+ * The 25-id cap keeps the `IN (...)` clause clear of D1's bound-parameter
+ * ceiling once the rest of the list query's placeholders are counted
+ * (`SQL_BATCH_SIZE` is 50 for a query binding nothing else).
+ */
+const bylineFilterParam = z
+	.string()
+	.trim()
+	.min(1)
+	.max(2000)
+	.optional()
+	.transform((value) =>
+		value === undefined
+			? undefined
+			: value === "none"
+				? ("none" as const)
+				: [...new Set(value.split(",").map((id) => id.trim()))].filter((id) => id.length > 0),
+	)
+	.refine((value) => value === undefined || value === "none" || value.length <= 25, {
+		message: "at most 25 bylines may be selected",
+	})
+	.refine((value) => value === undefined || value === "none" || value.length > 0, {
+		message: "must contain at least one byline id",
+	});
+
+/** Query-string boolean. Explicit values only — `z.coerce.boolean()` reads "false" as true. */
+const booleanParam = z
+	.enum(["1", "0", "true", "false"])
+	.optional()
+	.transform((value) => value === "1" || value === "true");
+
+const contentFieldComparable = z.union([z.string().max(2048), z.number().finite()]);
+const contentFieldFilterScalar = z.union([contentFieldComparable, z.boolean(), z.null()]);
+const contentFieldFilterValue = z.union([
+	contentFieldFilterScalar,
+	z
+		.object({
+			in: z
+				.array(z.union([contentFieldComparable, z.boolean()]))
+				.min(1)
+				.max(SQL_BATCH_SIZE),
+		})
+		.strict(),
+	z
+		.object({
+			gt: contentFieldComparable.optional(),
+			gte: contentFieldComparable.optional(),
+			lt: contentFieldComparable.optional(),
+			lte: contentFieldComparable.optional(),
+		})
+		.strict()
+		.refine((value) => Object.values(value).some((bound) => bound !== undefined), {
+			message: "Range filter must include at least one bound",
+		}),
+]);
+
+function contentFieldFilterOperandCount(value: unknown): number {
+	if (value === null) return 0;
+	if (!value || typeof value !== "object" || Array.isArray(value)) return 1;
+	if ("in" in value && Array.isArray(value.in)) return value.in.length;
+	return Object.values(value).filter((bound) => bound !== undefined).length;
+}
+
+/** AND-combined filters over custom fields explicitly marked as indexed. */
+export const contentFieldFiltersSchema = z
+	.record(
+		z
+			.string()
+			.max(128)
+			.regex(/^[a-z][a-z0-9_]*$/, "must be a safe field identifier"),
+		contentFieldFilterValue,
+	)
+	.refine((filters) => Object.keys(filters).length <= 20, {
+		message: "At most 20 indexed field filters are allowed",
+	})
+	.refine(
+		(filters) =>
+			Object.values(filters).reduce<number>(
+				(total, value) => total + contentFieldFilterOperandCount(value),
+				0,
+			) <= SQL_BATCH_SIZE,
+		{
+			message: `Indexed field filters have a total operand budget of ${SQL_BATCH_SIZE}`,
+		},
+	);
+
+const contentFieldFiltersQuery = z
+	.string()
+	.max(8192)
+	.transform((value, ctx): unknown => {
+		try {
+			return JSON.parse(value);
+		} catch {
+			ctx.addIssue({ code: "custom", message: "must be valid JSON" });
+			return z.NEVER;
+		}
+	})
+	.pipe(contentFieldFiltersSchema);
+
 export const contentListQuery = cursorPaginationQuery
 	.extend({
 		status: z.string().optional(),
 		orderBy: z.string().optional(),
 		order: z.enum(["asc", "desc"]).optional(),
 		locale: localeCode.optional(),
-		/** Case-insensitive substring search across the collection's title/name/slug. */
+		/** Search across the collection's display fields, slug, and searchable custom fields. */
 		q: z.string().trim().min(1).max(200).optional(),
 		/** Filter to entries authored by this user (the `author_id` column). */
 		authorId: z.string().min(1).max(64).optional(),
@@ -42,7 +145,25 @@ export const contentListQuery = cursorPaginationQuery
 		dateFrom: contentDateBound,
 		/** Inclusive upper bound for the date range. Requires `dateField`. */
 		dateTo: contentDateBound,
+		/**
+		 * Comma-separated byline ids; an entry matches if it is credited to any
+		 * of them. The literal `none` (alone) matches entries with no byline.
+		 */
+		bylines: bylineFilterParam,
+		/**
+		 * Also match the byline inferred from an entry's author when it has no
+		 * explicit credit — i.e. filter on the byline the list renders rather
+		 * than on the credits stored against the entry. Off by default.
+		 */
+		includeInferredBylines: booleanParam,
+		/** JSON-encoded indexed custom-field filters, combined with AND semantics. */
+		fieldFilters: contentFieldFiltersQuery.optional(),
 	})
+	.transform(({ bylines, ...rest }) => ({
+		...rest,
+		bylinesNone: bylines === "none",
+		bylines: bylines === "none" ? undefined : bylines,
+	}))
 	.meta({ id: "ContentListQuery" });
 
 /** ISO 8601 datetime for `publishedAt` / `createdAt`. Routes gate writes behind `content:publish_any`. */

package/src/api/schemas/media-usage.ts

@@ -109,8 +109,141 @@ export const mediaUsageRepairResponseSchema = z
 	})
 	.meta({ id: "MediaUsageRepairResponse" });
 
+export const mediaUsageWorkStateSchema = z
+	.enum(["pending", "retry", "leased", "failed"])
+	.meta({ id: "MediaUsageWorkState" });
+
+export const mediaUsageWorkListQuery = z.object({
+	collection: z.string().min(1).max(63).regex(slugPattern, "Invalid collection slug"),
+	state: mediaUsageWorkStateSchema.optional(),
+	cursor: z.string().min(1).max(2048).optional().meta({
+		description: "Opaque work-page cursor",
+	}),
+	limit: z.coerce.number().int().min(1).max(100).optional().default(50).meta({
+		description: "Maximum number of work items to return (1-100, default 50)",
+	}),
+});
+
+export const mediaUsageWorkItemSchema = z
+	.object({
+		collectionId: z.string(),
+		collectionSlug: z.string(),
+		contentId: z.string(),
+		state: mediaUsageWorkStateSchema,
+		attemptCount: z.number().int().min(0),
+		nextAttemptAt: z.string(),
+		leaseExpiresAt: z.string().nullable(),
+		lastAttemptedAt: z.string().nullable(),
+		lastErrorCode: z.string().nullable(),
+		updatedAt: z.string(),
+	})
+	.meta({ id: "MediaUsageWorkItem" });
+
+export const mediaUsageWorkListResponseSchema = z
+	.object({
+		items: z.array(mediaUsageWorkItemSchema),
+		nextCursor: z.string().optional(),
+	})
+	.meta({ id: "MediaUsageWorkListResponse" });
+
+const boundedOpaqueMediaUsageId = z.string().min(1).max(2048);
+
+export const mediaUsageWorkRetryBody = z
+	.object({
+		collectionId: boundedOpaqueMediaUsageId.meta({
+			description: "Current immutable collection identity",
+		}),
+		contentId: boundedOpaqueMediaUsageId.meta({
+			description: "Content entry identity, including a deleted entry",
+		}),
+	})
+	.strict()
+	.meta({ id: "MediaUsageWorkRetryBody" });
+
+export const mediaUsageWorkRetryResponseSchema = z
+	.object({
+		changed: z.boolean(),
+		item: mediaUsageWorkItemSchema,
+	})
+	.meta({ id: "MediaUsageWorkRetryResponse" });
+
+export const mediaUsageWorkRetryConflictSchema = z.object({
+	success: z.literal(false),
+	error: z.discriminatedUnion("code", [
+		z.object({
+			code: z.literal("WORK_LEASE_ACTIVE"),
+			message: z.string(),
+			details: z.object({ leaseExpiresAt: z.string() }),
+		}),
+		z.object({
+			code: z.literal("WORK_CHANGED"),
+			message: z.string(),
+		}),
+	]),
+});
+
+export const mediaUsageCollectionDeletionStateSchema = z
+	.enum(["pending", "retry", "leased", "failed"])
+	.meta({ id: "MediaUsageCollectionDeletionState" });
+export const mediaUsageCollectionDeletionPhaseSchema = z
+	.enum(["fence", "registry", "table", "work", "sources", "status", "finalize"])
+	.meta({ id: "MediaUsageCollectionDeletionPhase" });
+export const mediaUsageCollectionDeletionListQuery = z
+	.object({
+		state: mediaUsageCollectionDeletionStateSchema.optional().default("failed"),
+		cursor: z.string().min(1).max(2048).optional(),
+		limit: z.coerce.number().int().min(1).max(100).optional().default(50),
+	})
+	.meta({ id: "MediaUsageCollectionDeletionListQuery" });
+export const mediaUsageCollectionDeletionItemSchema = z
+	.object({
+		collectionId: z.string(),
+		collectionSlug: z.string(),
+		state: mediaUsageCollectionDeletionStateSchema,
+		phase: mediaUsageCollectionDeletionPhaseSchema,
+		attemptCount: z.number().int().min(0),
+		nextAttemptAt: z.string(),
+		leaseExpiresAt: z.string().nullable(),
+		lastErrorCode: z.string().nullable(),
+		updatedAt: z.string(),
+	})
+	.meta({ id: "MediaUsageCollectionDeletionItem" });
+export const mediaUsageCollectionDeletionListResponseSchema = z
+	.object({
+		items: z.array(mediaUsageCollectionDeletionItemSchema),
+		nextCursor: z.string().optional(),
+	})
+	.meta({ id: "MediaUsageCollectionDeletionListResponse" });
+export const mediaUsageCollectionDeletionRetryBody = z
+	.object({ collectionId: boundedOpaqueMediaUsageId })
+	.strict()
+	.meta({ id: "MediaUsageCollectionDeletionRetryBody" });
+export const mediaUsageCollectionDeletionRetryResponseSchema = z
+	.object({
+		changed: z.boolean(),
+		item: mediaUsageCollectionDeletionItemSchema,
+	})
+	.meta({ id: "MediaUsageCollectionDeletionRetryResponse" });
+
 export type MediaUsageRepairRequest = z.infer<typeof mediaUsageRepairBody>;
 export type MediaUsageRepairResponse = z.infer<typeof mediaUsageRepairResponseSchema>;
+export type MediaUsageWorkListQuery = z.infer<typeof mediaUsageWorkListQuery>;
+export type MediaUsageWorkItem = z.infer<typeof mediaUsageWorkItemSchema>;
+export type MediaUsageWorkListResponse = z.infer<typeof mediaUsageWorkListResponseSchema>;
+export type MediaUsageWorkRetryRequest = z.infer<typeof mediaUsageWorkRetryBody>;
+export type MediaUsageWorkRetryResponse = z.infer<typeof mediaUsageWorkRetryResponseSchema>;
+export type MediaUsageCollectionDeletionListQuery = z.infer<
+	typeof mediaUsageCollectionDeletionListQuery
+>;
+export type MediaUsageCollectionDeletionListResponse = z.infer<
+	typeof mediaUsageCollectionDeletionListResponseSchema
+>;
+export type MediaUsageCollectionDeletionRetryRequest = z.infer<
+	typeof mediaUsageCollectionDeletionRetryBody
+>;
+export type MediaUsageCollectionDeletionRetryResponse = z.infer<
+	typeof mediaUsageCollectionDeletionRetryResponseSchema
+>;
 export type MediaUsageCoverageStatus = z.infer<typeof mediaUsageCoverageStatusSchema>;
 export type MediaUsageCoverage = z.infer<typeof mediaUsageCoverageSchema>;
 export type MediaUsageSummary = z.infer<typeof mediaUsageSummarySchema>;