@andesine/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1167 @@
+import { i as AndesineStreamProtocolError, n as AndesineAPIError, r as AndesineStreamError, t as createAnswerStream } from "./answer-stream-7N_gLhVS.js";
+import createFetchClient from "openapi-fetch";
+//#region src/paginate.ts
+/**
+* Iterate cursor-paginated pages, retaining their metadata.
+*
+* @param getPage - Fetch one page for the supplied cursor. The first cursor is undefined unless supplied.
+* Keep filters stable. This generic helper does not bind snapshots; use content.paginateEntryPages()
+* or content.paginateCollectionPages() for automatic published snapshot handling.
+* @param options - Optional cursor from an earlier page to resume processing.
+* @returns A lazy iterator that requests the next page only after the previous page is consumed.
+* Save pagination.nextCursor after processing a page. Break the loop to stop further requests.
+* @throws Error for a missing or repeated next cursor. Callback failures pass through unchanged.
+*/
+const paginatePages = async function* (getPage, options = {}) {
+	const seen = new Set(options.cursor ? [options.cursor] : []);
+	let cursor = options.cursor;
+	do {
+		const page = await getPage(cursor);
+		const next = page.pagination.nextCursor;
+		if (page.pagination.hasMore && (!next || seen.has(next))) throw new Error("Pagination returned a missing or repeated cursor");
+		yield page;
+		if (!page.pagination.hasMore) return;
+		seen.add(next);
+		cursor = next;
+	} while (cursor);
+};
+/**
+* Iterate items across cursor-paginated pages without collecting them in memory.
+*
+* @param getPage - Fetch one page using the cursor. Keep scope and filters stable in this callback.
+* This generic helper does not bind snapshots; content.paginateEntries() and
+* content.paginateCollections() do that automatically for published content.
+* @param options - Optional starting cursor; retain its matching scope and snapshot yourself.
+* @returns Items in API order. Break the loop to prevent further page requests.
+* @throws Pagination errors from paginatePages(), or the original callback error.
+*/
+const paginate = async function* (getPage, options = {}) {
+	for await (const page of paginatePages(getPage, options)) yield* page.data;
+};
+//#endregion
+//#region src/content-client.ts
+const paginateSnapshotPages = async function* (list, input, options = {}) {
+	let query = { ...input };
+	yield* paginatePages(async (cursor) => {
+		const page = await list({
+			...query,
+			cursor
+		}, {
+			...options,
+			response: "data"
+		});
+		if (query.snapshotID !== void 0 && page.snapshotID !== query.snapshotID) throw new Error("Pagination returned a different snapshot");
+		query = {
+			...query,
+			channel: void 0,
+			snapshotID: page.snapshotID
+		};
+		return page;
+	}, { cursor: input.cursor });
+};
+const createContentClient = (content) => {
+	const paginateEntryPages = (input = {}, options) => paginateSnapshotPages((query, requestOptions) => content.listEntries(query, requestOptions), input, options);
+	const paginateCollectionPages = (input = {}, options) => paginateSnapshotPages((query, requestOptions) => content.listCollections(query, requestOptions), input, options);
+	return {
+		...content,
+		paginateEntryPages,
+		async *paginateEntries(input, options) {
+			for await (const page of paginateEntryPages(input, options)) yield* page.data;
+		},
+		paginateCollectionPages,
+		async *paginateCollections(input, options) {
+			for await (const page of paginateCollectionPages(input, options)) yield* page.data;
+		}
+	};
+};
+//#endregion
+//#region src/query.ts
+const serializeQuery = (query) => {
+	const parameters = new URLSearchParams();
+	const escapeKey = (key) => key.replace(/[\\[\]]/g, (character) => `\\${character}`);
+	const append = (path, value) => {
+		if (value === void 0 || value === null) return;
+		if (Array.isArray(value)) value.forEach((item, index) => append(`${path}[${index}]`, item));
+		else if (typeof value === "object") for (const [key, item] of Object.entries(value)) append(`${path}[${escapeKey(key)}]`, item);
+		else parameters.append(path, String(value));
+	};
+	for (const [key, value] of Object.entries(query)) append(escapeKey(key), value);
+	return parameters.toString();
+};
+//#endregion
+//#region src/operation.ts
+const operation = (request, definition) => {
+	return ((input, options) => {
+		return request(definition, input || {}, options);
+	});
+};
+//#endregion
+//#region src/generated/resources.ts
+const createResources = (request) => ({
+	assets: {
+		search: operation(request, {
+			method: "get",
+			path: "/assets/search",
+			pathParams: [],
+			queryParams: [
+				"query",
+				"checksum",
+				"semantic",
+				"limit"
+			],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		importURL: operation(request, {
+			method: "post",
+			path: "/assets/imports",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		attach: operation(request, {
+			method: "post",
+			path: "/assets/{assetID}/attachments",
+			pathParams: ["assetID"],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		register: operation(request, {
+			method: "post",
+			path: "/assets/uploads",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		upload: operation(request, {
+			method: "put",
+			path: "/assets/{assetID}/upload",
+			pathParams: ["assetID"],
+			queryParams: [],
+			body: true,
+			multipart: true,
+			binary: false,
+			anonymous: false
+		}),
+		get: operation(request, {
+			method: "get",
+			path: "/assets/{assetID}",
+			pathParams: ["assetID"],
+			queryParams: ["entryID"],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		})
+	},
+	instance: { get: operation(request, {
+		method: "get",
+		path: "/instance",
+		pathParams: [],
+		queryParams: [],
+		body: false,
+		multipart: false,
+		binary: false,
+		anonymous: false
+	}) },
+	entries: {
+		create: operation(request, {
+			method: "post",
+			path: "/entries",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		bulkDelete: operation(request, {
+			method: "post",
+			path: "/entries/bulk/delete",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		delete: operation(request, {
+			method: "delete",
+			path: "/entries/{id}",
+			pathParams: ["id"],
+			queryParams: [],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		update: operation(request, {
+			method: "put",
+			path: "/entries/{id}",
+			pathParams: ["id"],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		get: operation(request, {
+			method: "get",
+			path: "/entries/get",
+			pathParams: [],
+			queryParams: [
+				"id",
+				"path",
+				"expectedSchemaHash"
+			],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		list: operation(request, {
+			method: "get",
+			path: "/entries/list",
+			pathParams: [],
+			queryParams: [
+				"collectionID",
+				"collectionPath",
+				"cursor",
+				"limit"
+			],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		})
+	},
+	collections: {
+		create: operation(request, {
+			method: "post",
+			path: "/collections",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		bulkDelete: operation(request, {
+			method: "post",
+			path: "/collections/bulk/delete",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		delete: operation(request, {
+			method: "delete",
+			path: "/collections/{id}",
+			pathParams: ["id"],
+			queryParams: [],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		update: operation(request, {
+			method: "put",
+			path: "/collections/{id}",
+			pathParams: ["id"],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		list: operation(request, {
+			method: "get",
+			path: "/collections/list",
+			pathParams: [],
+			queryParams: [
+				"collectionID",
+				"collectionPath",
+				"cursor",
+				"limit"
+			],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		})
+	},
+	content: {
+		listCollections: operation(request, {
+			method: "get",
+			path: "/content/collections",
+			pathParams: [],
+			queryParams: [
+				"cursor",
+				"limit",
+				"collectionID",
+				"collectionPath",
+				"channel",
+				"snapshotID"
+			],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		listEntries: operation(request, {
+			method: "get",
+			path: "/content/entries",
+			pathParams: [],
+			queryParams: [
+				"cursor",
+				"limit",
+				"collectionID",
+				"collectionPath",
+				"channel",
+				"snapshotID",
+				"descendants",
+				"includeContent",
+				"filters"
+			],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		getSchema: operation(request, {
+			method: "get",
+			path: "/content/entries/schema",
+			pathParams: [],
+			queryParams: [
+				"entryID",
+				"path",
+				"channel",
+				"snapshotID"
+			],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		getAsset: operation(request, {
+			method: "get",
+			path: "/content/assets/{workspaceID}/{snapshotID}/{entryID}/{assetID}/{variant}",
+			pathParams: [
+				"workspaceID",
+				"snapshotID",
+				"entryID",
+				"assetID",
+				"variant"
+			],
+			queryParams: [],
+			body: false,
+			multipart: false,
+			binary: true,
+			anonymous: true
+		}),
+		get: operation(request, {
+			method: "get",
+			path: "/content/entries/get",
+			pathParams: [],
+			queryParams: [
+				"entryID",
+				"path",
+				"expectedSchemaHash",
+				"channel",
+				"snapshotID"
+			],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		getTree: operation(request, {
+			method: "get",
+			path: "/content/tree",
+			pathParams: [],
+			queryParams: [
+				"collectionID",
+				"collectionPath",
+				"channel",
+				"snapshotID"
+			],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		})
+	},
+	roles: {
+		list: operation(request, {
+			method: "get",
+			path: "/roles",
+			pathParams: [],
+			queryParams: [],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		create: operation(request, {
+			method: "post",
+			path: "/roles",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		update: operation(request, {
+			method: "put",
+			path: "/roles/{id}",
+			pathParams: ["id"],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		delete: operation(request, {
+			method: "delete",
+			path: "/roles/{id}",
+			pathParams: ["id"],
+			queryParams: [],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		})
+	},
+	search: {
+		current: operation(request, {
+			method: "post",
+			path: "/search/current",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		published: operation(request, {
+			method: "post",
+			path: "/search/published",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		askCurrent: operation(request, {
+			method: "post",
+			path: "/search/current/ask",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		askPublished: operation(request, {
+			method: "post",
+			path: "/search/published/ask",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		askCurrentStream: operation(request, {
+			streaming: true,
+			method: "post",
+			path: "/search/current/ask/stream",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		askPublishedStream: operation(request, {
+			streaming: true,
+			method: "post",
+			path: "/search/published/ask/stream",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		})
+	},
+	schemas: {
+		create: operation(request, {
+			method: "post",
+			path: "/collections/{collectionID}/schema",
+			pathParams: ["collectionID"],
+			queryParams: [],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		delete: operation(request, {
+			method: "delete",
+			path: "/schemas/{schemaID}",
+			pathParams: ["schemaID"],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		getRevision: operation(request, {
+			method: "get",
+			path: "/schema-revisions/{revisionID}",
+			pathParams: ["revisionID"],
+			queryParams: [],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		get: operation(request, {
+			method: "get",
+			path: "/schemas/collection",
+			pathParams: [],
+			queryParams: ["collectionID", "collectionPath"],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		apply: operation(request, {
+			method: "post",
+			path: "/schemas/{schemaID}/apply",
+			pathParams: ["schemaID"],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		})
+	},
+	schemaMigrations: {
+		listContentLossEntries: operation(request, {
+			method: "get",
+			path: "/schema-migrations/{id}/content-loss-entries",
+			pathParams: ["id"],
+			queryParams: ["cursor", "limit"],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		getActive: operation(request, {
+			method: "get",
+			path: "/collections/{collectionID}/schema-migration",
+			pathParams: ["collectionID"],
+			queryParams: [],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		get: operation(request, {
+			method: "get",
+			path: "/schema-migrations/{id}",
+			pathParams: ["id"],
+			queryParams: [],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		})
+	},
+	schemaVersions: {
+		list: operation(request, {
+			method: "get",
+			path: "/schemas/{schemaID}/versions",
+			pathParams: ["schemaID"],
+			queryParams: ["cursor", "limit"],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		get: operation(request, {
+			method: "get",
+			path: "/schema-versions/{id}",
+			pathParams: ["id"],
+			queryParams: [],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		update: operation(request, {
+			method: "patch",
+			path: "/schema-versions/{id}",
+			pathParams: ["id"],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		revert: operation(request, {
+			method: "post",
+			path: "/schema-versions/{id}/revert",
+			pathParams: ["id"],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		})
+	},
+	memberships: {
+		list: operation(request, {
+			method: "get",
+			path: "/memberships",
+			pathParams: [],
+			queryParams: ["cursor", "limit"],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		invite: operation(request, {
+			method: "post",
+			path: "/memberships",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		update: operation(request, {
+			method: "patch",
+			path: "/memberships/{id}",
+			pathParams: ["id"],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		remove: operation(request, {
+			method: "delete",
+			path: "/memberships/{id}",
+			pathParams: ["id"],
+			queryParams: [],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		listInvites: operation(request, {
+			method: "get",
+			path: "/memberships/invites",
+			pathParams: [],
+			queryParams: ["cursor", "limit"],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		resendInvite: operation(request, {
+			method: "post",
+			path: "/memberships/invites/{id}/resend",
+			pathParams: ["id"],
+			queryParams: [],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		revokeInvite: operation(request, {
+			method: "delete",
+			path: "/memberships/invites/{id}",
+			pathParams: ["id"],
+			queryParams: [],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		})
+	},
+	publishing: {
+		setCollection: operation(request, {
+			method: "put",
+			path: "/publishing/collections/{collectionID}",
+			pathParams: ["collectionID"],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		publishCollection: operation(request, {
+			method: "post",
+			path: "/publishing/collections/{collectionID}",
+			pathParams: ["collectionID"],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		unpublishCollection: operation(request, {
+			method: "delete",
+			path: "/publishing/collections/{collectionID}",
+			pathParams: ["collectionID"],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		bulkSetCollections: operation(request, {
+			method: "post",
+			path: "/publishing/collections/bulk/set",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		bulkPublishCollections: operation(request, {
+			method: "post",
+			path: "/publishing/collections/bulk/publish",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		bulkUnpublishCollections: operation(request, {
+			method: "post",
+			path: "/publishing/collections/bulk/unpublish",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		publishEntry: operation(request, {
+			method: "post",
+			path: "/publishing/entries/{entryID}",
+			pathParams: ["entryID"],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		unpublishEntry: operation(request, {
+			method: "delete",
+			path: "/publishing/entries/{entryID}",
+			pathParams: ["entryID"],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		bulkPublishEntries: operation(request, {
+			method: "post",
+			path: "/publishing/entries/bulk/publish",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		bulkUnpublishEntries: operation(request, {
+			method: "post",
+			path: "/publishing/entries/bulk/unpublish",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		revertChanges: operation(request, {
+			method: "post",
+			path: "/publishing/changes/revert",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		getEntryVersion: operation(request, {
+			method: "get",
+			path: "/publishing/entries/{entryID}/version",
+			pathParams: ["entryID"],
+			queryParams: [
+				"channel",
+				"expectedSchemaHash",
+				"snapshotID"
+			],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		listEntryPublications: operation(request, {
+			method: "get",
+			path: "/publishing/entries/{entryID}/publications",
+			pathParams: ["entryID"],
+			queryParams: [],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		listChannels: operation(request, {
+			method: "get",
+			path: "/publishing/channels",
+			pathParams: [],
+			queryParams: ["includeAssignmentCount"],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		createChannel: operation(request, {
+			method: "post",
+			path: "/publishing/channels",
+			pathParams: [],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		getChannelContent: operation(request, {
+			method: "get",
+			path: "/publishing/channels/{channel}/content",
+			pathParams: ["channel"],
+			queryParams: ["collectionID"],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		deleteChannel: operation(request, {
+			method: "delete",
+			path: "/publishing/channels/{code}",
+			pathParams: ["code"],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		})
+	},
+	versions: {
+		create: operation(request, {
+			method: "post",
+			path: "/entries/{entryID}/versions",
+			pathParams: ["entryID"],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		list: operation(request, {
+			method: "get",
+			path: "/entries/{entryID}/versions",
+			pathParams: ["entryID"],
+			queryParams: ["cursor", "limit"],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		get: operation(request, {
+			method: "get",
+			path: "/versions/{id}",
+			pathParams: ["id"],
+			queryParams: ["expectedSchemaHash"],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		update: operation(request, {
+			method: "patch",
+			path: "/versions/{id}",
+			pathParams: ["id"],
+			queryParams: [],
+			body: true,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		}),
+		revert: operation(request, {
+			method: "post",
+			path: "/versions/{id}/revert",
+			pathParams: ["id"],
+			queryParams: [],
+			body: false,
+			multipart: false,
+			binary: false,
+			anonymous: false
+		})
+	}
+});
+//#endregion
+//#region src/retry.ts
+const wait = (delay, signal) => {
+	signal.throwIfAborted();
+	return new Promise((resolve, reject) => {
+		const abort = () => {
+			clearTimeout(timer);
+			reject(signal.reason);
+		};
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", abort);
+			resolve();
+		}, delay);
+		signal.addEventListener("abort", abort, { once: true });
+	});
+};
+const retryDelay = (attempt, response) => {
+	const value = response?.headers.get("Retry-After");
+	const seconds = value === null || value === void 0 ? NaN : Number(value);
+	const date = value ? Date.parse(value) : NaN;
+	if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+	if (Number.isFinite(date)) return Math.max(0, date - Date.now());
+	return Math.min(1e3 * 2 ** attempt, 3e4) + Math.random() * 250;
+};
+const fetchWithRetries = async (fetcher, request, retries) => {
+	const signal = request.signal;
+	for (let attempt = 0;; attempt += 1) {
+		let response;
+		signal.throwIfAborted();
+		try {
+			response = await fetcher(request.clone());
+		} catch (error) {
+			if (signal.aborted || attempt >= retries || !(error instanceof TypeError)) throw error;
+			await wait(retryDelay(attempt), signal);
+			continue;
+		}
+		if (attempt >= retries || ![
+			429,
+			500,
+			502,
+			503,
+			504
+		].includes(response.status)) return response;
+		const delay = retryDelay(attempt, response);
+		await response.body?.cancel();
+		await wait(delay, signal);
+	}
+};
+//#endregion
+//#region src/client.ts
+/**
+* Create a typed API client for a hosted or self-hosted Andesine instance.
+*
+* Methods return response data by default. Use response: "full" for status and headers,
+* including conditional reads that can return 304. Creation does not make a request.
+* @param config - Optional API root, credentials, transport, and request defaults.
+* Defaults to https://api.andesine.app and process.env.ANDESINE_API_KEY when available.
+* Runtimes without process.env use no default key. No environment files are loaded.
+* @returns API resources and helpers for published-content snapshots and pagination.
+* @throws TypeError if baseURL is not HTTP(S) or includes credentials, a query, or a fragment.
+* Request failures throw AndesineAPIError; abort and timeout reasons are preserved.
+* @example
+* const client = createClient();
+* const page = await client.content.get({ path: "/Docs/Welcome" });
+*/
+const createClient = (config = {}) => {
+	const baseURL = (config.baseURL ?? "https://api.andesine.app").replace(/\/+$/, "");
+	const apiKey = config.apiKey ?? globalThis.process?.env?.ANDESINE_API_KEY;
+	const url = new URL(baseURL);
+	const fetcher = config.fetch ?? globalThis.fetch;
+	if (!["http:", "https:"].includes(url.protocol) || url.search || url.hash || url.username || url.password) throw new TypeError("baseURL must be an HTTP(S) URL without credentials, query, or fragment");
+	const request = async (definition, input, options = {}) => {
+		const controller = new AbortController();
+		const signal = options.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+		const timeout = options.timeout ?? config.timeout ?? 3e4;
+		const retries = options.retries ?? config.retries ?? 0;
+		const headers = new Headers(config.headers);
+		const path = Object.fromEntries(definition.pathParams.map((key) => [key, input[key]]));
+		const query = Object.fromEntries(definition.queryParams.map((key) => [key, input[key]]));
+		const body = Object.fromEntries(Object.entries(input).filter(([key]) => !definition.pathParams.includes(key) && !definition.queryParams.includes(key)));
+		const client = createFetchClient({
+			baseUrl: baseURL,
+			querySerializer: serializeQuery
+		});
+		if (!Number.isFinite(timeout) || timeout < 0 || !Number.isInteger(retries) || retries < 0) throw new TypeError("timeout and retries must be nonnegative; retries must be an integer");
+		if (query.channel !== void 0 && query.snapshotID !== void 0) throw new TypeError("Use either channel or snapshotID, not both");
+		for (const key of definition.pathParams) if (input[key] === void 0 || input[key] === null) throw new TypeError(`Missing path parameter: ${key}`);
+		new Headers(options.headers).forEach((value, key) => headers.set(key, value));
+		if (definition.streaming && !headers.has("Accept")) headers.set("Accept", "text/event-stream");
+		if (apiKey && !definition.anonymous) headers.set("Authorization", `Bearer ${apiKey}`);
+		const timer = timeout > 0 ? setTimeout(() => controller.abort(new DOMException("Request timed out", "TimeoutError")), timeout) : void 0;
+		let streamOwnsRequest = false;
+		try {
+			const result = await client.request(definition.method, definition.path, {
+				params: {
+					path,
+					query
+				},
+				headers,
+				signal,
+				body: definition.body ? body : void 0,
+				parseAs: "stream",
+				bodySerializer: definition.multipart ? (value) => {
+					const form = new FormData();
+					for (const [key, item] of Object.entries(value)) if (item instanceof Blob) form.append(key, item);
+					else if (item !== void 0) form.append(key, typeof item === "string" ? item : JSON.stringify(item));
+					return form;
+				} : void 0,
+				fetch: (request) => fetchWithRetries(fetcher, request, definition.method === "get" ? retries : 0)
+			});
+			const response = result.response;
+			if (response.status === 304) {
+				if (options.response !== "full") throw new TypeError("Use response: 'full' for conditional requests that can return 304");
+				return {
+					status: 304,
+					headers: response.headers,
+					data: void 0,
+					notModified: true
+				};
+			}
+			if (!response.ok) throw new AndesineAPIError(response, result.error);
+			if (definition.streaming) {
+				const data = createAnswerStream(response, {
+					signal,
+					cancel: () => controller.abort(),
+					cleanup: () => {
+						if (timer !== void 0) clearTimeout(timer);
+					}
+				});
+				streamOwnsRequest = true;
+				return options.response === "full" ? {
+					status: response.status,
+					headers: response.headers,
+					data,
+					notModified: false
+				} : data;
+			}
+			const text = definition.binary || response.status === 204 ? void 0 : await response.text();
+			const data = definition.binary ? await response.blob() : text ? JSON.parse(text) : void 0;
+			return options.response === "full" ? {
+				status: response.status,
+				headers: response.headers,
+				data,
+				notModified: false
+			} : data;
+		} finally {
+			if (!streamOwnsRequest && timer !== void 0) clearTimeout(timer);
+		}
+	};
+	const resources = createResources(request);
+	return {
+		...resources,
+		content: createContentClient(resources.content),
+		atSnapshot(snapshotID) {
+			return createContentClient(createResources((definition, input, options) => {
+				const pinned = definition.path.startsWith("/content/") && definition.queryParams.includes("snapshotID");
+				if (pinned && (input.channel !== void 0 || input.snapshotID !== void 0 && input.snapshotID !== snapshotID)) throw new TypeError("Cannot override a pinned snapshot");
+				return request(definition, pinned ? {
+					...input,
+					snapshotID
+				} : input, options);
+			}).content);
+		}
+	};
+};
+//#endregion
+//#region src/content-url.ts
+/**
+* Convert a canonical Andesine path or search/citation location to a website URL.
+*
+* Encodes each decoded path segment and anchor without changing case or deriving slugs.
+* This is a pure function: it does not resolve IDs, fetch content, or pin a snapshot.
+* @param source - An absolute decoded path (starting with /), or an object with path and anchor.
+* Collection-ID-relative selectors must first be resolved through the API to a canonical path.
+* @param options - Source collection root and destination URL prefix.
+* @returns A root-relative URL by default, or an absolute URL when baseURL is absolute.
+* The source root itself maps to the destination root without adding a trailing slash.
+* @throws TypeError for invalid paths, a source outside rootPath, or an invalid baseURL.
+* @example
+* toContentURL({ path: "/Docs/Getting started", anchor: "install" }, {
+*   rootPath: "/Docs", baseURL: "/docs"
+* }); // "/docs/Getting%20started#install"
+*/
+const toContentURL = (source, options = {}) => {
+	const location = typeof source === "string" ? { path: source } : source;
+	const segments = contentPathSegments(location.path);
+	const root = contentPathSegments(options.rootPath ?? "/");
+	const outsideRoot = root.some((segment, index) => segments[index] !== segment);
+	const baseURL = options.baseURL ?? "/";
+	const relative = baseURL.startsWith("/") && !baseURL.startsWith("//");
+	const url = new URL(baseURL, relative ? "https://andesine.invalid" : void 0);
+	const invalidBase = !["http:", "https:"].includes(url.protocol) || Boolean(url.search || url.hash || url.username || url.password) || baseURL.includes("\\");
+	if (outsideRoot) throw new TypeError("Content path is outside rootPath");
+	if (invalidBase) throw new TypeError("baseURL must be a root-relative or HTTP(S) URL without credentials, query, or fragment");
+	const suffix = segments.slice(root.length).map(encodeURIComponent).join("/");
+	const prefix = url.pathname.replace(/\/+$/, "");
+	url.pathname = (suffix ? `${prefix}/${suffix}` : prefix) || "/";
+	url.hash = location.anchor ? encodeURIComponent(location.anchor) : "";
+	return relative ? `${url.pathname}${url.hash}` : url.href;
+};
+const contentPathSegments = (path) => {
+	const segments = path === "/" ? [] : path.slice(1).split("/");
+	if (!path.startsWith("/") || segments.some((segment) => !segment || segment === "." || segment === "..")) throw new TypeError("Use an absolute decoded content path without empty or dot segments");
+	return segments;
+};
+//#endregion
+//#region src/structured-content.ts
+/**
+* Unwrap property values and fragment documents for use in application code.
+*
+* @param page - Full entry content with properties and fragments, including published list items.
+* @returns A new object with property.value and fragment.content exposed by key. Other fields,
+* including schema metadata and assets, are preserved. Nested content is shared, not cloned.
+* This helper does not validate content, convert formats, or infer collection-specific types.
+* @example
+* const tutorial = toStructuredContent(page);
+* const body = tutorial.fragments.body;
+* const enabled = tutorial.properties.enabled;
+*/
+const toStructuredContent = (page) => ({
+	...page,
+	properties: Object.fromEntries(Object.entries(page.properties).map(([key, property]) => [key, property.value])),
+	fragments: Object.fromEntries(Object.entries(page.fragments).map(([key, fragment]) => [key, fragment.content]))
+});
+//#endregion
+export { AndesineAPIError, AndesineStreamError, AndesineStreamProtocolError, createClient, paginate, paginatePages, toContentURL, toStructuredContent };
+
+//# sourceMappingURL=index.js.map