@shapio/client 0.2.0

package/dist/index.js

@@ -0,0 +1,1009 @@
+import { a as toQueryString, i as resolveUploadUrl, n as buildUploadForm, o as ADMIN_PATHS, r as createMediaApi, s as withId, t as ShapioApiError } from "./errors-BXMW0adL.js";
+//#region src/admin/appUsers.ts
+/** App users (Users → App users) and app roles (Settings → Roles → App roles). */
+const createAppUsersApi = (request) => ({
+	appUsers: {
+		list: (query = {}) => request(`${ADMIN_PATHS.appUsers}${toQueryString(query)}`),
+		get: (id) => request(withId(ADMIN_PATHS.appUsers, id)),
+		/** Block/unblock and replace custom roles. Blocking takes effect on the user's next request. */
+		update: (id, body) => request(withId(ADMIN_PATHS.appUsers, id), {
+			method: "PATCH",
+			body
+		}),
+		remove: (id) => request(withId(ADMIN_PATHS.appUsers, id), { method: "DELETE" }),
+		/** 409 NOT_CONFIGURED without APP_AUTH_CONFIRM_EMAIL_URL; 409 ALREADY_CONFIRMED. */
+		resendConfirmation: (id) => request(`${withId(ADMIN_PATHS.appUsers, id)}/resend-confirmation`, { method: "POST" })
+	},
+	appRoles: {
+		list: () => request(ADMIN_PATHS.appRoles),
+		get: (id) => request(withId(ADMIN_PATHS.appRoles, id)),
+		create: (body) => request(ADMIN_PATHS.appRoles, {
+			method: "POST",
+			body
+		}),
+		/** 409 VERSION_CONFLICT when `expectedVersion` is stale. */
+		update: (id, body) => request(withId(ADMIN_PATHS.appRoles, id), {
+			method: "PATCH",
+			body
+		}),
+		remove: (id) => request(withId(ADMIN_PATHS.appRoles, id), { method: "DELETE" })
+	}
+});
+//#endregion
+//#region src/admin/assist.ts
+const ASSIST_PATHS = {
+	status: "/api/admin/assist/status",
+	altText: "/api/admin/assist/alt-text",
+	summarize: "/api/admin/assist/summarize",
+	translate: "/api/admin/assist/translate",
+	rewrite: "/api/admin/assist/rewrite",
+	schemaDraft: "/api/admin/assist/schema/draft",
+	contentOpsPropose: "/api/admin/assist/content-ops/propose",
+	contentOps: "/api/admin/assist/content-ops"
+};
+/** Editor assists with the instance's own model provider (documentation/assist.md). */
+const createAssistApi = (request) => ({ assist: {
+	status: () => request(ASSIST_PATHS.status),
+	altText: (body) => request(ASSIST_PATHS.altText, {
+		method: "POST",
+		body
+	}),
+	summarize: (body) => request(ASSIST_PATHS.summarize, {
+		method: "POST",
+		body
+	}),
+	translate: (body) => request(ASSIST_PATHS.translate, {
+		method: "POST",
+		body
+	}),
+	rewrite: (body) => request(ASSIST_PATHS.rewrite, {
+		method: "POST",
+		body
+	}),
+	schemaDraft: (body) => request(ASSIST_PATHS.schemaDraft, {
+		method: "POST",
+		body
+	}),
+	/** Starts a background run (202); poll it with `contentOpsRun`. */
+	proposeContentOps: (body) => request(ASSIST_PATHS.contentOpsPropose, {
+		method: "POST",
+		body
+	}),
+	contentOpsRun: (runId) => request(withId(ASSIST_PATHS.contentOps, runId))
+} });
+//#endregion
+//#region src/admin/changeSets.ts
+const setPath = (id) => withId(ADMIN_PATHS.changeSets, id);
+const draftPath = (id, definitionId) => `${setPath(id)}/schema/${encodeURIComponent(definitionId)}`;
+/** Change sets (schema + content shipped as one snapshot) and the snapshot ledger. */
+const createChangeSetsApi = (request) => ({
+	changeSets: {
+		list: (query = {}) => request(`${ADMIN_PATHS.changeSets}${toQueryString(query)}`),
+		get: (id) => request(setPath(id)),
+		create: (body) => request(ADMIN_PATHS.changeSets, {
+			method: "POST",
+			body
+		}),
+		update: (id, body) => request(setPath(id), {
+			method: "PATCH",
+			body
+		}),
+		/** Keeps the set as history (`discarded`) and deletes its schema drafts. */
+		discard: (id) => request(`${setPath(id)}/discard`, { method: "POST" }),
+		addEntry: (id, body) => request(`${setPath(id)}/items`, {
+			method: "POST",
+			body
+		}),
+		removeItem: (id, itemId) => request(`${setPath(id)}/items/${encodeURIComponent(itemId)}`, { method: "DELETE" }),
+		getSchemaDraft: (id, definitionId) => request(draftPath(id, definitionId)),
+		putSchemaDraft: (id, definitionId, body) => request(draftPath(id, definitionId), {
+			method: "PUT",
+			body
+		}),
+		removeSchemaDraft: (id, definitionId) => request(draftPath(id, definitionId), { method: "DELETE" }),
+		review: (id) => request(`${setPath(id)}/review`),
+		/**
+		* Resolves with the set: `shipped` (or `failed`) when it shipped inline, `shipping` (HTTP 202) when
+		* prerequisites run in the background. Poll `get` until it leaves `shipping`.
+		*/
+		ship: (id, body) => request(`${setPath(id)}/ship`, {
+			method: "POST",
+			body
+		}),
+		schedule: (id, body) => request(`${setPath(id)}/schedule`, {
+			method: "POST",
+			body
+		}),
+		unschedule: (id) => request(`${setPath(id)}/unschedule`, { method: "POST" }),
+		timeline: async (id) => (await request(`${setPath(id)}/timeline`)).items,
+		unassigned: (query = {}) => request(`${ADMIN_PATHS.changeSets}/unassigned${toQueryString(query)}`)
+	},
+	snapshots: {
+		list: (query = {}) => request(`${ADMIN_PATHS.snapshots}${toQueryString(query)}`),
+		get: (seq) => request(`${ADMIN_PATHS.snapshots}/${seq}`),
+		/** Creates an open restore change set (reviewable); nothing goes live until it ships. */
+		restore: (seq) => request(`${ADMIN_PATHS.snapshots}/${seq}/restore`, { method: "POST" })
+	}
+});
+//#endregion
+//#region src/admin/contentQuery.ts
+/**
+* Serialises a content list query into the bracket querystring the content compiler parses
+* (`filters[title][$eq]=A&sort=title:asc&page=2`). Lists repeat the key (`filters[id][$in]=a&filters[id][$in]=b`).
+*/
+const appendFilter = (params, prefix, value) => {
+	if (value === void 0 || value === null) return;
+	if (Array.isArray(value)) {
+		value.forEach((item, index) => {
+			if (typeof item === "object" && item !== null) appendFilter(params, `${prefix}[${index}]`, item);
+			else params.append(prefix, String(item));
+		});
+		return;
+	}
+	if (typeof value === "object") {
+		for (const [key, child] of Object.entries(value)) appendFilter(params, `${prefix}[${key}]`, child);
+		return;
+	}
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") params.append(prefix, String(value));
+};
+const toContentQueryString = (query = {}) => {
+	const params = new URLSearchParams();
+	if (query.filters) appendFilter(params, "filters", query.filters);
+	for (const term of query.sort ?? []) params.append("sort", `${term.field}:${term.direction}`);
+	if (query.page !== void 0) params.set("page", String(query.page));
+	if (query.pageSize !== void 0) params.set("pageSize", String(query.pageSize));
+	if (query.q) params.set("q", query.q);
+	if (query.locale) params.set("locale", query.locale);
+	for (const field of query.fields ?? []) params.append("fields", field);
+	for (const path of query.populate ?? []) params.append("populate", path);
+	if (query.status) params.set("status", query.status);
+	if (query.author) params.set("author", query.author);
+	const serialised = params.toString();
+	return serialised ? `?${serialised}` : "";
+};
+//#endregion
+//#region src/admin/content.ts
+const modelPath = (modelKey) => withId(ADMIN_PATHS.content, modelKey);
+const entryPath$1 = (modelKey, id) => withId(modelPath(modelKey), id);
+const revisionsPath = (modelKey, id) => `${entryPath$1(modelKey, id)}/revisions`;
+/**
+* Content of any model through the generic admin routes (`/api/admin/content/:modelKey`, where `modelKey`
+* is the model's singular API ID for collections too; only the delivery API uses the plural). Drafts are read
+* and written here; publishing is per locale. Writes carry the draft `version` the editor saw and fail with
+* 409 CONTENT_VERSION_CONFLICT (or SCHEMA_CHANGED) when it moved.
+*/
+const createContentApi = (request) => ({
+	content: {
+		list: (modelKey, query = {}) => request(`${modelPath(modelKey)}${toContentQueryString(query)}`),
+		get: (modelKey, id, { locale } = {}) => request(`${entryPath$1(modelKey, id)}${toQueryString({ locale })}`),
+		/** Fully validated (`required` included); 422 CONTENT_INVALID with `details.issues`. */
+		create: (modelKey, body) => request(modelPath(modelKey), {
+			method: "POST",
+			body
+		}),
+		/** Saves a patch of one locale's draft; `autosave` skips `required` and creates no revision. */
+		update: (modelKey, id, body) => request(entryPath$1(modelKey, id), {
+			method: "PUT",
+			body
+		}),
+		/** 409 ENTRY_REFERENCED with `details.referrers` while other entries point at it. */
+		remove: (modelKey, id) => request(entryPath$1(modelKey, id), { method: "DELETE" }),
+		duplicate: (modelKey, id) => request(`${entryPath$1(modelKey, id)}/duplicate`, { method: "POST" }),
+		publish: (modelKey, id, body = {}) => request(`${entryPath$1(modelKey, id)}/publish`, {
+			method: "POST",
+			body
+		}),
+		unpublish: (modelKey, id, body = {}) => request(`${entryPath$1(modelKey, id)}/unpublish`, {
+			method: "POST",
+			body
+		}),
+		revisions: async (modelKey, id, { locale } = {}) => (await request(`${revisionsPath(modelKey, id)}${toQueryString({ locale })}`)).items,
+		revision: (modelKey, id, revisionId) => request(withId(revisionsPath(modelKey, id), revisionId)),
+		/** Brings an older revision back as the new draft of its locale (a new revision). */
+		restore: (modelKey, id, revisionId, expectedVersion) => request(`${withId(revisionsPath(modelKey, id), revisionId)}/restore`, {
+			method: "POST",
+			body: { expectedVersion }
+		})
+	},
+	extensions: { 
+	/** Custom field editors the project installed (`shapio.config` + `extensions/editors/*.js`). */
+editors: () => request(ADMIN_PATHS.editorManifest) }
+});
+//#endregion
+//#region src/admin/editing.ts
+const entryPath = (base, modelKey, id) => withId(withId(base, modelKey), id);
+/** The entry document's endpoints: pre-flight, content health (the Inbox), presence and counts. */
+const createEditingApi = (request) => ({
+	preflight: { 
+	/** What publishing these locales would run into, without publishing (no hooks, no locks). */
+run: (modelKey, id, body = {}) => request(`${entryPath(ADMIN_PATHS.content, modelKey, id)}/preflight`, {
+		method: "POST",
+		body
+	}) },
+	contentHealth: {
+		list: (query = {}) => request(`${ADMIN_PATHS.contentHealth}${toQueryString(query)}`),
+		summary: () => request(`${ADMIN_PATHS.contentHealth}/summary`)
+	},
+	presence: {
+		/** Heartbeat (every 15s while the document is visible); returns who else has the entry open. */
+		heartbeat: (modelKey, id, body) => request(entryPath(ADMIN_PATHS.presence, modelKey, id), {
+			method: "PUT",
+			body
+		}),
+		entry: (modelKey, id) => request(entryPath(ADMIN_PATHS.presence, modelKey, id)),
+		/** Everyone editing an entry of the model (list rows). */
+		model: (modelKey) => request(withId(ADMIN_PATHS.presence, modelKey)),
+		leave: (modelKey, id, tabId) => request(`${entryPath(ADMIN_PATHS.presence, modelKey, id)}${toQueryString({ tabId })}`, { method: "DELETE" })
+	},
+	contentCounts: { list: () => request(ADMIN_PATHS.contentCounts) }
+});
+//#endregion
+//#region src/admin/publishing.ts
+/** Jobs, scheduled publications, webhooks, deployment connections and runs, preview (package H). */
+const createPublishingApi = (request) => ({
+	jobs: {
+		list: (query = {}) => request(`${ADMIN_PATHS.jobs}${toQueryString(query)}`),
+		summary: () => request(`${ADMIN_PATHS.jobs}/summary`),
+		get: (id) => request(withId(ADMIN_PATHS.jobs, id)),
+		/** Dead jobs only: runs again from attempt 1. 409 JOB_NOT_RETRYABLE otherwise. */
+		retry: (id) => request(`${withId(ADMIN_PATHS.jobs, id)}/retry`, { method: "POST" })
+	},
+	schedules: {
+		list: (query = {}) => request(`${ADMIN_PATHS.schedules}${toQueryString(query)}`),
+		create: (body) => request(ADMIN_PATHS.schedules, {
+			method: "POST",
+			body
+		}),
+		cancel: (id) => request(withId(ADMIN_PATHS.schedules, id), { method: "DELETE" })
+	},
+	webhooks: {
+		list: () => request(ADMIN_PATHS.webhooks),
+		events: async () => (await request(`${ADMIN_PATHS.webhooks}/events`)).items,
+		get: (id) => request(withId(ADMIN_PATHS.webhooks, id)),
+		create: (body) => request(ADMIN_PATHS.webhooks, {
+			method: "POST",
+			body
+		}),
+		update: (id, body) => request(withId(ADMIN_PATHS.webhooks, id), {
+			method: "PATCH",
+			body
+		}),
+		remove: (id) => request(withId(ADMIN_PATHS.webhooks, id), { method: "DELETE" }),
+		rotateSecret: (id) => request(`${withId(ADMIN_PATHS.webhooks, id)}/rotate-secret`, { method: "POST" }),
+		/** Queues a `webhook.test` delivery; poll the delivery log for its outcome. */
+		test: (id) => request(`${withId(ADMIN_PATHS.webhooks, id)}/test`, { method: "POST" }),
+		deliveries: (id, query = {}) => request(`${withId(ADMIN_PATHS.webhooks, id)}/deliveries${toQueryString(query)}`),
+		/** Sends the same payload again as a new delivery. */
+		redeliver: (id, deliveryId) => request(`${withId(ADMIN_PATHS.webhooks, id)}/deliveries/${encodeURIComponent(deliveryId)}/redeliver`, { method: "POST" })
+	},
+	deployments: {
+		connections: {
+			list: () => request(ADMIN_PATHS.deploymentConnections),
+			get: (id) => request(withId(ADMIN_PATHS.deploymentConnections, id)),
+			create: (body) => request(ADMIN_PATHS.deploymentConnections, {
+				method: "POST",
+				body
+			}),
+			update: (id, body) => request(withId(ADMIN_PATHS.deploymentConnections, id), {
+				method: "PATCH",
+				body
+			}),
+			remove: (id) => request(withId(ADMIN_PATHS.deploymentConnections, id), { method: "DELETE" }),
+			test: (id) => request(`${withId(ADMIN_PATHS.deploymentConnections, id)}/test`, { method: "POST" }),
+			/** A manual run at the current publication snapshot. */
+			trigger: (id) => request(`${withId(ADMIN_PATHS.deploymentConnections, id)}/runs`, { method: "POST" })
+		},
+		runs: {
+			list: (query = {}) => request(`${ADMIN_PATHS.deploymentRuns}${toQueryString(query)}`),
+			get: (id) => request(withId(ADMIN_PATHS.deploymentRuns, id)),
+			/** A new run (linked by `retryOf`) at the current snapshot. */
+			retry: (id) => request(`${withId(ADMIN_PATHS.deploymentRuns, id)}/retry`, { method: "POST" })
+		}
+	},
+	preview: {
+		tokens: {
+			list: (query = {}) => request(`${ADMIN_PATHS.previewTokens}${toQueryString(query)}`),
+			create: (body) => request(ADMIN_PATHS.previewTokens, {
+				method: "POST",
+				body
+			}),
+			revoke: (id) => request(withId(ADMIN_PATHS.previewTokens, id), { method: "DELETE" })
+		},
+		/** The site's connections with a preview URL (the entry form's Preview pane). */
+		targets: () => request(`${ADMIN_PATHS.preview}/targets`),
+		/** The entry form's Preview action: a short-lived entry token and the rendered preview URL. */
+		open: (body) => request(`${ADMIN_PATHS.preview}/open`, {
+			method: "POST",
+			body
+		})
+	}
+});
+//#endregion
+//#region src/admin/schema.ts
+const DEFINITION_PATHS = {
+	model: ADMIN_PATHS.models,
+	component: ADMIN_PATHS.components
+};
+/** Models (collections and singletons) and components share one set of endpoints under their own base. */
+const createDefinitionApi = (request, category) => {
+	const base = DEFINITION_PATHS[category];
+	return {
+		list: async () => (await request(base)).items,
+		get: (id) => request(withId(base, id)),
+		/** Creates and activates a definition (`pending` when prerequisites must run first). */
+		create: (body) => request(base, {
+			method: "POST",
+			body
+		}),
+		/** Plan preview of a create: classification and impact, nothing written. */
+		planCreate: (definition) => request(`${base}/plan`, {
+			method: "POST",
+			body: { definition }
+		}),
+		/** Changes a definition; 409 SCHEMA_VERSION_CONFLICT when `expectedVersion` is stale. */
+		update: (id, body) => request(withId(base, id), {
+			method: "PUT",
+			body
+		}),
+		planUpdate: (id, body) => request(`${withId(base, id)}/plan`, {
+			method: "POST",
+			body
+		}),
+		/** Soft delete: entries are kept and reappear if the definition is applied again. */
+		remove: (id, expectedVersion) => request(`${withId(base, id)}${toQueryString({ expectedVersion })}`, { method: "DELETE" }),
+		revisions: async (id) => (await request(`${withId(base, id)}/revisions`)).items,
+		changes: async (id) => (await request(`${withId(base, id)}/changes`)).items
+	};
+};
+/** Schema-wide endpoints: the version summary, planned-change status, the read-only lock, locales. */
+const createSchemaApi = (request) => ({
+	models: createDefinitionApi(request, "model"),
+	components: createDefinitionApi(request, "component"),
+	schema: {
+		/** The global schema version and every visible definition's version (cheap; poll it for changes). */
+		summary: () => request(ADMIN_PATHS.schema),
+		change: (changeId) => request(withId(ADMIN_PATHS.schemaChanges, changeId)),
+		/** Every definition in the pull format, with the schema version they come from (`shapio schema pull`). */
+		export: () => request(ADMIN_PATHS.schemaExport),
+		/** Applies definition files live through the change planner; refuses when the base moved (409). */
+		apply: (body) => request(ADMIN_PATHS.schemaApply, {
+			method: "POST",
+			body
+		}),
+		settings: () => request(ADMIN_PATHS.schemaSettings),
+		updateSettings: (body) => request(ADMIN_PATHS.schemaSettings, {
+			method: "PUT",
+			body
+		})
+	},
+	locales: {
+		list: async () => (await request(ADMIN_PATHS.locales)).items,
+		create: (body) => request(ADMIN_PATHS.locales, {
+			method: "POST",
+			body
+		}),
+		update: (code, body) => request(withId(ADMIN_PATHS.locales, code), {
+			method: "PUT",
+			body
+		}),
+		/** A contract change: without `acknowledgeBreaking` the server answers 409 SCHEMA_CHANGE_NOT_ACKNOWLEDGED. */
+		setDefault: (code, acknowledgeBreaking) => request(`${withId(ADMIN_PATHS.locales, code)}/default`, {
+			method: "POST",
+			body: { acknowledgeBreaking }
+		}),
+		/**
+		* Deletes a locale and purges its content. When content exists and `acknowledgeDestructive` is false,
+		* the server answers 409 SCHEMA_CHANGE_NOT_ACKNOWLEDGED with `details.plan.impact.affectedHeads`.
+		*/
+		remove: (code, acknowledgeDestructive) => request(`${withId(ADMIN_PATHS.locales, code)}${toQueryString({ acknowledgeDestructive: acknowledgeDestructive || void 0 })}`, { method: "DELETE" })
+	}
+});
+//#endregion
+//#region src/admin/sites.ts
+const SITES_PATHS = { sites: "/api/admin/sites" };
+/** The admin API header that names the site a site-scoped request is about (default: the primary site). */
+const SITE_HEADER = "shapio-site";
+const sitePath = (id) => `${SITES_PATHS.sites}/${encodeURIComponent(id)}`;
+/** Sites (network routes): listing shows the sites the caller holds a role on; changes need `sites.manage`. */
+const createSitesApi = (request) => ({ sites: {
+	list: () => request(SITES_PATHS.sites),
+	get: (id) => request(sitePath(id)),
+	create: (body) => request(SITES_PATHS.sites, {
+		method: "POST",
+		body
+	}),
+	update: (id, body) => request(sitePath(id), {
+		method: "PATCH",
+		body
+	}),
+	/** Only an empty site (409 `SITE_NOT_EMPTY`); never the primary site (409 `SITE_IS_PRIMARY`). */
+	remove: (id) => request(sitePath(id), { method: "DELETE" }),
+	/** The app roles bound to the site's anonymous callers (`public`) and signed-in app users (`authenticated`). */
+	appRoles: {
+		get: (id) => request(`${sitePath(id)}/app-roles`),
+		/** Replaces both bindings (`roles.manage`). */
+		set: (id, body) => request(`${sitePath(id)}/app-roles`, {
+			method: "PUT",
+			body
+		})
+	}
+} });
+//#endregion
+//#region src/admin/usage.ts
+const USAGE_PATHS = { fields: "/api/admin/usage/fields" };
+/** Who reads which fields (needs `tokens.manage`). */
+const createUsageApi = (request) => ({ usage: { fields: (query) => request(`${USAGE_PATHS.fields}${toQueryString(query)}`) } });
+//#endregion
+//#region src/admin/types.ts
+const CONTENT_ACTIONS = [
+	"read",
+	"create",
+	"update",
+	"delete",
+	"publish",
+	"schemaManage"
+];
+/**
+* Network actions: about the whole instance. Only roles assigned on every site grant them, so a role held
+* on one site never reaches the network.
+*/
+const NETWORK_ACTIONS = [
+	"schema.create",
+	"users.manage",
+	"roles.manage",
+	"audit.read",
+	"sites.manage"
+];
+/** Site actions: about one site's library, tokens and publishing. */
+const SITE_ACTIONS = [
+	"tokens.manage",
+	"media.read",
+	"media.write",
+	"media.manage",
+	"publishing.manage",
+	"webhooks.manage",
+	"deployments.manage",
+	"deployments.trigger",
+	"changes.manage",
+	"changes.ship"
+];
+/** Actions not scoped to a model: network actions and site actions. */
+const GLOBAL_ACTIONS = [
+	"schema.create",
+	"users.manage",
+	"roles.manage",
+	"tokens.manage",
+	"audit.read",
+	"sites.manage",
+	"media.read",
+	"media.write",
+	"media.manage",
+	"publishing.manage",
+	"webhooks.manage",
+	"deployments.manage",
+	"deployments.trigger",
+	"changes.manage",
+	"changes.ship"
+];
+//#endregion
+//#region src/admin/publishingTypes.ts
+const JOB_STATUSES = [
+	"pending",
+	"running",
+	"succeeded",
+	"dead"
+];
+const PUBLICATION_ACTIONS = ["publish", "unpublish"];
+const SCHEDULE_STATUSES = [
+	"scheduled",
+	"done",
+	"failed",
+	"cancelled"
+];
+const DEPLOYMENT_PROVIDERS = [
+	"generic_webhook",
+	"cloudflare_pages",
+	"vercel",
+	"netlify",
+	"github"
+];
+const DEPLOYMENT_TRIGGERS = [
+	"publish",
+	"change_set",
+	"schema",
+	"manual"
+];
+const DEPLOYMENT_RUN_STATUSES = [
+	"queued",
+	"triggered",
+	"building",
+	"deployed",
+	"failed",
+	"unknown"
+];
+//#endregion
+//#region src/admin/appUsersTypes.ts
+/** What app roles may grant: content actions only. */
+const APP_CONTENT_ACTIONS = [
+	"read",
+	"create",
+	"update",
+	"delete",
+	"publish"
+];
+/** Built-in app role keys: `public` applies to anonymous callers, `authenticated` to every app user. */
+const BUILT_IN_APP_ROLE_KEYS = ["public", "authenticated"];
+//#endregion
+//#region src/admin/changeSetTypes.ts
+/**
+* Change sets and snapshots (developer-face plan §5), mirroring the TypeBox route schemas in
+* apps/api/src/routes/admin/{changeSets,snapshots}/schemas.ts. Dates are ISO-8601 strings.
+*/
+const CHANGE_SET_STATUSES = [
+	"open",
+	"scheduled",
+	"shipping",
+	"shipped",
+	"failed",
+	"discarded"
+];
+const NOT_RESTORABLE_REASONS = [
+	"entry_deleted",
+	"model_missing",
+	"publishing_disabled",
+	"localization_changed",
+	"locale_missing",
+	"invalid",
+	"unique_conflict"
+];
+const SNAPSHOT_SOURCES = [
+	"publish",
+	"unpublish",
+	"delete",
+	"schedule",
+	"change_set",
+	"schema",
+	"conversion",
+	"import",
+	"legacy"
+];
+//#endregion
+//#region src/admin/editingTypes.ts
+/**
+* Shapes of the entry document's endpoints (editor experience, E0b): publish pre-flight, content health
+* findings, presence and per-model counts. Sentences are never sent: the admin builds them from `rule` and
+* `params` with its translations.
+*/
+/** Health rules evaluated per entry (`apps/api/src/services/contentHealth.ts`). */
+const HEALTH_RULES = [
+	"requiredEmpty",
+	"altMissing",
+	"localeMissing",
+	"relationMissing",
+	"relationUnpublished",
+	"uniqueConflict",
+	"staleDraft",
+	"unpublishedChanges"
+];
+//#endregion
+//#region src/admin/assistTypes.ts
+const CONTENT_OPS_RULES = ["altMissing", "localeMissing"];
+//#endregion
+//#region src/admin/index.ts
+/**
+* Admin endpoints: identity (setup, auth, sessions, users, invitations, roles, tokens, audit) and the schema
+* registry (models, components, schema, locales), the media library and content.
+*/
+const createAdminApi = (request) => ({
+	setup: {
+		status: () => request(ADMIN_PATHS.setup),
+		complete: (body) => request(ADMIN_PATHS.setup, {
+			method: "POST",
+			body
+		})
+	},
+	auth: {
+		csrf: () => request(ADMIN_PATHS.csrf),
+		login: (body) => request(ADMIN_PATHS.login, {
+			method: "POST",
+			body
+		}),
+		logout: () => request(ADMIN_PATHS.logout, { method: "POST" }),
+		me: () => request(ADMIN_PATHS.me),
+		updateProfile: (body) => request(ADMIN_PATHS.me, {
+			method: "PATCH",
+			body
+		}),
+		/** The session is rotated: the response carries the new session's CSRF token. */
+		changePassword: (body) => request(ADMIN_PATHS.password, {
+			method: "POST",
+			body
+		}),
+		requestPasswordReset: (body) => request(ADMIN_PATHS.passwordReset, {
+			method: "POST",
+			body
+		}),
+		confirmPasswordReset: (body) => request(ADMIN_PATHS.passwordResetConfirm, {
+			method: "POST",
+			body
+		})
+	},
+	sessions: {
+		list: () => request(ADMIN_PATHS.sessions),
+		revoke: (id) => request(withId(ADMIN_PATHS.sessions, id), { method: "DELETE" })
+	},
+	users: {
+		list: () => request(ADMIN_PATHS.users),
+		get: (id) => request(withId(ADMIN_PATHS.users, id)),
+		update: (id, body) => request(withId(ADMIN_PATHS.users, id), {
+			method: "PATCH",
+			body
+		}),
+		remove: (id) => request(withId(ADMIN_PATHS.users, id), { method: "DELETE" }),
+		revokeSessions: (id) => request(`${withId(ADMIN_PATHS.users, id)}/sessions`, { method: "DELETE" })
+	},
+	invitations: {
+		list: () => request(ADMIN_PATHS.invitations),
+		create: (body) => request(ADMIN_PATHS.invitations, {
+			method: "POST",
+			body
+		}),
+		revoke: (id) => request(withId(ADMIN_PATHS.invitations, id), { method: "DELETE" }),
+		/** A fresh link to send by hand; any earlier link for this invitation stops working. */
+		link: (id) => request(`${withId(ADMIN_PATHS.invitations, id)}/link`, { method: "POST" }),
+		/** Public: the token travels in the body, never in a URL the server logs. */
+		inspect: (token) => request(ADMIN_PATHS.inspectInvitation, {
+			method: "POST",
+			body: { token }
+		}),
+		accept: (body) => request(ADMIN_PATHS.acceptInvitation, {
+			method: "POST",
+			body
+		})
+	},
+	roles: {
+		list: () => request(ADMIN_PATHS.roles),
+		get: (id) => request(withId(ADMIN_PATHS.roles, id)),
+		create: (body) => request(ADMIN_PATHS.roles, {
+			method: "POST",
+			body
+		}),
+		update: (id, body) => request(withId(ADMIN_PATHS.roles, id), {
+			method: "PATCH",
+			body
+		}),
+		remove: (id) => request(withId(ADMIN_PATHS.roles, id), { method: "DELETE" })
+	},
+	tokens: {
+		list: () => request(ADMIN_PATHS.tokens),
+		create: (body) => request(ADMIN_PATHS.tokens, {
+			method: "POST",
+			body
+		}),
+		revoke: (id) => request(withId(ADMIN_PATHS.tokens, id), { method: "DELETE" })
+	},
+	audit: { list: (query = {}) => request(`${ADMIN_PATHS.audit}${toQueryString(query)}`) },
+	...createSchemaApi(request),
+	...createMediaApi(request),
+	...createContentApi(request),
+	...createEditingApi(request),
+	...createPublishingApi(request),
+	...createAppUsersApi(request),
+	...createChangeSetsApi(request),
+	...createUsageApi(request),
+	...createSitesApi(request),
+	...createAssistApi(request)
+});
+//#endregion
+//#region src/appAuth/index.ts
+const APP_AUTH_PATHS = {
+	register: "/api/app-auth/register",
+	login: "/api/app-auth/login",
+	refresh: "/api/app-auth/refresh",
+	logout: "/api/app-auth/logout",
+	me: "/api/app-auth/me",
+	password: "/api/app-auth/me/password",
+	confirmEmail: "/api/app-auth/confirm-email",
+	resendConfirmation: "/api/app-auth/confirm-email/resend",
+	passwordReset: "/api/app-auth/password-reset",
+	passwordResetConfirm: "/api/app-auth/password-reset/confirm",
+	providers: "/api/app-auth/providers",
+	oauthExchange: "/api/app-auth/oauth/exchange"
+};
+/**
+* App-user endpoints. Calls that act as the signed-in user need a client created with `token: accessToken`.
+* `baseUrl` is the client's base URL, used to build the OAuth start link the browser navigates to.
+*/
+const createAppAuthApi = (request, baseUrl) => ({
+	register: (body) => request(APP_AUTH_PATHS.register, {
+		method: "POST",
+		body
+	}),
+	login: (body) => request(APP_AUTH_PATHS.login, {
+		method: "POST",
+		body
+	}),
+	refresh: (refreshToken) => request(APP_AUTH_PATHS.refresh, {
+		method: "POST",
+		body: { refreshToken }
+	}),
+	/**
+	* Signs the account out everywhere: this login's refresh tokens are revoked, and every access token the
+	* account holds (on any device) is refused from the next request. Other logins recover with their own
+	* refresh token.
+	*/
+	logout: (refreshToken) => request(APP_AUTH_PATHS.logout, {
+		method: "POST",
+		body: { refreshToken }
+	}),
+	/** The signed-in user. Answers 401 once the account logged out anywhere, changed its password or was blocked. */
+	me: () => request(APP_AUTH_PATHS.me),
+	updateMe: (body) => request(APP_AUTH_PATHS.me, {
+		method: "PATCH",
+		body
+	}),
+	/** Returns a new session; every other sign-in of the account is revoked. */
+	changePassword: (body) => request(APP_AUTH_PATHS.password, {
+		method: "POST",
+		body
+	}),
+	deleteMe: (body = {}) => request(APP_AUTH_PATHS.me, {
+		method: "DELETE",
+		body
+	}),
+	/** The token from the `#token=` fragment of the confirmation link. */
+	confirmEmail: (token) => request(APP_AUTH_PATHS.confirmEmail, {
+		method: "POST",
+		body: { token }
+	}),
+	resendConfirmation: (email) => request(APP_AUTH_PATHS.resendConfirmation, {
+		method: "POST",
+		body: { email }
+	}),
+	requestPasswordReset: (email) => request(APP_AUTH_PATHS.passwordReset, {
+		method: "POST",
+		body: { email }
+	}),
+	confirmPasswordReset: (body) => request(APP_AUTH_PATHS.passwordResetConfirm, {
+		method: "POST",
+		body
+	}),
+	providers: async () => (await request(APP_AUTH_PATHS.providers)).providers,
+	/**
+	* Where to send the browser to sign in with a provider. `codeChallenge` comes from `createPkcePair()`;
+	* keep its `codeVerifier` until the browser returns. It comes back to `redirectTo` (an allowed return URL,
+	* by default an origin listed in CORS_ORIGINS) with `?code=` (pass it to `exchangeCode`) or `?error=`.
+	*/
+	oauthStartUrl: (provider, redirectTo, codeChallenge) => `${baseUrl.replace(/\/+$/, "")}/api/app-auth/oauth/${provider}/start?redirectTo=${encodeURIComponent(redirectTo)}&codeChallenge=${encodeURIComponent(codeChallenge)}`,
+	/** Trades the one-time code for a session. A wrong verifier spends the code: start the sign-in again. */
+	exchangeCode: (code, codeVerifier) => request(APP_AUTH_PATHS.oauthExchange, {
+		method: "POST",
+		body: {
+			code,
+			codeVerifier
+		}
+	})
+});
+//#endregion
+//#region src/delivery.ts
+const DELIVERY_PATH = "/api/content";
+const routePath = (routeKey) => `${DELIVERY_PATH}/${encodeURIComponent(routeKey)}`;
+/** The content query string plus `snapshot`, which only delivery reads take. */
+const deliveryQueryString = ({ snapshot, ...query }) => {
+	const base = toContentQueryString(query);
+	if (snapshot === void 0) return base;
+	const pinned = `snapshot=${encodeURIComponent(String(snapshot))}`;
+	return base ? `${base}&${pinned}` : `?${pinned}`;
+};
+/**
+* Published content, typed by the caller (`delivery.list<Article>('articles', { locale: 'fr', snapshot })`).
+* A collection is read with `list` (a page) and `get` (one entry); a singleton with `singleton`.
+*/
+const createDeliveryApi = (request) => ({
+	list: (routeKey, query = {}) => request(`${routePath(routeKey)}${deliveryQueryString(query)}`),
+	singleton: (apiKey, query = {}) => request(`${routePath(apiKey)}${deliveryQueryString(query)}`),
+	get: (routeKey, id, query = {}) => request(`${routePath(routeKey)}/${encodeURIComponent(id)}${deliveryQueryString(query)}`)
+});
+//#endregion
+//#region src/snapshots.ts
+const SNAPSHOT_PATHS = {
+	current: "/api/snapshots/current",
+	changes: "/api/snapshots/changes"
+};
+/** Snapshots and the diff between two of them, for incremental site builds (delivery credentials). */
+const createSnapshotsApi = (request) => {
+	const changes = (query) => request(`${SNAPSHOT_PATHS.changes}${toQueryString(query)}`);
+	return {
+		current: () => request(SNAPSHOT_PATHS.current),
+		changes,
+		/** Every change between `from` and `to`, following `nextCursor` until the last page. */
+		allChanges: async (query) => {
+			const items = [];
+			let page = await changes(query);
+			items.push(...page.items);
+			while (page.nextCursor !== null) {
+				page = await changes({
+					...query,
+					to: page.to,
+					after: page.nextCursor
+				});
+				items.push(...page.items);
+			}
+			return {
+				from: page.from,
+				to: page.to,
+				schemaVersions: page.schemaVersions,
+				items
+			};
+		}
+	};
+};
+//#endregion
+//#region src/site.ts
+/** Delivery reads name their site with `?site=`; everything else with the `Shapio-Site` header. */
+const SITE_QUERY_PARAMETER = "site";
+/** Delivery reads (content and snapshots): a GET there carries the site in its URL. */
+const DELIVERY_READ_PREFIXES = [
+	`${DELIVERY_PATH}/`,
+	`${DELIVERY_PATH}?`,
+	"/api/snapshots/"
+];
+const isDeliveryRead = (method, path) => method === "GET" && (path === "/api/content" || Object.values(SNAPSHOT_PATHS).some((snapshotPath) => path === snapshotPath) || DELIVERY_READ_PREFIXES.some((prefix) => path.startsWith(prefix)));
+const namesSite = (path) => {
+	const index = path.indexOf("?");
+	return index !== -1 && new URLSearchParams(path.slice(index + 1)).has("site");
+};
+/**
+* Where a request names the client's site (sites plan §H). Delivery GETs put it in the query string: a
+* simple cross-origin GET needs no CORS preflight, and URL-keyed CDN caches keep sites apart. Every other
+* request sends the `Shapio-Site` header. A path that already names a site is left as it is.
+*/
+const applySite = (site, method, path) => {
+	if (site === void 0 || namesSite(path)) return {
+		path,
+		headers: {}
+	};
+	if (isDeliveryRead(method, path)) {
+		const parameter = `${SITE_QUERY_PARAMETER}=${encodeURIComponent(site)}`;
+		return {
+			path: `${path}${path.includes("?") ? "&" : "?"}${parameter}`,
+			headers: {}
+		};
+	}
+	return {
+		path,
+		headers: { [SITE_HEADER]: site }
+	};
+};
+//#endregion
+//#region src/request.ts
+const parseBody = async (response) => {
+	const text = await response.text();
+	if (text.length === 0) return;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+};
+/** Builds the JSON request function every endpoint group uses. Non-2xx responses throw ShapioApiError. */
+const createRequest = ({ baseUrl, token, fetch, credentials, headers, site }) => {
+	const origin = baseUrl.replace(/\/+$/, "");
+	return async (requestPath, { method = "GET", body, signal } = {}) => {
+		const { path, headers: siteHeaders } = applySite(site, method, requestPath);
+		const requestHeaders = {
+			accept: "application/json",
+			...siteHeaders,
+			...headers?.()
+		};
+		if (token) requestHeaders.authorization = `Bearer ${token}`;
+		if (body !== void 0) requestHeaders["content-type"] = "application/json";
+		const response = await fetch(`${origin}${path}`, {
+			method,
+			headers: requestHeaders,
+			...body !== void 0 ? { body: JSON.stringify(body) } : {},
+			...signal ? { signal } : {},
+			...credentials ? { credentials } : {}
+		});
+		const parsed = await parseBody(response);
+		if (!response.ok) throw new ShapioApiError(response.status, parsed);
+		return parsed;
+	};
+};
+//#endregion
+//#region src/client.ts
+const createClient = ({ baseUrl, token, fetch = globalThis.fetch, credentials, headers, site }) => {
+	const request = createRequest({
+		baseUrl,
+		token,
+		fetch,
+		credentials,
+		headers,
+		site
+	});
+	return {
+		/**
+		* Any Shapio route, e.g. the delivery API. Delivery paths use the model's route key: a collection's
+		* plural API ID (`request('/api/content/articles')`, `/api/content/articles/<id>`), a singleton's API ID
+		* (`/api/content/homepage`). The admin API (`admin.*`) always uses the singular API ID.
+		*/
+		request,
+		system: {
+			health: (signal) => request("/api/health", signal ? { signal } : {}),
+			ready: (signal) => request("/api/ready", signal ? { signal } : {}),
+			version: (signal) => request("/api/version", signal ? { signal } : {})
+		},
+		/** Published content (the delivery API), typed by the caller. */
+		delivery: createDeliveryApi(request),
+		admin: createAdminApi(request),
+		/** Publication snapshots and the diff between two (incremental builds). */
+		snapshots: createSnapshotsApi(request),
+		/** End users of your sites and apps: sign-up, sign-in, tokens, OAuth. */
+		appAuth: createAppAuthApi(request, baseUrl)
+	};
+};
+//#endregion
+//#region src/webhooks.ts
+/**
+* Verifying Shapio's signed webhooks and deploy triggers on the receiving side (a site's revalidate route,
+* a build hook). The scheme is the server's (`apps/api/src/publishing/signature.ts`):
+* `X-Shapio-Signature: v1=<hex HMAC-SHA256(secret, "<timestamp>.<raw body>")>` with
+* `X-Shapio-Timestamp: <unix seconds>`; several comma-separated `v1=` values are accepted (secret rotation).
+* Uses Web Crypto, so it runs in Node, edge runtimes and browsers alike.
+*/
+const WEBHOOK_SIGNATURE_HEADER = "x-shapio-signature";
+const WEBHOOK_TIMESTAMP_HEADER = "x-shapio-timestamp";
+const WEBHOOK_EVENT_HEADER = "x-shapio-event";
+/** Requests signed further from now than this are rejected (replay protection). */
+const WEBHOOK_TOLERANCE_SECONDS = 300;
+const SIGNATURE_VERSION = "v1";
+const toHex = (bytes) => Array.from(new Uint8Array(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+/** Compares two strings without returning early on the first difference. */
+const constantTimeEqual = (a, b) => {
+	let difference = a.length ^ b.length;
+	for (let index = 0; index < Math.max(a.length, b.length); index += 1) difference |= (a.charCodeAt(index) || 0) ^ (b.charCodeAt(index) || 0);
+	return difference === 0;
+};
+const expectedSignature = async (secret, timestamp, body) => {
+	const encoder = new TextEncoder();
+	const key = await globalThis.crypto.subtle.importKey("raw", encoder.encode(secret), {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	const mac = await globalThis.crypto.subtle.sign("HMAC", key, encoder.encode(`${timestamp}.${body}`));
+	return `${SIGNATURE_VERSION}=${toHex(mac)}`;
+};
+/** Checks a Shapio signature; `{ ok: false, reason }` says why it was refused (never throws for bad input). */
+const verifyWebhookSignature = async ({ secret, signature, timestamp, body, now = /* @__PURE__ */ new Date(), toleranceSeconds = 300 }) => {
+	if (!signature || !timestamp || !/^\d{1,12}$/.test(timestamp)) return {
+		ok: false,
+		reason: "missing signature or timestamp"
+	};
+	const seconds = Number(timestamp);
+	if (Math.abs(now.getTime() / 1e3 - seconds) > toleranceSeconds) return {
+		ok: false,
+		reason: "timestamp outside the allowed window"
+	};
+	const expected = await expectedSignature(secret, seconds, body);
+	return signature.split(",").map((candidate) => candidate.trim()).some((candidate) => constantTimeEqual(candidate, expected)) ? { ok: true } : {
+		ok: false,
+		reason: "signature mismatch"
+	};
+};
+//#endregion
+//#region src/appAuth/pkce.ts
+const toBase64Url = (bytes) => btoa(String.fromCharCode(...bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+/** The S256 challenge of a verifier: base64url(SHA-256(verifier)). */
+const codeChallengeOf = async (codeVerifier) => toBase64Url(new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(codeVerifier))));
+/** A fresh verifier (32 random bytes, 43 characters) and its S256 challenge. */
+const createPkcePair = async () => {
+	const codeVerifier = toBase64Url(globalThis.crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(32)));
+	return {
+		codeVerifier,
+		codeChallenge: await codeChallengeOf(codeVerifier)
+	};
+};
+//#endregion
+export { ADMIN_PATHS, APP_AUTH_PATHS, APP_CONTENT_ACTIONS, ASSIST_PATHS, BUILT_IN_APP_ROLE_KEYS, CHANGE_SET_STATUSES, CONTENT_ACTIONS, CONTENT_OPS_RULES, DELIVERY_PATH, DEPLOYMENT_PROVIDERS, DEPLOYMENT_RUN_STATUSES, DEPLOYMENT_TRIGGERS, GLOBAL_ACTIONS, HEALTH_RULES, JOB_STATUSES, NETWORK_ACTIONS, NOT_RESTORABLE_REASONS, PUBLICATION_ACTIONS, SCHEDULE_STATUSES, SITES_PATHS, SITE_ACTIONS, SITE_HEADER, SITE_QUERY_PARAMETER, SNAPSHOT_SOURCES, ShapioApiError, WEBHOOK_EVENT_HEADER, WEBHOOK_SIGNATURE_HEADER, WEBHOOK_TIMESTAMP_HEADER, WEBHOOK_TOLERANCE_SECONDS, buildUploadForm, codeChallengeOf, createClient, createPkcePair, resolveUploadUrl, toContentQueryString, verifyWebhookSignature };
+
+//# sourceMappingURL=index.js.map