kizlo 0.1.0

package/dist/shared/router.d.ts

@@ -0,0 +1,7 @@
+import { AnyProcedureRouter } from "./procedure.js";
+import { AnyRouter } from "@orpc/server";
+
+//#region src/shared/router.d.ts
+declare function createOrpcRouter(router: AnyProcedureRouter): AnyRouter;
+//#endregion
+export { createOrpcRouter };

package/dist/shared/router.js

@@ -0,0 +1,26 @@
+import { buildProcedure } from "./procedure.js";
+
+//#region src/shared/router.ts
+function createOrpcRouter(router) {
+	const cache = /* @__PURE__ */ new Map();
+	return new Proxy(router, { get: (target, p) => {
+		if (typeof p === "symbol") return target[p];
+		if (cache.has(p)) return cache.get(p);
+		const value = target[p];
+		if (value === void 0) return void 0;
+		let resolved;
+		if (isProcedure(value)) resolved = buildProcedure(value);
+		else if (typeof value === "object" && value !== null) resolved = createOrpcRouter(value);
+		else resolved = value;
+		cache.set(p, resolved);
+		return resolved;
+	} });
+}
+function isProcedure(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const brand = value["~kizlo"];
+	return typeof brand === "object" && brand !== null && "options" in brand && "uses" in brand && "handler" in brand && typeof brand.handler === "function";
+}
+
+//#endregion
+export { createOrpcRouter };

package/dist/shared/schema.d.ts

@@ -0,0 +1,55 @@
+import z from "zod/v4";
+
+//#region src/shared/schema.d.ts
+declare const LIST_ORDER: readonly ["asc", "desc"];
+declare const ListOrder: z.ZodEnum<{
+  asc: "asc";
+  desc: "desc";
+}>;
+type ListOrder = z.infer<typeof ListOrder>;
+declare const ListMetadata: z.ZodObject<{
+  page: z.ZodNumber;
+  totalItems: z.ZodNumber;
+  totalPages: z.ZodNumber;
+  nextPage: z.ZodNullable<z.ZodNumber>;
+  prevPage: z.ZodNullable<z.ZodNumber>;
+  hasNextPage: z.ZodBoolean;
+  hasPrevPage: z.ZodBoolean;
+}, z.core.$strip>;
+type ListMetadata = z.infer<typeof ListMetadata>;
+declare const CurrencyFormat: z.ZodObject<{
+  currencyCode: z.ZodString;
+  currencySymbol: z.ZodString;
+  currencyPrefix: z.ZodString;
+  currencySuffix: z.ZodString;
+  currencyMinorUnit: z.ZodNumber;
+  currencyDecimalSeparator: z.ZodString;
+  currencyThousandSeparator: z.ZodString;
+}, z.core.$strip>;
+type CurrencyFormat = z.infer<typeof CurrencyFormat>;
+declare const Media: z.ZodObject<{
+  id: z.ZodNumber;
+  name: z.ZodString;
+  alt: z.ZodString;
+  src: z.ZodString;
+}, z.core.$strip>;
+type Media = z.infer<typeof Media>;
+declare const IdentifierInput: z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodCoercedNumber<string | number>>, z.ZodString]>;
+type IdentifierInput = z.output<typeof IdentifierInput>;
+declare const PreviewTokenPayload: z.ZodObject<{
+  id: z.ZodNumber;
+  parent: z.ZodNumber;
+  expires: z.ZodNumber;
+}, z.core.$strip>;
+type PreviewTokenPayload = z.infer<typeof PreviewTokenPayload>;
+declare const PreviewTokenData: z.ZodObject<{
+  hash: z.ZodString;
+  payload: z.ZodObject<{
+    id: z.ZodNumber;
+    parent: z.ZodNumber;
+    expires: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type PreviewTokenData = z.infer<typeof PreviewTokenData>;
+//#endregion
+export { CurrencyFormat, IdentifierInput, LIST_ORDER, ListMetadata, ListOrder, Media, PreviewTokenData, PreviewTokenPayload };

package/dist/shared/schema.js

@@ -0,0 +1,43 @@
+import { NumberLike } from "@kizlo/shared";
+import z from "zod/v4";
+
+//#region src/shared/schema.ts
+const LIST_ORDER = ["asc", "desc"];
+const ListOrder = z.enum(LIST_ORDER);
+const ListMetadata = z.object({
+	page: z.number(),
+	totalItems: z.number(),
+	totalPages: z.number(),
+	nextPage: z.number().nullable(),
+	prevPage: z.number().nullable(),
+	hasNextPage: z.boolean(),
+	hasPrevPage: z.boolean()
+});
+const CurrencyFormat = z.object({
+	currencyCode: z.string(),
+	currencySymbol: z.string(),
+	currencyPrefix: z.string(),
+	currencySuffix: z.string(),
+	currencyMinorUnit: z.number(),
+	currencyDecimalSeparator: z.string(),
+	currencyThousandSeparator: z.string()
+});
+const Media = z.object({
+	id: z.number(),
+	name: z.string(),
+	alt: z.string(),
+	src: z.string()
+});
+const IdentifierInput = z.union([NumberLike, z.string()]);
+const PreviewTokenPayload = z.object({
+	id: z.number(),
+	parent: z.number(),
+	expires: z.number()
+});
+const PreviewTokenData = z.object({
+	hash: z.string(),
+	payload: PreviewTokenPayload
+});
+
+//#endregion
+export { CurrencyFormat, IdentifierInput, LIST_ORDER, ListMetadata, ListOrder, Media, PreviewTokenData, PreviewTokenPayload };

package/dist/shared/serialize.d.ts

@@ -0,0 +1,12 @@
+import { WP_CurrencyFormat, WP_ListMetadata } from "../wordpress/types.js";
+import "../wordpress/index.js";
+import { CurrencyFormat, ListMetadata } from "./schema.js";
+import { List } from "./types.js";
+
+//#region src/shared/serialize.d.ts
+declare function emptyList<T>(): List<T>;
+declare function deserializeListMetadata(data: WP_ListMetadata): ListMetadata;
+declare function serializeCurrencyFormat(data: CurrencyFormat): WP_CurrencyFormat;
+declare function deserializeCurrencyFormat(data: WP_CurrencyFormat): CurrencyFormat;
+//#endregion
+export { deserializeCurrencyFormat, deserializeListMetadata, emptyList, serializeCurrencyFormat };

package/dist/shared/serialize.js

@@ -0,0 +1,51 @@
+//#region src/shared/serialize.ts
+function emptyList() {
+	return {
+		items: [],
+		meta: {
+			hasNextPage: false,
+			hasPrevPage: false,
+			nextPage: 0,
+			page: 0,
+			prevPage: 0,
+			totalItems: 0,
+			totalPages: 0
+		}
+	};
+}
+function deserializeListMetadata(data) {
+	return {
+		hasNextPage: data.has_next_page,
+		hasPrevPage: data.has_prev_page,
+		nextPage: data.next_page,
+		page: data.page,
+		prevPage: data.prev_page,
+		totalItems: data.total_items,
+		totalPages: data.total_pages
+	};
+}
+function serializeCurrencyFormat(data) {
+	return {
+		currency_code: data.currencyCode,
+		currency_symbol: data.currencySymbol,
+		currency_prefix: data.currencyPrefix,
+		currency_suffix: data.currencySuffix,
+		currency_minor_unit: data.currencyMinorUnit,
+		currency_decimal_separator: data.currencyDecimalSeparator,
+		currency_thousand_separator: data.currencyThousandSeparator
+	};
+}
+function deserializeCurrencyFormat(data) {
+	return {
+		currencyCode: data.currency_code,
+		currencySymbol: data.currency_symbol,
+		currencyPrefix: data.currency_prefix,
+		currencySuffix: data.currency_suffix,
+		currencyMinorUnit: data.currency_minor_unit,
+		currencyDecimalSeparator: data.currency_decimal_separator,
+		currencyThousandSeparator: data.currency_thousand_separator
+	};
+}
+
+//#endregion
+export { deserializeCurrencyFormat, deserializeListMetadata, emptyList, serializeCurrencyFormat };

package/dist/shared/types.d.ts

@@ -0,0 +1,35 @@
+import { ListMetadata } from "./schema.js";
+import { NestedClient } from "@orpc/client";
+import { CookieOptions, CookieWithOptions } from "@kizlo/shared";
+
+//#region src/shared/types.d.ts
+type AnyContext = Record<PropertyKey, any>;
+type AnyNestedClient = NestedClient<any>;
+type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD";
+type List<T> = {
+  items: T[];
+  meta: ListMetadata;
+};
+type MaybeOptionalOptions<TOptions> = Record<never, never> extends TOptions ? [options?: TOptions] : [options: TOptions];
+type RedirectStatus = 301 | 302 | 303 | 307 | 308;
+interface RedirectInput {
+  to: string | URL;
+  status?: RedirectStatus;
+  searchParams?: Record<string, string>;
+}
+interface CookiesAdapter {
+  setAll(cookies: CookieWithOptions[]): Promise<void> | void;
+  getAll(): Promise<{
+    name: string;
+    value: string;
+  }[] | null> | {
+    name: string;
+    value: string;
+  }[] | null;
+  deleteAll(cookies: {
+    name: string;
+    options?: CookieOptions;
+  }[]): Promise<void> | void;
+}
+//#endregion
+export { AnyContext, AnyNestedClient, CookiesAdapter, HTTPMethod, List, MaybeOptionalOptions, RedirectInput, RedirectStatus };

package/dist/shared/utils.js

@@ -0,0 +1,17 @@
+import "zod/v4";
+
+//#region src/shared/utils.ts
+function getObjectProperty(object, path) {
+	let current = object;
+	for (const key of path) {
+		if (!isTypescriptObject(current)) return;
+		current = current[key];
+	}
+	return current;
+}
+function isTypescriptObject(value) {
+	return !!value && (typeof value === "object" || typeof value === "function");
+}
+
+//#endregion
+export { getObjectProperty, isTypescriptObject };

package/dist/test/auth.d.ts

@@ -0,0 +1,7 @@
+import { AuthAdapter } from "../adapters/auth.js";
+import { TestAuthAdapterUser } from "./users.js";
+
+//#region src/test/auth.d.ts
+declare function testAuthAdapter(user: TestAuthAdapterUser): AuthAdapter;
+//#endregion
+export { testAuthAdapter };

package/dist/test/auth.js

@@ -0,0 +1,15 @@
+//#region src/test/auth.ts
+function testAuthAdapter(user) {
+	return { getUser() {
+		return {
+			id: user.wpUserId,
+			email: user.email,
+			phone: user.phone,
+			firstName: user.firstName,
+			lastName: user.lastName
+		};
+	} };
+}
+
+//#endregion
+export { testAuthAdapter };

package/dist/test/captcha.d.ts

@@ -0,0 +1,7 @@
+import { CaptchaAdapter } from "../adapters/captcha.js";
+
+//#region src/test/captcha.d.ts
+declare const CAPTCHA_TEST_TOKEN_PASS = "test-token-pass";
+declare function captchaMock(): CaptchaAdapter;
+//#endregion
+export { CAPTCHA_TEST_TOKEN_PASS, captchaMock };

package/dist/test/captcha.js

@@ -0,0 +1,8 @@
+//#region src/test/captcha.ts
+const CAPTCHA_TEST_TOKEN_PASS = "test-token-pass";
+function captchaMock() {
+	return async ({ token }) => token === CAPTCHA_TEST_TOKEN_PASS;
+}
+
+//#endregion
+export { CAPTCHA_TEST_TOKEN_PASS, captchaMock };

package/dist/test/client.d.ts

@@ -0,0 +1,11 @@
+import { AnyExtension } from "../shared/extension.js";
+import { RootRouter } from "../kizlo.js";
+import { KizloClient } from "../client.js";
+import "../index.js";
+import { KizloTestInstance } from "./server.js";
+
+//#region src/test/client.d.ts
+declare function getKizloClientTestInstance(kizlo: KizloTestInstance): Promise<KizloClient<RootRouter<readonly AnyExtension[]>>>;
+type KizloClientTestInstance = Awaited<ReturnType<typeof getKizloClientTestInstance>>;
+//#endregion
+export { KizloClientTestInstance, getKizloClientTestInstance };

package/dist/test/client.js

@@ -0,0 +1,14 @@
+import { generateContract } from "../shared/contract.js";
+import { KizloClient } from "../client.js";
+
+//#region src/test/client.ts
+async function getKizloClientTestInstance(kizlo) {
+	return new KizloClient({
+		url: "http://test.local",
+		fetch: (req) => kizlo.handler(req),
+		contract: await generateContract(kizlo.router)
+	});
+}
+
+//#endregion
+export { getKizloClientTestInstance };

package/dist/test/fixtures.d.ts

@@ -0,0 +1,14 @@
+import { Fixture } from "../cli/wp/types.js";
+import { menuFixture } from "../menu/fixture.js";
+import { postFixture } from "../post/fixture.js";
+
+//#region src/test/fixtures.d.ts
+
+/**
+ * The kizlo core content fixtures (posts/comments + menu). Mount these in
+ * `kizlo.config.ts` so the toolkit's own suites have content to read; consumers
+ * who only need a clean WP stack can leave them out.
+ */
+declare const coreFixtures: Fixture[];
+//#endregion
+export { coreFixtures };

package/dist/test/fixtures.js

@@ -0,0 +1,13 @@
+import { menuFixture } from "../menu/fixture.js";
+import { postFixture } from "../post/fixture.js";
+
+//#region src/test/fixtures.ts
+/**
+* The kizlo core content fixtures (posts/comments + menu). Mount these in
+* `kizlo.config.ts` so the toolkit's own suites have content to read; consumers
+* who only need a clean WP stack can leave them out.
+*/
+const coreFixtures = [postFixture(), menuFixture()];
+
+//#endregion
+export { coreFixtures };

package/dist/test/server.d.ts

@@ -0,0 +1,10 @@
+import { AnyExtension } from "../shared/extension.js";
+import { Kizlo } from "../kizlo.js";
+
+//#region src/test/server.d.ts
+declare function getKizloTestInstance<TExts extends readonly AnyExtension[] = []>(options?: {
+  extensions?: TExts;
+}): Kizlo<TExts>;
+type KizloTestInstance = ReturnType<typeof getKizloTestInstance>;
+//#endregion
+export { KizloTestInstance, getKizloTestInstance };

package/dist/test/server.js

@@ -0,0 +1,32 @@
+import { geoMock } from "../adapters/geo.js";
+import { consoleLog } from "../adapters/logger.js";
+import { Kizlo } from "../kizlo.js";
+import { getTestCredentials } from "../cli/wp/utils.js";
+import { testAuthAdapter } from "./auth.js";
+import { captchaMock } from "./captcha.js";
+import { toTestUser } from "./users.js";
+
+//#region src/test/server.ts
+function getKizloTestInstance(options) {
+	const creds = getTestCredentials();
+	return new Kizlo({
+		baseUrl: "http://test.local",
+		siteSecret: "test-secret",
+		environment: "test",
+		credentials: {
+			url: creds.url,
+			username: creds.users.admin.username,
+			password: creds.users.admin.applicationPassword
+		},
+		adapters: {
+			geo: geoMock(),
+			auth: testAuthAdapter(toTestUser(creds.users.user)),
+			captcha: captchaMock(),
+			logger: consoleLog({ levels: ["warn", "error"] })
+		},
+		extensions: options?.extensions
+	});
+}
+
+//#endregion
+export { getKizloTestInstance };

package/dist/test/users.d.ts

@@ -0,0 +1,14 @@
+import { TestCredentials } from "../cli/wp/types.js";
+
+//#region src/test/users.d.ts
+interface TestAuthAdapterUser {
+  wpUserId: number;
+  username: string;
+  firstName: string;
+  lastName: string;
+  email: string;
+  phone: string;
+}
+declare function toTestUser(user: TestCredentials["users"]["user"]): TestAuthAdapterUser;
+//#endregion
+export { TestAuthAdapterUser, toTestUser };

package/dist/test/users.js

@@ -0,0 +1,17 @@
+//#region src/test/users.ts
+const STATIC_FIELDS = {
+	firstName: "Test",
+	lastName: "Customer",
+	email: "customer@example.com",
+	phone: "+10000000002"
+};
+function toTestUser(user) {
+	return {
+		wpUserId: user.id,
+		username: user.username,
+		...STATIC_FIELDS
+	};
+}
+
+//#endregion
+export { toTestUser };

package/dist/test.d.ts

@@ -0,0 +1,12 @@
+import { compose, composeDown, composeStop, composeUp, wpCli } from "./cli/wp/docker.js";
+import { Fixture, JsonValue, PluginSource, SeedContext, TestAdminUser, TestCredentials, TestUser, defineFixture } from "./cli/wp/types.js";
+import { credentialsPath, ensurePlugin, findConfigDir, getTestCredentials, githubRelease, isSeeded, resolvePluginSource } from "./cli/wp/utils.js";
+import { TestAuthAdapterUser, toTestUser } from "./test/users.js";
+import { testAuthAdapter } from "./test/auth.js";
+import { CAPTCHA_TEST_TOKEN_PASS, captchaMock } from "./test/captcha.js";
+import { KizloTestInstance, getKizloTestInstance } from "./test/server.js";
+import { KizloClientTestInstance, getKizloClientTestInstance } from "./test/client.js";
+import { menuFixture } from "./menu/fixture.js";
+import { postFixture } from "./post/fixture.js";
+import { coreFixtures } from "./test/fixtures.js";
+export { CAPTCHA_TEST_TOKEN_PASS, Fixture, JsonValue, KizloClientTestInstance, KizloTestInstance, PluginSource, SeedContext, TestAdminUser, TestAuthAdapterUser, TestCredentials, TestUser, captchaMock, compose, composeDown, composeStop, composeUp, coreFixtures, credentialsPath, defineFixture, ensurePlugin, findConfigDir, getKizloClientTestInstance, getKizloTestInstance, getTestCredentials, githubRelease, isSeeded, menuFixture, postFixture, resolvePluginSource, testAuthAdapter, toTestUser, wpCli };

package/dist/test.js

@@ -0,0 +1,13 @@
+import { credentialsPath, ensurePlugin, findConfigDir, getTestCredentials, githubRelease, isSeeded, resolvePluginSource } from "./cli/wp/utils.js";
+import { compose, composeDown, composeStop, composeUp, wpCli } from "./cli/wp/docker.js";
+import { defineFixture } from "./cli/wp/types.js";
+import { testAuthAdapter } from "./test/auth.js";
+import { CAPTCHA_TEST_TOKEN_PASS, captchaMock } from "./test/captcha.js";
+import { getKizloClientTestInstance } from "./test/client.js";
+import { menuFixture } from "./menu/fixture.js";
+import { postFixture } from "./post/fixture.js";
+import { coreFixtures } from "./test/fixtures.js";
+import { toTestUser } from "./test/users.js";
+import { getKizloTestInstance } from "./test/server.js";
+
+export { CAPTCHA_TEST_TOKEN_PASS, captchaMock, compose, composeDown, composeStop, composeUp, coreFixtures, credentialsPath, defineFixture, ensurePlugin, findConfigDir, getKizloClientTestInstance, getKizloTestInstance, getTestCredentials, githubRelease, isSeeded, menuFixture, postFixture, resolvePluginSource, testAuthAdapter, toTestUser, wpCli };

package/dist/webhook/index.d.ts

@@ -0,0 +1,38 @@
+import { WebhookEvent } from "./schema.js";
+import { DefinedErrorMapLike } from "../shared/error.js";
+import { ServerContext } from "../context.js";
+import { Procedure } from "../shared/procedure.js";
+import "../index.js";
+import { Pathname, Schema, SchemaOutput } from "@kizlo/shared";
+
+//#region src/webhook/index.d.ts
+type AnyWebhookEventSchema<TData = unknown> = Schema<unknown, TData>;
+type AnyWebhookEvents = {
+  types: string[];
+  data: AnyWebhookEventSchema;
+}[];
+type InferWebhookEventUnion<T extends AnyWebhookEvents> = { [K in keyof T]: {
+  type: T[K]["types"][number];
+  data: SchemaOutput<T[K]["data"]>;
+} }[number];
+type WebhookHandlerFn<T extends AnyWebhookEvents> = (event: InferWebhookEventUnion<T> | WebhookEvent | null, context: ServerContext) => Promise<void> | void;
+interface WebhookOptions {
+  path?: Pathname;
+  events?: EventHandler[];
+}
+interface EventHandler {
+  events?: AnyWebhookEvents;
+  handler: WebhookHandlerFn<AnyWebhookEvents>;
+}
+declare function createEventHandler<const T extends AnyWebhookEvents = never>(handler: WebhookHandlerFn<T>): EventHandler;
+declare function createEventHandler<const T extends AnyWebhookEvents = never>(events: T, handler: WebhookHandlerFn<T>): EventHandler;
+declare function createWebhookRouter(options?: WebhookOptions): {
+  webhooks: Procedure<"api", {
+    body: {
+      type: string;
+      data: unknown;
+    };
+  }, unknown, DefinedErrorMapLike>;
+};
+//#endregion
+export { AnyWebhookEventSchema, AnyWebhookEvents, EventHandler, InferWebhookEventUnion, WebhookHandlerFn, WebhookOptions, createEventHandler, createWebhookRouter };

package/dist/webhook/index.js

@@ -0,0 +1,44 @@
+import { KizloError } from "../shared/error.js";
+import { createProcedure } from "../shared/procedure.js";
+import { AnyWebhookEvent } from "./schema.js";
+import { validateWebhookEvent } from "./utils.js";
+import { tryCatchSync, verifyWebhook } from "@kizlo/shared";
+import z from "zod";
+
+//#region src/webhook/index.ts
+function createEventHandler(eventsOrHandler, maybeHandler) {
+	const events = Array.isArray(eventsOrHandler) ? eventsOrHandler : [];
+	const handler = Array.isArray(eventsOrHandler) ? maybeHandler : eventsOrHandler;
+	if (!handler) throw new Error("Event handler not defined.");
+	return {
+		events,
+		handler
+	};
+}
+function createWebhookRouter(options) {
+	return { webhooks: createProcedure({
+		scope: "api",
+		method: "POST",
+		body: AnyWebhookEvent,
+		path: options?.path ?? "/webhooks",
+		output: z.void()
+	}, async ({ context, input }) => {
+		const payload = await context.request?.text() ?? "";
+		const headers = Object.fromEntries(context.request?.headers.entries() ?? []);
+		const [err] = tryCatchSync(() => verifyWebhook({
+			secret: context.config.siteSecret,
+			payload,
+			headers
+		}));
+		if (err) throw new KizloError("FORBIDDEN", { message: "Signature verification failed." });
+		const results = await Promise.allSettled((options?.events ?? []).map(async ({ events, handler }) => {
+			const event = await validateWebhookEvent(events, input.body);
+			if (!event) return;
+			await handler(event, context);
+		}));
+		for (const result of results) if (result.status === "rejected") context.logger.error("Webhook handler failed", result.reason);
+	}) };
+}
+
+//#endregion
+export { createEventHandler, createWebhookRouter };

package/dist/webhook/schema.d.ts

@@ -0,0 +1,45 @@
+import z from "zod/v4";
+
+//#region src/webhook/schema.d.ts
+
+declare const WebhookEvent: z.ZodUnion<readonly [z.ZodObject<{
+  type: z.ZodEnum<{
+    "post.created": "post.created";
+    "post.updated": "post.updated";
+    "post.trashed": "post.trashed";
+    "post.deleted": "post.deleted";
+  }>;
+  data: z.ZodObject<{
+    post_id: z.ZodNumber;
+    post_type: z.ZodString;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodEnum<{
+    "term.created": "term.created";
+    "term.updated": "term.updated";
+    "term.deleted": "term.deleted";
+  }>;
+  data: z.ZodObject<{
+    term_id: z.ZodNumber;
+    taxonomy: z.ZodString;
+    post_types: z.ZodArray<z.ZodString>;
+    count: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodEnum<{
+    "payment.status_requested": "payment.status_requested";
+  }>;
+  data: z.ZodObject<{
+    transaction_id: z.ZodNullable<z.ZodString>;
+    payment_method_id: z.ZodString;
+    payment_session_id: z.ZodString;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodEnum<{
+    "settings.saved": "settings.saved";
+  }>;
+  data: z.ZodNull;
+}, z.core.$strip>]>;
+type WebhookEvent = z.infer<typeof WebhookEvent>;
+//#endregion
+export { WebhookEvent };

package/dist/webhook/schema.js

@@ -0,0 +1,72 @@
+import z from "zod/v4";
+
+//#region src/webhook/schema.ts
+const TERM_WEBHOOK_EVENT_TYPES = [
+	"term.created",
+	"term.updated",
+	"term.deleted"
+];
+const TermWebhookEventType = z.enum(TERM_WEBHOOK_EVENT_TYPES);
+const POST_WEBHOOK_EVENT_TYPES = [
+	"post.created",
+	"post.updated",
+	"post.trashed",
+	"post.deleted"
+];
+const PostWebhookEventType = z.enum(POST_WEBHOOK_EVENT_TYPES);
+const PAYMENT_WEBHOOK_EVENT_TYPES = ["payment.status_requested"];
+const PaymentWebhookEventType = z.enum(PAYMENT_WEBHOOK_EVENT_TYPES);
+const SETTINGS_WEBHOOK_EVENT_TYPES = ["settings.saved"];
+const SettingsWebhookEventType = z.enum(SETTINGS_WEBHOOK_EVENT_TYPES);
+const WEBHOOK_EVENT_TYPES = [
+	...TERM_WEBHOOK_EVENT_TYPES,
+	...POST_WEBHOOK_EVENT_TYPES,
+	...PAYMENT_WEBHOOK_EVENT_TYPES,
+	...SETTINGS_WEBHOOK_EVENT_TYPES
+];
+const WebhookEventType = z.enum(WEBHOOK_EVENT_TYPES);
+const PostWebhookEventData = z.object({
+	post_id: z.number(),
+	post_type: z.string()
+});
+const PostWebhookEvent = z.object({
+	type: PostWebhookEventType,
+	data: PostWebhookEventData
+});
+const TermWebhookEventData = z.object({
+	term_id: z.number(),
+	taxonomy: z.string(),
+	post_types: z.array(z.string()),
+	count: z.number().nonnegative()
+});
+const TermWebhookEvent = z.object({
+	type: TermWebhookEventType,
+	data: TermWebhookEventData
+});
+const PaymentWebhookEventData = z.object({
+	transaction_id: z.nullable(z.string()),
+	payment_method_id: z.string(),
+	payment_session_id: z.string()
+});
+const PaymentWebhookEvent = z.object({
+	type: PaymentWebhookEventType,
+	data: PaymentWebhookEventData
+});
+const SettingsWebhookEventData = z.null();
+const SettingsWebhookEvent = z.object({
+	type: SettingsWebhookEventType,
+	data: SettingsWebhookEventData
+});
+const WebhookEvent = z.union([
+	PostWebhookEvent,
+	TermWebhookEvent,
+	PaymentWebhookEvent,
+	SettingsWebhookEvent
+]);
+const AnyWebhookEvent = z.object({
+	type: z.string(),
+	data: z.unknown()
+});
+
+//#endregion
+export { AnyWebhookEvent, WebhookEvent };