@prosewire/sdk 0.2.0 → 0.4.0

package/dist/index.mjs

@@ -1,10 +1,47 @@
 import { Effect, Schema } from "effect";
 import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
 import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
+//#region ../contract/src/import.ts
+/** Imports use a streaming body rather than the buffered JSON HttpApi adapter. */
+const portableImportPath = "/api/v1/import";
+const portableImportReport = Schema.Struct({
+	mode: Schema.Literals(["preview", "apply"]),
+	fingerprint: Schema.String,
+	preserveStates: Schema.Boolean,
+	counts: Schema.Record(Schema.String, Schema.Int),
+	alreadyImported: Schema.Boolean
+});
+Schema.TaggedError()("ApiImportRejected", {
+	item: Schema.String,
+	message: Schema.String
+}, { httpApiStatus: 400 });
+Schema.TaggedError()("ApiImportConflict", {
+	item: Schema.String,
+	message: Schema.String
+}, { httpApiStatus: 409 });
+//#endregion
 //#region ../contract/src/schemas.ts
 const withDefault = (schema, value) => Schema.withDecodingDefaultKey(Effect.succeed(value))(schema);
-const uuid$2 = Schema.String.check(Schema.isUUID());
-const isoDateTime = Schema.String.check(Schema.isPattern(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/));
+const uuid = Schema.String.check(Schema.isUUID());
+const isoDateTime = Schema.String.check(Schema.isPattern(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/), Schema.makeFilter((value) => {
+	const [year, month, day, hour, minute, second] = value.slice(0, 19).split(/[-T:]/).map(Number);
+	if (year === void 0 || month === void 0 || day === void 0 || hour === void 0 || minute === void 0 || second === void 0) return false;
+	const days = [
+		31,
+		year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 29 : 28,
+		31,
+		30,
+		31,
+		30,
+		31,
+		31,
+		30,
+		31,
+		30,
+		31
+	];
+	return month >= 1 && month <= 12 && day >= 1 && day <= (days[month - 1] ?? 0) && hour < 24 && minute < 60 && second < 60;
+}, { expected: "a valid ISO calendar date and time" }));
 const url = Schema.String.check(Schema.isPattern(/^[a-z][a-z\d+.-]*:\/\/\S+$/i));
 const nullable = (schema) => Schema.NullOr(schema);
 const postStatus = Schema.Literals([
@@ -14,7 +51,7 @@ const postStatus = Schema.Literals([
 	"archived"
 ]);
 const authorOutput = Schema.Struct({
-	id: uuid$2,
+	id: uuid,
 	name: Schema.String,
 	slug: Schema.String,
 	bio: nullable(Schema.String),
@@ -23,19 +60,20 @@ const authorOutput = Schema.Struct({
 	credentials: nullable(Schema.String)
 });
 const categoryOutput = Schema.Struct({
-	id: uuid$2,
+	id: uuid,
 	name: Schema.String,
 	slug: Schema.String,
 	description: nullable(Schema.String)
 });
 const postOutput = Schema.Struct({
-	id: uuid$2,
-	blogId: uuid$2,
+	id: uuid,
+	blogId: uuid,
 	title: Schema.String,
 	slug: Schema.String,
 	excerpt: Schema.String,
 	contentMarkdown: Schema.String,
 	contentHtml: Schema.String,
+	coverImageAssetId: nullable(uuid),
 	coverImageUrl: nullable(Schema.String),
 	coverImageAlt: nullable(Schema.String),
 	status: postStatus,
@@ -52,11 +90,41 @@ const postOutput = Schema.Struct({
 	author: authorOutput,
 	categories: Schema.Array(categoryOutput)
 });
-const authorId = uuid$2;
+const postRevisionSnapshot = Schema.Struct({
+	authorId: uuid,
+	title: Schema.String,
+	slug: Schema.String,
+	excerpt: Schema.String,
+	contentMarkdown: Schema.String,
+	coverImageAssetId: Schema.optionalKey(nullable(uuid)),
+	coverImageUrl: nullable(Schema.String),
+	coverImageAlt: nullable(Schema.String),
+	status: postStatus,
+	locale: Schema.String,
+	featured: Schema.Boolean,
+	seoTitle: nullable(Schema.String),
+	seoDescription: nullable(Schema.String),
+	focusKeyword: nullable(Schema.String),
+	canonicalUrl: nullable(Schema.String),
+	scheduledAt: nullable(isoDateTime),
+	publishedAt: nullable(isoDateTime),
+	archivedAt: nullable(isoDateTime),
+	categoryIds: nullable(Schema.Array(uuid))
+});
+const postRevisionOutput = Schema.Struct({
+	id: uuid,
+	postId: uuid,
+	editorId: nullable(Schema.String),
+	version: Schema.Int,
+	snapshot: postRevisionSnapshot,
+	createdAt: isoDateTime
+});
+const authorId = uuid;
 const title = Schema.Trim.pipe(Schema.check(Schema.isMinLength(1), Schema.isMaxLength(180)));
 const slug = Schema.Trim.pipe(Schema.check(Schema.isMinLength(1), Schema.isMaxLength(120), Schema.isPattern(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)));
 const excerpt = Schema.String.check(Schema.isMaxLength(500));
 const contentMarkdown = Schema.String;
+const coverImageAssetId = nullable(uuid);
 const coverImageUrl = nullable(url);
 const coverImageAlt = nullable(Schema.String.check(Schema.isMaxLength(180)));
 const locale = Schema.String.check(Schema.isMinLength(2), Schema.isMaxLength(10));
@@ -66,18 +134,19 @@ const seoDescription = nullable(Schema.String.check(Schema.isMaxLength(180)));
 const focusKeyword = nullable(Schema.String.check(Schema.isMaxLength(120)));
 const canonicalUrl = nullable(url);
 const scheduledAt = nullable(isoDateTime);
-const categoryIds = Schema.Array(uuid$2);
+const categoryIds = Schema.Array(uuid);
 const postCreateInput = Schema.Struct({
-	blogId: uuid$2,
+	blogId: uuid,
 	authorId,
 	title,
 	slug,
 	excerpt: Schema.optionalKey(excerpt),
 	contentMarkdown: withDefault(contentMarkdown, ""),
+	coverImageAssetId: Schema.optionalKey(coverImageAssetId),
 	coverImageUrl: Schema.optionalKey(coverImageUrl),
 	coverImageAlt: Schema.optionalKey(coverImageAlt),
 	status: withDefault(postStatus, "draft"),
-	locale: withDefault(locale, "en"),
+	locale: Schema.optionalKey(locale),
 	featured: withDefault(featured, false),
 	seoTitle: Schema.optionalKey(seoTitle),
 	seoDescription: Schema.optionalKey(seoDescription),
@@ -92,6 +161,7 @@ const postUpdateInput = Schema.Struct({
 	slug: Schema.optionalKey(slug),
 	excerpt: Schema.optionalKey(excerpt),
 	contentMarkdown: Schema.optionalKey(contentMarkdown),
+	coverImageAssetId: Schema.optionalKey(coverImageAssetId),
 	coverImageUrl: Schema.optionalKey(coverImageUrl),
 	coverImageAlt: Schema.optionalKey(coverImageAlt),
 	status: Schema.optionalKey(postStatus),
@@ -105,11 +175,12 @@ const postUpdateInput = Schema.Struct({
 	categoryIds: Schema.optionalKey(categoryIds)
 });
 const blogOutput = Schema.Struct({
-	id: uuid$2,
+	id: uuid,
 	name: Schema.String,
 	slug: Schema.String,
 	description: Schema.String,
 	locale: Schema.String,
+	locales: Schema.Array(Schema.String),
 	accentColor: Schema.String,
 	customCss: Schema.String,
 	publicUrl: nullable(Schema.String),
@@ -117,7 +188,7 @@ const blogOutput = Schema.Struct({
 	updatedAt: isoDateTime
 });
 const publicBlogOutput = Schema.Struct({
-	id: uuid$2,
+	id: uuid,
 	name: Schema.String,
 	slug: Schema.String,
 	description: Schema.String,
@@ -128,7 +199,7 @@ const publicBlogOutput = Schema.Struct({
 	updatedAt: isoDateTime
 });
 const publicPostOutput = Schema.Struct({
-	id: uuid$2,
+	id: uuid,
 	slug: Schema.String,
 	title: Schema.String,
 	excerpt: Schema.String,
@@ -141,7 +212,7 @@ const publicPostOutput = Schema.Struct({
 	featured: Schema.Boolean,
 	publishedAt: nullable(isoDateTime),
 	updatedAt: isoDateTime,
-	readingMinutes: Schema.Number,
+	readingMinutes: Schema.Finite,
 	seoTitle: nullable(Schema.String),
 	seoDescription: nullable(Schema.String),
 	canonicalUrl: nullable(Schema.String),
@@ -162,80 +233,239 @@ const publicPostResult = Schema.Struct({
 	blog: publicBlogOutput,
 	post: publicPostOutput
 });
+const publicRedirectOutput = Schema.Struct({
+	fromPath: Schema.String,
+	toPath: Schema.String,
+	statusCode: Schema.Literals([
+		301,
+		302,
+		307,
+		308
+	])
+});
 const paginatedPosts = Schema.Struct({
 	items: Schema.Array(postOutput),
 	total: Schema.Int,
 	page: Schema.Int,
 	pageSize: Schema.Int
 });
+const mediaAssetStatus = Schema.Literals([
+	"pending",
+	"processing",
+	"ready",
+	"failed",
+	"deleted"
+]);
+const mediaVariantOutput = Schema.Struct({
+	kind: Schema.Literals([
+		"original",
+		"large",
+		"thumbnail"
+	]),
+	url,
+	mimeType: Schema.String,
+	byteSize: Schema.Int,
+	width: Schema.Int,
+	height: Schema.Int,
+	checksumSha256: Schema.String
+});
+const mediaReferenceOutput = Schema.Struct({
+	postId: uuid,
+	title: Schema.String,
+	slug: Schema.String
+});
+const mediaAssetOutput = Schema.Struct({
+	id: uuid,
+	blogId: uuid,
+	filename: Schema.String,
+	mimeType: Schema.String,
+	byteSize: Schema.Int,
+	storageBytes: Schema.Int,
+	width: nullable(Schema.Int),
+	height: nullable(Schema.Int),
+	checksumSha256: nullable(Schema.String),
+	status: mediaAssetStatus,
+	url: nullable(url),
+	variants: Schema.Array(mediaVariantOutput),
+	references: Schema.Array(mediaReferenceOutput),
+	uploadedAt: nullable(isoDateTime),
+	createdAt: isoDateTime,
+	updatedAt: isoDateTime
+});
+const mediaUsageOutput = Schema.Struct({
+	usedBytes: Schema.Int,
+	quotaBytes: Schema.Int,
+	remainingBytes: Schema.Int
+});
+const mediaListOutput = Schema.Struct({
+	items: Schema.Array(mediaAssetOutput),
+	usage: mediaUsageOutput,
+	configured: Schema.Boolean,
+	maxUploadBytes: Schema.Int
+});
+const mediaStartUploadInput = Schema.Struct({
+	blogId: uuid,
+	filename: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(255)),
+	mimeType: Schema.String,
+	byteSize: Schema.Int.check(Schema.isGreaterThan(0))
+});
+const mediaUploadReservationOutput = Schema.Struct({
+	asset: mediaAssetOutput,
+	upload: Schema.Struct({
+		url,
+		method: Schema.Literal("PUT"),
+		headers: Schema.Record(Schema.String, Schema.String),
+		expiresAt: isoDateTime
+	}),
+	usage: mediaUsageOutput
+});
 //#endregion
 //#region ../contract/src/router.ts
-var ApiInputRejected = class extends Schema.TaggedError()("ApiInputRejected", { message: Schema.String }, { httpApiStatus: 400 }) {};
-var ApiAuthenticationFailed = class extends Schema.TaggedError()("ApiAuthenticationFailed", { message: Schema.String }, { httpApiStatus: 401 }) {};
-var ApiAccessDenied = class extends Schema.TaggedError()("ApiAccessDenied", { message: Schema.String }, { httpApiStatus: 403 }) {};
-var ApiPostNotFound = class extends Schema.TaggedError()("ApiPostNotFound", { message: Schema.String }, { httpApiStatus: 404 }) {};
-var ApiUnavailable = class extends Schema.TaggedError()("ApiUnavailable", { message: Schema.String }, { httpApiStatus: 500 }) {};
+const apiErrorStatusByTag = {
+	ApiInputRejected: 400,
+	ApiPostConflict: 409,
+	ApiAuthenticationFailed: 401,
+	ApiAccessDenied: 403,
+	ApiPostNotFound: 404,
+	ApiRevisionNotFound: 404,
+	ApiMediaNotFound: 404,
+	ApiMediaConflict: 409,
+	ApiMediaTooLarge: 413,
+	ApiMediaUnavailable: 503,
+	ApiUnavailable: 500
+};
+const privateApiPaths = {
+	prefix: "/api/v1",
+	health: "/health",
+	blogs: "/blogs",
+	posts: "/posts",
+	media: "/media"
+};
+var ApiPostConflict = class extends Schema.TaggedError()("ApiPostConflict", { message: Schema.String }, { httpApiStatus: apiErrorStatusByTag.ApiPostConflict }) {};
+var ApiInputRejected = class extends Schema.TaggedError()("ApiInputRejected", { message: Schema.String }, { httpApiStatus: apiErrorStatusByTag.ApiInputRejected }) {};
+var ApiAuthenticationFailed = class extends Schema.TaggedError()("ApiAuthenticationFailed", { message: Schema.String }, { httpApiStatus: apiErrorStatusByTag.ApiAuthenticationFailed }) {};
+var ApiAccessDenied = class extends Schema.TaggedError()("ApiAccessDenied", { message: Schema.String }, { httpApiStatus: apiErrorStatusByTag.ApiAccessDenied }) {};
+var ApiPostNotFound = class extends Schema.TaggedError()("ApiPostNotFound", { message: Schema.String }, { httpApiStatus: apiErrorStatusByTag.ApiPostNotFound }) {};
+var ApiRevisionNotFound = class extends Schema.TaggedError()("ApiRevisionNotFound", { message: Schema.String }, { httpApiStatus: apiErrorStatusByTag.ApiRevisionNotFound }) {};
+var ApiMediaNotFound = class extends Schema.TaggedError()("ApiMediaNotFound", { message: Schema.String }, { httpApiStatus: apiErrorStatusByTag.ApiMediaNotFound }) {};
+var ApiMediaConflict = class extends Schema.TaggedError()("ApiMediaConflict", { message: Schema.String }, { httpApiStatus: apiErrorStatusByTag.ApiMediaConflict }) {};
+var ApiMediaTooLarge = class extends Schema.TaggedError()("ApiMediaTooLarge", { message: Schema.String }, { httpApiStatus: apiErrorStatusByTag.ApiMediaTooLarge }) {};
+var ApiMediaUnavailable = class extends Schema.TaggedError()("ApiMediaUnavailable", { message: Schema.String }, { httpApiStatus: apiErrorStatusByTag.ApiMediaUnavailable }) {};
+var ApiUnavailable = class extends Schema.TaggedError()("ApiUnavailable", { message: Schema.String }, { httpApiStatus: apiErrorStatusByTag.ApiUnavailable }) {};
 const apiErrors = [
+	ApiPostConflict,
 	ApiInputRejected,
 	ApiAuthenticationFailed,
 	ApiAccessDenied,
 	ApiPostNotFound,
+	ApiRevisionNotFound,
+	ApiMediaNotFound,
+	ApiMediaConflict,
+	ApiMediaTooLarge,
+	ApiMediaUnavailable,
 	ApiUnavailable
 ];
-const uuid$1 = Schema.String.check(Schema.isUUID());
-const pageNumber$1 = Schema.NumberFromString.pipe(Schema.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(1)));
-const pageSize$1 = Schema.NumberFromString.pipe(Schema.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(100)));
-const health = HttpApiGroup.make("health").add(HttpApiEndpoint.get("check", "/health", {
+const privateApiPostId = Schema.String.check(Schema.isUUID());
+const privateApiRevisionId = Schema.String.check(Schema.isUUID());
+const privateApiMediaId = Schema.String.check(Schema.isUUID());
+const privateApiPageNumber = Schema.FiniteFromString.pipe(Schema.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(1)));
+const privateApiPageSize = Schema.FiniteFromString.pipe(Schema.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(100)));
+const privateApiPostListQueryFields = {
+	blog: Schema.optionalKey(Schema.String),
+	search: Schema.optionalKey(Schema.String),
+	status: Schema.optionalKey(postStatus),
+	page: Schema.optionalKey(privateApiPageNumber),
+	pageSize: Schema.optionalKey(privateApiPageSize)
+};
+Schema.Struct(privateApiPostListQueryFields);
+const health = HttpApiGroup.make("health").add(HttpApiEndpoint.get("check", privateApiPaths.health, {
 	success: Schema.Struct({
 		status: Schema.Literal("ok"),
 		version: Schema.String
 	}),
 	error: ApiUnavailable
 }).annotate(OpenApi.Summary, "Database readiness probe"));
-const blogs = HttpApiGroup.make("blogs").add(HttpApiEndpoint.get("list", "/blogs", {
+const blogs = HttpApiGroup.make("blogs").add(HttpApiEndpoint.get("list", privateApiPaths.blogs, {
 	success: Schema.Array(blogOutput),
 	error: apiErrors
 }).annotate(OpenApi.Summary, "List blogs"));
-const posts = HttpApiGroup.make("posts").add(HttpApiEndpoint.get("list", "/posts", {
-	query: {
-		blog: Schema.optionalKey(Schema.String),
-		search: Schema.optionalKey(Schema.String),
-		status: Schema.optionalKey(postStatus),
-		page: Schema.optionalKey(pageNumber$1),
-		pageSize: Schema.optionalKey(pageSize$1)
-	},
+const posts = HttpApiGroup.make("posts").add(HttpApiEndpoint.get("list", privateApiPaths.posts, {
+	query: privateApiPostListQueryFields,
 	success: paginatedPosts,
 	error: apiErrors
-}).annotate(OpenApi.Summary, "List posts")).add(HttpApiEndpoint.get("get", "/posts/:id", {
-	params: { id: uuid$1 },
+}).annotate(OpenApi.Summary, "List posts")).add(HttpApiEndpoint.get("get", `${privateApiPaths.posts}/:id`, {
+	params: { id: privateApiPostId },
 	success: postOutput,
 	error: apiErrors
-}).annotate(OpenApi.Summary, "Get a post")).add(HttpApiEndpoint.post("create", "/posts", {
+}).annotate(OpenApi.Summary, "Get a post")).add(HttpApiEndpoint.post("create", privateApiPaths.posts, {
 	payload: postCreateInput,
 	success: postOutput.pipe(HttpApiSchema.status(200)),
 	error: apiErrors
-}).annotate(OpenApi.Summary, "Create a post")).add(HttpApiEndpoint.patch("update", "/posts/:id", {
-	params: { id: uuid$1 },
+}).annotate(OpenApi.Summary, "Create a post")).add(HttpApiEndpoint.patch("update", `${privateApiPaths.posts}/:id`, {
+	params: { id: privateApiPostId },
 	payload: postUpdateInput,
 	success: postOutput,
 	error: apiErrors
-}).annotate(OpenApi.Summary, "Update a post")).add(HttpApiEndpoint.delete("archive", "/posts/:id", {
-	params: { id: uuid$1 },
+}).annotate(OpenApi.Summary, "Update a post")).add(HttpApiEndpoint.delete("archive", `${privateApiPaths.posts}/:id`, {
+	params: { id: privateApiPostId },
 	success: Schema.Struct({ ok: Schema.Literal(true) }),
 	error: apiErrors
-}).annotate(OpenApi.Summary, "Archive a post"));
-const api = HttpApi.make("ProsewireApi").add(health, blogs, posts).prefix("/api/v1").annotate(OpenApi.Title, "Prosewire private API").annotate(OpenApi.Version, "1.0.0");
-Schema.String.check(Schema.isUUID());
-Schema.NumberFromString.pipe(Schema.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(1)));
-Schema.NumberFromString.pipe(Schema.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(100)));
+}).annotate(OpenApi.Summary, "Archive a post")).add(HttpApiEndpoint.get("listRevisions", `${privateApiPaths.posts}/:id/revisions`, {
+	params: { id: privateApiPostId },
+	success: Schema.Array(postRevisionOutput),
+	error: apiErrors
+}).annotate(OpenApi.Summary, "List post revisions")).add(HttpApiEndpoint.post("restoreRevision", `${privateApiPaths.posts}/:id/revisions/:revisionId/restore`, {
+	params: {
+		id: privateApiPostId,
+		revisionId: privateApiRevisionId
+	},
+	success: postOutput,
+	error: apiErrors
+}).annotate(OpenApi.Summary, "Restore a post revision"));
+const media = HttpApiGroup.make("media").add(HttpApiEndpoint.get("list", privateApiPaths.media, {
+	success: mediaListOutput,
+	error: apiErrors
+}).annotate(OpenApi.Summary, "List media assets and storage usage")).add(HttpApiEndpoint.get("get", `${privateApiPaths.media}/:id`, {
+	params: { id: privateApiMediaId },
+	success: mediaAssetOutput,
+	error: apiErrors
+}).annotate(OpenApi.Summary, "Get a media asset")).add(HttpApiEndpoint.post("startUpload", `${privateApiPaths.media}/uploads`, {
+	payload: mediaStartUploadInput,
+	success: mediaUploadReservationOutput.pipe(HttpApiSchema.status(201)),
+	error: apiErrors
+}).annotate(OpenApi.Summary, "Reserve storage and sign a direct upload")).add(HttpApiEndpoint.post("completeUpload", `${privateApiPaths.media}/:id/complete`, {
+	params: { id: privateApiMediaId },
+	success: mediaAssetOutput,
+	error: apiErrors
+}).annotate(OpenApi.Summary, "Validate and process an uploaded image")).add(HttpApiEndpoint.delete("delete", `${privateApiPaths.media}/:id`, {
+	params: { id: privateApiMediaId },
+	success: Schema.Struct({ ok: Schema.Literal(true) }),
+	error: apiErrors
+}).annotate(OpenApi.Summary, "Delete an unreferenced media asset"));
+const api = HttpApi.make("ProsewireApi").add(health, blogs, posts, media).prefix(privateApiPaths.prefix).annotate(OpenApi.Title, "Prosewire private API").annotate(OpenApi.Version, "1.0.0");
+//#endregion
+//#region ../contract/src/transport.ts
+const path = (route) => `${privateApiPaths.prefix}${route}`;
+path(privateApiPaths.health);
+path(privateApiPaths.blogs);
+path(privateApiPaths.posts);
+path(privateApiPaths.media);
 //#endregion
 //#region src/index.ts
+var ProsewireImportError = class extends Schema.TaggedError()("ProsewireImportError", {
+	status: Schema.Int,
+	item: Schema.String,
+	reason: Schema.String
+}) {
+	get message() {
+		return `${this.item}: ${this.reason}`;
+	}
+};
 function normalizedCreateInput(input) {
 	return {
 		...input,
 		contentMarkdown: input.contentMarkdown ?? "",
 		status: input.status ?? "draft",
-		locale: input.locale ?? "en",
 		featured: input.featured ?? false,
 		categoryIds: input.categoryIds ?? []
 	};
@@ -249,16 +479,61 @@ function createEffectClient(options) {
 	const provideFetch = (effect) => effect.pipe(Effect.provideService(FetchHttpClient.Fetch, options.fetch ?? globalThis.fetch));
 	return {
 		health: () => provideFetch(generated.health.check()),
+		imports: { run: (input) => Effect.tryPromise({
+			try: async (signal) => {
+				const query = new URLSearchParams({
+					mode: input.mode ?? "preview",
+					preserveStates: String(input.preserveStates ?? false)
+				});
+				const response = await (options.fetch ?? globalThis.fetch)(`${baseUrl}${portableImportPath}?${query}`, {
+					method: "POST",
+					headers: {
+						"content-type": input.contentType,
+						...options.apiKey ? { authorization: `Bearer ${options.apiKey}` } : {}
+					},
+					body: input.body,
+					duplex: "half",
+					signal
+				});
+				const body = await response.json();
+				if (!response.ok) {
+					const failure = Schema.decodeUnknownSync(Schema.Struct({
+						item: Schema.optionalKey(Schema.String),
+						message: Schema.String
+					}))(body);
+					throw new ProsewireImportError({
+						status: response.status,
+						item: failure.item ?? "request",
+						reason: failure.message
+					});
+				}
+				return Schema.decodeUnknownPromise(portableImportReport)(body);
+			},
+			catch: (cause) => cause instanceof ProsewireImportError ? cause : new ProsewireImportError({
+				status: 0,
+				item: "request",
+				reason: cause instanceof Error ? cause.message : "Publication import failed"
+			})
+		}) },
 		blogs: { list: () => provideFetch(generated.blogs.list()) },
 		posts: {
 			list: (input = {}) => provideFetch(generated.posts.list({ query: input })),
 			get: (input) => provideFetch(generated.posts.get(input)),
+			revisions: (input) => provideFetch(generated.posts.listRevisions(input)),
 			create: (input) => provideFetch(generated.posts.create({ payload: normalizedCreateInput(input) })),
 			update: (input) => provideFetch(generated.posts.update({
 				params: input.params,
 				payload: input.body
 			})),
-			archive: (input) => provideFetch(generated.posts.archive(input))
+			archive: (input) => provideFetch(generated.posts.archive(input)),
+			restore: (input) => provideFetch(generated.posts.restoreRevision(input))
+		},
+		media: {
+			list: () => provideFetch(generated.media.list()),
+			get: (input) => provideFetch(generated.media.get(input)),
+			startUpload: (input) => provideFetch(generated.media.startUpload({ payload: input })),
+			completeUpload: (input) => provideFetch(generated.media.completeUpload(input)),
+			delete: (input) => provideFetch(generated.media.delete(input))
 		}
 	};
 }
@@ -266,16 +541,36 @@ function createClient(options) {
 	const client = createEffectClient(options);
 	return {
 		health: () => Effect.runPromise(client.health()),
+		imports: { run: (input) => Effect.runPromise(client.imports.run(input)) },
 		blogs: { list: () => Effect.runPromise(client.blogs.list()) },
 		posts: {
 			list: (input = {}) => Effect.runPromise(client.posts.list(input)),
 			get: (input) => Effect.runPromise(client.posts.get(input)),
+			revisions: (input) => Effect.runPromise(client.posts.revisions(input)),
 			create: (input) => Effect.runPromise(client.posts.create(input)),
 			update: (input) => Effect.runPromise(client.posts.update(input)),
-			archive: (input) => Effect.runPromise(client.posts.archive(input))
+			archive: (input) => Effect.runPromise(client.posts.archive(input)),
+			restore: (input) => Effect.runPromise(client.posts.restore(input))
+		},
+		media: {
+			list: () => Effect.runPromise(client.media.list()),
+			get: (input) => Effect.runPromise(client.media.get(input)),
+			startUpload: (input) => Effect.runPromise(client.media.startUpload(input)),
+			completeUpload: (input) => Effect.runPromise(client.media.completeUpload(input)),
+			delete: (input) => Effect.runPromise(client.media.delete(input))
 		}
 	};
 }
+var ProsewireRequestError = class extends Error {
+	status;
+	url;
+	constructor(response) {
+		super(`Prosewire request failed (${String(response.status)})`);
+		this.name = "ProsewireRequestError";
+		this.status = response.status;
+		this.url = response.url;
+	}
+};
 async function decodeResponse(schema, response) {
 	return Schema.decodeUnknownPromise(schema)(await response.json());
 }
@@ -283,33 +578,72 @@ function createPublicClient(options) {
 	const request = options.fetch ?? fetch;
 	const base = options.baseUrl.replace(/\/$/, "");
 	const blog = encodeURIComponent(options.blog);
+	const postUrl = (slug) => `${base}/api/public/${blog}/posts/${encodeURIComponent(slug)}`;
+	const listPosts = async (input = {}) => {
+		const query = new URLSearchParams();
+		if (input.search) query.set("search", input.search);
+		if (input.category) query.set("category", input.category);
+		if (input.page) query.set("page", String(input.page));
+		if (input.pageSize) query.set("pageSize", String(input.pageSize));
+		if (input.limit) query.set("limit", String(input.limit));
+		const suffix = query.size ? `?${query.toString()}` : "";
+		const response = await request(`${base}/api/public/${blog}/posts${suffix}`);
+		if (!response.ok) throw new ProsewireRequestError(response);
+		return decodeResponse(publicPostPage, response);
+	};
+	const resolvePost = async (slug) => {
+		const response = await request(postUrl(slug));
+		if (response.status === 404) return { status: "not-found" };
+		if (!response.ok) throw new ProsewireRequestError(response);
+		const result = await decodeResponse(publicPostResult, response);
+		return result.post.slug === slug ? {
+			status: "found",
+			...result
+		} : {
+			status: "redirect",
+			slug: result.post.slug,
+			...result
+		};
+	};
 	return {
-		async listPosts(input = {}) {
-			const query = new URLSearchParams();
-			if (input.search) query.set("search", input.search);
-			if (input.category) query.set("category", input.category);
-			if (input.page) query.set("page", String(input.page));
-			if (input.pageSize) query.set("pageSize", String(input.pageSize));
-			if (input.limit) query.set("limit", String(input.limit));
-			const suffix = query.size ? `?${query.toString()}` : "";
-			const response = await request(`${base}/api/public/${blog}/posts${suffix}`);
-			if (!response.ok) throw new Error(`Prosewire request failed (${String(response.status)})`);
-			return decodeResponse(publicPostPage, response);
+		listPosts,
+		async listAllPosts(input = {}) {
+			const posts = [];
+			let page = 1;
+			while (true) {
+				const result = await listPosts({
+					...input,
+					page,
+					pageSize: 100
+				});
+				posts.push(...result.posts);
+				if (!result.pagination.hasMore) return posts;
+				page += 1;
+			}
 		},
 		async getPost(slug) {
-			const response = await request(`${base}/api/public/${blog}/posts/${encodeURIComponent(slug)}`);
-			if (!response.ok) throw new Error(`Prosewire request failed (${String(response.status)})`);
-			return decodeResponse(publicPostResult, response);
+			const result = await resolvePost(slug);
+			if (result.status === "not-found") throw new ProsewireRequestError(new Response(null, { status: 404 }));
+			return {
+				blog: result.blog,
+				post: result.post
+			};
+		},
+		resolvePost,
+		async listRedirects() {
+			const response = await request(`${base}/api/public/${blog}/redirects`);
+			if (!response.ok) throw new ProsewireRequestError(response);
+			return Schema.decodeUnknownPromise(Schema.Array(publicRedirectOutput))(await response.json());
 		},
 		async getRendered(path = "") {
 			const encodedPath = path.replace(/^\//, "").split("/").filter(Boolean).map(encodeURIComponent).join("/");
 			const response = await request(`${base}/api/rendered/${blog}/${encodedPath}`);
-			if (!response.ok) throw new Error(`Prosewire request failed (${String(response.status)})`);
+			if (!response.ok) throw new ProsewireRequestError(response);
 			return response.text();
 		}
 	};
 }
 //#endregion
-export { createClient, createEffectClient, createPublicClient };
+export { ProsewireImportError, ProsewireRequestError, createClient, createEffectClient, createPublicClient };
 
 //# sourceMappingURL=index.mjs.map