@neat-pdf/mcp 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,13 +1,3639 @@
 #!/usr/bin/env node
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import "./client.js";
-import { registerTools } from "./tools/index.js";
+import { NeatPdf } from "@neat-pdf/sdk";
+import { z } from "@hono/zod-openapi";
+import * as z$130 from "zod/v3";
+import * as z$129 from "zod/v3";
+import * as z$128 from "zod/v3";
+import * as z$127 from "zod/v3";
+import * as z$126 from "zod/v3";
+import * as z$125 from "zod/v3";
+import * as z$124 from "zod/v3";
+import * as z$123 from "zod/v3";
+import * as z$122 from "zod/v3";
+import * as z$121 from "zod/v3";
+import * as z$120 from "zod/v3";
+import * as z$119 from "zod/v3";
+import * as z$118 from "zod/v3";
+import * as z$117 from "zod/v3";
+import * as z$116 from "zod/v3";
+import * as z$115 from "zod/v3";
+import * as z$114 from "zod/v3";
+import * as z$113 from "zod/v3";
+import * as z$112 from "zod/v3";
+import * as z$111 from "zod/v3";
+import * as z$110 from "zod/v3";
+import * as z$109 from "zod/v3";
+import * as z$108 from "zod/v3";
+import * as z$107 from "zod/v3";
+import * as z$106 from "zod/v3";
+import * as z$105 from "zod/v3";
+import * as z$104 from "zod/v3";
+import * as z$103 from "zod/v3";
+import * as z$102 from "zod/v3";
+import * as z$101 from "zod/v3";
+import * as z$100 from "zod/v3";
+import * as z$99 from "zod/v3";
+import * as z$98 from "zod/v3";
+import * as z$97 from "zod/v3";
+import * as z$96 from "zod/v3";
+import * as z$95 from "zod/v3";
+import * as z$94 from "zod/v3";
+import * as z$93 from "zod/v3";
+import * as z$92 from "zod/v3";
+import * as z$91 from "zod/v3";
+import * as z$90 from "zod/v3";
+import * as z$89 from "zod/v3";
+import * as z$88 from "zod/v3";
+import * as z$87 from "zod/v3";
+import * as z$86 from "zod/v3";
+import * as z$85 from "zod/v3";
+import * as z$84 from "zod/v3";
+import * as z$83 from "zod/v3";
+import * as z$82 from "zod/v3";
+import * as z$81 from "zod/v3";
+import * as z$80 from "zod/v3";
+import * as z$79 from "zod/v3";
+import * as z$78 from "zod/v3";
+import * as z$77 from "zod/v3";
+import * as z$76 from "zod/v3";
+import * as z$75 from "zod/v3";
+import * as z$74 from "zod/v3";
+import * as z$73 from "zod/v3";
+import * as z$72 from "zod/v3";
+import * as z$71 from "zod/v3";
+import * as z$70 from "zod/v3";
+import * as z$69 from "zod/v3";
+import * as z$68 from "zod/v3";
+import * as z$67 from "zod/v3";
+import * as z$66 from "zod/v3";
+import * as z$65 from "zod/v3";
+import * as z$64 from "zod/v3";
+import * as z$63 from "zod/v3";
+import * as z$62 from "zod/v3";
+import * as z$61 from "zod/v3";
+import * as z$60 from "zod/v3";
+import * as z$59 from "zod/v3";
+import * as z$58 from "zod/v3";
+import * as z$57 from "zod/v3";
+import * as z$56 from "zod/v3";
+import * as z$55 from "zod/v3";
+import * as z$54 from "zod/v3";
+import * as z$53 from "zod/v3";
+import * as z$52 from "zod/v3";
+import * as z$51 from "zod/v3";
+import * as z$50 from "zod/v3";
+import * as z$49 from "zod/v3";
+import * as z$48 from "zod/v3";
+import * as z$47 from "zod/v3";
+import * as z$46 from "zod/v3";
+import * as z$45 from "zod/v3";
+import * as z$44 from "zod/v3";
+import * as z$43 from "zod/v3";
+import * as z$42 from "zod/v3";
+import * as z$41 from "zod/v3";
+import * as z$40 from "zod/v3";
+import * as z$39 from "zod/v3";
+import * as z$38 from "zod/v3";
+import * as z$37 from "zod/v3";
+import * as z$36 from "zod/v3";
+import * as z$35 from "zod/v3";
+import * as z$34 from "zod/v3";
+import * as z$33 from "zod/v3";
+import * as z$32 from "zod/v3";
+import * as z$31 from "zod/v3";
+import * as z$30 from "zod/v3";
+import * as z$29 from "zod/v3";
+import * as z$28 from "zod/v3";
+import * as z$27 from "zod/v3";
+import * as z$26 from "zod/v3";
+import * as z$25 from "zod/v3";
+import * as z$24 from "zod/v3";
+import * as z$23 from "zod/v3";
+import * as z$22 from "zod/v3";
+import * as z$21 from "zod/v3";
+import * as z$20 from "zod/v3";
+import * as z$19 from "zod/v3";
+import * as z$18 from "zod/v3";
+import * as z$17 from "zod/v3";
+import * as z$16 from "zod/v3";
+import * as z$15 from "zod/v3";
+import * as z$14 from "zod/v3";
+import * as z$13 from "zod/v3";
+import * as z$12 from "zod/v3";
+import * as z$11 from "zod/v3";
+import * as z$10 from "zod/v3";
+import * as z$9 from "zod/v3";
+import * as z$8 from "zod/v3";
+import * as z$7 from "zod/v3";
+import * as z$6 from "zod/v3";
+import * as z$5 from "zod/v3";
+import * as z$4 from "zod/v3";
+import * as z$3 from "zod/v3";
+import * as z$2 from "zod/v3";
+import { z as z$1 } from "zod";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+//#region src/constants.ts
+const INVALID_API_KEYS = ["${NEAT_PDF_API_KEY}", "your-api-key"];
+const SIGNUP_MESSAGE = `
+API key required. Get 100 free PDF generations:
+
+  1. Sign up at https://neat-pdf.com
+  2. Create an API key in your dashboard
+  3. Set NEAT_PDF_API_KEY in your environment
+
+Example: NEAT_PDF_API_KEY=your-key npx @neat-pdf/mcp
+`;
+const UPGRADE_MESSAGE = "No credits remaining. Upgrade your plan at https://neat-pdf.com/pricing";
+
+//#endregion
+//#region src/client.ts
+const apiKey = process.env.NEAT_PDF_API_KEY;
+if (!apiKey || INVALID_API_KEYS.includes(apiKey)) {
+	console.error(SIGNUP_MESSAGE);
+	process.exit(1);
+}
+const client = new NeatPdf({ apiKey });
+
+//#endregion
+//#region ../shared/dist/constants/files.js
+const MAX_FILE_SIZE_BYTES = 2 * 1024 * 1024;
+
+//#endregion
+//#region ../shared/dist/constants/plans.js
+const PlanTier = {
+	FREE: "free",
+	HOBBY: "hobby",
+	PRO: "pro",
+	BUSINESS: "business"
+};
+const PLAN_CONFIG = {
+	[PlanTier.FREE]: {
+		tier: PlanTier.FREE,
+		name: "Free",
+		priceMonthly: 0,
+		credits: 100,
+		rateLimit: 3,
+		maxFileSizeMb: 2,
+		timeoutSeconds: 15
+	},
+	[PlanTier.HOBBY]: {
+		tier: PlanTier.HOBBY,
+		name: "Hobby",
+		priceMonthly: 9,
+		credits: 500,
+		rateLimit: 10,
+		maxFileSizeMb: 5,
+		timeoutSeconds: 20
+	},
+	[PlanTier.PRO]: {
+		tier: PlanTier.PRO,
+		name: "Pro",
+		priceMonthly: 19,
+		credits: 2e3,
+		rateLimit: 60,
+		maxFileSizeMb: 20,
+		timeoutSeconds: 30
+	},
+	[PlanTier.BUSINESS]: {
+		tier: PlanTier.BUSINESS,
+		name: "Business",
+		priceMonthly: 49,
+		credits: 1e4,
+		rateLimit: 200,
+		maxFileSizeMb: 100,
+		timeoutSeconds: 60
+	}
+};
+const PLAN_TIERS = Object.values(PlanTier);
+const BYTES_PER_MB = 1024 * 1024;
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/lib/http.js
+const codeRangeRE$1 = new RegExp("^[0-9]xx$", "i");
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/lib/base64.js
+function bytesToBase64(u8arr) {
+	return btoa(String.fromCodePoint(...u8arr));
+}
+function bytesFromBase64(encoded) {
+	return Uint8Array.from(atob(encoded), (c) => c.charCodeAt(0));
+}
+function stringToBytes(str) {
+	return new TextEncoder().encode(str);
+}
+const zodOutbound = z$130.instanceof(Uint8Array).or(z$130.string().transform(stringToBytes));
+const zodInbound = z$130.instanceof(Uint8Array).or(z$130.string().transform(bytesFromBase64));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/lib/is-plain-object.js
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/lib/encodings.js
+var EncodingError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "EncodingError";
+	}
+};
+function formEncoder(sep) {
+	return (key, value, options) => {
+		let out = "";
+		const pairs = options?.explode ? explode(key, value) : [[key, value]];
+		if (pairs.every(([_, v]) => v == null)) return;
+		const encodeString = (v) => {
+			return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+		};
+		const encodeValue = (v) => encodeString(serializeValue(v));
+		const encodedSep = encodeString(sep);
+		pairs.forEach(([pk, pv]) => {
+			let tmp = "";
+			let encValue = null;
+			if (pv == null) return;
+			else if (Array.isArray(pv)) encValue = mapDefined(pv, (v) => `${encodeValue(v)}`)?.join(encodedSep);
+			else if (isPlainObject(pv)) encValue = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
+				return `${encodeString(k)}${encodedSep}${encodeValue(v)}`;
+			})?.join(encodedSep);
+			else encValue = `${encodeValue(pv)}`;
+			if (encValue == null) return;
+			tmp = `${encodeString(pk)}=${encValue}`;
+			if (!tmp || tmp === "=") return;
+			out += `&${tmp}`;
+		});
+		return out.slice(1);
+	};
+}
+const encodeForm = formEncoder(",");
+const encodeSpaceDelimited = formEncoder(" ");
+const encodePipeDelimited = formEncoder("|");
+function encodeDeepObject(key, value, options) {
+	if (value == null) return;
+	if (!isPlainObject(value)) throw new EncodingError(`Value of parameter '${key}' which uses deepObject encoding must be an object or null`);
+	return encodeDeepObjectObject(key, value, options);
+}
+function encodeDeepObjectObject(key, value, options) {
+	if (value == null) return;
+	let out = "";
+	const encodeString = (v) => {
+		return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+	};
+	if (!isPlainObject(value)) throw new EncodingError(`Expected parameter '${key}' to be an object.`);
+	Object.entries(value).forEach(([ck, cv]) => {
+		if (cv == null) return;
+		const pk = `${key}[${ck}]`;
+		if (isPlainObject(cv)) {
+			const objOut = encodeDeepObjectObject(pk, cv, options);
+			out += objOut == null ? "" : `&${objOut}`;
+			return;
+		}
+		const pairs = Array.isArray(cv) ? cv : [cv];
+		const encoded = mapDefined(pairs, (v) => {
+			return `${encodeString(pk)}=${encodeString(serializeValue(v))}`;
+		})?.join("&");
+		out += encoded == null ? "" : `&${encoded}`;
+	});
+	return out.slice(1);
+}
+function encodeJSON(key, value, options) {
+	if (typeof value === "undefined") return;
+	const encodeString = (v) => {
+		return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+	};
+	const encVal = encodeString(JSON.stringify(value, jsonReplacer));
+	return options?.explode ? encVal : `${encodeString(key)}=${encVal}`;
+}
+function explode(key, value) {
+	if (Array.isArray(value)) return value.map((v) => [key, v]);
+	else if (isPlainObject(value)) {
+		const o = value ?? {};
+		return Object.entries(o).map(([k, v]) => [k, v]);
+	} else return [[key, value]];
+}
+function serializeValue(value) {
+	if (value == null) return "";
+	else if (value instanceof Date) return value.toISOString();
+	else if (value instanceof Uint8Array) return bytesToBase64(value);
+	else if (typeof value === "object") return JSON.stringify(value, jsonReplacer);
+	return `${value}`;
+}
+function jsonReplacer(_, value) {
+	if (value instanceof Uint8Array) return bytesToBase64(value);
+	else return value;
+}
+function mapDefined(inp, mapper) {
+	const res = inp.reduce((acc, v) => {
+		if (v == null) return acc;
+		const m = mapper(v);
+		if (m == null) return acc;
+		acc.push(m);
+		return acc;
+	}, []);
+	return res.length ? res : null;
+}
+function mapDefinedEntries(inp, mapper) {
+	const acc = [];
+	for (const [k, v] of inp) {
+		if (v == null) continue;
+		const m = mapper([k, v]);
+		if (m == null) continue;
+		acc.push(m);
+	}
+	return acc.length ? acc : null;
+}
+function queryJoin(...args) {
+	return args.filter(Boolean).join("&");
+}
+function queryEncoder(f) {
+	const bulkEncode = function(values, options) {
+		const opts = {
+			...options,
+			explode: options?.explode ?? true,
+			charEncoding: options?.charEncoding ?? "percent"
+		};
+		const allowEmptySet = new Set(options?.allowEmptyValue ?? []);
+		const encoded = Object.entries(values).map(([key, value]) => {
+			if (allowEmptySet.has(key)) {
+				if (value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0) return `${encodeURIComponent(key)}=`;
+			}
+			return f(key, value, opts);
+		});
+		return queryJoin(...encoded);
+	};
+	return bulkEncode;
+}
+const encodeJSONQuery = queryEncoder(encodeJSON);
+const encodeFormQuery = queryEncoder(encodeForm);
+const encodeSpaceDelimitedQuery = queryEncoder(encodeSpaceDelimited);
+const encodePipeDelimitedQuery = queryEncoder(encodePipeDelimited);
+const encodeDeepObjectQuery = queryEncoder(encodeDeepObject);
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/lib/env.js
+const envSchema = z$129.object({
+	UNKEY_ROOT_KEY: z$129.string().optional(),
+	UNKEY_DEBUG: z$129.coerce.boolean().optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/lib/retries.js
+const codeRangeRE = new RegExp("^[0-9]xx$", "i");
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/lib/sdks.js
+var __classPrivateFieldSet$1 = void 0 && (void 0).__classPrivateFieldSet || function(receiver, state, value, kind, f) {
+	if (kind === "m") throw new TypeError("Private method is not writable");
+	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+	return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet$1 = void 0 && (void 0).__classPrivateFieldGet || function(receiver, state, kind, f) {
+	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+	return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ClientSDK_httpClient, _ClientSDK_hooks, _ClientSDK_logger;
+const gt = typeof globalThis === "undefined" ? null : globalThis;
+const webWorkerLike = typeof gt === "object" && gt != null && "importScripts" in gt && typeof gt["importScripts"] === "function";
+const isBrowserLike = webWorkerLike || typeof navigator !== "undefined" && "serviceWorker" in navigator || typeof window === "object" && typeof window.document !== "undefined";
+_ClientSDK_httpClient = new WeakMap(), _ClientSDK_hooks = new WeakMap(), _ClientSDK_logger = new WeakMap();
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/errors/unkeyerror.js
+/** The base class for all HTTP error responses */
+var UnkeyError = class extends Error {
+	constructor(message, httpMeta) {
+		super(message);
+		this.statusCode = httpMeta.response.status;
+		this.body = httpMeta.body;
+		this.headers = httpMeta.response.headers;
+		this.contentType = httpMeta.response.headers.get("content-type") || "";
+		this.rawResponse = httpMeta.response;
+		this.name = "UnkeyError";
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/errors/sdkvalidationerror.js
+var SDKValidationError = class extends Error {
+	static [Symbol.hasInstance](instance) {
+		if (!(instance instanceof Error)) return false;
+		if (!("rawValue" in instance)) return false;
+		if (!("rawMessage" in instance)) return false;
+		if (!("pretty" in instance)) return false;
+		if (typeof instance.pretty !== "function") return false;
+		return true;
+	}
+	constructor(message, cause, rawValue) {
+		super(`${message}: ${cause}`);
+		this.name = "SDKValidationError";
+		this.cause = cause;
+		this.rawValue = rawValue;
+		this.rawMessage = message;
+	}
+	/**
+	* Return a pretty-formatted error message if the underlying validation error
+	* is a ZodError or some other recognized error type, otherwise return the
+	* default error message.
+	*/
+	pretty() {
+		if (this.cause instanceof z$128.ZodError) return `${this.rawMessage}\n${formatZodError(this.cause)}`;
+		else return this.toString();
+	}
+};
+function formatZodError(err, level = 0) {
+	let pre = "  ".repeat(level);
+	pre = level > 0 ? `│${pre}` : pre;
+	pre += " ".repeat(level);
+	let message = "";
+	const append = (str) => message += `\n${pre}${str}`;
+	const len = err.issues.length;
+	const headline = len === 1 ? `${len} issue found` : `${len} issues found`;
+	if (len) append(`┌ ${headline}:`);
+	for (const issue of err.issues) {
+		let path = issue.path.join(".");
+		path = path ? `<root>.${path}` : "<root>";
+		append(`│ • [${path}]: ${issue.message} (${issue.code})`);
+		switch (issue.code) {
+			case "invalid_literal":
+			case "invalid_type": {
+				append(`│     Want: ${issue.expected}`);
+				append(`│      Got: ${issue.received}`);
+				break;
+			}
+			case "unrecognized_keys": {
+				append(`│     Keys: ${issue.keys.join(", ")}`);
+				break;
+			}
+			case "invalid_enum_value": {
+				append(`│     Allowed: ${issue.options.join(", ")}`);
+				append(`│         Got: ${issue.received}`);
+				break;
+			}
+			case "invalid_union_discriminator": {
+				append(`│     Allowed: ${issue.options.join(", ")}`);
+				break;
+			}
+			case "invalid_union": {
+				const len$1 = issue.unionErrors.length;
+				append(`│   ✖︎ Attemped to deserialize into one of ${len$1} union members:`);
+				issue.unionErrors.forEach((err$1, i) => {
+					append(`│   ✖︎ Member ${i + 1} of ${len$1}`);
+					append(`${formatZodError(err$1, level + 1)}`);
+				});
+			}
+		}
+	}
+	if (err.issues.length) append(`└─*`);
+	return message.slice(1);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/lib/primitives.js
+/**
+* Converts or omits an object's keys according to a mapping.
+*
+* @param inp An object whose keys will be remapped
+* @param mappings A mapping of original keys to new keys. If a key is not present in the mapping, it will be left as is. If a key is mapped to `null`, it will be removed in the resulting object.
+* @returns A new object with keys remapped or omitted according to the mappings
+*/
+function remap(inp, mappings) {
+	let out = {};
+	if (!Object.keys(mappings).length) {
+		out = inp;
+		return out;
+	}
+	for (const [k, v] of Object.entries(inp)) {
+		const j = mappings[k];
+		if (j === null) continue;
+		out[j ?? k] = v;
+	}
+	return out;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/lib/security.js
+var SecurityErrorCode;
+(function(SecurityErrorCode$1) {
+	SecurityErrorCode$1["Incomplete"] = "incomplete";
+	SecurityErrorCode$1["UnrecognisedSecurityType"] = "unrecognized_security_type";
+})(SecurityErrorCode || (SecurityErrorCode = {}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/validationerror.js
+/** @internal */
+const ValidationError$inboundSchema = z$127.object({
+	location: z$127.string(),
+	message: z$127.string(),
+	fix: z$127.string().optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/badrequesterrordetails.js
+/** @internal */
+const BadRequestErrorDetails$inboundSchema = z$126.object({
+	detail: z$126.string(),
+	status: z$126.number().int(),
+	title: z$126.string(),
+	type: z$126.string(),
+	errors: z$126.array(ValidationError$inboundSchema)
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/baseerror.js
+/** @internal */
+const BaseError$inboundSchema = z$125.object({
+	detail: z$125.string(),
+	status: z$125.number().int(),
+	title: z$125.string(),
+	type: z$125.string()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/emptyresponse.js
+/** @internal */
+const EmptyResponse$inboundSchema = z$124.object({});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/ratelimitresponse.js
+/** @internal */
+const RatelimitResponse$inboundSchema = z$123.object({
+	id: z$123.string(),
+	name: z$123.string(),
+	limit: z$123.number().int(),
+	duration: z$123.number().int(),
+	autoApply: z$123.boolean()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/identity.js
+/** @internal */
+const Identity$inboundSchema = z$122.object({
+	id: z$122.string(),
+	externalId: z$122.string(),
+	meta: z$122.record(z$122.any()).optional(),
+	ratelimits: z$122.array(RatelimitResponse$inboundSchema).optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/keycreditsrefill.js
+/**
+* How often credits are automatically refilled.
+*/
+const KeyCreditsRefillInterval = {
+	Daily: "daily",
+	Monthly: "monthly"
+};
+/** @internal */
+const KeyCreditsRefillInterval$inboundSchema = z$121.nativeEnum(KeyCreditsRefillInterval);
+/** @internal */
+const KeyCreditsRefillInterval$outboundSchema = KeyCreditsRefillInterval$inboundSchema;
+/** @internal */
+const KeyCreditsRefill$inboundSchema = z$121.object({
+	interval: KeyCreditsRefillInterval$inboundSchema,
+	amount: z$121.number().int(),
+	refillDay: z$121.number().int().optional()
+});
+/** @internal */
+const KeyCreditsRefill$outboundSchema = z$121.object({
+	interval: KeyCreditsRefillInterval$outboundSchema,
+	amount: z$121.number().int(),
+	refillDay: z$121.number().int().optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/keycreditsdata.js
+/** @internal */
+const KeyCreditsData$inboundSchema = z$120.object({
+	remaining: z$120.nullable(z$120.number().int()),
+	refill: KeyCreditsRefill$inboundSchema.optional()
+});
+/** @internal */
+const KeyCreditsData$outboundSchema = z$120.object({
+	remaining: z$120.nullable(z$120.number().int()),
+	refill: KeyCreditsRefill$outboundSchema.optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/keyresponsedata.js
+/** @internal */
+const KeyResponseData$inboundSchema = z$119.object({
+	keyId: z$119.string(),
+	start: z$119.string(),
+	enabled: z$119.boolean(),
+	name: z$119.string().optional(),
+	meta: z$119.record(z$119.any()).optional(),
+	createdAt: z$119.number().int(),
+	updatedAt: z$119.number().int().optional(),
+	expires: z$119.number().int().optional(),
+	permissions: z$119.array(z$119.string()).optional(),
+	roles: z$119.array(z$119.string()).optional(),
+	credits: KeyCreditsData$inboundSchema.optional(),
+	identity: Identity$inboundSchema.optional(),
+	plaintext: z$119.string().optional(),
+	ratelimits: z$119.array(RatelimitResponse$inboundSchema).optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/keysverifykeycredits.js
+/** @internal */
+const KeysVerifyKeyCredits$outboundSchema = z$118.object({ cost: z$118.number().int() });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/keysverifykeyratelimit.js
+/** @internal */
+const KeysVerifyKeyRatelimit$outboundSchema = z$117.object({
+	name: z$117.string(),
+	cost: z$117.number().int().default(1),
+	limit: z$117.number().int().optional(),
+	duration: z$117.number().int().optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/meta.js
+/** @internal */
+const Meta$inboundSchema = z$116.object({ requestId: z$116.string() });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/pagination.js
+/** @internal */
+const Pagination$inboundSchema = z$115.object({
+	cursor: z$115.string().optional(),
+	hasMore: z$115.boolean()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/permission.js
+/** @internal */
+const Permission$inboundSchema = z$114.object({
+	id: z$114.string(),
+	name: z$114.string(),
+	slug: z$114.string(),
+	description: z$114.string().optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/ratelimitoverride.js
+/** @internal */
+const RatelimitOverride$inboundSchema = z$113.object({
+	overrideId: z$113.string(),
+	duration: z$113.number().int(),
+	identifier: z$113.string(),
+	limit: z$113.number().int()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/ratelimitrequest.js
+/** @internal */
+const RatelimitRequest$outboundSchema = z$112.object({
+	name: z$112.string(),
+	limit: z$112.number().int(),
+	duration: z$112.number().int(),
+	autoApply: z$112.boolean().default(false)
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/role.js
+/** @internal */
+const Role$inboundSchema = z$111.object({
+	id: z$111.string(),
+	name: z$111.string(),
+	description: z$111.string().optional(),
+	permissions: z$111.array(Permission$inboundSchema).optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/security.js
+/** @internal */
+const Security$outboundSchema = z$110.object({ rootKey: z$110.string().optional() });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/updatekeycreditsrefill.js
+/**
+* How often credits are automatically refilled.
+*/
+const UpdateKeyCreditsRefillInterval = {
+	Daily: "daily",
+	Monthly: "monthly"
+};
+/** @internal */
+const UpdateKeyCreditsRefillInterval$outboundSchema = z$109.nativeEnum(UpdateKeyCreditsRefillInterval);
+/** @internal */
+const UpdateKeyCreditsRefill$outboundSchema = z$109.object({
+	interval: UpdateKeyCreditsRefillInterval$outboundSchema,
+	amount: z$109.number().int(),
+	refillDay: z$109.number().int().optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/updatekeycreditsdata.js
+/** @internal */
+const UpdateKeyCreditsData$outboundSchema = z$108.object({
+	remaining: z$108.nullable(z$108.number().int()).optional(),
+	refill: z$108.nullable(UpdateKeyCreditsRefill$outboundSchema).optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2analyticsgetverificationsrequestbody.js
+/** @internal */
+const V2AnalyticsGetVerificationsRequestBody$outboundSchema = z$107.object({ query: z$107.string() });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2analyticsgetverificationsresponsebody.js
+/** @internal */
+const V2AnalyticsGetVerificationsResponseBody$inboundSchema = z$106.object({
+	meta: Meta$inboundSchema,
+	data: z$106.array(z$106.record(z$106.any()))
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2apiscreateapirequestbody.js
+/** @internal */
+const V2ApisCreateApiRequestBody$outboundSchema = z$105.object({ name: z$105.string() });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2apiscreateapiresponsedata.js
+/** @internal */
+const V2ApisCreateApiResponseData$inboundSchema = z$104.object({ apiId: z$104.string() });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2apiscreateapiresponsebody.js
+/** @internal */
+const V2ApisCreateApiResponseBody$inboundSchema = z$103.object({
+	meta: Meta$inboundSchema,
+	data: V2ApisCreateApiResponseData$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2apisdeleteapirequestbody.js
+/** @internal */
+const V2ApisDeleteApiRequestBody$outboundSchema = z$102.object({ apiId: z$102.string() });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2apisdeleteapiresponsebody.js
+/** @internal */
+const V2ApisDeleteApiResponseBody$inboundSchema = z$101.object({
+	meta: Meta$inboundSchema,
+	data: EmptyResponse$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2apisgetapirequestbody.js
+/** @internal */
+const V2ApisGetApiRequestBody$outboundSchema = z$100.object({ apiId: z$100.string() });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2apisgetapiresponsedata.js
+/** @internal */
+const V2ApisGetApiResponseData$inboundSchema = z$99.object({
+	id: z$99.string(),
+	name: z$99.string()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2apisgetapiresponsebody.js
+/** @internal */
+const V2ApisGetApiResponseBody$inboundSchema = z$98.object({
+	meta: Meta$inboundSchema,
+	data: V2ApisGetApiResponseData$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2apislistkeysrequestbody.js
+/** @internal */
+const V2ApisListKeysRequestBody$outboundSchema = z$97.object({
+	apiId: z$97.string(),
+	limit: z$97.number().int().default(100),
+	cursor: z$97.string().optional(),
+	externalId: z$97.string().optional(),
+	decrypt: z$97.boolean().default(false),
+	revalidateKeysCache: z$97.boolean().default(false)
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2apislistkeysresponsebody.js
+/** @internal */
+const V2ApisListKeysResponseBody$inboundSchema = z$96.object({
+	meta: Meta$inboundSchema,
+	data: z$96.array(KeyResponseData$inboundSchema),
+	pagination: Pagination$inboundSchema.optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2identitiescreateidentityrequestbody.js
+/** @internal */
+const V2IdentitiesCreateIdentityRequestBody$outboundSchema = z$95.object({
+	externalId: z$95.string(),
+	meta: z$95.record(z$95.any()).optional(),
+	ratelimits: z$95.array(RatelimitRequest$outboundSchema).optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2identitiescreateidentityresponsedata.js
+/** @internal */
+const V2IdentitiesCreateIdentityResponseData$inboundSchema = z$94.object({ identityId: z$94.string() });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2identitiescreateidentityresponsebody.js
+/** @internal */
+const V2IdentitiesCreateIdentityResponseBody$inboundSchema = z$93.object({
+	meta: Meta$inboundSchema,
+	data: V2IdentitiesCreateIdentityResponseData$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2identitiesdeleteidentityrequestbody.js
+/** @internal */
+const V2IdentitiesDeleteIdentityRequestBody$outboundSchema = z$92.object({ identity: z$92.string() });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2identitiesdeleteidentityresponsebody.js
+/** @internal */
+const V2IdentitiesDeleteIdentityResponseBody$inboundSchema = z$91.object({ meta: Meta$inboundSchema });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2identitiesgetidentityrequestbody.js
+/** @internal */
+const V2IdentitiesGetIdentityRequestBody$outboundSchema = z$90.object({ identity: z$90.string() });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2identitiesgetidentityresponsebody.js
+/** @internal */
+const V2IdentitiesGetIdentityResponseBody$inboundSchema = z$89.object({
+	meta: Meta$inboundSchema,
+	data: Identity$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2identitieslistidentitiesrequestbody.js
+/** @internal */
+const V2IdentitiesListIdentitiesRequestBody$outboundSchema = z$88.object({
+	limit: z$88.number().int().default(100),
+	cursor: z$88.string().optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2identitieslistidentitiesresponsebody.js
+/** @internal */
+const V2IdentitiesListIdentitiesResponseBody$inboundSchema = z$87.object({
+	meta: Meta$inboundSchema,
+	data: z$87.array(Identity$inboundSchema),
+	pagination: Pagination$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2identitiesupdateidentityrequestbody.js
+/** @internal */
+const V2IdentitiesUpdateIdentityRequestBody$outboundSchema = z$86.object({
+	identity: z$86.string(),
+	meta: z$86.record(z$86.any()).optional(),
+	ratelimits: z$86.array(RatelimitRequest$outboundSchema).optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2identitiesupdateidentityresponsebody.js
+/** @internal */
+const V2IdentitiesUpdateIdentityResponseBody$inboundSchema = z$85.object({
+	data: Identity$inboundSchema,
+	meta: Meta$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysaddpermissionsrequestbody.js
+/** @internal */
+const V2KeysAddPermissionsRequestBody$outboundSchema = z$84.object({
+	keyId: z$84.string(),
+	permissions: z$84.array(z$84.string())
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysaddpermissionsresponsebody.js
+/** @internal */
+const V2KeysAddPermissionsResponseBody$inboundSchema = z$83.object({
+	meta: Meta$inboundSchema,
+	data: z$83.array(Permission$inboundSchema)
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysaddrolesrequestbody.js
+/** @internal */
+const V2KeysAddRolesRequestBody$outboundSchema = z$82.object({
+	keyId: z$82.string(),
+	roles: z$82.array(z$82.string())
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysaddrolesresponsebody.js
+/** @internal */
+const V2KeysAddRolesResponseBody$inboundSchema = z$81.object({
+	meta: Meta$inboundSchema,
+	data: z$81.array(Role$inboundSchema)
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keyscreatekeyrequestbody.js
+/** @internal */
+const V2KeysCreateKeyRequestBody$outboundSchema = z$80.object({
+	apiId: z$80.string(),
+	prefix: z$80.string().optional(),
+	name: z$80.string().optional(),
+	byteLength: z$80.number().int().default(16),
+	externalId: z$80.string().optional(),
+	meta: z$80.record(z$80.any()).optional(),
+	roles: z$80.array(z$80.string()).optional(),
+	permissions: z$80.array(z$80.string()).optional(),
+	expires: z$80.number().int().optional(),
+	credits: KeyCreditsData$outboundSchema.optional(),
+	ratelimits: z$80.array(RatelimitRequest$outboundSchema).optional(),
+	enabled: z$80.boolean().default(true),
+	recoverable: z$80.boolean().default(false)
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keyscreatekeyresponsedata.js
+/** @internal */
+const V2KeysCreateKeyResponseData$inboundSchema = z$79.object({
+	keyId: z$79.string(),
+	key: z$79.string()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keyscreatekeyresponsebody.js
+/** @internal */
+const V2KeysCreateKeyResponseBody$inboundSchema = z$78.object({
+	meta: Meta$inboundSchema,
+	data: V2KeysCreateKeyResponseData$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysdeletekeyrequestbody.js
+/** @internal */
+const V2KeysDeleteKeyRequestBody$outboundSchema = z$77.object({
+	keyId: z$77.string(),
+	permanent: z$77.boolean().default(false)
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysdeletekeyresponsebody.js
+/** @internal */
+const V2KeysDeleteKeyResponseBody$inboundSchema = z$76.object({
+	meta: Meta$inboundSchema,
+	data: EmptyResponse$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysgetkeyrequestbody.js
+/** @internal */
+const V2KeysGetKeyRequestBody$outboundSchema = z$75.object({
+	keyId: z$75.string(),
+	decrypt: z$75.boolean().default(false)
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysgetkeyresponsebody.js
+/** @internal */
+const V2KeysGetKeyResponseBody$inboundSchema = z$74.object({
+	meta: Meta$inboundSchema,
+	data: KeyResponseData$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysmigratekeydata.js
+/** @internal */
+const V2KeysMigrateKeyData$outboundSchema = z$73.object({
+	hash: z$73.string(),
+	name: z$73.string().optional(),
+	externalId: z$73.string().optional(),
+	meta: z$73.record(z$73.any()).optional(),
+	roles: z$73.array(z$73.string()).optional(),
+	permissions: z$73.array(z$73.string()).optional(),
+	expires: z$73.number().int().optional(),
+	enabled: z$73.boolean().default(true),
+	credits: KeyCreditsData$outboundSchema.optional(),
+	ratelimits: z$73.array(RatelimitRequest$outboundSchema).optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysmigratekeysmigration.js
+/** @internal */
+const V2KeysMigrateKeysMigration$inboundSchema = z$72.object({
+	hash: z$72.string(),
+	keyId: z$72.string()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysmigratekeysrequestbody.js
+/** @internal */
+const V2KeysMigrateKeysRequestBody$outboundSchema = z$71.object({
+	migrationId: z$71.string(),
+	apiId: z$71.string(),
+	keys: z$71.array(V2KeysMigrateKeyData$outboundSchema)
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysmigratekeysresponsedata.js
+/** @internal */
+const V2KeysMigrateKeysResponseData$inboundSchema = z$70.object({
+	migrated: z$70.array(V2KeysMigrateKeysMigration$inboundSchema),
+	failed: z$70.array(z$70.string())
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysmigratekeysresponsebody.js
+/** @internal */
+const V2KeysMigrateKeysResponseBody$inboundSchema = z$69.object({
+	meta: Meta$inboundSchema,
+	data: V2KeysMigrateKeysResponseData$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysremovepermissionsrequestbody.js
+/** @internal */
+const V2KeysRemovePermissionsRequestBody$outboundSchema = z$68.object({
+	keyId: z$68.string(),
+	permissions: z$68.array(z$68.string())
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysremovepermissionsresponsebody.js
+/** @internal */
+const V2KeysRemovePermissionsResponseBody$inboundSchema = z$67.object({
+	meta: Meta$inboundSchema,
+	data: z$67.array(Permission$inboundSchema)
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysremoverolesrequestbody.js
+/** @internal */
+const V2KeysRemoveRolesRequestBody$outboundSchema = z$66.object({
+	keyId: z$66.string(),
+	roles: z$66.array(z$66.string())
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysremoverolesresponsebody.js
+/** @internal */
+const V2KeysRemoveRolesResponseBody$inboundSchema = z$65.object({
+	meta: Meta$inboundSchema,
+	data: z$65.array(Role$inboundSchema)
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysrerollkeyrequestbody.js
+/** @internal */
+const V2KeysRerollKeyRequestBody$outboundSchema = z$64.object({
+	keyId: z$64.string(),
+	expiration: z$64.number().int()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysrerollkeyresponsedata.js
+/** @internal */
+const V2KeysRerollKeyResponseData$inboundSchema = z$63.object({
+	keyId: z$63.string(),
+	key: z$63.string()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysrerollkeyresponsebody.js
+/** @internal */
+const V2KeysRerollKeyResponseBody$inboundSchema = z$62.object({
+	meta: Meta$inboundSchema,
+	data: V2KeysRerollKeyResponseData$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keyssetpermissionsrequestbody.js
+/** @internal */
+const V2KeysSetPermissionsRequestBody$outboundSchema = z$61.object({
+	keyId: z$61.string(),
+	permissions: z$61.array(z$61.string())
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keyssetpermissionsresponsebody.js
+/** @internal */
+const V2KeysSetPermissionsResponseBody$inboundSchema = z$60.object({
+	meta: Meta$inboundSchema,
+	data: z$60.array(Permission$inboundSchema)
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keyssetrolesrequestbody.js
+/** @internal */
+const V2KeysSetRolesRequestBody$outboundSchema = z$59.object({
+	keyId: z$59.string(),
+	roles: z$59.array(z$59.string())
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keyssetrolesresponsebody.js
+/** @internal */
+const V2KeysSetRolesResponseBody$inboundSchema = z$58.object({
+	meta: Meta$inboundSchema,
+	data: z$58.array(Role$inboundSchema)
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysupdatecreditsrequestbody.js
+/**
+* Defines how to modify the key's remaining credits. Use 'set' to replace current credits with a specific value or unlimited usage, 'increment' to add credits for plan upgrades or credit purchases, and 'decrement' to reduce credits for refunds or policy violations.
+*
+* @remarks
+*/
+const Operation = {
+	Set: "set",
+	Increment: "increment",
+	Decrement: "decrement"
+};
+/** @internal */
+const Operation$outboundSchema = z$57.nativeEnum(Operation);
+/** @internal */
+const V2KeysUpdateCreditsRequestBody$outboundSchema = z$57.object({
+	keyId: z$57.string(),
+	value: z$57.nullable(z$57.number().int()).optional(),
+	operation: Operation$outboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysupdatecreditsresponsebody.js
+/** @internal */
+const V2KeysUpdateCreditsResponseBody$inboundSchema = z$56.object({
+	meta: Meta$inboundSchema,
+	data: KeyCreditsData$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysupdatekeyrequestbody.js
+/** @internal */
+const V2KeysUpdateKeyRequestBody$outboundSchema = z$55.object({
+	keyId: z$55.string(),
+	name: z$55.nullable(z$55.string()).optional(),
+	externalId: z$55.nullable(z$55.string()).optional(),
+	meta: z$55.nullable(z$55.record(z$55.any())).optional(),
+	expires: z$55.nullable(z$55.number().int()).optional(),
+	credits: z$55.nullable(UpdateKeyCreditsData$outboundSchema).optional(),
+	ratelimits: z$55.array(RatelimitRequest$outboundSchema).optional(),
+	enabled: z$55.boolean().optional(),
+	roles: z$55.array(z$55.string()).optional(),
+	permissions: z$55.array(z$55.string()).optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysupdatekeyresponsebody.js
+/** @internal */
+const V2KeysUpdateKeyResponseBody$inboundSchema = z$54.object({
+	meta: Meta$inboundSchema,
+	data: EmptyResponse$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysverifykeyrequestbody.js
+/** @internal */
+const V2KeysVerifyKeyRequestBody$outboundSchema = z$53.object({
+	key: z$53.string(),
+	tags: z$53.array(z$53.string()).optional(),
+	permissions: z$53.string().optional(),
+	credits: KeysVerifyKeyCredits$outboundSchema.optional(),
+	ratelimits: z$53.array(KeysVerifyKeyRatelimit$outboundSchema).optional(),
+	migrationId: z$53.string().optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/verifykeyratelimitdata.js
+/** @internal */
+const VerifyKeyRatelimitData$inboundSchema = z$52.object({
+	exceeded: z$52.boolean(),
+	id: z$52.string(),
+	name: z$52.string(),
+	limit: z$52.number().int(),
+	duration: z$52.number().int(),
+	reset: z$52.number().int(),
+	remaining: z$52.number().int(),
+	autoApply: z$52.boolean()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysverifykeyresponsedata.js
+/**
+* A machine-readable code indicating the verification status
+*
+* @remarks
+* or failure reason. Values: `VALID` (key is valid and passed all checks), `NOT_FOUND` (key doesn't
+* exist or belongs to wrong API), `FORBIDDEN` (key lacks required permissions), `INSUFFICIENT_PERMISSIONS`
+* (key lacks specific required permissions for this request), `INSUFFICIENT_CREDITS`
+* (key has no remaining credits), `USAGE_EXCEEDED` (key exceeded usage limits), `RATE_LIMITED` (key exceeded rate limits), `DISABLED` (key was explicitly disabled),
+* `EXPIRED` (key has passed its expiration date).
+*/
+const Code = {
+	Valid: "VALID",
+	NotFound: "NOT_FOUND",
+	Forbidden: "FORBIDDEN",
+	InsufficientPermissions: "INSUFFICIENT_PERMISSIONS",
+	InsufficientCredits: "INSUFFICIENT_CREDITS",
+	UsageExceeded: "USAGE_EXCEEDED",
+	RateLimited: "RATE_LIMITED",
+	Disabled: "DISABLED",
+	Expired: "EXPIRED"
+};
+/** @internal */
+const Code$inboundSchema = z$51.nativeEnum(Code);
+/** @internal */
+const V2KeysVerifyKeyResponseData$inboundSchema = z$51.object({
+	valid: z$51.boolean(),
+	code: Code$inboundSchema,
+	keyId: z$51.string().optional(),
+	name: z$51.string().optional(),
+	meta: z$51.record(z$51.any()).optional(),
+	expires: z$51.number().int().optional(),
+	credits: z$51.number().int().optional(),
+	enabled: z$51.boolean().optional(),
+	permissions: z$51.array(z$51.string()).optional(),
+	roles: z$51.array(z$51.string()).optional(),
+	identity: Identity$inboundSchema.optional(),
+	ratelimits: z$51.array(VerifyKeyRatelimitData$inboundSchema).optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keysverifykeyresponsebody.js
+/** @internal */
+const V2KeysVerifyKeyResponseBody$inboundSchema = z$50.object({
+	meta: Meta$inboundSchema,
+	data: V2KeysVerifyKeyResponseData$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keyswhoamirequestbody.js
+/** @internal */
+const V2KeysWhoamiRequestBody$outboundSchema = z$49.object({ key: z$49.string() });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2keyswhoamiresponsebody.js
+/** @internal */
+const V2KeysWhoamiResponseBody$inboundSchema = z$48.object({
+	meta: Meta$inboundSchema,
+	data: KeyResponseData$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2permissionscreatepermissionrequestbody.js
+/** @internal */
+const V2PermissionsCreatePermissionRequestBody$outboundSchema = z$47.object({
+	name: z$47.string(),
+	slug: z$47.string(),
+	description: z$47.string().optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2permissionscreatepermissionresponsedata.js
+/** @internal */
+const V2PermissionsCreatePermissionResponseData$inboundSchema = z$46.object({ permissionId: z$46.string() });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2permissionscreatepermissionresponsebody.js
+/** @internal */
+const V2PermissionsCreatePermissionResponseBody$inboundSchema = z$45.object({
+	meta: Meta$inboundSchema,
+	data: V2PermissionsCreatePermissionResponseData$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2permissionscreaterolerequestbody.js
+/** @internal */
+const V2PermissionsCreateRoleRequestBody$outboundSchema = z$44.object({
+	name: z$44.string(),
+	description: z$44.string().optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2permissionscreateroleresponsedata.js
+/** @internal */
+const V2PermissionsCreateRoleResponseData$inboundSchema = z$43.object({ roleId: z$43.string() });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2permissionscreateroleresponsebody.js
+/** @internal */
+const V2PermissionsCreateRoleResponseBody$inboundSchema = z$42.object({
+	meta: Meta$inboundSchema,
+	data: V2PermissionsCreateRoleResponseData$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2permissionsdeletepermissionrequestbody.js
+/** @internal */
+const V2PermissionsDeletePermissionRequestBody$outboundSchema = z$41.object({ permission: z$41.string() });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2permissionsdeletepermissionresponsebody.js
+/** @internal */
+const V2PermissionsDeletePermissionResponseBody$inboundSchema = z$40.object({
+	meta: Meta$inboundSchema,
+	data: EmptyResponse$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2permissionsdeleterolerequestbody.js
+/** @internal */
+const V2PermissionsDeleteRoleRequestBody$outboundSchema = z$39.object({ role: z$39.string() });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2permissionsdeleteroleresponsebody.js
+/** @internal */
+const V2PermissionsDeleteRoleResponseBody$inboundSchema = z$38.object({
+	meta: Meta$inboundSchema,
+	data: EmptyResponse$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2permissionsgetpermissionrequestbody.js
+/** @internal */
+const V2PermissionsGetPermissionRequestBody$outboundSchema = z$37.object({ permission: z$37.string() });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2permissionsgetpermissionresponsebody.js
+/** @internal */
+const V2PermissionsGetPermissionResponseBody$inboundSchema = z$36.object({
+	meta: Meta$inboundSchema,
+	data: Permission$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2permissionsgetrolerequestbody.js
+/** @internal */
+const V2PermissionsGetRoleRequestBody$outboundSchema = z$35.object({ role: z$35.string() });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2permissionsgetroleresponsebody.js
+/** @internal */
+const V2PermissionsGetRoleResponseBody$inboundSchema = z$34.object({
+	meta: Meta$inboundSchema,
+	data: Role$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2permissionslistpermissionsrequestbody.js
+/** @internal */
+const V2PermissionsListPermissionsRequestBody$outboundSchema = z$33.object({
+	cursor: z$33.string().optional(),
+	limit: z$33.number().int().default(100)
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2permissionslistpermissionsresponsebody.js
+/** @internal */
+const V2PermissionsListPermissionsResponseBody$inboundSchema = z$32.object({
+	meta: Meta$inboundSchema,
+	data: z$32.array(Permission$inboundSchema),
+	pagination: Pagination$inboundSchema.optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2permissionslistrolesrequestbody.js
+/** @internal */
+const V2PermissionsListRolesRequestBody$outboundSchema = z$31.object({
+	limit: z$31.number().int().default(100),
+	cursor: z$31.string().optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2permissionslistrolesresponsebody.js
+/** @internal */
+const V2PermissionsListRolesResponseBody$inboundSchema = z$30.object({
+	meta: Meta$inboundSchema,
+	data: z$30.array(Role$inboundSchema),
+	pagination: Pagination$inboundSchema.optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2ratelimitdeleteoverriderequestbody.js
+/** @internal */
+const V2RatelimitDeleteOverrideRequestBody$outboundSchema = z$29.object({
+	namespace: z$29.string(),
+	identifier: z$29.string()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2ratelimitdeleteoverrideresponsedata.js
+/** @internal */
+const V2RatelimitDeleteOverrideResponseData$inboundSchema = z$28.object({});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2ratelimitdeleteoverrideresponsebody.js
+/** @internal */
+const V2RatelimitDeleteOverrideResponseBody$inboundSchema = z$27.object({
+	meta: Meta$inboundSchema,
+	data: V2RatelimitDeleteOverrideResponseData$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2ratelimitgetoverriderequestbody.js
+/** @internal */
+const V2RatelimitGetOverrideRequestBody$outboundSchema = z$26.object({
+	namespace: z$26.string(),
+	identifier: z$26.string()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2ratelimitgetoverrideresponsebody.js
+/** @internal */
+const V2RatelimitGetOverrideResponseBody$inboundSchema = z$25.object({
+	meta: Meta$inboundSchema,
+	data: RatelimitOverride$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2ratelimitlimitrequestbody.js
+/** @internal */
+const V2RatelimitLimitRequestBody$outboundSchema = z$24.object({
+	namespace: z$24.string(),
+	cost: z$24.number().int().default(1),
+	duration: z$24.number().int(),
+	identifier: z$24.string(),
+	limit: z$24.number().int()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2ratelimitlimitresponsedata.js
+/** @internal */
+const V2RatelimitLimitResponseData$inboundSchema = z$23.object({
+	limit: z$23.number().int(),
+	remaining: z$23.number().int(),
+	reset: z$23.number().int(),
+	success: z$23.boolean(),
+	overrideId: z$23.string().optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2ratelimitlimitresponsebody.js
+/** @internal */
+const V2RatelimitLimitResponseBody$inboundSchema = z$22.object({
+	meta: Meta$inboundSchema,
+	data: V2RatelimitLimitResponseData$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2ratelimitlistoverridesrequestbody.js
+/** @internal */
+const V2RatelimitListOverridesRequestBody$outboundSchema = z$21.object({
+	namespace: z$21.string(),
+	cursor: z$21.string().optional(),
+	limit: z$21.number().int().default(10)
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2ratelimitlistoverridesresponsebody.js
+/** @internal */
+const V2RatelimitListOverridesResponseBody$inboundSchema = z$20.object({
+	meta: Meta$inboundSchema,
+	data: z$20.array(RatelimitOverride$inboundSchema),
+	pagination: Pagination$inboundSchema.optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2ratelimitmultilimitcheck.js
+/** @internal */
+const V2RatelimitMultiLimitCheck$inboundSchema = z$19.object({
+	namespace: z$19.string(),
+	identifier: z$19.string(),
+	limit: z$19.number().int(),
+	remaining: z$19.number().int(),
+	reset: z$19.number().int(),
+	passed: z$19.boolean(),
+	overrideId: z$19.string().optional()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2ratelimitmultilimitresponsedata.js
+/** @internal */
+const V2RatelimitMultiLimitResponseData$inboundSchema = z$18.object({
+	passed: z$18.boolean(),
+	limits: z$18.array(V2RatelimitMultiLimitCheck$inboundSchema)
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2ratelimitmultilimitresponsebody.js
+/** @internal */
+const V2RatelimitMultiLimitResponseBody$inboundSchema = z$17.object({
+	meta: Meta$inboundSchema,
+	data: V2RatelimitMultiLimitResponseData$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2ratelimitsetoverriderequestbody.js
+/** @internal */
+const V2RatelimitSetOverrideRequestBody$outboundSchema = z$16.object({
+	namespace: z$16.string(),
+	duration: z$16.number().int(),
+	identifier: z$16.string(),
+	limit: z$16.number().int()
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2ratelimitsetoverrideresponsedata.js
+/** @internal */
+const V2RatelimitSetOverrideResponseData$inboundSchema = z$15.object({ overrideId: z$15.string() });
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/components/v2ratelimitsetoverrideresponsebody.js
+/** @internal */
+const V2RatelimitSetOverrideResponseBody$inboundSchema = z$14.object({
+	meta: Meta$inboundSchema,
+	data: V2RatelimitSetOverrideResponseData$inboundSchema
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/errors/badrequesterrorresponse.js
+/**
+* Error response for invalid requests that cannot be processed due to client-side errors. This typically occurs when request parameters are missing, malformed, or fail validation rules. The response includes detailed information about the specific errors in the request, including the location of each error and suggestions for fixing it. When receiving this error, check the 'errors' array in the response for specific validation issues that need to be addressed before retrying.
+*/
+var BadRequestErrorResponse = class extends UnkeyError {
+	constructor(err, httpMeta) {
+		const message = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
+		super(message, httpMeta);
+		this.data$ = err;
+		this.meta = err.meta;
+		this.error = err.error;
+		this.name = "BadRequestErrorResponse";
+	}
+};
+/** @internal */
+const BadRequestErrorResponse$inboundSchema = z$13.object({
+	meta: Meta$inboundSchema,
+	error: BadRequestErrorDetails$inboundSchema,
+	request$: z$13.instanceof(Request),
+	response$: z$13.instanceof(Response),
+	body$: z$13.string()
+}).transform((v) => {
+	return new BadRequestErrorResponse(v, {
+		request: v.request$,
+		response: v.response$,
+		body: v.body$
+	});
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/errors/conflicterrorresponse.js
+/**
+* Error response when the request conflicts with the current state of the resource. This occurs when:
+*
+* @remarks
+* - Attempting to create a resource that already exists
+* - Modifying a resource that has been changed by another operation
+* - Violating unique constraints or business rules
+*
+* To resolve this error, check the current state of the resource and adjust your request accordingly.
+*/
+var ConflictErrorResponse = class extends UnkeyError {
+	constructor(err, httpMeta) {
+		const message = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
+		super(message, httpMeta);
+		this.data$ = err;
+		this.meta = err.meta;
+		this.error = err.error;
+		this.name = "ConflictErrorResponse";
+	}
+};
+/** @internal */
+const ConflictErrorResponse$inboundSchema = z$12.object({
+	meta: Meta$inboundSchema,
+	error: BaseError$inboundSchema,
+	request$: z$12.instanceof(Request),
+	response$: z$12.instanceof(Response),
+	body$: z$12.string()
+}).transform((v) => {
+	return new ConflictErrorResponse(v, {
+		request: v.request$,
+		response: v.response$,
+		body: v.body$
+	});
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/errors/forbiddenerrorresponse.js
+/**
+* Error response when the provided credentials are valid but lack sufficient permissions for the requested operation. This occurs when:
+*
+* @remarks
+* - The root key doesn't have the required permissions for this endpoint
+* - The operation requires elevated privileges that the current key lacks
+* - Access to the requested resource is restricted based on workspace settings
+*
+* To resolve this error, ensure your root key has the necessary permissions or contact your workspace administrator.
+*/
+var ForbiddenErrorResponse = class extends UnkeyError {
+	constructor(err, httpMeta) {
+		const message = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
+		super(message, httpMeta);
+		this.data$ = err;
+		this.meta = err.meta;
+		this.error = err.error;
+		this.name = "ForbiddenErrorResponse";
+	}
+};
+/** @internal */
+const ForbiddenErrorResponse$inboundSchema = z$11.object({
+	meta: Meta$inboundSchema,
+	error: BaseError$inboundSchema,
+	request$: z$11.instanceof(Request),
+	response$: z$11.instanceof(Response),
+	body$: z$11.string()
+}).transform((v) => {
+	return new ForbiddenErrorResponse(v, {
+		request: v.request$,
+		response: v.response$,
+		body: v.body$
+	});
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/errors/goneerrorresponse.js
+/**
+* Error response when the requested resource has been soft-deleted and is no longer available. This occurs when:
+*
+* @remarks
+* - The resource has been marked as deleted but still exists in the database
+* - The resource is intentionally unavailable but could potentially be restored
+* - The resource cannot be restored through the API or dashboard
+*
+* To resolve this error, contact support if you need the resource restored.
+*/
+var GoneErrorResponse = class extends UnkeyError {
+	constructor(err, httpMeta) {
+		const message = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
+		super(message, httpMeta);
+		this.data$ = err;
+		this.meta = err.meta;
+		this.error = err.error;
+		this.name = "GoneErrorResponse";
+	}
+};
+/** @internal */
+const GoneErrorResponse$inboundSchema = z$10.object({
+	meta: Meta$inboundSchema,
+	error: BaseError$inboundSchema,
+	request$: z$10.instanceof(Request),
+	response$: z$10.instanceof(Response),
+	body$: z$10.string()
+}).transform((v) => {
+	return new GoneErrorResponse(v, {
+		request: v.request$,
+		response: v.response$,
+		body: v.body$
+	});
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/errors/internalservererrorresponse.js
+/**
+* Error response when an unexpected error occurs on the server. This indicates a problem with Unkey's systems rather than your request.
+*
+* @remarks
+*
+* When you encounter this error:
+* - The request ID in the response can help Unkey support investigate the issue
+* - The error is likely temporary and retrying may succeed
+* - If the error persists, contact Unkey support with the request ID
+*/
+var InternalServerErrorResponse = class extends UnkeyError {
+	constructor(err, httpMeta) {
+		const message = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
+		super(message, httpMeta);
+		this.data$ = err;
+		this.meta = err.meta;
+		this.error = err.error;
+		this.name = "InternalServerErrorResponse";
+	}
+};
+/** @internal */
+const InternalServerErrorResponse$inboundSchema = z$9.object({
+	meta: Meta$inboundSchema,
+	error: BaseError$inboundSchema,
+	request$: z$9.instanceof(Request),
+	response$: z$9.instanceof(Response),
+	body$: z$9.string()
+}).transform((v) => {
+	return new InternalServerErrorResponse(v, {
+		request: v.request$,
+		response: v.response$,
+		body: v.body$
+	});
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/errors/notfounderrorresponse.js
+/**
+* Error response when the requested resource cannot be found. This occurs when:
+*
+* @remarks
+* - The specified resource ID doesn't exist in your workspace
+* - The resource has been deleted or moved
+* - The resource exists but is not accessible with current permissions
+*
+* To resolve this error, verify the resource ID is correct and that you have access to it.
+*/
+var NotFoundErrorResponse = class extends UnkeyError {
+	constructor(err, httpMeta) {
+		const message = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
+		super(message, httpMeta);
+		this.data$ = err;
+		this.meta = err.meta;
+		this.error = err.error;
+		this.name = "NotFoundErrorResponse";
+	}
+};
+/** @internal */
+const NotFoundErrorResponse$inboundSchema = z$8.object({
+	meta: Meta$inboundSchema,
+	error: BaseError$inboundSchema,
+	request$: z$8.instanceof(Request),
+	response$: z$8.instanceof(Response),
+	body$: z$8.string()
+}).transform((v) => {
+	return new NotFoundErrorResponse(v, {
+		request: v.request$,
+		response: v.response$,
+		body: v.body$
+	});
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/errors/preconditionfailederrorresponse.js
+/**
+* Error response when one or more conditions specified in the request headers are not met. This typically occurs when:
+*
+* @remarks
+* - Using conditional requests with If-Match or If-None-Match headers
+* - The resource version doesn't match the expected value
+* - Optimistic concurrency control detects a conflict
+*
+* To resolve this error, fetch the latest version of the resource and retry with updated conditions.
+*/
+var PreconditionFailedErrorResponse = class extends UnkeyError {
+	constructor(err, httpMeta) {
+		const message = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
+		super(message, httpMeta);
+		this.data$ = err;
+		this.meta = err.meta;
+		this.error = err.error;
+		this.name = "PreconditionFailedErrorResponse";
+	}
+};
+/** @internal */
+const PreconditionFailedErrorResponse$inboundSchema = z$7.object({
+	meta: Meta$inboundSchema,
+	error: BaseError$inboundSchema,
+	request$: z$7.instanceof(Request),
+	response$: z$7.instanceof(Response),
+	body$: z$7.string()
+}).transform((v) => {
+	return new PreconditionFailedErrorResponse(v, {
+		request: v.request$,
+		response: v.response$,
+		body: v.body$
+	});
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/errors/serviceunavailableerrorresponse.js
+/**
+* Error response when a required service is temporarily unavailable. This indicates that the service exists but cannot be reached or is not responding.
+*
+* @remarks
+*
+* When you encounter this error:
+* - The service is likely experiencing temporary issues
+* - Retrying the request after a short delay may succeed
+* - If the error persists, the service may be undergoing maintenance
+* - Contact Unkey support if the issue continues
+*/
+var ServiceUnavailableErrorResponse = class extends UnkeyError {
+	constructor(err, httpMeta) {
+		const message = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
+		super(message, httpMeta);
+		this.data$ = err;
+		this.meta = err.meta;
+		this.error = err.error;
+		this.name = "ServiceUnavailableErrorResponse";
+	}
+};
+/** @internal */
+const ServiceUnavailableErrorResponse$inboundSchema = z$6.object({
+	meta: Meta$inboundSchema,
+	error: BaseError$inboundSchema,
+	request$: z$6.instanceof(Request),
+	response$: z$6.instanceof(Response),
+	body$: z$6.string()
+}).transform((v) => {
+	return new ServiceUnavailableErrorResponse(v, {
+		request: v.request$,
+		response: v.response$,
+		body: v.body$
+	});
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/errors/toomanyrequestserrorresponse.js
+/**
+* Error response when the client has sent too many requests in a given time period. This occurs when you've exceeded a rate limit or quota for the resource you're accessing.
+*
+* @remarks
+*
+* The rate limit resets automatically after the time window expires. To avoid this error:
+* - Implement exponential backoff when retrying requests
+* - Cache results where appropriate to reduce request frequency
+* - Check the error detail message for specific quota information
+* - Contact support if you need a higher quota for your use case
+*/
+var TooManyRequestsErrorResponse = class extends UnkeyError {
+	constructor(err, httpMeta) {
+		const message = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
+		super(message, httpMeta);
+		this.data$ = err;
+		this.meta = err.meta;
+		this.error = err.error;
+		this.name = "TooManyRequestsErrorResponse";
+	}
+};
+/** @internal */
+const TooManyRequestsErrorResponse$inboundSchema = z$5.object({
+	meta: Meta$inboundSchema,
+	error: BaseError$inboundSchema,
+	request$: z$5.instanceof(Request),
+	response$: z$5.instanceof(Response),
+	body$: z$5.string()
+}).transform((v) => {
+	return new TooManyRequestsErrorResponse(v, {
+		request: v.request$,
+		response: v.response$,
+		body: v.body$
+	});
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/errors/unauthorizederrorresponse.js
+/**
+* Error response when authentication has failed or credentials are missing. This occurs when:
+*
+* @remarks
+* - No authentication token is provided in the request
+* - The provided token is invalid, expired, or malformed
+* - The token format doesn't match expected patterns
+*
+* To resolve this error, ensure you're including a valid root key in the Authorization header.
+*/
+var UnauthorizedErrorResponse = class extends UnkeyError {
+	constructor(err, httpMeta) {
+		const message = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
+		super(message, httpMeta);
+		this.data$ = err;
+		this.meta = err.meta;
+		this.error = err.error;
+		this.name = "UnauthorizedErrorResponse";
+	}
+};
+/** @internal */
+const UnauthorizedErrorResponse$inboundSchema = z$4.object({
+	meta: Meta$inboundSchema,
+	error: BaseError$inboundSchema,
+	request$: z$4.instanceof(Request),
+	response$: z$4.instanceof(Response),
+	body$: z$4.string()
+}).transform((v) => {
+	return new UnauthorizedErrorResponse(v, {
+		request: v.request$,
+		response: v.response$,
+		body: v.body$
+	});
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/errors/unprocessableentityerrorresponse.js
+/**
+* Error response when the request is syntactically valid but cannot be processed due to semantic constraints or resource limitations. This occurs when:
+*
+* @remarks
+* - A query exceeds execution time limits
+* - A query uses more memory than allowed
+* - A query scans too many rows
+* - A query result exceeds size limits
+*
+* The request syntax is correct, but the operation cannot be completed due to business rules or resource constraints. Review the error details for specific limitations and adjust your request accordingly.
+*/
+var UnprocessableEntityErrorResponse = class extends UnkeyError {
+	constructor(err, httpMeta) {
+		const message = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
+		super(message, httpMeta);
+		this.data$ = err;
+		this.meta = err.meta;
+		this.error = err.error;
+		this.name = "UnprocessableEntityErrorResponse";
+	}
+};
+/** @internal */
+const UnprocessableEntityErrorResponse$inboundSchema = z$3.object({
+	meta: Meta$inboundSchema,
+	error: BaseError$inboundSchema,
+	request$: z$3.instanceof(Request),
+	response$: z$3.instanceof(Response),
+	body$: z$3.string()
+}).transform((v) => {
+	return new UnprocessableEntityErrorResponse(v, {
+		request: v.request$,
+		response: v.response$,
+		body: v.body$
+	});
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/types/async.js
+var __classPrivateFieldSet = void 0 && (void 0).__classPrivateFieldSet || function(receiver, state, value, kind, f) {
+	if (kind === "m") throw new TypeError("Private method is not writable");
+	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+	return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet = void 0 && (void 0).__classPrivateFieldGet || function(receiver, state, kind, f) {
+	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+	return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _APIPromise_promise, _APIPromise_unwrapped, _a;
+_APIPromise_promise = new WeakMap(), _APIPromise_unwrapped = new WeakMap(), _a = Symbol.toStringTag;
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/models/operations/identitieslistidentities.js
+/** @internal */
+const IdentitiesListIdentitiesResponse$inboundSchema = z$2.object({ Result: V2IdentitiesListIdentitiesResponseBody$inboundSchema }).transform((v) => {
+	return remap(v, { "Result": "result" });
+});
+
+//#endregion
+//#region ../../node_modules/.pnpm/@unkey+api@2.2.1/node_modules/@unkey/api/dist/esm/types/operations.js
+const URL_OVERRIDE = Symbol("URL_OVERRIDE");
+
+//#endregion
+//#region ../../node_modules/.pnpm/@asteasolutions+zod-to-openapi@8.4.0_zod@4.1.13/node_modules/@asteasolutions/zod-to-openapi/dist/index.cjs
+var require_dist = __commonJS({ "../../node_modules/.pnpm/@asteasolutions+zod-to-openapi@8.4.0_zod@4.1.13/node_modules/@asteasolutions/zod-to-openapi/dist/index.cjs"(exports) {
+	/******************************************************************************
+	
+	Copyright (c) Microsoft Corporation.
+	
+	
+	
+	Permission to use, copy, modify, and/or distribute this software for any
+	
+	purpose with or without fee is hereby granted.
+	
+	
+	
+	THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+	
+	REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+	
+	AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+	
+	INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+	
+	LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+	
+	OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+	
+	PERFORMANCE OF THIS SOFTWARE.
+	
+	***************************************************************************** */
+	function __rest(s, e) {
+		var t = {};
+		for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+		if (s != null && typeof Object.getOwnPropertySymbols === "function") {
+			for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+		}
+		return t;
+	}
+	const ZodTypeKeys = {
+		ZodAny: "any",
+		ZodArray: "array",
+		ZodBigInt: "bigint",
+		ZodBoolean: "boolean",
+		ZodDefault: "default",
+		ZodPrefault: "prefault",
+		ZodTransform: "transform",
+		ZodEnum: "enum",
+		ZodIntersection: "intersection",
+		ZodLazy: "lazy",
+		ZodLiteral: "literal",
+		ZodNever: "never",
+		ZodNull: "null",
+		ZodNullable: "nullable",
+		ZodNumber: "number",
+		ZodNonOptional: "nonoptional",
+		ZodObject: "object",
+		ZodOptional: "optional",
+		ZodPipe: "pipe",
+		ZodReadonly: "readonly",
+		ZodRecord: "record",
+		ZodString: "string",
+		ZodTuple: "tuple",
+		ZodType: "type",
+		ZodUnion: "union",
+		ZodDiscriminatedUnion: "union",
+		ZodUnknown: "unknown",
+		ZodVoid: "void",
+		ZodDate: "date",
+		ZodTemplateLiteral: "template_literal"
+	};
+	function isZodType(schema, typeNames) {
+		const typeNamesArray = Array.isArray(typeNames) ? typeNames : [typeNames];
+		return typeNamesArray.some((typeName) => {
+			var _a$1;
+			const typeNameMatch = ((_a$1 = schema === null || schema === void 0 ? void 0 : schema.def) === null || _a$1 === void 0 ? void 0 : _a$1.type) === ZodTypeKeys[typeName];
+			if (typeName === "ZodDiscriminatedUnion") return typeNameMatch && "discriminator" in schema.def;
+			return typeNameMatch;
+		});
+	}
+	function isAnyZodType(schema) {
+		return schema && "def" in schema;
+	}
+	/**
+	* The schema.isNullable() is deprecated. This is the suggested replacement
+	* as this was how isNullable operated beforehand.
+	*/
+	function isNullableSchema(schema) {
+		return schema.safeParse(null).success;
+	}
+	/**
+	* The schema.isOptional() is deprecated. This is the suggested replacement
+	* as this was how isOptional operated beforehand.
+	*/
+	function isOptionalSchema(schema) {
+		return schema.safeParse(void 0).success;
+	}
+	var $ZodRegistry = class {
+		constructor() {
+			this._map = new Map();
+			this._idmap = new Map();
+		}
+		add(schema, ..._meta) {
+			const meta = _meta[0];
+			this._map.set(schema, meta);
+			if (meta && typeof meta === "object" && "id" in meta) {
+				if (this._idmap.has(meta.id)) throw new Error(`ID ${meta.id} already exists in the registry`);
+				this._idmap.set(meta.id, schema);
+			}
+			return this;
+		}
+		clear() {
+			this._map = new Map();
+			this._idmap = new Map();
+			return this;
+		}
+		remove(schema) {
+			const meta = this._map.get(schema);
+			if (meta && typeof meta === "object" && "id" in meta) this._idmap.delete(meta.id);
+			this._map.delete(schema);
+			return this;
+		}
+		get(schema) {
+			const p = schema._zod.parent;
+			if (p) {
+				const pm = { ...this.get(p) ?? {} };
+				delete pm.id;
+				return {
+					...pm,
+					...this._map.get(schema)
+				};
+			}
+			return this._map.get(schema);
+		}
+		has(schema) {
+			return this._map.has(schema);
+		}
+	};
+	function registry() {
+		return new $ZodRegistry();
+	}
+	function isEqual(x, y) {
+		if (x === null || x === void 0 || y === null || y === void 0) return x === y;
+		if (x === y || x.valueOf() === y.valueOf()) return true;
+		if (Array.isArray(x)) {
+			if (!Array.isArray(y)) return false;
+			if (x.length !== y.length) return false;
+		}
+		if (!(x instanceof Object) || !(y instanceof Object)) return false;
+		const keysX = Object.keys(x);
+		return Object.keys(y).every((keyY) => keysX.indexOf(keyY) !== -1) && keysX.every((key) => isEqual(x[key], y[key]));
+	}
+	var ObjectSet = class {
+		constructor() {
+			this.buckets = new Map();
+		}
+		put(value) {
+			const hashCode = this.hashCodeOf(value);
+			const itemsByCode = this.buckets.get(hashCode);
+			if (!itemsByCode) {
+				this.buckets.set(hashCode, [value]);
+				return;
+			}
+			const alreadyHasItem = itemsByCode.some((_) => isEqual(_, value));
+			if (!alreadyHasItem) itemsByCode.push(value);
+		}
+		contains(value) {
+			const hashCode = this.hashCodeOf(value);
+			const itemsByCode = this.buckets.get(hashCode);
+			if (!itemsByCode) return false;
+			return itemsByCode.some((_) => isEqual(_, value));
+		}
+		values() {
+			return [...this.buckets.values()].flat();
+		}
+		stats() {
+			let totalBuckets = 0;
+			let totalValues = 0;
+			let collisions = 0;
+			for (const bucket of this.buckets.values()) {
+				totalBuckets += 1;
+				totalValues += bucket.length;
+				if (bucket.length > 1) collisions += 1;
+			}
+			const hashEffectiveness = totalBuckets / totalValues;
+			return {
+				totalBuckets,
+				collisions,
+				totalValues,
+				hashEffectiveness
+			};
+		}
+		hashCodeOf(object) {
+			let hashCode = 0;
+			if (Array.isArray(object)) {
+				for (let i = 0; i < object.length; i++) hashCode ^= this.hashCodeOf(object[i]) * i;
+				return hashCode;
+			}
+			if (typeof object === "string") {
+				for (let i = 0; i < object.length; i++) hashCode ^= object.charCodeAt(i) * i;
+				return hashCode;
+			}
+			if (typeof object === "number") return object;
+			if (typeof object === "object") for (const [key, value] of Object.entries(object)) hashCode ^= this.hashCodeOf(key) + this.hashCodeOf(value !== null && value !== void 0 ? value : "");
+			return hashCode;
+		}
+	};
+	function isUndefined(value) {
+		return value === void 0;
+	}
+	function mapValues(object, mapper) {
+		const result = {};
+		Object.entries(object).forEach(([key, value]) => {
+			result[key] = mapper(value);
+		});
+		return result;
+	}
+	function omit(object, keys) {
+		const result = {};
+		Object.entries(object).forEach(([key, value]) => {
+			if (!keys.some((keyToOmit) => keyToOmit === key)) result[key] = value;
+		});
+		return result;
+	}
+	function omitBy(object, predicate) {
+		const result = {};
+		Object.entries(object).forEach(([key, value]) => {
+			if (!predicate(value, key)) result[key] = value;
+		});
+		return result;
+	}
+	function compact(arr) {
+		return arr.filter((elem) => !isUndefined(elem));
+	}
+	const objectEquals = isEqual;
+	function uniq(values) {
+		const set = new ObjectSet();
+		values.forEach((value) => set.put(value));
+		return [...set.values()];
+	}
+	function isString(val) {
+		return typeof val === "string";
+	}
+	function sortObjectByKeys(obj) {
+		return Object.fromEntries(Object.entries(obj).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)));
+	}
+	/**
+	* @deprecated This is not really deprecated but this should always be used with
+	* caution. Using it may alter the behavior of the library and the generated schemas.
+	*/
+	const zodToOpenAPIRegistry = registry();
+	var Metadata = class {
+		static collectMetadata(schema, metadata) {
+			const currentMetadata = this.getMetadataFromRegistry(schema);
+			const _internal = Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata._internal), metadata === null || metadata === void 0 ? void 0 : metadata._internal);
+			const param = Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param), metadata === null || metadata === void 0 ? void 0 : metadata.param);
+			const totalMetadata = Object.assign(Object.assign(Object.assign(Object.assign({}, Object.keys(_internal).length > 0 ? { _internal } : {}), currentMetadata), metadata), Object.keys(param).length > 0 ? { param } : {});
+			if (isZodType(schema, [
+				"ZodOptional",
+				"ZodNullable",
+				"ZodDefault",
+				"ZodPrefault",
+				"ZodReadonly",
+				"ZodNonOptional"
+			]) && isAnyZodType(schema._zod.def.innerType)) return this.collectMetadata(schema._zod.def.innerType, totalMetadata);
+			if (isZodType(schema, "ZodPipe")) {
+				const inSchema = schema._zod.def.in;
+				const outSchema = schema._zod.def.out;
+				if (isZodType(inSchema, "ZodTransform") && isAnyZodType(outSchema)) return this.collectMetadata(outSchema, totalMetadata);
+				if (isAnyZodType(inSchema)) return this.collectMetadata(inSchema, totalMetadata);
+			}
+			return totalMetadata;
+		}
+		/**
+		* @deprecated Use one of `getOpenApiMetadata` or `getInternalMetadata` instead
+		*/
+		static getMetadata(zodSchema) {
+			return this.collectMetadata(zodSchema);
+		}
+		static getOpenApiMetadata(zodSchema) {
+			const metadata = this.collectMetadata(zodSchema);
+			const _a$1 = metadata !== null && metadata !== void 0 ? metadata : {}, rest = __rest(_a$1, ["_internal"]);
+			return rest;
+		}
+		static getInternalMetadata(zodSchema) {
+			var _a$1;
+			return (_a$1 = this.collectMetadata(zodSchema)) === null || _a$1 === void 0 ? void 0 : _a$1._internal;
+		}
+		static getParamMetadata(zodSchema) {
+			const metadata = this.collectMetadata(zodSchema);
+			return Object.assign(Object.assign({}, metadata), { param: Object.assign(Object.assign({}, (metadata === null || metadata === void 0 ? void 0 : metadata.description) ? { description: metadata.description } : {}), metadata === null || metadata === void 0 ? void 0 : metadata.param) });
+		}
+		/**
+		* A method that omits all custom keys added to the regular OpenAPI
+		* metadata properties
+		*/
+		static buildSchemaMetadata(metadata) {
+			return omitBy(omit(metadata, ["param", "_internal"]), isUndefined);
+		}
+		static buildParameterMetadata(metadata) {
+			return omitBy(metadata, isUndefined);
+		}
+		static applySchemaMetadata(initialData, metadata) {
+			return omitBy(Object.assign(Object.assign({}, initialData), this.buildSchemaMetadata(metadata)), isUndefined);
+		}
+		static getRefId(zodSchema) {
+			var _a$1;
+			return (_a$1 = this.getInternalMetadata(zodSchema)) === null || _a$1 === void 0 ? void 0 : _a$1.refId;
+		}
+		static unwrapChained(schema) {
+			return this.unwrapUntil(schema);
+		}
+		static getDefaultValue(zodSchema) {
+			var _a$1;
+			const unwrapped = (_a$1 = this.unwrapUntil(zodSchema, "ZodDefault")) !== null && _a$1 !== void 0 ? _a$1 : this.unwrapUntil(zodSchema, "ZodPrefault");
+			return unwrapped === null || unwrapped === void 0 ? void 0 : unwrapped._zod.def.defaultValue;
+		}
+		static unwrapUntil(schema, typeName) {
+			if (typeName && isZodType(schema, typeName)) return schema;
+			if (isZodType(schema, [
+				"ZodOptional",
+				"ZodNullable",
+				"ZodDefault",
+				"ZodPrefault",
+				"ZodReadonly",
+				"ZodNonOptional"
+			]) && isAnyZodType(schema._zod.def.innerType)) return this.unwrapUntil(schema._zod.def.innerType, typeName);
+			if (isZodType(schema, "ZodPipe")) {
+				const inSchema = schema._zod.def.in;
+				const outSchema = schema._zod.def.out;
+				if (isZodType(inSchema, "ZodTransform") && isAnyZodType(outSchema)) return this.unwrapUntil(outSchema, typeName);
+				if (isAnyZodType(inSchema)) return this.unwrapUntil(inSchema, typeName);
+			}
+			return typeName ? void 0 : schema;
+		}
+		static getMetadataFromInternalRegistry(zodSchema) {
+			return zodToOpenAPIRegistry.get(zodSchema);
+		}
+		static getMetadataFromRegistry(zodSchema) {
+			const internal = this.getMetadataFromInternalRegistry(zodSchema);
+			const general = zodSchema.meta();
+			if (!internal) return general;
+			const { _internal } = internal, rest = __rest(internal, ["_internal"]);
+			const _a$1 = general !== null && general !== void 0 ? general : {}, { id, title } = _a$1, restGeneral = __rest(_a$1, ["id", "title"]);
+			return Object.assign(Object.assign(Object.assign({ _internal: Object.assign(Object.assign({}, id ? { refId: id } : {}), _internal) }, rest), title ? { description: title } : {}), restGeneral);
+		}
+		static setMetadataInRegistry(zodSchema, metadata) {
+			zodToOpenAPIRegistry.add(zodSchema, metadata);
+		}
+	};
+	function preserveMetadataFromModifier(zodSchema, modifier) {
+		const zodModifier = zodSchema[modifier];
+		if (typeof zodModifier !== "function") return;
+		zodSchema[modifier] = function(...args) {
+			const result = zodModifier.apply(this, args);
+			const meta = Metadata.getMetadataFromRegistry(this);
+			if (meta) Metadata.setMetadataInRegistry(result, meta);
+			return result;
+		};
+	}
+	function extendZodWithOpenApi(zod) {
+		if (typeof zod.ZodType.prototype.openapi !== "undefined") return;
+		zod.ZodType.prototype.openapi = function(...args) {
+			const { refId, metadata, options } = getOpenApiConfiguration(...args);
+			const _a$1 = metadata !== null && metadata !== void 0 ? metadata : {}, { param } = _a$1, restOfOpenApi = __rest(_a$1, ["param"]);
+			const allMetadata = Metadata.getMetadataFromRegistry(this);
+			const _b = allMetadata !== null && allMetadata !== void 0 ? allMetadata : {}, { _internal: internalMetadata } = _b, currentMetadata = __rest(_b, ["_internal"]);
+			const _internal = Object.assign(Object.assign(Object.assign({}, internalMetadata), options), refId ? { refId } : void 0);
+			const resultMetadata = Object.assign(Object.assign(Object.assign({}, currentMetadata), restOfOpenApi), (currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param) || param ? { param: Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param), param) } : void 0);
+			const result = new this.constructor(this._def);
+			function setMetadata(schema) {
+				Metadata.setMetadataInRegistry(schema, Object.assign(Object.assign({}, Object.keys(_internal).length > 0 ? { _internal } : void 0), resultMetadata));
+			}
+			setMetadata(result);
+			/**
+			* In order to handle z.json() which is implemented as:
+			*
+			* const jsonSchema = lazy(() => { return union([ ... ]) });
+			* return jsonSchema;
+			*
+			* We need to not only set the metadata to the resulting schema (which would be different
+			* from `jsonSchema`), but also to the original lazy schema so that the _internal metadata (refId)
+			* is also present in the internally used `jsonSchema`.
+			*/
+			if (isZodType(result, "ZodLazy")) setMetadata(this);
+			if (isZodType(result, "ZodObject")) {
+				const currentMetadata$1 = Metadata.getMetadataFromRegistry(result);
+				const originalExtend = result.extend;
+				result.extend = function(...args$1) {
+					const extendedResult = originalExtend.apply(result, args$1);
+					const _a$2 = currentMetadata$1 !== null && currentMetadata$1 !== void 0 ? currentMetadata$1 : {}, { _internal: _internal$1 } = _a$2, rest = __rest(_a$2, ["_internal"]);
+					Metadata.setMetadataInRegistry(extendedResult, { _internal: { extendedFrom: (_internal$1 === null || _internal$1 === void 0 ? void 0 : _internal$1.refId) ? {
+						refId: _internal$1.refId,
+						schema: result
+					} : _internal$1 === null || _internal$1 === void 0 ? void 0 : _internal$1.extendedFrom } });
+					return extendedResult.openapi(rest);
+				};
+				preserveMetadataFromModifier(result, "catchall");
+			}
+			preserveMetadataFromModifier(result, "optional");
+			preserveMetadataFromModifier(result, "nullable");
+			preserveMetadataFromModifier(result, "default");
+			preserveMetadataFromModifier(result, "transform");
+			preserveMetadataFromModifier(result, "refine");
+			preserveMetadataFromModifier(result, "length");
+			preserveMetadataFromModifier(result, "min");
+			preserveMetadataFromModifier(result, "max");
+			const originalMeta = result.meta;
+			result.meta = function(...args$1) {
+				const result$1 = originalMeta.apply(this, args$1);
+				if (args$1[0]) {
+					const meta = Metadata.getMetadataFromInternalRegistry(this);
+					if (meta) Metadata.setMetadataInRegistry(result$1, Object.assign(Object.assign({}, meta), args$1[0]));
+				}
+				return result$1;
+			};
+			return result;
+		};
+	}
+	function getOpenApiConfiguration(refOrOpenapi, metadataOrOptions, options) {
+		if (typeof refOrOpenapi === "string") return {
+			refId: refOrOpenapi,
+			metadata: metadataOrOptions,
+			options
+		};
+		return {
+			refId: void 0,
+			metadata: refOrOpenapi,
+			options: metadataOrOptions
+		};
+	}
+	function getOpenApiMetadata(zodSchema) {
+		var _a$1;
+		return omitBy((_a$1 = Metadata.getOpenApiMetadata(zodSchema)) !== null && _a$1 !== void 0 ? _a$1 : {}, isUndefined);
+	}
+	function getRefId(zodSchema) {
+		return Metadata.getRefId(zodSchema);
+	}
+	var OpenAPIRegistry = class {
+		constructor(parents) {
+			this.parents = parents;
+			this._definitions = [];
+		}
+		get definitions() {
+			var _a$1, _b;
+			const parentDefinitions = (_b = (_a$1 = this.parents) === null || _a$1 === void 0 ? void 0 : _a$1.flatMap((par) => par._definitions)) !== null && _b !== void 0 ? _b : [];
+			return [...parentDefinitions, ...this._definitions];
+		}
+		/**
+		* Registers a new component schema under /components/schemas/${name}
+		*/
+		register(refId, zodSchema) {
+			const schemaWithRefId = this.schemaWithRefId(refId, zodSchema);
+			this._definitions.push({
+				type: "schema",
+				schema: schemaWithRefId
+			});
+			return schemaWithRefId;
+		}
+		/**
+		* Registers a new parameter schema under /components/parameters/${name}
+		*/
+		registerParameter(refId, zodSchema) {
+			var _a$1, _b, _c;
+			const schemaWithRefId = this.schemaWithRefId(refId, zodSchema);
+			const currentMetadata = (_a$1 = Metadata.getOpenApiMetadata(schemaWithRefId)) !== null && _a$1 !== void 0 ? _a$1 : {};
+			const schemaWithMetadata = schemaWithRefId.openapi(Object.assign(Object.assign({}, currentMetadata), { param: Object.assign(Object.assign({}, currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param), { name: (_c = (_b = currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.param) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : refId }) }));
+			this._definitions.push({
+				type: "parameter",
+				schema: schemaWithMetadata
+			});
+			return schemaWithMetadata;
+		}
+		/**
+		* Registers a new path that would be generated under paths:
+		*/
+		registerPath(route) {
+			this._definitions.push({
+				type: "route",
+				route
+			});
+		}
+		/**
+		* Registers a new webhook that would be generated under webhooks:
+		*/
+		registerWebhook(webhook) {
+			this._definitions.push({
+				type: "webhook",
+				webhook
+			});
+		}
+		/**
+		* Registers a raw OpenAPI component. Use this if you have a simple object instead of a Zod schema.
+		*
+		* @param type The component type, e.g. `schemas`, `responses`, `securitySchemes`, etc.
+		* @param name The name of the object, it is the key under the component
+		*             type in the resulting OpenAPI document
+		* @param component The actual object to put there
+		*/
+		registerComponent(type, name, component) {
+			this._definitions.push({
+				type: "component",
+				componentType: type,
+				name,
+				component
+			});
+			return {
+				name,
+				ref: { $ref: `#/components/${type}/${name}` }
+			};
+		}
+		schemaWithRefId(refId, zodSchema) {
+			return zodSchema.openapi(refId);
+		}
+	};
+	var ZodToOpenAPIError = class {
+		constructor(message) {
+			this.message = message;
+		}
+	};
+	var ConflictError = class extends ZodToOpenAPIError {
+		constructor(message, data) {
+			super(message);
+			this.data = data;
+		}
+	};
+	var MissingParameterDataError = class extends ZodToOpenAPIError {
+		constructor(data) {
+			super(`Missing parameter data, please specify \`${data.missingField}\` and other OpenAPI parameter props using the \`param\` field of \`schema.openapi\``);
+			this.data = data;
+		}
+	};
+	function enhanceMissingParametersError(action, paramsToAdd) {
+		try {
+			return action();
+		} catch (error) {
+			if (error instanceof MissingParameterDataError) throw new MissingParameterDataError(Object.assign(Object.assign({}, error.data), paramsToAdd));
+			throw error;
+		}
+	}
+	var UnknownZodTypeError = class extends ZodToOpenAPIError {
+		constructor(data) {
+			super(`Unknown zod object type, please specify \`type\` and other OpenAPI props using \`schema.openapi\`.`);
+			this.data = data;
+		}
+	};
+	var ArrayTransformer = class {
+		transform(zodSchema, mapNullableType, mapItems) {
+			var _a$1, _b, _c, _d;
+			const itemType = zodSchema.def.element;
+			const minItems = (_b = (_a$1 = zodSchema.def.checks) === null || _a$1 === void 0 ? void 0 : _a$1.find((check) => check._zod.def.check === "min_length")) === null || _b === void 0 ? void 0 : _b._zod.def.minimum;
+			const maxItems = (_d = (_c = zodSchema.def.checks) === null || _c === void 0 ? void 0 : _c.find((check) => check._zod.def.check === "max_length")) === null || _d === void 0 ? void 0 : _d._zod.def.maximum;
+			return Object.assign(Object.assign({}, mapNullableType("array")), {
+				items: isAnyZodType(itemType) ? mapItems(itemType) : {},
+				minItems,
+				maxItems
+			});
+		}
+	};
+	var BigIntTransformer = class {
+		transform(mapNullableType) {
+			return Object.assign(Object.assign({}, mapNullableType("string")), { pattern: `^\d+$` });
+		}
+	};
+	var DiscriminatedUnionTransformer = class {
+		transform(zodSchema, isNullable, mapNullableOfArray, mapItem, generateSchemaRef) {
+			const options = [...zodSchema.def.options];
+			const optionSchema = options.map(mapItem);
+			if (isNullable) return { oneOf: mapNullableOfArray(optionSchema, isNullable) };
+			const discriminator = zodSchema._zod.def.discriminator;
+			if (!discriminator) {
+				console.error("No discriminator found for discriminated union", zodSchema);
+				return { oneOf: optionSchema };
+			}
+			return {
+				oneOf: optionSchema,
+				discriminator: this.mapDiscriminator(options, discriminator, generateSchemaRef)
+			};
+		}
+		mapDiscriminator(zodObjects, discriminator, generateSchemaRef) {
+			if (zodObjects.some((obj) => Metadata.getRefId(obj) === void 0)) return void 0;
+			const mapping = {};
+			zodObjects.forEach((obj) => {
+				var _a$1;
+				const refId = Metadata.getRefId(obj);
+				const value = (_a$1 = obj.def.shape) === null || _a$1 === void 0 ? void 0 : _a$1[discriminator];
+				if (isZodType(value, "ZodEnum")) {
+					const keys = Object.values(value._zod.def.entries).filter(isString);
+					keys.forEach((enumValue) => {
+						mapping[enumValue] = generateSchemaRef(refId);
+					});
+					return;
+				}
+				const literalValue = value === null || value === void 0 ? void 0 : value.def.values[0];
+				if (typeof literalValue !== "string") throw new Error(`Discriminator ${discriminator} could not be found in one of the values of a discriminated union`);
+				mapping[literalValue] = generateSchemaRef(refId);
+			});
+			return {
+				propertyName: discriminator,
+				mapping
+			};
+		}
+	};
+	/**
+	* Numeric enums have a reverse mapping https://www.typescriptlang.org/docs/handbook/enums.html#reverse-mappings
+	* whereas string ones don't.
+	*
+	* This function checks if an enum is fully numeric - i.e all values are numbers or not.
+	* And filters out only the actual enum values when a reverse mapping is apparent.
+	*/
+	function enumInfo(enumObject) {
+		const keysExceptReverseMappings = Object.keys(enumObject).filter((key) => typeof enumObject[enumObject[key]] !== "number");
+		const values = keysExceptReverseMappings.map((key) => enumObject[key]);
+		const numericCount = values.filter((_) => typeof _ === "number").length;
+		const type = numericCount === 0 ? "string" : numericCount === values.length ? "numeric" : "mixed";
+		return {
+			values,
+			type
+		};
+	}
+	var EnumTransformer = class {
+		transform(zodSchema, isNullable, mapNullableType) {
+			const { type, values } = enumInfo(zodSchema._zod.def.entries);
+			if (type === "mixed") throw new ZodToOpenAPIError("Enum has mixed string and number values, please specify the OpenAPI type manually");
+			return Object.assign(Object.assign({}, mapNullableType(type === "numeric" ? "integer" : "string")), { enum: isNullable ? [...values, null] : values });
+		}
+	};
+	var IntersectionTransformer = class {
+		transform(zodSchema, isNullable, mapNullableOfArray, mapItem) {
+			const subtypes = this.flattenIntersectionTypes(zodSchema);
+			const allOfSchema = { allOf: subtypes.map(mapItem) };
+			if (isNullable) return { anyOf: mapNullableOfArray([allOfSchema], isNullable) };
+			return allOfSchema;
+		}
+		flattenIntersectionTypes(schema) {
+			if (!isZodType(schema, "ZodIntersection")) return [schema];
+			const leftSubTypes = isAnyZodType(schema._zod.def.left) ? this.flattenIntersectionTypes(schema._zod.def.left) : [];
+			const rightSubTypes = isAnyZodType(schema._zod.def.right) ? this.flattenIntersectionTypes(schema._zod.def.right) : [];
+			return [...leftSubTypes, ...rightSubTypes];
+		}
+	};
+	var LiteralTransformer = class {
+		constructor() {
+			this.bigIntTransformer = new BigIntTransformer();
+		}
+		transform(zodSchema, mapNullableType) {
+			const type = typeof zodSchema.def.values[0];
+			if (type === "boolean" || type === "number" || type === "string" || type === "object") return Object.assign(Object.assign({}, mapNullableType(type)), { enum: [zodSchema.def.values[0]] });
+			if (type === "bigint") return this.bigIntTransformer.transform(mapNullableType);
+			return mapNullableType("null");
+		}
+	};
+	var NumberTransformer = class {
+		transform(zodSchema, mapNullableType, getNumberChecks) {
+			var _a$1;
+			return Object.assign(Object.assign(Object.assign({}, mapNullableType("number")), mapNullableType(zodSchema.format === "safeint" ? "integer" : "number")), getNumberChecks((_a$1 = zodSchema.def.checks) !== null && _a$1 !== void 0 ? _a$1 : []));
+		}
+	};
+	var ObjectTransformer = class {
+		transform(zodSchema, defaultValue, mapNullableType, mapItem) {
+			var _a$1;
+			const extendedFrom = (_a$1 = Metadata.getInternalMetadata(zodSchema)) === null || _a$1 === void 0 ? void 0 : _a$1.extendedFrom;
+			const required = this.requiredKeysOf(zodSchema);
+			const properties = mapValues(zodSchema.def.shape, mapItem);
+			if (!extendedFrom) return Object.assign(Object.assign(Object.assign(Object.assign({}, mapNullableType("object")), {
+				properties,
+				default: defaultValue
+			}), required.length > 0 ? { required } : {}), this.generateAdditionalProperties(zodSchema, mapItem));
+			const parent = extendedFrom.schema;
+			mapItem(parent);
+			const keysRequiredByParent = this.requiredKeysOf(parent);
+			const propsOfParent = mapValues(parent === null || parent === void 0 ? void 0 : parent.def.shape, mapItem);
+			const propertiesToAdd = Object.fromEntries(Object.entries(properties).filter(([key, type]) => {
+				return !objectEquals(propsOfParent[key], type);
+			}));
+			const additionallyRequired = required.filter((prop) => !keysRequiredByParent.includes(prop));
+			const objectData = Object.assign(Object.assign(Object.assign(Object.assign({}, mapNullableType("object")), {
+				default: defaultValue,
+				properties: propertiesToAdd
+			}), additionallyRequired.length > 0 ? { required: additionallyRequired } : {}), this.generateAdditionalProperties(zodSchema, mapItem));
+			return { allOf: [{ $ref: `#/components/schemas/${extendedFrom.refId}` }, objectData] };
+		}
+		generateAdditionalProperties(zodSchema, mapItem) {
+			const catchallSchema = zodSchema.def.catchall;
+			if (!catchallSchema) return {};
+			if (isZodType(catchallSchema, "ZodNever")) return { additionalProperties: false };
+			if (isAnyZodType(catchallSchema)) return { additionalProperties: mapItem(catchallSchema) };
+			return {};
+		}
+		requiredKeysOf(objectSchema) {
+			return Object.entries(objectSchema.def.shape).filter(([_key, type]) => !isOptionalSchema(type)).map(([key, _type]) => key);
+		}
+	};
+	var RecordTransformer = class {
+		transform(zodSchema, mapNullableType, mapItem) {
+			const propertiesType = zodSchema.valueType;
+			const keyType = zodSchema.keyType;
+			const propertiesSchema = isAnyZodType(propertiesType) ? mapItem(propertiesType) : {};
+			if (isZodType(keyType, "ZodEnum")) {
+				const keys = Object.values(keyType._zod.def.entries).filter(isString);
+				const properties = keys.reduce((acc, curr) => Object.assign(Object.assign({}, acc), { [curr]: propertiesSchema }), {});
+				return Object.assign(Object.assign({}, mapNullableType("object")), { properties });
+			}
+			return Object.assign(Object.assign({}, mapNullableType("object")), { additionalProperties: propertiesSchema });
+		}
+	};
+	function isZodCheckLengthEquals(check) {
+		return check._zod.def.check === "length_equals";
+	}
+	function isZodCheckRegex(check) {
+		return check._zod.def.check === "string_format" && check._zod.def.format === "regex";
+	}
+	var StringTransformer = class {
+		transform(zodSchema, mapNullableType) {
+			var _a$1, _b, _c, _d;
+			const regexCheck = (_a$1 = zodSchema.def.checks) === null || _a$1 === void 0 ? void 0 : _a$1.find(isZodCheckRegex);
+			const pattern = regexCheck === null || regexCheck === void 0 ? void 0 : regexCheck._zod.def.pattern.toString().replace(/^\/|\/$/g, "");
+			const check = (_b = zodSchema.def.checks) === null || _b === void 0 ? void 0 : _b.find(isZodCheckLengthEquals);
+			const length = check === null || check === void 0 ? void 0 : check._zod.def.length;
+			const maxLength = Number.isFinite(zodSchema.minLength) ? (_c = zodSchema.minLength) !== null && _c !== void 0 ? _c : void 0 : void 0;
+			const minLength = Number.isFinite(zodSchema.maxLength) ? (_d = zodSchema.maxLength) !== null && _d !== void 0 ? _d : void 0 : void 0;
+			return Object.assign(Object.assign({}, mapNullableType("string")), {
+				minLength: length !== null && length !== void 0 ? length : maxLength,
+				maxLength: length !== null && length !== void 0 ? length : minLength,
+				format: this.mapStringFormat(zodSchema),
+				pattern
+			});
+		}
+		/**
+		* Attempts to map Zod strings to known formats
+		* https://json-schema.org/understanding-json-schema/reference/string.html#built-in-formats
+		*/
+		mapStringFormat(zodString) {
+			if (zodString.format === "uuid") return "uuid";
+			if (zodString.format === "email") return "email";
+			if (zodString.format === "url") return "uri";
+			if (zodString.format === "date") return "date";
+			if (zodString.format === "datetime") return "date-time";
+			if (zodString.format === "cuid") return "cuid";
+			if (zodString.format === "cuid2") return "cuid2";
+			if (zodString.format === "ulid") return "ulid";
+			if (zodString.format === "ipv4") return "ip";
+			if (zodString.format === "ipv6") return "ip";
+			if (zodString.format === "emoji") return "emoji";
+			return void 0;
+		}
+	};
+	var TupleTransformer = class {
+		constructor(versionSpecifics) {
+			this.versionSpecifics = versionSpecifics;
+		}
+		transform(zodSchema, mapNullableType, mapItem) {
+			const items = zodSchema._zod.def.items;
+			const schemas = items.map((item) => isAnyZodType(item) ? mapItem(item) : {});
+			return Object.assign(Object.assign({}, mapNullableType("array")), this.versionSpecifics.mapTupleItems(schemas));
+		}
+	};
+	var UnionTransformer = class {
+		constructor(options) {
+			this.options = options;
+		}
+		transform(zodSchema, mapNullableOfArray, mapItem) {
+			var _a$1, _b, _c;
+			const internalMetadata = Metadata.getInternalMetadata(zodSchema);
+			const preferredType = (_c = (_a$1 = internalMetadata === null || internalMetadata === void 0 ? void 0 : internalMetadata.unionPreferredType) !== null && _a$1 !== void 0 ? _a$1 : (_b = this.options) === null || _b === void 0 ? void 0 : _b.unionPreferredType) !== null && _c !== void 0 ? _c : "anyOf";
+			const options = this.flattenUnionTypes(zodSchema);
+			const schemas = options.map((schema) => {
+				const optionToGenerate = this.unwrapNullable(schema);
+				return mapItem(optionToGenerate);
+			});
+			return { [preferredType]: mapNullableOfArray(schemas) };
+		}
+		flattenUnionTypes(schema) {
+			if (!isZodType(schema, "ZodUnion")) return [schema];
+			const options = schema.def.options;
+			return options.flatMap((option) => isAnyZodType(option) ? this.flattenUnionTypes(option) : []);
+		}
+		unwrapNullable(schema) {
+			if (isZodType(schema, "ZodNullable")) {
+				const unwrapped = schema.unwrap();
+				if (isAnyZodType(unwrapped)) return this.unwrapNullable(unwrapped);
+			}
+			return schema;
+		}
+	};
+	var DateTransformer = class {
+		transform(mapNullableType) {
+			return Object.assign(Object.assign({}, mapNullableType("string")), { format: "date-time" });
+		}
+	};
+	var LazyTransformer = class LazyTransformer {
+		transform(zodSchema, mapItem, mapNullableType, mapNullableRef) {
+			const result = mapItem(zodSchema._zod.def.getter());
+			return LazyTransformer.mapRecursive(result, mapNullableType, mapNullableRef);
+		}
+		static mapRecursive(schema, mapNullableType, mapNullableRef) {
+			if ("$ref" in schema) return mapNullableRef(schema);
+			if (schema.type) return Object.assign(Object.assign({}, schema), mapNullableType(schema.type));
+			return schema;
+		}
+	};
+	var TemplateLiteralTransformer = class {
+		transform(zodSchema, mapNullableType) {
+			const parts = zodSchema.def.parts;
+			const contentPattern = parts.map((part) => this.generatePattern(part)).join("");
+			return Object.assign(Object.assign({}, mapNullableType("string")), { pattern: `^${contentPattern}$` });
+		}
+		generatePattern(part) {
+			if (typeof part === "string" || typeof part === "number" || typeof part === "boolean" || typeof part === "bigint" || part === null || part === void 0) return this.escapeRegex(String(part));
+			if (isZodType(part, "ZodLiteral")) {
+				const value = part.def.values[0];
+				return this.escapeRegex(String(value));
+			}
+			if (isZodType(part, "ZodNumber")) return "[+-]?\\d+(\\.\\d+)?";
+			if (isZodType(part, "ZodBoolean")) return "(true|false)";
+			if (isZodType(part, "ZodEnum")) {
+				const { values } = enumInfo(part.def.entries);
+				return `(${values.map((v) => this.escapeRegex(String(v))).join("|")})`;
+			}
+			return ".*";
+		}
+		escapeRegex(str) {
+			return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		}
+	};
+	var OpenApiTransformer = class {
+		constructor(versionSpecifics, options) {
+			this.versionSpecifics = versionSpecifics;
+			this.objectTransformer = new ObjectTransformer();
+			this.stringTransformer = new StringTransformer();
+			this.numberTransformer = new NumberTransformer();
+			this.bigIntTransformer = new BigIntTransformer();
+			this.dateTransformer = new DateTransformer();
+			this.lazyTransformer = new LazyTransformer();
+			this.literalTransformer = new LiteralTransformer();
+			this.templateLiteralTransformer = new TemplateLiteralTransformer();
+			this.enumTransformer = new EnumTransformer();
+			this.arrayTransformer = new ArrayTransformer();
+			this.discriminatedUnionTransformer = new DiscriminatedUnionTransformer();
+			this.intersectionTransformer = new IntersectionTransformer();
+			this.recordTransformer = new RecordTransformer();
+			this.tupleTransformer = new TupleTransformer(versionSpecifics);
+			this.unionTransformer = new UnionTransformer(options);
+		}
+		transform(zodSchema, isNullable, mapItem, generateSchemaRef, defaultValue) {
+			if (isZodType(zodSchema, "ZodNull")) return this.versionSpecifics.nullType;
+			if (isZodType(zodSchema, "ZodUnknown") || isZodType(zodSchema, "ZodAny")) return this.versionSpecifics.mapNullableType(void 0, isNullable);
+			if (isZodType(zodSchema, "ZodObject")) return this.objectTransformer.transform(
+				zodSchema,
+				defaultValue,
+				// verified on TS level from input
+				(_) => this.versionSpecifics.mapNullableType(_, isNullable),
+				mapItem
+);
+			const schema = this.transformSchemaWithoutDefault(zodSchema, isNullable, mapItem, generateSchemaRef);
+			return Object.assign(Object.assign({}, schema), { default: defaultValue });
+		}
+		transformSchemaWithoutDefault(zodSchema, isNullable, mapItem, generateSchemaRef) {
+			if (isZodType(zodSchema, "ZodUnknown") || isZodType(zodSchema, "ZodAny")) return this.versionSpecifics.mapNullableType(void 0, isNullable);
+			if (isZodType(zodSchema, "ZodString")) return this.stringTransformer.transform(zodSchema, (schema) => this.versionSpecifics.mapNullableType(schema, isNullable));
+			if (isZodType(zodSchema, "ZodNumber")) return this.numberTransformer.transform(zodSchema, (schema) => this.versionSpecifics.mapNullableType(schema, isNullable), (_) => this.versionSpecifics.getNumberChecks(_));
+			if (isZodType(zodSchema, "ZodBigInt")) return this.bigIntTransformer.transform((schema) => this.versionSpecifics.mapNullableType(schema, isNullable));
+			if (isZodType(zodSchema, "ZodBoolean")) return this.versionSpecifics.mapNullableType("boolean", isNullable);
+			if (isZodType(zodSchema, "ZodLazy")) return this.lazyTransformer.transform(zodSchema, mapItem, (schema) => this.versionSpecifics.mapNullableType(schema, isNullable), (schema) => this.versionSpecifics.mapNullableOfRef(schema, isNullable));
+			if (isZodType(zodSchema, "ZodLiteral")) return this.literalTransformer.transform(zodSchema, (schema) => this.versionSpecifics.mapNullableType(schema, isNullable));
+			if (isZodType(zodSchema, "ZodTemplateLiteral")) return this.templateLiteralTransformer.transform(zodSchema, (schema) => this.versionSpecifics.mapNullableType(schema, isNullable));
+			if (isZodType(zodSchema, "ZodEnum")) return this.enumTransformer.transform(zodSchema, isNullable, (schema) => this.versionSpecifics.mapNullableType(schema, isNullable));
+			if (isZodType(zodSchema, "ZodArray")) return this.arrayTransformer.transform(zodSchema, (_) => this.versionSpecifics.mapNullableType(_, isNullable), mapItem);
+			if (isZodType(zodSchema, "ZodTuple")) return this.tupleTransformer.transform(zodSchema, (_) => this.versionSpecifics.mapNullableType(_, isNullable), mapItem);
+			if (isZodType(zodSchema, "ZodDiscriminatedUnion")) return this.discriminatedUnionTransformer.transform(zodSchema, isNullable, (_) => this.versionSpecifics.mapNullableOfArray(_, isNullable), mapItem, generateSchemaRef);
+			if (isZodType(zodSchema, "ZodUnion")) return this.unionTransformer.transform(zodSchema, (_) => this.versionSpecifics.mapNullableOfArray(_, isNullable), mapItem);
+			if (isZodType(zodSchema, "ZodIntersection")) return this.intersectionTransformer.transform(zodSchema, isNullable, (_) => this.versionSpecifics.mapNullableOfArray(_, isNullable), mapItem);
+			if (isZodType(zodSchema, "ZodRecord")) return this.recordTransformer.transform(zodSchema, (_) => this.versionSpecifics.mapNullableType(_, isNullable), mapItem);
+			if (isZodType(zodSchema, "ZodDate")) return this.dateTransformer.transform((_) => this.versionSpecifics.mapNullableType(_, isNullable));
+			const refId = Metadata.getRefId(zodSchema);
+			throw new UnknownZodTypeError({
+				currentSchema: zodSchema.def,
+				schemaName: refId
+			});
+		}
+	};
+	var OpenAPIGenerator = class {
+		constructor(definitions, versionSpecifics, options) {
+			this.definitions = definitions;
+			this.versionSpecifics = versionSpecifics;
+			this.options = options;
+			this.schemaRefs = {};
+			this.paramRefs = {};
+			this.pathRefs = {};
+			this.rawComponents = [];
+			this.openApiTransformer = new OpenApiTransformer(versionSpecifics, options);
+			this.sortDefinitions();
+		}
+		generateDocumentData() {
+			this.definitions.forEach((definition) => this.generateSingle(definition));
+			return {
+				components: this.buildComponents(),
+				paths: this.pathRefs
+			};
+		}
+		generateComponents() {
+			this.definitions.forEach((definition) => this.generateSingle(definition));
+			return { components: this.buildComponents() };
+		}
+		buildComponents() {
+			var _a$1, _b, _c, _d;
+			const rawComponents = {};
+			this.rawComponents.forEach(({ componentType, name, component }) => {
+				var _a$2;
+				(_a$2 = rawComponents[componentType]) !== null && _a$2 !== void 0 || (rawComponents[componentType] = {});
+				rawComponents[componentType][name] = component;
+			});
+			const allSchemas = Object.assign(Object.assign({}, (_a$1 = rawComponents.schemas) !== null && _a$1 !== void 0 ? _a$1 : {}), this.filteredSchemaRefs);
+			const schemas = ((_b = this.options) === null || _b === void 0 ? void 0 : _b.sortComponents) === "alphabetically" ? sortObjectByKeys(allSchemas) : allSchemas;
+			const allParameters = Object.assign(Object.assign({}, (_c = rawComponents.parameters) !== null && _c !== void 0 ? _c : {}), this.paramRefs);
+			const parameters = ((_d = this.options) === null || _d === void 0 ? void 0 : _d.sortComponents) === "alphabetically" ? sortObjectByKeys(allParameters) : allParameters;
+			return Object.assign(Object.assign({}, rawComponents), {
+				schemas,
+				parameters
+			});
+		}
+		isNotPendingRefEntry(entry) {
+			return entry[1] !== "pending";
+		}
+		get filteredSchemaRefs() {
+			const filtered = Object.entries(this.schemaRefs).filter(this.isNotPendingRefEntry);
+			return Object.fromEntries(filtered);
+		}
+		sortDefinitions() {
+			const generationOrder = [
+				"schema",
+				"parameter",
+				"component",
+				"route"
+			];
+			this.definitions.sort((left, right) => {
+				if (!("type" in left)) {
+					if (!("type" in right)) return 0;
+					return -1;
+				}
+				if (!("type" in right)) return 1;
+				const leftIndex = generationOrder.findIndex((type) => type === left.type);
+				const rightIndex = generationOrder.findIndex((type) => type === right.type);
+				return leftIndex - rightIndex;
+			});
+		}
+		generateSingle(definition) {
+			if (!("type" in definition)) {
+				this.generateSchemaWithRef(definition);
+				return;
+			}
+			switch (definition.type) {
+				case "parameter":
+					this.generateParameterDefinition(definition.schema);
+					return;
+				case "schema":
+					this.generateSchemaWithRef(definition.schema);
+					return;
+				case "route":
+					this.generateSingleRoute(definition.route);
+					return;
+				case "component":
+					this.rawComponents.push(definition);
+					return;
+			}
+		}
+		generateParameterDefinition(zodSchema) {
+			const refId = Metadata.getRefId(zodSchema);
+			const result = this.generateParameter(zodSchema);
+			if (refId) this.paramRefs[refId] = result;
+			return result;
+		}
+		getParameterRef(schema, external) {
+			const metadata = Metadata.getOpenApiMetadata(schema);
+			const internalMetadata = Metadata.getInternalMetadata(schema);
+			const parameterMetadata = metadata === null || metadata === void 0 ? void 0 : metadata.param;
+			const existingRef = (internalMetadata === null || internalMetadata === void 0 ? void 0 : internalMetadata.refId) ? this.paramRefs[internalMetadata.refId] : void 0;
+			if (!(internalMetadata === null || internalMetadata === void 0 ? void 0 : internalMetadata.refId) || !existingRef) return void 0;
+			if (parameterMetadata && existingRef.in !== parameterMetadata.in || (external === null || external === void 0 ? void 0 : external.in) && existingRef.in !== external.in) throw new ConflictError(`Conflicting location for parameter ${existingRef.name}`, {
+				key: "in",
+				values: compact([
+					existingRef.in,
+					external === null || external === void 0 ? void 0 : external.in,
+					parameterMetadata === null || parameterMetadata === void 0 ? void 0 : parameterMetadata.in
+				])
+			});
+			if (parameterMetadata && existingRef.name !== parameterMetadata.name || (external === null || external === void 0 ? void 0 : external.name) && existingRef.name !== (external === null || external === void 0 ? void 0 : external.name)) throw new ConflictError(`Conflicting names for parameter`, {
+				key: "name",
+				values: compact([
+					existingRef.name,
+					external === null || external === void 0 ? void 0 : external.name,
+					parameterMetadata === null || parameterMetadata === void 0 ? void 0 : parameterMetadata.name
+				])
+			});
+			return { $ref: `#/components/parameters/${internalMetadata.refId}` };
+		}
+		generateInlineParameters(zodSchema, location) {
+			const metadata = Metadata.getOpenApiMetadata(zodSchema);
+			const parameterMetadata = metadata === null || metadata === void 0 ? void 0 : metadata.param;
+			const referencedSchema = this.getParameterRef(zodSchema, { in: location });
+			if (referencedSchema) return [referencedSchema];
+			if (isZodType(zodSchema, "ZodObject")) {
+				const propTypes = zodSchema.def.shape;
+				const parameters = Object.entries(propTypes).map(([key, schema]) => {
+					var _a$1;
+					const innerMetadata = Metadata.getOpenApiMetadata(schema);
+					const referencedSchema$1 = this.getParameterRef(schema, {
+						in: location,
+						name: key
+					});
+					if (referencedSchema$1) return referencedSchema$1;
+					const innerParameterMetadata = innerMetadata === null || innerMetadata === void 0 ? void 0 : innerMetadata.param;
+					if ((innerParameterMetadata === null || innerParameterMetadata === void 0 ? void 0 : innerParameterMetadata.name) && innerParameterMetadata.name !== key) throw new ConflictError(`Conflicting names for parameter`, {
+						key: "name",
+						values: [key, innerParameterMetadata.name]
+					});
+					if ((innerParameterMetadata === null || innerParameterMetadata === void 0 ? void 0 : innerParameterMetadata.in) && innerParameterMetadata.in !== location) throw new ConflictError(`Conflicting location for parameter ${(_a$1 = innerParameterMetadata.name) !== null && _a$1 !== void 0 ? _a$1 : key}`, {
+						key: "in",
+						values: [location, innerParameterMetadata.in]
+					});
+					return this.generateParameter(schema.openapi({ param: {
+						name: key,
+						in: location
+					} }));
+				});
+				return parameters;
+			}
+			if ((parameterMetadata === null || parameterMetadata === void 0 ? void 0 : parameterMetadata.in) && parameterMetadata.in !== location) throw new ConflictError(`Conflicting location for parameter ${parameterMetadata.name}`, {
+				key: "in",
+				values: [location, parameterMetadata.in]
+			});
+			return [this.generateParameter(zodSchema.openapi({ param: { in: location } }))];
+		}
+		generateSimpleParameter(zodSchema) {
+			const metadata = Metadata.getParamMetadata(zodSchema);
+			const paramMetadata = metadata === null || metadata === void 0 ? void 0 : metadata.param;
+			const required = !isOptionalSchema(zodSchema) && !isNullableSchema(zodSchema);
+			const schema = this.generateSchemaWithRef(zodSchema);
+			return Object.assign({
+				schema,
+				required
+			}, paramMetadata ? Metadata.buildParameterMetadata(paramMetadata) : {});
+		}
+		generateParameter(zodSchema) {
+			const metadata = Metadata.getOpenApiMetadata(zodSchema);
+			const paramMetadata = metadata === null || metadata === void 0 ? void 0 : metadata.param;
+			const paramName = paramMetadata === null || paramMetadata === void 0 ? void 0 : paramMetadata.name;
+			const paramLocation = paramMetadata === null || paramMetadata === void 0 ? void 0 : paramMetadata.in;
+			if (!paramName) throw new MissingParameterDataError({ missingField: "name" });
+			if (!paramLocation) throw new MissingParameterDataError({
+				missingField: "in",
+				paramName
+			});
+			const baseParameter = this.generateSimpleParameter(zodSchema);
+			return Object.assign(Object.assign({}, baseParameter), {
+				in: paramLocation,
+				name: paramName
+			});
+		}
+		generateSchemaWithMetadata(zodSchema) {
+			const innerSchema = Metadata.unwrapChained(zodSchema);
+			const metadata = Metadata.getOpenApiMetadata(zodSchema);
+			const defaultValue = Metadata.getDefaultValue(zodSchema);
+			const refId = Metadata.getRefId(zodSchema);
+			if (refId && typeof this.schemaRefs[refId] === "object") return this.schemaRefs[refId];
+			if (refId && this.schemaRefs[refId] === "pending") {
+				const refSchema = { $ref: this.generateSchemaRef(refId) };
+				return this.versionSpecifics.mapNullableOfRef(refSchema, isNullableSchema(zodSchema));
+			}
+			if (refId && !this.schemaRefs[refId]) this.schemaRefs[refId] = "pending";
+			const result = (metadata === null || metadata === void 0 ? void 0 : metadata.type) ? { type: metadata.type } : this.toOpenAPISchema(innerSchema, isNullableSchema(zodSchema), defaultValue);
+			return metadata ? Metadata.applySchemaMetadata(result, metadata) : omitBy(result, isUndefined);
+		}
+		/**
+		* Same as above but applies nullable
+		*/
+		constructReferencedOpenAPISchema(zodSchema) {
+			const metadata = Metadata.getOpenApiMetadata(zodSchema);
+			const innerSchema = Metadata.unwrapChained(zodSchema);
+			const defaultValue = Metadata.getDefaultValue(zodSchema);
+			const isNullable = isNullableSchema(zodSchema);
+			if (metadata === null || metadata === void 0 ? void 0 : metadata.type) return this.versionSpecifics.mapNullableType(metadata.type, isNullable);
+			const refId = Metadata.getRefId(zodSchema);
+			if (refId && typeof this.schemaRefs[refId] === "object") return LazyTransformer.mapRecursive(this.schemaRefs[refId], (schema) => this.versionSpecifics.mapNullableType(schema, isNullable), (schema) => this.versionSpecifics.mapNullableOfRef(schema, isNullable));
+			if (refId && this.schemaRefs[refId] === "pending") {
+				const refSchema = { $ref: this.generateSchemaRef(refId) };
+				return this.versionSpecifics.mapNullableOfRef(refSchema, isNullable);
+			}
+			if (refId && !this.schemaRefs[refId]) this.schemaRefs[refId] = "pending";
+			return this.toOpenAPISchema(innerSchema, isNullable, defaultValue);
+		}
+		/**
+		* Generates an OpenAPI SchemaObject or a ReferenceObject with all the provided metadata applied
+		*/
+		generateSimpleSchema(zodSchema) {
+			const metadata = Metadata.getOpenApiMetadata(zodSchema);
+			const refId = Metadata.getRefId(zodSchema);
+			if (!refId || !this.schemaRefs[refId]) return this.generateSchemaWithMetadata(zodSchema);
+			const schemaRef = this.schemaRefs[refId];
+			const referenceObject = { $ref: this.generateSchemaRef(refId) };
+			if (this.schemaRefs[refId] === "pending") return this.versionSpecifics.mapNullableOfRef(referenceObject, isNullableSchema(zodSchema));
+			const newMetadata = omitBy(Metadata.buildSchemaMetadata(metadata !== null && metadata !== void 0 ? metadata : {}), (value, key) => value === void 0 || objectEquals(value, schemaRef[key]));
+			if (newMetadata.type) return { allOf: [referenceObject, newMetadata] };
+			const newSchemaMetadata = omitBy(this.constructReferencedOpenAPISchema(zodSchema), (value, key) => value === void 0 || objectEquals(value, schemaRef[key]));
+			const appliedMetadata = Metadata.applySchemaMetadata(newSchemaMetadata, newMetadata);
+			if (Object.keys(appliedMetadata).length > 0) return { allOf: [referenceObject, appliedMetadata] };
+			return referenceObject;
+		}
+		/**
+		* Same as `generateSchema` but if the new schema is added into the
+		* referenced schemas, it would return a ReferenceObject and not the
+		* whole result.
+		*
+		* Should be used for nested objects, arrays, etc.
+		*/
+		generateSchemaWithRef(zodSchema) {
+			const refId = Metadata.getRefId(zodSchema);
+			if (refId && !this.schemaRefs[refId]) {
+				this.schemaRefs[refId] = this.generateSimpleSchema(zodSchema);
+				return { $ref: this.generateSchemaRef(refId) };
+			}
+			return this.generateSimpleSchema(zodSchema);
+		}
+		generateSchemaRef(refId) {
+			return `#/components/schemas/${refId}`;
+		}
+		getRequestBody(requestBody) {
+			if (!requestBody) return;
+			const { content } = requestBody, rest = __rest(requestBody, ["content"]);
+			const requestBodyContent = this.getBodyContent(content);
+			return Object.assign(Object.assign({}, rest), { content: requestBodyContent });
+		}
+		getParameters(request) {
+			if (!request) return [];
+			const { headers } = request;
+			const query = this.cleanParameter(request.query);
+			const params = this.cleanParameter(request.params);
+			const cookies = this.cleanParameter(request.cookies);
+			const queryParameters = enhanceMissingParametersError(() => query ? this.generateInlineParameters(query, "query") : [], { location: "query" });
+			const pathParameters = enhanceMissingParametersError(() => params ? this.generateInlineParameters(params, "path") : [], { location: "path" });
+			const cookieParameters = enhanceMissingParametersError(() => cookies ? this.generateInlineParameters(cookies, "cookie") : [], { location: "cookie" });
+			const headerParameters = enhanceMissingParametersError(() => {
+				if (Array.isArray(headers)) return headers.flatMap((header) => this.generateInlineParameters(header, "header"));
+				const cleanHeaders = this.cleanParameter(headers);
+				return cleanHeaders ? this.generateInlineParameters(cleanHeaders, "header") : [];
+			}, { location: "header" });
+			return [
+				...pathParameters,
+				...queryParameters,
+				...headerParameters,
+				...cookieParameters
+			];
+		}
+		cleanParameter(schema) {
+			if (!schema) return void 0;
+			if (isZodType(schema, "ZodPipe")) {
+				const inSchema = schema._zod.def.in;
+				const outSchema = schema._zod.def.out;
+				if (isZodType(inSchema, "ZodObject")) return this.cleanParameter(inSchema);
+				if (isZodType(outSchema, "ZodObject")) return this.cleanParameter(outSchema);
+				return void 0;
+			}
+			return schema;
+		}
+		generatePath(route) {
+			const { method, path, request, responses } = route, pathItemConfig = __rest(route, [
+				"method",
+				"path",
+				"request",
+				"responses"
+			]);
+			const generatedResponses = mapValues(responses, (response) => {
+				return this.getResponse(response);
+			});
+			const parameters = enhanceMissingParametersError(() => this.getParameters(request), { route: `${method} ${path}` });
+			const requestBody = this.getRequestBody(request === null || request === void 0 ? void 0 : request.body);
+			const routeDoc = { [method]: Object.assign(Object.assign(Object.assign(Object.assign({}, pathItemConfig), parameters.length > 0 ? { parameters: [...pathItemConfig.parameters || [], ...parameters] } : {}), requestBody ? { requestBody } : {}), { responses: generatedResponses }) };
+			return routeDoc;
+		}
+		generateSingleRoute(route) {
+			const routeDoc = this.generatePath(route);
+			this.pathRefs[route.path] = Object.assign(Object.assign({}, this.pathRefs[route.path]), routeDoc);
+			return routeDoc;
+		}
+		getResponse(response) {
+			if (this.isReferenceObject(response)) return response;
+			const { content, headers } = response, rest = __rest(response, ["content", "headers"]);
+			const responseContent = content ? { content: this.getBodyContent(content) } : {};
+			if (!headers) return Object.assign(Object.assign({}, rest), responseContent);
+			const responseHeaders = isZodType(headers, "ZodObject") ? this.getResponseHeaders(headers) : headers;
+			return Object.assign(Object.assign(Object.assign({}, rest), { headers: responseHeaders }), responseContent);
+		}
+		isReferenceObject(schema) {
+			return "$ref" in schema;
+		}
+		getResponseHeaders(headers) {
+			const schemaShape = headers.def.shape;
+			const responseHeaders = mapValues(schemaShape, (_) => this.generateSimpleParameter(_));
+			return responseHeaders;
+		}
+		getBodyContent(content) {
+			return mapValues(content, (config) => {
+				if (!config || !isAnyZodType(config.schema)) return config;
+				const { schema: configSchema } = config, rest = __rest(config, ["schema"]);
+				const schema = this.generateSchemaWithRef(configSchema);
+				return Object.assign({ schema }, rest);
+			});
+		}
+		toOpenAPISchema(zodSchema, isNullable, defaultValue) {
+			const result = this.openApiTransformer.transform(zodSchema, isNullable, (_) => this.generateSchemaWithRef(_), (_) => this.generateSchemaRef(_), defaultValue);
+			return result;
+		}
+	};
+	var OpenApiGeneratorV30Specifics = class {
+		get nullType() {
+			return { nullable: true };
+		}
+		mapNullableOfArray(objects, isNullable) {
+			if (isNullable && !objects.some((object) => objectEquals(object, this.nullType))) return [...objects, this.nullType];
+			return objects;
+		}
+		mapNullableType(type, isNullable) {
+			return Object.assign(Object.assign({}, type ? { type } : void 0), isNullable ? this.nullType : void 0);
+		}
+		mapNullableOfRef(ref, isNullable) {
+			if (isNullable) return { allOf: [ref, this.nullType] };
+			return ref;
+		}
+		mapTupleItems(schemas) {
+			const uniqueSchemas = uniq(schemas);
+			return {
+				items: uniqueSchemas.length === 1 ? uniqueSchemas[0] : { anyOf: uniqueSchemas },
+				minItems: schemas.length,
+				maxItems: schemas.length
+			};
+		}
+		getNumberChecks(checks) {
+			return Object.assign({}, ...checks.map((check) => {
+				switch (check._zod.def.check) {
+					case "greater_than": {
+						const greaterThanCheck = check;
+						return greaterThanCheck._zod.def.inclusive ? { minimum: Number(greaterThanCheck._zod.def.value) } : {
+							minimum: Number(greaterThanCheck._zod.def.value),
+							exclusiveMinimum: true
+						};
+					}
+					case "less_than": {
+						const lessThanCheck = check;
+						return lessThanCheck._zod.def.inclusive ? { maximum: Number(lessThanCheck._zod.def.value) } : {
+							maximum: Number(lessThanCheck._zod.def.value),
+							exclusiveMaximum: !lessThanCheck._zod.def.inclusive
+						};
+					}
+					default: return {};
+				}
+			}));
+		}
+	};
+	var OpenApiGeneratorV3 = class {
+		constructor(definitions, options) {
+			const specifics = new OpenApiGeneratorV30Specifics();
+			this.generator = new OpenAPIGenerator(definitions, specifics, options);
+		}
+		generateDocument(config) {
+			const baseData = this.generator.generateDocumentData();
+			return Object.assign(Object.assign({}, config), baseData);
+		}
+		generateComponents() {
+			return this.generator.generateComponents();
+		}
+	};
+	var OpenApiGeneratorV31Specifics = class {
+		get nullType() {
+			return { type: "null" };
+		}
+		mapNullableOfArray(objects, isNullable) {
+			if (isNullable && !objects.some((object) => objectEquals(object, this.nullType))) return [...objects, this.nullType];
+			return objects;
+		}
+		mapNullableType(type, isNullable) {
+			if (!type) return {};
+			if (isNullable) {
+				const typeArray = Array.isArray(type) ? type : [type];
+				const nullableType = uniq([...typeArray, "null"]);
+				return { type: nullableType };
+			}
+			return { type };
+		}
+		mapNullableOfRef(ref, isNullable) {
+			if (isNullable) return { oneOf: [ref, this.nullType] };
+			return ref;
+		}
+		mapTupleItems(schemas) {
+			return { prefixItems: schemas };
+		}
+		getNumberChecks(checks) {
+			return Object.assign({}, ...checks.map((check) => {
+				switch (check._zod.def.check) {
+					case "greater_than": {
+						const greaterThanCheck = check;
+						return greaterThanCheck._zod.def.inclusive ? { minimum: Number(greaterThanCheck._zod.def.value) } : { exclusiveMinimum: Number(greaterThanCheck._zod.def.value) };
+					}
+					case "less_than": {
+						const lessThanCheck = check;
+						return lessThanCheck._zod.def.inclusive ? { maximum: Number(lessThanCheck._zod.def.value) } : { exclusiveMaximum: Number(lessThanCheck._zod.def.value) };
+					}
+					default: return {};
+				}
+			}));
+		}
+	};
+	function isWebhookDefinition(definition) {
+		return "type" in definition && definition.type === "webhook";
+	}
+	var OpenApiGeneratorV31 = class {
+		constructor(definitions, options) {
+			this.definitions = definitions;
+			this.webhookRefs = {};
+			const specifics = new OpenApiGeneratorV31Specifics();
+			this.generator = new OpenAPIGenerator(this.definitions, specifics, options);
+		}
+		generateDocument(config) {
+			const baseDocument = this.generator.generateDocumentData();
+			this.definitions.filter(isWebhookDefinition).forEach((definition) => this.generateSingleWebhook(definition.webhook));
+			return Object.assign(Object.assign(Object.assign({}, config), baseDocument), { webhooks: this.webhookRefs });
+		}
+		generateComponents() {
+			return this.generator.generateComponents();
+		}
+		generateSingleWebhook(route) {
+			const routeDoc = this.generator.generatePath(route);
+			this.webhookRefs[route.path] = Object.assign(Object.assign({}, this.webhookRefs[route.path]), routeDoc);
+			return routeDoc;
+		}
+	};
+	exports.OpenAPIRegistry = OpenAPIRegistry;
+	exports.OpenApiGeneratorV3 = OpenApiGeneratorV3;
+	exports.OpenApiGeneratorV31 = OpenApiGeneratorV31;
+	exports.extendZodWithOpenApi = extendZodWithOpenApi;
+	exports.getOpenApiMetadata = getOpenApiMetadata;
+	exports.getRefId = getRefId;
+	exports.zodToOpenAPIRegistry = zodToOpenAPIRegistry;
+} });
+var import_dist = __toESM(require_dist(), 1);
+
+//#endregion
+//#region ../shared/dist/schemas/zod.js
+(0, import_dist.extendZodWithOpenApi)(z$1);
+
+//#endregion
+//#region ../shared/dist/schemas/options/page-elements.js
+const pageElementConfigSchema = z$1.object({
+	position: z$1.enum(["header", "footer"]).openapi({
+		description: "Position of the element (header or footer)",
+		example: "footer"
+	}),
+	alignment: z$1.enum([
+		"left",
+		"center",
+		"right"
+	]).openapi({
+		description: "Text alignment within the header/footer",
+		example: "center"
+	}),
+	fontSize: z$1.number().min(6).max(36).optional().openapi({
+		description: "Font size in pixels (6-36)",
+		example: 10
+	}),
+	fontFamily: z$1.string().optional().openapi({
+		description: "Font family name",
+		example: "Arial"
+	}),
+	fontColor: z$1.string().regex(/^#[0-9A-Fa-f]{6}$/).optional().openapi({
+		description: "Text color as hex code",
+		example: "#000000"
+	})
+}).openapi("PageElementConfig");
+const titleConfigSchema = pageElementConfigSchema.extend({ value: z$1.string().optional().openapi({
+	description: "Custom title text to display",
+	example: "My Document"
+}) }).openapi("TitleConfig");
+const dateConfigSchema = pageElementConfigSchema.extend({ value: z$1.string().optional().openapi({
+	description: "Custom date string to display (e.g. '2024-01-15' or 'January 15, 2024')",
+	example: "2024-01-15"
+}) }).openapi("DateConfig");
+const pageNumberConfigSchema = pageElementConfigSchema.extend({ includeTotal: z$1.boolean().optional().openapi({
+	description: "Include total page count (shows X / Y format)",
+	example: false
+}) }).openapi("PageNumberConfig");
+const pageElementsSchema = z$1.object({
+	date: dateConfigSchema.optional().openapi({ description: "Display a date. If value is not provided, uses the document generation date." }),
+	title: titleConfigSchema.optional().openapi({ description: "Display a title. If value is not provided, uses the document title." }),
+	pageNumber: pageNumberConfigSchema.optional().openapi({ description: "Display the current page number. Enable includeTotal for X / Y format." })
+}).openapi("PageElements");
+
+//#endregion
+//#region ../shared/dist/schemas/options/pdf-formatting.js
+const pdfFormattingOptionsSchema = z$1.object({
+	paperWidth: z$1.string().optional().openapi({ description: "Paper width (e.g., '8.5in', '210mm')" }),
+	paperHeight: z$1.string().optional().openapi({ description: "Paper height (e.g., '11in', '297mm')" }),
+	marginTop: z$1.string().optional().openapi({ description: "Top margin" }),
+	marginBottom: z$1.string().optional().openapi({ description: "Bottom margin" }),
+	marginLeft: z$1.string().optional().openapi({ description: "Left margin" }),
+	marginRight: z$1.string().optional().openapi({ description: "Right margin" }),
+	landscape: z$1.boolean().optional().openapi({ description: "Landscape orientation" }),
+	scale: z$1.number().min(.1).max(2).optional().openapi({ description: "Page scale (0.1-2.0)" }),
+	singlePage: z$1.boolean().optional().openapi({ description: "Print entire content on one page" }),
+	preferCssPageSize: z$1.boolean().optional().openapi({ description: "Prefer CSS-defined page dimensions" }),
+	generateDocumentOutline: z$1.boolean().optional().openapi({ description: "Embed document outline in PDF" }),
+	generateTaggedPdf: z$1.boolean().optional().openapi({ description: "Generate accessible/tagged PDF" }),
+	printBackground: z$1.boolean().optional().openapi({ description: "Include background graphics" }),
+	omitBackground: z$1.boolean().optional().openapi({ description: "Transparent background (no white default)" }),
+	nativePageRanges: z$1.string().optional().openapi({ description: "Pages to print (e.g., '1-5, 8, 11-13')" }),
+	pageElements: pageElementsSchema.optional().openapi({ description: "Configure header/footer elements (date, title, page numbers)" })
+});
+
+//#endregion
+//#region ../shared/dist/schemas/options/compress-pdf.js
+const compressPdfOptionsSchema = z$1.object({
+	losslessImageCompression: z$1.boolean().optional().openapi({ description: "Use lossless compression (PNG) instead of lossy (JPEG)" }),
+	quality: z$1.number().min(1).max(100).optional().openapi({ description: "JPEG compression quality (1-100)" }),
+	reduceImageResolution: z$1.boolean().optional().openapi({ description: "Enable DPI reduction" }),
+	maxImageResolution: z$1.enum([
+		"75",
+		"150",
+		"300",
+		"600",
+		"1200"
+	]).optional().openapi({ description: "Maximum image resolution in DPI" })
+}).openapi("CompressPdfOptions");
+
+//#endregion
+//#region ../shared/dist/schemas/options/office-to-pdf.js
+const officeToPdfOptionsSchema = z$1.object({ landscape: z$1.boolean().optional().openapi({ description: "Landscape orientation" }) }).openapi("OfficeToPdfOptions");
+
+//#endregion
+//#region ../shared/dist/schemas/options/merge-pdf.js
+const mergePdfOptionsSchema = z$1.object({}).openapi("MergePdfOptions");
+
+//#endregion
+//#region ../shared/dist/schemas/requests/html-to-pdf.js
+const htmlToPdfRequestSchema = z$1.object({
+	html: z$1.string().min(1).openapi({
+		description: "HTML content to convert to PDF",
+		example: "<html><body><h1>Hello World</h1></body></html>"
+	}),
+	...pdfFormattingOptionsSchema.shape
+}).openapi("HtmlToPdfRequest");
+
+//#endregion
+//#region ../shared/dist/schemas/requests/url-to-pdf.js
+const urlToPdfRequestSchema = z$1.object({
+	url: z$1.string().url().openapi({
+		description: "URL to convert to PDF",
+		example: "https://example.com"
+	}),
+	...pdfFormattingOptionsSchema.shape
+}).openapi("UrlToPdfRequest");
+
+//#endregion
+//#region ../shared/dist/schemas/error.js
+const errorResponseSchema = z$1.object({
+	error: z$1.string().openapi({ description: "Error message" }),
+	details: z$1.string().optional().openapi({ description: "Error details" })
+}).openapi("ErrorResponse");
+
+//#endregion
+//#region src/utils/encoding.ts
+async function blobToBase64(blob) {
+	const buffer = await blob.arrayBuffer();
+	return Buffer.from(buffer).toString("base64");
+}
+function base64ToBlob(base64, mimeType = "application/pdf") {
+	return new Blob([Buffer.from(base64, "base64")], { type: mimeType });
+}
+
+//#endregion
+//#region src/utils/error-handler.ts
+function textResponse(text) {
+	return { content: [{
+		type: "text",
+		text
+	}] };
+}
+function handleError(error) {
+	const err = error;
+	if (err.status === 402) return textResponse(UPGRADE_MESSAGE);
+	if (err.status === 401) return textResponse("Invalid API key. Check your NEAT_PDF_API_KEY.");
+	const details = JSON.stringify(error, Object.getOwnPropertyNames(error), 2);
+	return textResponse(`Error: ${err.message || "Unknown error"}\n\nDetails:\n${details}`);
+}
+
+//#endregion
+//#region src/utils/response.ts
+function formatPdfResponse(base64, action) {
+	const sizeKb = Math.round(base64.length * .75 / 1024);
+	return { content: [{
+		type: "text",
+		text: `PDF ${action} successfully (${sizeKb} KB)`
+	}, {
+		type: "text",
+		text: `data:application/pdf;base64,${base64}`
+	}] };
+}
+
+//#endregion
+//#region src/tools/compress-pdf.ts
+function registerCompressPdf(server$1) {
+	server$1.registerTool("neat_compress_pdf", {
+		description: "Compress an existing PDF file. Accepts base64-encoded PDF, returns compressed base64-encoded PDF.",
+		inputSchema: {
+			file: z.string().describe("Base64-encoded PDF file to compress"),
+			...compressPdfOptionsSchema.shape
+		}
+	}, async ({ file,...options }) => {
+		const blob = base64ToBlob(file);
+		const result = await client.compressPdf({ body: {
+			file: blob,
+			...options
+		} });
+		if (result.error) return handleError(result.error);
+		const base64 = await blobToBase64(result.data);
+		return formatPdfResponse(base64, "compressed");
+	});
+}
+
+//#endregion
+//#region src/tools/html-to-pdf.ts
+function registerHtmlToPdf(server$1) {
+	server$1.registerTool("neat_html_to_pdf", {
+		description: "Convert HTML string to PDF. Returns base64-encoded PDF.",
+		inputSchema: htmlToPdfRequestSchema.shape
+	}, async ({ html,...options }) => {
+		const result = await client.htmlToPdf({ body: {
+			html,
+			...options
+		} });
+		if (result.error) return handleError(result.error);
+		const base64 = await blobToBase64(result.data);
+		return formatPdfResponse(base64, "generated");
+	});
+}
+
+//#endregion
+//#region src/tools/merge-pdf.ts
+function registerMergePdf(server$1) {
+	server$1.registerTool("neat_merge_pdf", {
+		description: "Merge multiple PDF files into one. Accepts array of base64-encoded PDFs, returns merged base64-encoded PDF.",
+		inputSchema: { files: z.array(z.string()).min(2).describe("Array of base64-encoded PDF files to merge (order determines output order)") }
+	}, async ({ files }) => {
+		const blobs = files.map((f) => base64ToBlob(f));
+		const result = await client.mergePdf({ body: { files: blobs } });
+		if (result.error) return handleError(result.error);
+		const base64 = await blobToBase64(result.data);
+		return formatPdfResponse(base64, "merged");
+	});
+}
+
+//#endregion
+//#region src/tools/office-to-pdf.ts
+const MIME_TYPES = {
+	docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+	doc: "application/msword",
+	xls: "application/vnd.ms-excel",
+	ppt: "application/vnd.ms-powerpoint",
+	odt: "application/vnd.oasis.opendocument.text",
+	ods: "application/vnd.oasis.opendocument.spreadsheet",
+	odp: "application/vnd.oasis.opendocument.presentation",
+	rtf: "application/rtf",
+	txt: "text/plain",
+	csv: "text/csv"
+};
+function registerOfficeToPdf(server$1) {
+	server$1.registerTool("neat_office_to_pdf", {
+		description: "Convert Office documents (DOCX, XLSX, PPTX, etc.) to PDF. Accepts base64-encoded file, returns base64-encoded PDF.",
+		inputSchema: {
+			file: z.string().describe("Base64-encoded Office file to convert"),
+			filename: z.string().describe("Original filename with extension (e.g., 'document.docx')"),
+			...officeToPdfOptionsSchema.shape
+		}
+	}, async ({ file, filename, landscape }) => {
+		const ext = filename.split(".").pop()?.toLowerCase() ?? "";
+		const mimeType = MIME_TYPES[ext] ?? "application/octet-stream";
+		const blob = base64ToBlob(file, mimeType);
+		const result = await client.officeToPdf({ body: {
+			file: blob,
+			landscape
+		} });
+		if (result.error) return handleError(result.error);
+		const base64 = await blobToBase64(result.data);
+		return formatPdfResponse(base64, "generated");
+	});
+}
+
+//#endregion
+//#region src/tools/url-to-pdf.ts
+function registerUrlToPdf(server$1) {
+	server$1.registerTool("neat_url_to_pdf", {
+		description: "Convert a webpage URL to PDF. Returns base64-encoded PDF.",
+		inputSchema: urlToPdfRequestSchema.shape
+	}, async ({ url,...options }) => {
+		const result = await client.urlToPdf({ body: {
+			url,
+			...options
+		} });
+		if (result.error) return handleError(result.error);
+		const base64 = await blobToBase64(result.data);
+		return formatPdfResponse(base64, "generated");
+	});
+}
+
+//#endregion
+//#region src/tools/index.ts
+function registerTools(server$1) {
+	registerHtmlToPdf(server$1);
+	registerUrlToPdf(server$1);
+	registerCompressPdf(server$1);
+	registerOfficeToPdf(server$1);
+	registerMergePdf(server$1);
+}
+
+//#endregion
+//#region src/index.ts
 const server = new McpServer({
-    name: "neat-pdf",
-    version: "0.1.0",
+	name: "neat-pdf",
+	version: "0.1.0"
 });
 registerTools(server);
 const transport = new StdioServerTransport();
 await server.connect(transport);
+
+//#endregion
 //# sourceMappingURL=index.js.map