@kubb/agent 5.0.0-alpha.34 → 5.0.0-alpha.36

package/.output/server/node_modules/@kubb/plugin-msw/dist/components-DgtTZkWX.js

@@ -0,0 +1,277 @@
+import "./chunk--u3MIqq1.js";
+import { File, Function as Function$1, FunctionParams } from "@kubb/react-fabric";
+import { jsx } from "@kubb/react-fabric/jsx-runtime";
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
+		return word.charAt(0).toUpperCase() + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Splits `text` on `.` and applies `transformPart` to each segment.
+* The last segment receives `isLast = true`, all earlier segments receive `false`.
+* Segments are joined with `/` to form a file path.
+*/
+function applyToFileParts(text, transformPart) {
+	const parts = text.split(".");
+	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+}
+/**
+* Converts `text` to camelCase.
+* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
+*
+* @example
+* camelCase('hello-world')                   // 'helloWorld'
+* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+*/
+function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
+		prefix,
+		suffix
+	} : {}));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+//#endregion
+//#region ../../internals/utils/src/reserved.ts
+/**
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+*/
+function isValidVarName(name) {
+	try {
+		new Function(`var ${name}`);
+	} catch {
+		return false;
+	}
+	return true;
+}
+//#endregion
+//#region ../../internals/utils/src/urlPath.ts
+/**
+* Parses and transforms an OpenAPI/Swagger path string into various URL formats.
+*
+* @example
+* const p = new URLPath('/pet/{petId}')
+* p.URL      // '/pet/:petId'
+* p.template // '`/pet/${petId}`'
+*/
+var URLPath = class {
+	/** The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`. */
+	path;
+	#options;
+	constructor(path, options = {}) {
+		this.path = path;
+		this.#options = options;
+	}
+	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+	get URL() {
+		return this.toURLPath();
+	}
+	/** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`). */
+	get isURL() {
+		try {
+			return !!new URL(this.path).href;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Converts the OpenAPI path to a TypeScript template literal string.
+	*
+	* @example
+	* new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
+	* new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
+	*/
+	get template() {
+		return this.toTemplateString();
+	}
+	/** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set. */
+	get object() {
+		return this.toObject();
+	}
+	/** Returns a map of path parameter names, or `undefined` when the path has no parameters. */
+	get params() {
+		return this.getParams();
+	}
+	#transformParam(raw) {
+		const param = isValidVarName(raw) ? raw : camelCase(raw);
+		return this.#options.casing === "camelcase" ? camelCase(param) : param;
+	}
+	/** Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name. */
+	#eachParam(fn) {
+		for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
+			const raw = match[1];
+			fn(raw, this.#transformParam(raw));
+		}
+	}
+	toObject({ type = "path", replacer, stringify } = {}) {
+		const object = {
+			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
+			params: this.getParams()
+		};
+		if (stringify) {
+			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
+			if (object.params) return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
+			return `{ url: '${object.url}' }`;
+		}
+		return object;
+	}
+	/**
+	* Converts the OpenAPI path to a TypeScript template literal string.
+	* An optional `replacer` can transform each extracted parameter name before interpolation.
+	*
+	* @example
+	* new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
+	*/
+	toTemplateString({ prefix = "", replacer } = {}) {
+		return `\`${prefix}${this.path.split(/\{([^}]+)\}/).map((part, i) => {
+			if (i % 2 === 0) return part;
+			const param = this.#transformParam(part);
+			return `\${${replacer ? replacer(param) : param}}`;
+		}).join("")}\``;
+	}
+	/**
+	* Extracts all `{param}` segments from the path and returns them as a key-value map.
+	* An optional `replacer` transforms each parameter name in both key and value positions.
+	* Returns `undefined` when no path parameters are found.
+	*/
+	getParams(replacer) {
+		const params = {};
+		this.#eachParam((_raw, param) => {
+			const key = replacer ? replacer(param) : param;
+			params[key] = key;
+		});
+		return Object.keys(params).length > 0 ? params : void 0;
+	}
+	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+	toURLPath() {
+		return this.path.replace(/\{([^}]+)\}/g, ":$1");
+	}
+};
+//#endregion
+//#region src/components/Handlers.tsx
+function Handlers({ name, handlers }) {
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isIndexable: true,
+		isExportable: true,
+		children: `export const ${name} = ${JSON.stringify(handlers).replaceAll(`"`, "")} as const`
+	});
+}
+//#endregion
+//#region src/components/Mock.tsx
+function Mock({ baseURL = "", name, typeName, operation }) {
+	const method = operation.method;
+	const successStatusCodes = operation.getResponseStatusCodes().filter((code) => code.startsWith("2"));
+	const statusCode = successStatusCodes.length > 0 ? Number(successStatusCodes[0]) : 200;
+	const responseObject = operation.getResponseByStatusCode(statusCode);
+	const contentType = Object.keys(responseObject.content || {})?.[0];
+	const url = new URLPath(operation.path).toURLPath().replace(/([^/]):/g, "$1\\\\:");
+	const headers = [contentType ? `'Content-Type': '${contentType}'` : void 0].filter(Boolean);
+	const dataType = contentType && responseObject?.content?.[contentType]?.schema !== void 0 ? typeName : "string | number | boolean | null | object";
+	const params = FunctionParams.factory({ data: {
+		type: `${dataType} | ((
+        info: Parameters<Parameters<typeof http.${method}>[1]>[0],
+      ) => Response | Promise<Response>)`,
+		optional: true
+	} });
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isIndexable: true,
+		isExportable: true,
+		children: /* @__PURE__ */ jsx(Function$1, {
+			name,
+			export: true,
+			params: params.toConstructor(),
+			children: `return http.${method}(\`${baseURL}${url.replace(/([^/]):/g, "$1\\\\:")}\`, function handler(info) {
+    if(typeof data === 'function') return data(info)
+
+    return new Response(JSON.stringify(data), {
+      status: ${statusCode},
+      ${headers.length ? `  headers: {
+        ${headers.join(", \n")}
+      },` : ""}
+    })
+  })`
+		})
+	});
+}
+//#endregion
+//#region src/components/MockWithFaker.tsx
+function MockWithFaker({ baseURL = "", name, fakerName, typeName, operation }) {
+	const method = operation.method;
+	const successStatusCodes = operation.getResponseStatusCodes().filter((code) => code.startsWith("2"));
+	const statusCode = successStatusCodes.length > 0 ? Number(successStatusCodes[0]) : 200;
+	const responseObject = operation.getResponseByStatusCode(statusCode);
+	const contentType = Object.keys(responseObject.content || {})?.[0];
+	const url = new URLPath(operation.path).toURLPath().replace(/([^/]):/g, "$1\\\\:");
+	const headers = [contentType ? `'Content-Type': '${contentType}'` : void 0].filter(Boolean);
+	const params = FunctionParams.factory({ data: {
+		type: `${typeName} | ((
+        info: Parameters<Parameters<typeof http.${method}>[1]>[0],
+      ) => Response | Promise<Response>)`,
+		optional: true
+	} });
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isIndexable: true,
+		isExportable: true,
+		children: /* @__PURE__ */ jsx(Function$1, {
+			name,
+			export: true,
+			params: params.toConstructor(),
+			children: `return http.${method}('${baseURL}${url.replace(/([^/]):/g, "$1\\\\:")}', function handler(info) {
+    if(typeof data === 'function') return data(info)
+
+    return new Response(JSON.stringify(data || ${fakerName}(data)), {
+      status: ${statusCode},
+      ${headers.length ? `  headers: {
+        ${headers.join(", \n")}
+      },` : ""}
+    })
+  })`
+		})
+	});
+}
+//#endregion
+//#region src/components/Response.tsx
+function Response({ name, typeName, operation, statusCode }) {
+	const responseObject = operation.getResponseByStatusCode(statusCode);
+	const contentType = Object.keys(responseObject.content || {})?.[0];
+	const headers = [contentType ? `'Content-Type': '${contentType}'` : void 0].filter(Boolean);
+	const hasResponseSchema = contentType && responseObject?.content?.[contentType]?.schema !== void 0;
+	const params = FunctionParams.factory({ data: {
+		type: `${typeName}`,
+		optional: !hasResponseSchema
+	} });
+	const responseName = `${name}Response${statusCode}`;
+	return /* @__PURE__ */ jsx(File.Source, {
+		name: responseName,
+		isIndexable: true,
+		isExportable: true,
+		children: /* @__PURE__ */ jsx(Function$1, {
+			name: responseName,
+			export: true,
+			params: params.toConstructor(),
+			children: `
+    return new Response(JSON.stringify(data), {
+      status: ${statusCode},
+      ${headers.length ? `  headers: {
+        ${headers.join(", \n")}
+      },` : ""}
+    })`
+		})
+	});
+}
+//#endregion
+export { camelCase as a, Handlers as i, MockWithFaker as n, Mock as r, Response as t };
+
+//# sourceMappingURL=components-DgtTZkWX.js.map

package/.output/server/node_modules/@kubb/plugin-msw/dist/generators-C34kqa1L.js

@@ -0,0 +1,161 @@
+import "./chunk--u3MIqq1.js";
+import { i as Handlers, n as MockWithFaker, r as Mock, t as Response } from "./components-DgtTZkWX.js";
+import { pluginFakerName } from "@kubb/plugin-faker";
+import { pluginTsName } from "@kubb/plugin-ts";
+import { usePluginManager } from "@kubb/core/hooks";
+import { createReactGenerator } from "@kubb/plugin-oas/generators";
+import { useOas, useOperationManager } from "@kubb/plugin-oas/hooks";
+import { getBanner, getFooter } from "@kubb/plugin-oas/utils";
+import { File } from "@kubb/react-fabric";
+import { jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
+//#region src/generators/handlersGenerator.tsx
+const handlersGenerator = createReactGenerator({
+	name: "plugin-msw",
+	Operations({ operations, generator, plugin }) {
+		const pluginManager = usePluginManager();
+		const oas = useOas();
+		const { getName, getFile } = useOperationManager(generator);
+		const file = pluginManager.getFile({
+			name: "handlers",
+			extname: ".ts",
+			pluginKey: plugin.key
+		});
+		const imports = operations.map((operation) => {
+			const operationFile = getFile(operation, { pluginKey: plugin.key });
+			const operationName = getName(operation, {
+				pluginKey: plugin.key,
+				type: "function"
+			});
+			return /* @__PURE__ */ jsx(File.Import, {
+				name: [operationName],
+				root: file.path,
+				path: operationFile.path
+			}, operationFile.path);
+		});
+		const handlers = operations.map((operation) => `${getName(operation, {
+			type: "function",
+			pluginKey: plugin.key
+		})}()`);
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: file.baseName,
+			path: file.path,
+			meta: file.meta,
+			banner: getBanner({
+				oas,
+				output: plugin.options.output,
+				config: pluginManager.config
+			}),
+			footer: getFooter({
+				oas,
+				output: plugin.options.output
+			}),
+			children: [imports, /* @__PURE__ */ jsx(Handlers, {
+				name: "handlers",
+				handlers
+			})]
+		});
+	}
+});
+//#endregion
+//#region src/generators/mswGenerator.tsx
+const mswGenerator = createReactGenerator({
+	name: "msw",
+	Operation({ operation, generator, plugin }) {
+		const { options: { output, parser, baseURL } } = plugin;
+		const pluginManager = usePluginManager();
+		const oas = useOas();
+		const { getSchemas, getName, getFile } = useOperationManager(generator);
+		const mock = {
+			name: getName(operation, { type: "function" }),
+			file: getFile(operation)
+		};
+		const faker = {
+			file: getFile(operation, { pluginKey: [pluginFakerName] }),
+			schemas: getSchemas(operation, {
+				pluginKey: [pluginFakerName],
+				type: "function"
+			})
+		};
+		const type = {
+			file: getFile(operation, { pluginKey: [pluginTsName] }),
+			schemas: getSchemas(operation, {
+				pluginKey: [pluginTsName],
+				type: "type"
+			})
+		};
+		const responseStatusCodes = operation.getResponseStatusCodes();
+		const types = [];
+		for (const code of responseStatusCodes) {
+			if (code === "default") {
+				types.push(["default", type.schemas.response.name]);
+				continue;
+			}
+			if (code.startsWith("2")) {
+				types.push([Number(code), type.schemas.response.name]);
+				continue;
+			}
+			const codeType = type.schemas.errors?.find((err) => err.statusCode === Number(code));
+			if (codeType) types.push([Number(code), codeType.name]);
+		}
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: mock.file.baseName,
+			path: mock.file.path,
+			meta: mock.file.meta,
+			banner: getBanner({
+				oas,
+				output,
+				config: pluginManager.config
+			}),
+			footer: getFooter({
+				oas,
+				output
+			}),
+			children: [
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["http"],
+					path: "msw"
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["ResponseResolver"],
+					isTypeOnly: true,
+					path: "msw"
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: Array.from(new Set([type.schemas.response.name, ...types.map((t) => t[1])])),
+					path: type.file.path,
+					root: mock.file.path,
+					isTypeOnly: true
+				}),
+				parser === "faker" && faker.file && faker.schemas.response && /* @__PURE__ */ jsx(File.Import, {
+					name: [faker.schemas.response.name],
+					root: mock.file.path,
+					path: faker.file.path
+				}),
+				types.filter(([code]) => code !== "default").map(([code, typeName]) => /* @__PURE__ */ jsx(Response, {
+					typeName,
+					operation,
+					name: mock.name,
+					statusCode: code
+				})),
+				parser === "faker" && /* @__PURE__ */ jsx(MockWithFaker, {
+					name: mock.name,
+					typeName: type.schemas.response.name,
+					fakerName: faker.schemas.response.name,
+					operation,
+					baseURL
+				}),
+				parser === "data" && /* @__PURE__ */ jsx(Mock, {
+					name: mock.name,
+					typeName: type.schemas.response.name,
+					fakerName: faker.schemas.response.name,
+					operation,
+					baseURL
+				})
+			]
+		});
+	}
+});
+//#endregion
+export { handlersGenerator as n, mswGenerator as t };
+
+//# sourceMappingURL=generators-C34kqa1L.js.map

package/.output/server/node_modules/@kubb/plugin-msw/dist/index.js

@@ -0,0 +1,84 @@
+import "./chunk--u3MIqq1.js";
+import { a as camelCase } from "./components-DgtTZkWX.js";
+import { n as handlersGenerator, t as mswGenerator } from "./generators-C34kqa1L.js";
+import path from "node:path";
+import { definePlugin, getBarrelFiles, getMode } from "@kubb/core";
+import { pluginFakerName } from "@kubb/plugin-faker";
+import { OperationGenerator, pluginOasName } from "@kubb/plugin-oas";
+import { pluginTsName } from "@kubb/plugin-ts";
+//#region src/plugin.ts
+const pluginMswName = "plugin-msw";
+const pluginMsw = definePlugin((options) => {
+	const { output = {
+		path: "handlers",
+		barrelType: "named"
+	}, group, exclude = [], include, override = [], transformers = {}, handlers = false, parser = "data", generators = [mswGenerator, handlers ? handlersGenerator : void 0].filter(Boolean), contentType, baseURL } = options;
+	return {
+		name: pluginMswName,
+		options: {
+			output,
+			parser,
+			group,
+			baseURL
+		},
+		pre: [
+			pluginOasName,
+			pluginTsName,
+			parser === "faker" ? pluginFakerName : void 0
+		].filter(Boolean),
+		resolvePath(baseName, pathMode, options) {
+			const root = path.resolve(this.config.root, this.config.output.path);
+			if ((pathMode ?? getMode(path.resolve(root, output.path))) === "single")
+ /**
+			* when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
+			* Other plugins then need to call addOrAppend instead of just add from the fileManager class
+			*/
+			return path.resolve(root, output.path);
+			if (group && (options?.group?.path || options?.group?.tag)) {
+				const groupName = group?.name ? group.name : (ctx) => {
+					if (group?.type === "path") return `${ctx.group.split("/")[1]}`;
+					return `${camelCase(ctx.group)}Controller`;
+				};
+				return path.resolve(root, output.path, groupName({ group: group.type === "path" ? options.group.path : options.group.tag }), baseName);
+			}
+			return path.resolve(root, output.path, baseName);
+		},
+		resolveName(name, type) {
+			const resolvedName = camelCase(name, {
+				suffix: type ? "handler" : void 0,
+				isFile: type === "file"
+			});
+			if (type) return transformers?.name?.(resolvedName, type) || resolvedName;
+			return resolvedName;
+		},
+		async install() {
+			const root = path.resolve(this.config.root, this.config.output.path);
+			const mode = getMode(path.resolve(root, output.path));
+			const oas = await this.getOas();
+			const files = await new OperationGenerator(this.plugin.options, {
+				fabric: this.fabric,
+				oas,
+				pluginManager: this.pluginManager,
+				events: this.events,
+				plugin: this.plugin,
+				contentType,
+				exclude,
+				include,
+				override,
+				mode
+			}).build(...generators);
+			await this.upsertFile(...files);
+			const barrelFiles = await getBarrelFiles(this.fabric.files, {
+				type: output.barrelType ?? "named",
+				root,
+				output,
+				meta: { pluginKey: this.plugin.key }
+			});
+			await this.upsertFile(...barrelFiles);
+		}
+	};
+});
+//#endregion
+export { pluginMsw, pluginMswName };
+
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@kubb/plugin-msw/package.json

@@ -0,0 +1,109 @@
+{
+  "name": "@kubb/plugin-msw",
+  "version": "4.37.2",
+  "description": "Mock Service Worker (MSW) handlers generator plugin for Kubb, creating API mocks from OpenAPI specifications for frontend development and testing.",
+  "keywords": [
+    "msw",
+    "mock-service-worker",
+    "api-mocking",
+    "mocking",
+    "mocks",
+    "testing",
+    "development",
+    "interceptor",
+    "typescript",
+    "openapi",
+    "swagger",
+    "oas",
+    "code-generator",
+    "codegen",
+    "plugins",
+    "kubb"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kubb-labs/kubb.git",
+    "directory": "packages/plugin-msw"
+  },
+  "license": "MIT",
+  "author": "stijnvanhulle",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./components": {
+      "import": "./dist/components.js",
+      "require": "./dist/components.cjs"
+    },
+    "./generators": {
+      "import": "./dist/generators.js",
+      "require": "./dist/generators.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "utils": [
+        "./dist/utils.d.ts"
+      ],
+      "hooks": [
+        "./dist/hooks.d.ts"
+      ],
+      "components": [
+        "./dist/components.d.ts"
+      ],
+      "generators": [
+        "./dist/generators.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "src",
+    "dist",
+    "!/**/**.test.**",
+    "!/**/__tests__/**",
+    "!/**/__snapshots__/**"
+  ],
+  "size-limit": [
+    {
+      "path": "./dist/*.js",
+      "limit": "510 KiB",
+      "gzip": true
+    }
+  ],
+  "dependencies": {
+    "@kubb/react-fabric": "0.14.0",
+    "@kubb/core": "4.37.2",
+    "@kubb/oas": "4.37.2",
+    "@kubb/plugin-faker": "4.37.2",
+    "@kubb/plugin-oas": "4.37.2",
+    "@kubb/plugin-ts": "4.37.2"
+  },
+  "devDependencies": {
+    "@internals/utils": "0.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "scripts": {
+    "build": "tsdown && size-limit",
+    "clean": "npx rimraf ./dist",
+    "lint": "bun biome lint .",
+    "lint:fix": "bun biome lint --fix --unsafe .",
+    "release": "pnpm publish --no-git-check",
+    "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check",
+    "start": "tsdown --watch",
+    "test": "vitest --passWithNoTests",
+    "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"
+  }
+}

package/.output/server/node_modules/@kubb/plugin-oas/dist/SchemaMapper-CqMkO2T1.js

@@ -0,0 +1,58 @@
+import "./chunk--u3MIqq1.js";
+//#region src/SchemaMapper.ts
+const schemaKeywords = {
+	any: "any",
+	unknown: "unknown",
+	number: "number",
+	integer: "integer",
+	bigint: "bigint",
+	string: "string",
+	boolean: "boolean",
+	undefined: "undefined",
+	nullable: "nullable",
+	null: "null",
+	nullish: "nullish",
+	array: "array",
+	tuple: "tuple",
+	enum: "enum",
+	union: "union",
+	datetime: "datetime",
+	date: "date",
+	email: "email",
+	uuid: "uuid",
+	url: "url",
+	void: "void",
+	default: "default",
+	const: "const",
+	and: "and",
+	describe: "describe",
+	min: "min",
+	max: "max",
+	exclusiveMinimum: "exclusiveMinimum",
+	exclusiveMaximum: "exclusiveMaximum",
+	optional: "optional",
+	readOnly: "readOnly",
+	writeOnly: "writeOnly",
+	object: "object",
+	ref: "ref",
+	matches: "matches",
+	firstName: "firstName",
+	lastName: "lastName",
+	password: "password",
+	phone: "phone",
+	blob: "blob",
+	deprecated: "deprecated",
+	example: "example",
+	schema: "schema",
+	catchall: "catchall",
+	time: "time",
+	name: "name",
+	interface: "interface"
+};
+function isKeyword(meta, keyword) {
+	return meta.keyword === keyword;
+}
+//#endregion
+export { schemaKeywords as n, isKeyword as t };
+
+//# sourceMappingURL=SchemaMapper-CqMkO2T1.js.map

package/.output/server/node_modules/@kubb/plugin-oas/dist/chunk--u3MIqq1.js

@@ -0,0 +1,8 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+//#endregion
+export { __name as t };