@kubb/kit 5.7.0 → 5.8.0

package/README.md

@@ -77,6 +77,19 @@ Rounding out the package are the option and hook types every plugin, generator,
 import { createMockedPlugin, renderGeneratorSchema } from 'kubb/kit/testing'
 ```
 
+## Options schemas
+
+`@kubb/kit/options` holds Zod schemas for the options most plugins share (`outputOptionsSchema`, `includeSchema`, `excludeSchema`, `overrideSchema`, `resolverSchema`, `macrosSchema`), plus `suggest()` for an open string with suggested values and `when()` for an option that only applies when another option matches. Install `zod` 4 to use it. The main `@kubb/kit` import never pulls in Zod.
+
+```typescript
+import { excludeSchema, outputOptionsSchema, suggest } from '@kubb/kit/options'
+
+const optionsSchema = outputOptionsSchema.extend({
+  exclude: excludeSchema.optional(),
+  importPath: suggest(['zod', 'zod/mini']).optional(),
+})
+```
+
 ## Why a separate package from `@kubb/core`
 
 `@kubb/core` also runs the build engine: the plugin driver, the file manager, and the CLI reporters. None of that is part of authoring a plugin. `@kubb/kit` keeps the two apart, the same way the surrounding `kubb/ast` and `kubb/jsx` subpaths separate the AST layer and the JSX renderer from the engine that drives them.

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#endregion
+require("./rolldown-runtime-qbf5tadS.cjs");
 let _kubb_ast = require("@kubb/ast");
 let _kubb_core = require("@kubb/core");
 //#region ../../internals/utils/src/casing.ts

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
 import { SchemaNode, ast, ast as ast$1 } from "@kubb/ast";
-import { Adapter, AdapterFactoryOptions, AdapterSource, BannerMeta, Config, Diagnostic, Diagnostics, Exclude, ExtensionDependencies, ExtensionDependency, ExtensionDependencyRecord, ExtensionFactory, ExtensionKind, ExtensionMeta, Generator as Generator$1, GeneratorContext, Group, Hookable, Include, KubbHooks, KubbPluginEndContext, KubbPluginSetupContext, KubbPluginStartContext, NodeCache, NormalizedPlugin, Output, OutputOptions, Override, Parser, ParserDefinition, ParserFactory, Plugin, PluginDefinition, PluginFactory, PluginFactoryOptions, PluginType, Renderer, RendererFactory, ResolveFileOptions, ResolveImportsOptions, ResolvePathOptions, Resolver, ResolverFile, ResolverFileParams, ResolverFilePathParams, ResolverPatch, Storage, addGenerator, addMacro, assertPluginOption, createAdapter, createRenderer, createResolver, createStorage, defineGenerator, defineParser, definePlugin, fsStorage, injectFile, kubbContext, memoryStorage, requirePlugin, setMacros, setOptions, setResolver, tryUseKubb, useConfig, useKubb, useOptions } from "@kubb/core";
+import { Adapter, AdapterFactoryOptions, AdapterSource, BannerMeta, Config, Diagnostic, Diagnostics, Exclude, ExtensionDependencies, ExtensionDependency, ExtensionDependencyRecord, ExtensionFactory, ExtensionKind, ExtensionMeta, Generator as Generator$1, GeneratorContext, Group, Hookable, Include, KubbHooks, KubbPluginEndContext, KubbPluginSetupContext, KubbPluginStartContext, NodeCache, NormalizedPlugin, Output, OutputOptions, Override, Parser, ParserDefinition, ParserFactory, Plugin, PluginDefinition, PluginFactory, PluginFactoryOptions, PluginOptions, PluginType, Renderer, RendererFactory, ResolveFileOptions, ResolveImportsOptions, ResolvePathOptions, Resolver, ResolverFile, ResolverFileParams, ResolverFilePathParams, ResolverPatch, StandardSchemaV1, Storage, addGenerator, addMacro, assertPluginOption, createAdapter, createRenderer, createResolver, createStorage, defineGenerator, defineParser, definePlugin, fsStorage, injectFile, kubbContext, memoryStorage, requirePlugin, setMacros, setOptions, setResolver, tryUseKubb, useConfig, useKubb, useOptions } from "@kubb/core";
 //#region src/Url.d.ts
 type URLObject = {
   /**
@@ -232,5 +232,5 @@ export declare function containsCircularRef(node: SchemaNode | undefined, { circ
   excludeName?: string;
 }): boolean;
 //#endregion
-export { type Adapter, type AdapterFactoryOptions, type AdapterSource, type BannerMeta, type Config, type Diagnostic, Diagnostics, type Exclude, type ExtensionDependencies, type ExtensionDependency, type ExtensionDependencyRecord, type ExtensionFactory, type ExtensionKind, type ExtensionMeta, type Generator$1 as Generator, type GeneratorContext, type Group, Hookable, type Include, type KubbHooks, type KubbPluginEndContext, type KubbPluginSetupContext, type KubbPluginStartContext, type NodeCache, type NormalizedPlugin, type Output, type OutputOptions, type Override, type Parser, type ParserDefinition, type ParserFactory, type Plugin, type PluginDefinition, type PluginFactory, type PluginFactoryOptions, type PluginType, type Renderer, type RendererFactory, type ResolveFileOptions, type ResolveImportsOptions, type ResolvePathOptions, Resolver, type ResolverFile, type ResolverFileParams, type ResolverFilePathParams, type ResolverPatch, type Storage, addGenerator, addMacro, assertPluginOption, ast, createAdapter, createRenderer, createResolver, createStorage, defineGenerator, defineParser, definePlugin, fsStorage, injectFile, kubbContext, memoryStorage, requirePlugin, setMacros, setOptions, setResolver, tryUseKubb, useConfig, useKubb, useOptions };
+export { type Adapter, type AdapterFactoryOptions, type AdapterSource, type BannerMeta, type Config, type Diagnostic, Diagnostics, type Exclude, type ExtensionDependencies, type ExtensionDependency, type ExtensionDependencyRecord, type ExtensionFactory, type ExtensionKind, type ExtensionMeta, type Generator$1 as Generator, type GeneratorContext, type Group, Hookable, type Include, type KubbHooks, type KubbPluginEndContext, type KubbPluginSetupContext, type KubbPluginStartContext, type NodeCache, type NormalizedPlugin, type Output, type OutputOptions, type Override, type Parser, type ParserDefinition, type ParserFactory, type Plugin, type PluginDefinition, type PluginFactory, type PluginFactoryOptions, type PluginOptions, type PluginType, type Renderer, type RendererFactory, type ResolveFileOptions, type ResolveImportsOptions, type ResolvePathOptions, Resolver, type ResolverFile, type ResolverFileParams, type ResolverFilePathParams, type ResolverPatch, type StandardSchemaV1, type Storage, addGenerator, addMacro, assertPluginOption, ast, createAdapter, createRenderer, createResolver, createStorage, defineGenerator, defineParser, definePlugin, fsStorage, injectFile, kubbContext, memoryStorage, requirePlugin, setMacros, setOptions, setResolver, tryUseKubb, useConfig, useKubb, useOptions };
 //# sourceMappingURL=index.d.ts.map

package/dist/options.cjs

@@ -0,0 +1,140 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("./rolldown-runtime-qbf5tadS.cjs");
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let zod = require("zod");
+zod = require_rolldown_runtime.__toESM(zod, 1);
+//#region src/options.ts
+/**
+* Builds `x-kubb-when` metadata for `.meta()`, such as `.meta({ description, ...when({ 'enum.type': 'asConst' }) })`.
+*/
+function when(condition) {
+	return { "x-kubb-when": condition };
+}
+/**
+* Accepts any string while its type autocompletes `values`. JSON Schema lists them as `x-kubb-values`.
+*/
+function suggest(values) {
+	return zod.string().meta({ "x-kubb-values": values });
+}
+function functionSchema() {
+	return zod.custom((value) => typeof value === "function", { message: "Expected a function" });
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isMacro(value) {
+	if (!isObject(value) || typeof value.name !== "string") return false;
+	return Object.entries(value).every(([key, member]) => key === "name" || key === "enforce" || member === void 0 || typeof member === "function");
+}
+const bannerSchema = zod.union([zod.string(), functionSchema()]);
+/**
+* Mirrors core's `Output`, including `barrel`. The `group` check lives in {@link outputOptionsSchema}.
+* @see https://kubb.dev/docs/5.x/reference/plugin-options#output
+*/
+const outputSchema = zod.object({
+	path: zod.string().meta({ description: "Directory where the plugin writes its generated code, resolved against the global `output.path` set on `defineConfig`. With `mode: 'file'`, this is the full output file path and must include the extension (e.g. `'types.ts'`, `'models.py'`)." }),
+	mode: zod.enum(["directory", "file"]).meta({ description: "How generated code is consolidated into files. `'file'` writes everything into a single file, `'directory'` writes one file per operation or schema under `path`. Defaults to `'file'` when `path` carries an extension and `'directory'` when it does not." }).optional(),
+	banner: bannerSchema.meta({ description: "Text prepended to every generated file. Useful for license headers, lint disables, or `@ts-nocheck` directives. Pass a function to compute the banner from the file's `BannerMeta`." }).optional(),
+	footer: bannerSchema.meta({ description: "Text appended at the end of every generated file. Pass a function to compute the footer from the file's `BannerMeta`." }).optional(),
+	barrel: zod.union([zod.object({
+		type: zod.enum(["all", "named"]).meta({ description: "Export strategy for the plugin's barrel files. `'all'` uses wildcard exports, `'named'` uses explicit exports." }),
+		nested: zod.boolean().meta({ description: "Generate an `index.ts` in every sub-directory, each re-exporting only what's directly inside it." }).optional()
+	}), zod.literal(false)]).meta({ description: "Barrel configuration for this plugin's output. Set to `{ type: 'named' | 'all' }` to opt into a barrel, or `false` to disable it. Falls back to `config.output.barrel` when omitted." }).optional()
+}).meta({ description: "Output configuration shared by every plugin." });
+/**
+* Mirrors core's `Group`.
+* @see https://kubb.dev/docs/5.x/reference/plugin-options#group
+*/
+const groupSchema = zod.object({
+	type: zod.enum(["tag", "path"]).meta({ description: "Property used to assign each operation to a group. `'tag'` uses the first tag, `'path'` uses the first segment of the operation's URL." }),
+	name: functionSchema().meta({ description: "Returns the subdirectory name from the group key. Defaults to the camelCased tag for `tag` groups, or the first path segment as written in the spec for `path` groups." }).optional()
+}).meta({ description: "Groups generated files into subdirectories based on an OpenAPI tag or path segment." });
+function refineGroup(options, ctx) {
+	if (!options.output || !options.group) return;
+	if ((options.output.mode ?? (node_path.default.extname(options.output.path) ? "file" : "directory")) === "file") ctx.addIssue({
+		code: "custom",
+		path: ["group"],
+		message: "A single-file output has nothing to group. Remove the `group` option, give `output.path` an extensionless directory name, or set `output.mode: 'directory'` explicitly."
+	});
+}
+/**
+* `output` and `group` together. Rejects `group` when `output.mode` resolves to `'file'`. `.extend()` keeps the check.
+* @see https://kubb.dev/docs/5.x/reference/plugin-options#output
+*/
+const outputOptionsSchema = zod.object({
+	output: outputSchema.optional(),
+	group: groupSchema.optional()
+}).superRefine(refineGroup);
+const patternSchema = zod.union([zod.string(), zod.instanceof(RegExp)]);
+function byPattern(type, typeDescription, patternDescription) {
+	return zod.object({
+		type: zod.literal(type).meta({ description: typeDescription }),
+		pattern: patternSchema.meta({ description: patternDescription })
+	});
+}
+/**
+* Mirrors core's `Filter`: one include, exclude, or override rule.
+* @see https://kubb.dev/docs/5.x/reference/plugin-options#include
+*/
+const filterSchema = zod.discriminatedUnion("type", [
+	byPattern("tag", "Filter by OpenAPI `tags` field. Matches one or more tags assigned to operations.", "Tag name to match (case-sensitive). Can be a literal string or regex pattern."),
+	byPattern("operationId", "Filter by OpenAPI `operationId` field. Each operation (GET, POST, etc.) has a unique identifier.", "Operation ID to match (case-sensitive). Can be a literal string or regex pattern."),
+	byPattern("path", "Filter by OpenAPI `path` (URL endpoint). Useful to group or filter by service segments like `/pets`, `/users`, etc.", "URL path to match (case-sensitive). Can be a literal string or regex pattern. Matches against the full path."),
+	zod.object({
+		type: zod.literal("method").meta({ description: "Filter by HTTP method." }),
+		pattern: zod.union([zod.enum([
+			"GET",
+			"POST",
+			"PUT",
+			"PATCH",
+			"DELETE",
+			"HEAD",
+			"OPTIONS",
+			"TRACE"
+		]), zod.instanceof(RegExp)]).meta({ description: "HTTP method to match, as one of the `HttpMethod` values or a regex." })
+	}),
+	byPattern("contentType", "Filter by response or request content type: `'application/json'`, `'application/xml'`, etc.", "Content type to match (case-sensitive). Can be a literal string or regex pattern."),
+	byPattern("schemaName", "Filter by schema component name (TypeScript or JSON schema). Matches schemas in `#/components/schemas`.", "Schema name to match (case-sensitive). Can be a literal string or regex pattern.")
+]).meta({ description: "Pattern filter that matches operations or schemas by tag, operationId, path, method, content type, or schema name." });
+/**
+* @see https://kubb.dev/docs/5.x/reference/plugin-options#include
+*/
+const includeSchema = zod.array(filterSchema).meta({ description: "Restricts generation to operations or schemas matching at least one entry." });
+/**
+* @see https://kubb.dev/docs/5.x/reference/plugin-options#exclude
+*/
+const excludeSchema = zod.array(filterSchema).meta({ description: "Skips matching operations or schemas during generation." });
+/**
+* Builds the `override` option from a plugin's options schema, with partial `options` and no `override` key.
+* @see https://kubb.dev/docs/5.x/reference/plugin-options#override
+*/
+function overrideSchema(options) {
+	const { override: _override, ...shape } = options.shape;
+	return zod.array(zod.intersection(filterSchema, zod.object({ options: zod.object(shape).partial().superRefine((options, ctx) => refineGroup(options, ctx)).meta({ description: "Options merged on top of the plugin options when the filter matches." }) }))).meta({ description: "Filters paired with partial options. The first matching entry wins." });
+}
+/**
+* Mirrors core's `ResolverPatch<T>`.
+* @see https://kubb.dev/docs/5.x/reference/plugin-options#resolver
+*/
+function resolverSchema() {
+	return zod.custom((value) => isObject(value) && Object.values(value).every((member) => member === void 0 || typeof member === "function" || isObject(member)), { message: "Expected a resolver object of methods and method namespaces" }).meta({ description: "Partial resolver whose methods replace the plugin's naming and path defaults." });
+}
+/**
+* @see https://kubb.dev/docs/5.x/reference/plugin-options#macros
+*/
+const macrosSchema = zod.array(zod.custom(isMacro, { message: "Expected a macro object with a name and function hooks" })).meta({ description: "Named AST transforms that run before the generators." });
+//#endregion
+exports.excludeSchema = excludeSchema;
+exports.filterSchema = filterSchema;
+exports.groupSchema = groupSchema;
+exports.includeSchema = includeSchema;
+exports.macrosSchema = macrosSchema;
+exports.outputOptionsSchema = outputOptionsSchema;
+exports.outputSchema = outputSchema;
+exports.overrideSchema = overrideSchema;
+exports.resolverSchema = resolverSchema;
+exports.suggest = suggest;
+exports.when = when;
+
+//# sourceMappingURL=options.cjs.map

package/dist/options.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.cjs","names":["z","path"],"sources":["../src/options.ts"],"sourcesContent":["import path from 'node:path'\nimport type { LiteralUnion } from '@internals/utils'\nimport type { HttpMethod, Macro } from '@kubb/ast'\nimport type { BannerMeta, Resolver, ResolverPatch } from '@kubb/core'\nimport * as z from 'zod'\n\n/**\n * A value an option is compared against in a `when` condition.\n */\nexport type WhenValue = string | number | boolean | null\n\n/**\n * Shows an option only when every entry matches. Keys are dotted option paths, such as `'enum.type'`.\n */\nexport type WhenCondition = Record<string, WhenValue | ReadonlyArray<WhenValue>>\n\ndeclare module 'zod' {\n  interface GlobalMeta {\n    'x-kubb-when'?: WhenCondition\n    'x-kubb-values'?: ReadonlyArray<string>\n  }\n}\n\n/**\n * Builds `x-kubb-when` metadata for `.meta()`, such as `.meta({ description, ...when({ 'enum.type': 'asConst' }) })`.\n */\nexport function when(condition: WhenCondition): { 'x-kubb-when': WhenCondition } {\n  return { 'x-kubb-when': condition }\n}\n\n/**\n * Accepts any string while its type autocompletes `values`. JSON Schema lists them as `x-kubb-values`.\n */\nexport function suggest<const TValues extends ReadonlyArray<string>>(values: TValues): z.ZodType<LiteralUnion<TValues[number]>, LiteralUnion<TValues[number]>> {\n  return z.string().meta({ 'x-kubb-values': values })\n}\n\n// `z.function()` would wrap user callbacks, so accept any function as written.\nfunction functionSchema<T>() {\n  return z.custom<T>((value) => typeof value === 'function', { message: 'Expected a function' })\n}\n\nfunction isObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n\nfunction isMacro(value: unknown): boolean {\n  if (!isObject(value) || typeof value.name !== 'string') return false\n  return Object.entries(value).every(([key, member]) => key === 'name' || key === 'enforce' || member === undefined || typeof member === 'function')\n}\n\nconst bannerSchema = z.union([z.string(), functionSchema<(meta: BannerMeta) => string>()])\n\n/**\n * Mirrors core's `Output`, including `barrel`. The `group` check lives in {@link outputOptionsSchema}.\n * @see https://kubb.dev/docs/5.x/reference/plugin-options#output\n */\nexport const outputSchema = z\n  .object({\n    path: z.string().meta({\n      description:\n        \"Directory where the plugin writes its generated code, resolved against the global `output.path` set on `defineConfig`. With `mode: 'file'`, this is the full output file path and must include the extension (e.g. `'types.ts'`, `'models.py'`).\",\n    }),\n    mode: z\n      .enum(['directory', 'file'])\n      .meta({\n        description:\n          \"How generated code is consolidated into files. `'file'` writes everything into a single file, `'directory'` writes one file per operation or schema under `path`. Defaults to `'file'` when `path` carries an extension and `'directory'` when it does not.\",\n      })\n      .optional(),\n    banner: bannerSchema\n      .meta({\n        description:\n          \"Text prepended to every generated file. Useful for license headers, lint disables, or `@ts-nocheck` directives. Pass a function to compute the banner from the file's `BannerMeta`.\",\n      })\n      .optional(),\n    footer: bannerSchema\n      .meta({ description: \"Text appended at the end of every generated file. Pass a function to compute the footer from the file's `BannerMeta`.\" })\n      .optional(),\n    barrel: z\n      .union([\n        z.object({\n          type: z.enum(['all', 'named']).meta({\n            description: \"Export strategy for the plugin's barrel files. `'all'` uses wildcard exports, `'named'` uses explicit exports.\",\n          }),\n          nested: z\n            .boolean()\n            .meta({ description: \"Generate an `index.ts` in every sub-directory, each re-exporting only what's directly inside it.\" })\n            .optional(),\n        }),\n        z.literal(false),\n      ])\n      .meta({\n        description:\n          \"Barrel configuration for this plugin's output. Set to `{ type: 'named' | 'all' }` to opt into a barrel, or `false` to disable it. Falls back to `config.output.barrel` when omitted.\",\n      })\n      .optional(),\n  })\n  .meta({ description: 'Output configuration shared by every plugin.' })\n\n/**\n * Mirrors core's `Group`.\n * @see https://kubb.dev/docs/5.x/reference/plugin-options#group\n */\nexport const groupSchema = z\n  .object({\n    type: z.enum(['tag', 'path']).meta({\n      description: \"Property used to assign each operation to a group. `'tag'` uses the first tag, `'path'` uses the first segment of the operation's URL.\",\n    }),\n    name: functionSchema<(context: { group: string }) => string>()\n      .meta({\n        description:\n          'Returns the subdirectory name from the group key. Defaults to the camelCased tag for `tag` groups, or the first path segment as written in the spec for `path` groups.',\n      })\n      .optional(),\n  })\n  .meta({ description: 'Groups generated files into subdirectories based on an OpenAPI tag or path segment.' })\n\ntype GroupedOptions = { output?: { path: string; mode?: 'directory' | 'file' }; group?: object }\n\nfunction refineGroup(options: GroupedOptions, ctx: z.RefinementCtx): void {\n  if (!options.output || !options.group) return\n\n  const mode = options.output.mode ?? (path.extname(options.output.path) ? 'file' : 'directory')\n  if (mode === 'file') {\n    ctx.addIssue({\n      code: 'custom',\n      path: ['group'],\n      message:\n        \"A single-file output has nothing to group. Remove the `group` option, give `output.path` an extensionless directory name, or set `output.mode: 'directory'` explicitly.\",\n    })\n  }\n}\n\n/**\n * `output` and `group` together. Rejects `group` when `output.mode` resolves to `'file'`. `.extend()` keeps the check.\n * @see https://kubb.dev/docs/5.x/reference/plugin-options#output\n */\nexport const outputOptionsSchema = z\n  .object({\n    output: outputSchema.optional(),\n    group: groupSchema.optional(),\n  })\n  .superRefine(refineGroup)\n\nconst patternSchema = z.union([z.string(), z.instanceof(RegExp)])\n\nfunction byPattern<const TType extends string>(type: TType, typeDescription: string, patternDescription: string) {\n  return z.object({\n    type: z.literal(type).meta({ description: typeDescription }),\n    pattern: patternSchema.meta({ description: patternDescription }),\n  })\n}\n\nconst httpMethods = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS', 'TRACE'] as const satisfies ReadonlyArray<HttpMethod>\n\n/**\n * Mirrors core's `Filter`: one include, exclude, or override rule.\n * @see https://kubb.dev/docs/5.x/reference/plugin-options#include\n */\nexport const filterSchema = z\n  .discriminatedUnion('type', [\n    byPattern(\n      'tag',\n      'Filter by OpenAPI `tags` field. Matches one or more tags assigned to operations.',\n      'Tag name to match (case-sensitive). Can be a literal string or regex pattern.',\n    ),\n    byPattern(\n      'operationId',\n      'Filter by OpenAPI `operationId` field. Each operation (GET, POST, etc.) has a unique identifier.',\n      'Operation ID to match (case-sensitive). Can be a literal string or regex pattern.',\n    ),\n    byPattern(\n      'path',\n      'Filter by OpenAPI `path` (URL endpoint). Useful to group or filter by service segments like `/pets`, `/users`, etc.',\n      'URL path to match (case-sensitive). Can be a literal string or regex pattern. Matches against the full path.',\n    ),\n    z.object({\n      type: z.literal('method').meta({ description: 'Filter by HTTP method.' }),\n      pattern: z\n        .union([z.enum(httpMethods), z.instanceof(RegExp)])\n        .meta({ description: 'HTTP method to match, as one of the `HttpMethod` values or a regex.' }),\n    }),\n    byPattern(\n      'contentType',\n      \"Filter by response or request content type: `'application/json'`, `'application/xml'`, etc.\",\n      'Content type to match (case-sensitive). Can be a literal string or regex pattern.',\n    ),\n    byPattern(\n      'schemaName',\n      'Filter by schema component name (TypeScript or JSON schema). Matches schemas in `#/components/schemas`.',\n      'Schema name to match (case-sensitive). Can be a literal string or regex pattern.',\n    ),\n  ])\n  .meta({ description: 'Pattern filter that matches operations or schemas by tag, operationId, path, method, content type, or schema name.' })\n\n/**\n * @see https://kubb.dev/docs/5.x/reference/plugin-options#include\n */\nexport const includeSchema = z.array(filterSchema).meta({ description: 'Restricts generation to operations or schemas matching at least one entry.' })\n\n/**\n * @see https://kubb.dev/docs/5.x/reference/plugin-options#exclude\n */\nexport const excludeSchema = z.array(filterSchema).meta({ description: 'Skips matching operations or schemas during generation.' })\n\n/**\n * Builds the `override` option from a plugin's options schema, with partial `options` and no `override` key.\n * @see https://kubb.dev/docs/5.x/reference/plugin-options#override\n */\nexport function overrideSchema<TShape extends z.ZodRawShape>(options: z.ZodObject<TShape, z.core.$ZodObjectConfig>) {\n  const { override: _override, ...shape } = options.shape\n\n  return z\n    .array(\n      z.intersection(\n        filterSchema,\n        z.object({\n          options: z\n            .object(shape)\n            .partial()\n            .superRefine((options, ctx) => refineGroup(options as GroupedOptions, ctx))\n            .meta({ description: 'Options merged on top of the plugin options when the filter matches.' }),\n        }),\n      ),\n    )\n    .meta({ description: 'Filters paired with partial options. The first matching entry wins.' })\n}\n\n/**\n * Mirrors core's `ResolverPatch<T>`.\n * @see https://kubb.dev/docs/5.x/reference/plugin-options#resolver\n */\nexport function resolverSchema<T extends Resolver = Resolver>() {\n  return z\n    .custom<ResolverPatch<T>>(\n      (value) => isObject(value) && Object.values(value).every((member) => member === undefined || typeof member === 'function' || isObject(member)),\n      { message: 'Expected a resolver object of methods and method namespaces' },\n    )\n    .meta({ description: \"Partial resolver whose methods replace the plugin's naming and path defaults.\" })\n}\n\n/**\n * @see https://kubb.dev/docs/5.x/reference/plugin-options#macros\n */\nexport const macrosSchema = z\n  .array(z.custom<Macro>(isMacro, { message: 'Expected a macro object with a name and function hooks' }))\n  .meta({ description: 'Named AST transforms that run before the generators.' })\n"],"mappings":"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"}

package/dist/options.d.ts

@@ -0,0 +1,253 @@
+import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
+import { Macro } from "@kubb/ast";
+import { BannerMeta, Resolver, ResolverPatch } from "@kubb/core";
+import * as z from "zod";
+//#region ../../internals/utils/src/types.d.ts
+/** A union of known literals that still accepts any other value of `Base`, without collapsing
+ * the literals away. Editors keep autocompleting the known members while arbitrary strings stay
+ * assignable.
+ *
+ * @example
+ * ```ts
+ * type PluginName = LiteralUnion<'plugin-ts' | 'plugin-zod'>
+ * const a: PluginName = 'plugin-ts' // autocompletes
+ * const b: PluginName = 'anything'  // still allowed
+ * ```
+ */
+type LiteralUnion<T extends Base, Base = string> = T | (Base & {});
+//#endregion
+//#region src/options.d.ts
+/**
+ * A value an option is compared against in a `when` condition.
+ */
+export type WhenValue = string | number | boolean | null;
+/**
+ * Shows an option only when every entry matches. Keys are dotted option paths, such as `'enum.type'`.
+ */
+export type WhenCondition = Record<string, WhenValue | ReadonlyArray<WhenValue>>;
+declare module 'zod' {
+  interface GlobalMeta {
+    'x-kubb-when'?: WhenCondition;
+    'x-kubb-values'?: ReadonlyArray<string>;
+  }
+}
+/**
+ * Builds `x-kubb-when` metadata for `.meta()`, such as `.meta({ description, ...when({ 'enum.type': 'asConst' }) })`.
+ */
+export declare function when(condition: WhenCondition): {
+  'x-kubb-when': WhenCondition;
+};
+/**
+ * Accepts any string while its type autocompletes `values`. JSON Schema lists them as `x-kubb-values`.
+ */
+export declare function suggest<const TValues extends ReadonlyArray<string>>(values: TValues): z.ZodType<LiteralUnion<TValues[number]>, LiteralUnion<TValues[number]>>;
+/**
+ * Mirrors core's `Output`, including `barrel`. The `group` check lives in {@link outputOptionsSchema}.
+ * @see https://kubb.dev/docs/5.x/reference/plugin-options#output
+ */
+export declare const outputSchema: z.ZodObject<{
+  path: z.ZodString;
+  mode: z.ZodOptional<z.ZodEnum<{
+    directory: "directory";
+    file: "file";
+  }>>;
+  banner: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<(meta: BannerMeta) => string, (meta: BannerMeta) => string>]>>;
+  footer: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<(meta: BannerMeta) => string, (meta: BannerMeta) => string>]>>;
+  barrel: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodEnum<{
+      all: "all";
+      named: "named";
+    }>;
+    nested: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>, z.ZodLiteral<false>]>>;
+}, z.core.$strip>;
+/**
+ * Mirrors core's `Group`.
+ * @see https://kubb.dev/docs/5.x/reference/plugin-options#group
+ */
+export declare const groupSchema: z.ZodObject<{
+  type: z.ZodEnum<{
+    path: "path";
+    tag: "tag";
+  }>;
+  name: z.ZodOptional<z.ZodCustom<(context: {
+    group: string;
+  }) => string, (context: {
+    group: string;
+  }) => string>>;
+}, z.core.$strip>;
+/**
+ * `output` and `group` together. Rejects `group` when `output.mode` resolves to `'file'`. `.extend()` keeps the check.
+ * @see https://kubb.dev/docs/5.x/reference/plugin-options#output
+ */
+export declare const outputOptionsSchema: z.ZodObject<{
+  output: z.ZodOptional<z.ZodObject<{
+    path: z.ZodString;
+    mode: z.ZodOptional<z.ZodEnum<{
+      directory: "directory";
+      file: "file";
+    }>>;
+    banner: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<(meta: BannerMeta) => string, (meta: BannerMeta) => string>]>>;
+    footer: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<(meta: BannerMeta) => string, (meta: BannerMeta) => string>]>>;
+    barrel: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+      type: z.ZodEnum<{
+        all: "all";
+        named: "named";
+      }>;
+      nested: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodLiteral<false>]>>;
+  }, z.core.$strip>>;
+  group: z.ZodOptional<z.ZodObject<{
+    type: z.ZodEnum<{
+      path: "path";
+      tag: "tag";
+    }>;
+    name: z.ZodOptional<z.ZodCustom<(context: {
+      group: string;
+    }) => string, (context: {
+      group: string;
+    }) => string>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Mirrors core's `Filter`: one include, exclude, or override rule.
+ * @see https://kubb.dev/docs/5.x/reference/plugin-options#include
+ */
+export declare const filterSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"tag">;
+  pattern: z.ZodUnion<readonly [z.ZodString, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"operationId">;
+  pattern: z.ZodUnion<readonly [z.ZodString, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"path">;
+  pattern: z.ZodUnion<readonly [z.ZodString, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"method">;
+  pattern: z.ZodUnion<readonly [z.ZodEnum<{
+    GET: "GET";
+    POST: "POST";
+    PUT: "PUT";
+    PATCH: "PATCH";
+    DELETE: "DELETE";
+    HEAD: "HEAD";
+    OPTIONS: "OPTIONS";
+    TRACE: "TRACE";
+  }>, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"contentType">;
+  pattern: z.ZodUnion<readonly [z.ZodString, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"schemaName">;
+  pattern: z.ZodUnion<readonly [z.ZodString, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>], "type">;
+/**
+ * @see https://kubb.dev/docs/5.x/reference/plugin-options#include
+ */
+export declare const includeSchema: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"tag">;
+  pattern: z.ZodUnion<readonly [z.ZodString, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"operationId">;
+  pattern: z.ZodUnion<readonly [z.ZodString, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"path">;
+  pattern: z.ZodUnion<readonly [z.ZodString, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"method">;
+  pattern: z.ZodUnion<readonly [z.ZodEnum<{
+    GET: "GET";
+    POST: "POST";
+    PUT: "PUT";
+    PATCH: "PATCH";
+    DELETE: "DELETE";
+    HEAD: "HEAD";
+    OPTIONS: "OPTIONS";
+    TRACE: "TRACE";
+  }>, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"contentType">;
+  pattern: z.ZodUnion<readonly [z.ZodString, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"schemaName">;
+  pattern: z.ZodUnion<readonly [z.ZodString, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>], "type">>;
+/**
+ * @see https://kubb.dev/docs/5.x/reference/plugin-options#exclude
+ */
+export declare const excludeSchema: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"tag">;
+  pattern: z.ZodUnion<readonly [z.ZodString, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"operationId">;
+  pattern: z.ZodUnion<readonly [z.ZodString, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"path">;
+  pattern: z.ZodUnion<readonly [z.ZodString, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"method">;
+  pattern: z.ZodUnion<readonly [z.ZodEnum<{
+    GET: "GET";
+    POST: "POST";
+    PUT: "PUT";
+    PATCH: "PATCH";
+    DELETE: "DELETE";
+    HEAD: "HEAD";
+    OPTIONS: "OPTIONS";
+    TRACE: "TRACE";
+  }>, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"contentType">;
+  pattern: z.ZodUnion<readonly [z.ZodString, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"schemaName">;
+  pattern: z.ZodUnion<readonly [z.ZodString, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>], "type">>;
+/**
+ * Builds the `override` option from a plugin's options schema, with partial `options` and no `override` key.
+ * @see https://kubb.dev/docs/5.x/reference/plugin-options#override
+ */
+export declare function overrideSchema<TShape extends z.ZodRawShape>(options: z.ZodObject<TShape, z.core.$ZodObjectConfig>): z.ZodArray<z.ZodIntersection<z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"tag">;
+  pattern: z.ZodUnion<readonly [z.ZodString, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"operationId">;
+  pattern: z.ZodUnion<readonly [z.ZodString, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"path">;
+  pattern: z.ZodUnion<readonly [z.ZodString, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"method">;
+  pattern: z.ZodUnion<readonly [z.ZodEnum<{
+    GET: "GET";
+    POST: "POST";
+    PUT: "PUT";
+    PATCH: "PATCH";
+    DELETE: "DELETE";
+    HEAD: "HEAD";
+    OPTIONS: "OPTIONS";
+    TRACE: "TRACE";
+  }>, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"contentType">;
+  pattern: z.ZodUnion<readonly [z.ZodString, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"schemaName">;
+  pattern: z.ZodUnion<readonly [z.ZodString, z.ZodInstanceOf<RegExp>]>;
+}, z.core.$strip>], "type">, z.ZodObject<{
+  options: z.ZodObject<(Omit<TShape, "override"> extends (infer T_1) ? { -readonly [P in keyof T_1]: T_1[P]; } : never) extends (infer T extends Readonly<{
+    [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+  }>) ? { -readonly [k in keyof T]: z.ZodOptional<T[k]>; } : never, z.core.$strip>;
+}, z.core.$strip>>>;
+/**
+ * Mirrors core's `ResolverPatch<T>`.
+ * @see https://kubb.dev/docs/5.x/reference/plugin-options#resolver
+ */
+export declare function resolverSchema<T extends Resolver = Resolver>(): z.ZodCustom<ResolverPatch<T>, ResolverPatch<T>>;
+/**
+ * @see https://kubb.dev/docs/5.x/reference/plugin-options#macros
+ */
+export declare const macrosSchema: z.ZodArray<z.ZodCustom<Macro, Macro>>;
+//#endregion
+export {};
+//# sourceMappingURL=options.d.ts.map

package/dist/options.js

@@ -0,0 +1,127 @@
+import "./rolldown-runtime-C0LytTxp.js";
+import path from "node:path";
+import * as z from "zod";
+//#region src/options.ts
+/**
+* Builds `x-kubb-when` metadata for `.meta()`, such as `.meta({ description, ...when({ 'enum.type': 'asConst' }) })`.
+*/
+function when(condition) {
+	return { "x-kubb-when": condition };
+}
+/**
+* Accepts any string while its type autocompletes `values`. JSON Schema lists them as `x-kubb-values`.
+*/
+function suggest(values) {
+	return z.string().meta({ "x-kubb-values": values });
+}
+function functionSchema() {
+	return z.custom((value) => typeof value === "function", { message: "Expected a function" });
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isMacro(value) {
+	if (!isObject(value) || typeof value.name !== "string") return false;
+	return Object.entries(value).every(([key, member]) => key === "name" || key === "enforce" || member === void 0 || typeof member === "function");
+}
+const bannerSchema = z.union([z.string(), functionSchema()]);
+/**
+* Mirrors core's `Output`, including `barrel`. The `group` check lives in {@link outputOptionsSchema}.
+* @see https://kubb.dev/docs/5.x/reference/plugin-options#output
+*/
+const outputSchema = z.object({
+	path: z.string().meta({ description: "Directory where the plugin writes its generated code, resolved against the global `output.path` set on `defineConfig`. With `mode: 'file'`, this is the full output file path and must include the extension (e.g. `'types.ts'`, `'models.py'`)." }),
+	mode: z.enum(["directory", "file"]).meta({ description: "How generated code is consolidated into files. `'file'` writes everything into a single file, `'directory'` writes one file per operation or schema under `path`. Defaults to `'file'` when `path` carries an extension and `'directory'` when it does not." }).optional(),
+	banner: bannerSchema.meta({ description: "Text prepended to every generated file. Useful for license headers, lint disables, or `@ts-nocheck` directives. Pass a function to compute the banner from the file's `BannerMeta`." }).optional(),
+	footer: bannerSchema.meta({ description: "Text appended at the end of every generated file. Pass a function to compute the footer from the file's `BannerMeta`." }).optional(),
+	barrel: z.union([z.object({
+		type: z.enum(["all", "named"]).meta({ description: "Export strategy for the plugin's barrel files. `'all'` uses wildcard exports, `'named'` uses explicit exports." }),
+		nested: z.boolean().meta({ description: "Generate an `index.ts` in every sub-directory, each re-exporting only what's directly inside it." }).optional()
+	}), z.literal(false)]).meta({ description: "Barrel configuration for this plugin's output. Set to `{ type: 'named' | 'all' }` to opt into a barrel, or `false` to disable it. Falls back to `config.output.barrel` when omitted." }).optional()
+}).meta({ description: "Output configuration shared by every plugin." });
+/**
+* Mirrors core's `Group`.
+* @see https://kubb.dev/docs/5.x/reference/plugin-options#group
+*/
+const groupSchema = z.object({
+	type: z.enum(["tag", "path"]).meta({ description: "Property used to assign each operation to a group. `'tag'` uses the first tag, `'path'` uses the first segment of the operation's URL." }),
+	name: functionSchema().meta({ description: "Returns the subdirectory name from the group key. Defaults to the camelCased tag for `tag` groups, or the first path segment as written in the spec for `path` groups." }).optional()
+}).meta({ description: "Groups generated files into subdirectories based on an OpenAPI tag or path segment." });
+function refineGroup(options, ctx) {
+	if (!options.output || !options.group) return;
+	if ((options.output.mode ?? (path.extname(options.output.path) ? "file" : "directory")) === "file") ctx.addIssue({
+		code: "custom",
+		path: ["group"],
+		message: "A single-file output has nothing to group. Remove the `group` option, give `output.path` an extensionless directory name, or set `output.mode: 'directory'` explicitly."
+	});
+}
+/**
+* `output` and `group` together. Rejects `group` when `output.mode` resolves to `'file'`. `.extend()` keeps the check.
+* @see https://kubb.dev/docs/5.x/reference/plugin-options#output
+*/
+const outputOptionsSchema = z.object({
+	output: outputSchema.optional(),
+	group: groupSchema.optional()
+}).superRefine(refineGroup);
+const patternSchema = z.union([z.string(), z.instanceof(RegExp)]);
+function byPattern(type, typeDescription, patternDescription) {
+	return z.object({
+		type: z.literal(type).meta({ description: typeDescription }),
+		pattern: patternSchema.meta({ description: patternDescription })
+	});
+}
+/**
+* Mirrors core's `Filter`: one include, exclude, or override rule.
+* @see https://kubb.dev/docs/5.x/reference/plugin-options#include
+*/
+const filterSchema = z.discriminatedUnion("type", [
+	byPattern("tag", "Filter by OpenAPI `tags` field. Matches one or more tags assigned to operations.", "Tag name to match (case-sensitive). Can be a literal string or regex pattern."),
+	byPattern("operationId", "Filter by OpenAPI `operationId` field. Each operation (GET, POST, etc.) has a unique identifier.", "Operation ID to match (case-sensitive). Can be a literal string or regex pattern."),
+	byPattern("path", "Filter by OpenAPI `path` (URL endpoint). Useful to group or filter by service segments like `/pets`, `/users`, etc.", "URL path to match (case-sensitive). Can be a literal string or regex pattern. Matches against the full path."),
+	z.object({
+		type: z.literal("method").meta({ description: "Filter by HTTP method." }),
+		pattern: z.union([z.enum([
+			"GET",
+			"POST",
+			"PUT",
+			"PATCH",
+			"DELETE",
+			"HEAD",
+			"OPTIONS",
+			"TRACE"
+		]), z.instanceof(RegExp)]).meta({ description: "HTTP method to match, as one of the `HttpMethod` values or a regex." })
+	}),
+	byPattern("contentType", "Filter by response or request content type: `'application/json'`, `'application/xml'`, etc.", "Content type to match (case-sensitive). Can be a literal string or regex pattern."),
+	byPattern("schemaName", "Filter by schema component name (TypeScript or JSON schema). Matches schemas in `#/components/schemas`.", "Schema name to match (case-sensitive). Can be a literal string or regex pattern.")
+]).meta({ description: "Pattern filter that matches operations or schemas by tag, operationId, path, method, content type, or schema name." });
+/**
+* @see https://kubb.dev/docs/5.x/reference/plugin-options#include
+*/
+const includeSchema = z.array(filterSchema).meta({ description: "Restricts generation to operations or schemas matching at least one entry." });
+/**
+* @see https://kubb.dev/docs/5.x/reference/plugin-options#exclude
+*/
+const excludeSchema = z.array(filterSchema).meta({ description: "Skips matching operations or schemas during generation." });
+/**
+* Builds the `override` option from a plugin's options schema, with partial `options` and no `override` key.
+* @see https://kubb.dev/docs/5.x/reference/plugin-options#override
+*/
+function overrideSchema(options) {
+	const { override: _override, ...shape } = options.shape;
+	return z.array(z.intersection(filterSchema, z.object({ options: z.object(shape).partial().superRefine((options, ctx) => refineGroup(options, ctx)).meta({ description: "Options merged on top of the plugin options when the filter matches." }) }))).meta({ description: "Filters paired with partial options. The first matching entry wins." });
+}
+/**
+* Mirrors core's `ResolverPatch<T>`.
+* @see https://kubb.dev/docs/5.x/reference/plugin-options#resolver
+*/
+function resolverSchema() {
+	return z.custom((value) => isObject(value) && Object.values(value).every((member) => member === void 0 || typeof member === "function" || isObject(member)), { message: "Expected a resolver object of methods and method namespaces" }).meta({ description: "Partial resolver whose methods replace the plugin's naming and path defaults." });
+}
+/**
+* @see https://kubb.dev/docs/5.x/reference/plugin-options#macros
+*/
+const macrosSchema = z.array(z.custom(isMacro, { message: "Expected a macro object with a name and function hooks" })).meta({ description: "Named AST transforms that run before the generators." });
+//#endregion
+export { excludeSchema, filterSchema, groupSchema, includeSchema, macrosSchema, outputOptionsSchema, outputSchema, overrideSchema, resolverSchema, suggest, when };
+
+//# sourceMappingURL=options.js.map

package/dist/options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.js","names":[],"sources":["../src/options.ts"],"sourcesContent":["import path from 'node:path'\nimport type { LiteralUnion } from '@internals/utils'\nimport type { HttpMethod, Macro } from '@kubb/ast'\nimport type { BannerMeta, Resolver, ResolverPatch } from '@kubb/core'\nimport * as z from 'zod'\n\n/**\n * A value an option is compared against in a `when` condition.\n */\nexport type WhenValue = string | number | boolean | null\n\n/**\n * Shows an option only when every entry matches. Keys are dotted option paths, such as `'enum.type'`.\n */\nexport type WhenCondition = Record<string, WhenValue | ReadonlyArray<WhenValue>>\n\ndeclare module 'zod' {\n  interface GlobalMeta {\n    'x-kubb-when'?: WhenCondition\n    'x-kubb-values'?: ReadonlyArray<string>\n  }\n}\n\n/**\n * Builds `x-kubb-when` metadata for `.meta()`, such as `.meta({ description, ...when({ 'enum.type': 'asConst' }) })`.\n */\nexport function when(condition: WhenCondition): { 'x-kubb-when': WhenCondition } {\n  return { 'x-kubb-when': condition }\n}\n\n/**\n * Accepts any string while its type autocompletes `values`. JSON Schema lists them as `x-kubb-values`.\n */\nexport function suggest<const TValues extends ReadonlyArray<string>>(values: TValues): z.ZodType<LiteralUnion<TValues[number]>, LiteralUnion<TValues[number]>> {\n  return z.string().meta({ 'x-kubb-values': values })\n}\n\n// `z.function()` would wrap user callbacks, so accept any function as written.\nfunction functionSchema<T>() {\n  return z.custom<T>((value) => typeof value === 'function', { message: 'Expected a function' })\n}\n\nfunction isObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n\nfunction isMacro(value: unknown): boolean {\n  if (!isObject(value) || typeof value.name !== 'string') return false\n  return Object.entries(value).every(([key, member]) => key === 'name' || key === 'enforce' || member === undefined || typeof member === 'function')\n}\n\nconst bannerSchema = z.union([z.string(), functionSchema<(meta: BannerMeta) => string>()])\n\n/**\n * Mirrors core's `Output`, including `barrel`. The `group` check lives in {@link outputOptionsSchema}.\n * @see https://kubb.dev/docs/5.x/reference/plugin-options#output\n */\nexport const outputSchema = z\n  .object({\n    path: z.string().meta({\n      description:\n        \"Directory where the plugin writes its generated code, resolved against the global `output.path` set on `defineConfig`. With `mode: 'file'`, this is the full output file path and must include the extension (e.g. `'types.ts'`, `'models.py'`).\",\n    }),\n    mode: z\n      .enum(['directory', 'file'])\n      .meta({\n        description:\n          \"How generated code is consolidated into files. `'file'` writes everything into a single file, `'directory'` writes one file per operation or schema under `path`. Defaults to `'file'` when `path` carries an extension and `'directory'` when it does not.\",\n      })\n      .optional(),\n    banner: bannerSchema\n      .meta({\n        description:\n          \"Text prepended to every generated file. Useful for license headers, lint disables, or `@ts-nocheck` directives. Pass a function to compute the banner from the file's `BannerMeta`.\",\n      })\n      .optional(),\n    footer: bannerSchema\n      .meta({ description: \"Text appended at the end of every generated file. Pass a function to compute the footer from the file's `BannerMeta`.\" })\n      .optional(),\n    barrel: z\n      .union([\n        z.object({\n          type: z.enum(['all', 'named']).meta({\n            description: \"Export strategy for the plugin's barrel files. `'all'` uses wildcard exports, `'named'` uses explicit exports.\",\n          }),\n          nested: z\n            .boolean()\n            .meta({ description: \"Generate an `index.ts` in every sub-directory, each re-exporting only what's directly inside it.\" })\n            .optional(),\n        }),\n        z.literal(false),\n      ])\n      .meta({\n        description:\n          \"Barrel configuration for this plugin's output. Set to `{ type: 'named' | 'all' }` to opt into a barrel, or `false` to disable it. Falls back to `config.output.barrel` when omitted.\",\n      })\n      .optional(),\n  })\n  .meta({ description: 'Output configuration shared by every plugin.' })\n\n/**\n * Mirrors core's `Group`.\n * @see https://kubb.dev/docs/5.x/reference/plugin-options#group\n */\nexport const groupSchema = z\n  .object({\n    type: z.enum(['tag', 'path']).meta({\n      description: \"Property used to assign each operation to a group. `'tag'` uses the first tag, `'path'` uses the first segment of the operation's URL.\",\n    }),\n    name: functionSchema<(context: { group: string }) => string>()\n      .meta({\n        description:\n          'Returns the subdirectory name from the group key. Defaults to the camelCased tag for `tag` groups, or the first path segment as written in the spec for `path` groups.',\n      })\n      .optional(),\n  })\n  .meta({ description: 'Groups generated files into subdirectories based on an OpenAPI tag or path segment.' })\n\ntype GroupedOptions = { output?: { path: string; mode?: 'directory' | 'file' }; group?: object }\n\nfunction refineGroup(options: GroupedOptions, ctx: z.RefinementCtx): void {\n  if (!options.output || !options.group) return\n\n  const mode = options.output.mode ?? (path.extname(options.output.path) ? 'file' : 'directory')\n  if (mode === 'file') {\n    ctx.addIssue({\n      code: 'custom',\n      path: ['group'],\n      message:\n        \"A single-file output has nothing to group. Remove the `group` option, give `output.path` an extensionless directory name, or set `output.mode: 'directory'` explicitly.\",\n    })\n  }\n}\n\n/**\n * `output` and `group` together. Rejects `group` when `output.mode` resolves to `'file'`. `.extend()` keeps the check.\n * @see https://kubb.dev/docs/5.x/reference/plugin-options#output\n */\nexport const outputOptionsSchema = z\n  .object({\n    output: outputSchema.optional(),\n    group: groupSchema.optional(),\n  })\n  .superRefine(refineGroup)\n\nconst patternSchema = z.union([z.string(), z.instanceof(RegExp)])\n\nfunction byPattern<const TType extends string>(type: TType, typeDescription: string, patternDescription: string) {\n  return z.object({\n    type: z.literal(type).meta({ description: typeDescription }),\n    pattern: patternSchema.meta({ description: patternDescription }),\n  })\n}\n\nconst httpMethods = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS', 'TRACE'] as const satisfies ReadonlyArray<HttpMethod>\n\n/**\n * Mirrors core's `Filter`: one include, exclude, or override rule.\n * @see https://kubb.dev/docs/5.x/reference/plugin-options#include\n */\nexport const filterSchema = z\n  .discriminatedUnion('type', [\n    byPattern(\n      'tag',\n      'Filter by OpenAPI `tags` field. Matches one or more tags assigned to operations.',\n      'Tag name to match (case-sensitive). Can be a literal string or regex pattern.',\n    ),\n    byPattern(\n      'operationId',\n      'Filter by OpenAPI `operationId` field. Each operation (GET, POST, etc.) has a unique identifier.',\n      'Operation ID to match (case-sensitive). Can be a literal string or regex pattern.',\n    ),\n    byPattern(\n      'path',\n      'Filter by OpenAPI `path` (URL endpoint). Useful to group or filter by service segments like `/pets`, `/users`, etc.',\n      'URL path to match (case-sensitive). Can be a literal string or regex pattern. Matches against the full path.',\n    ),\n    z.object({\n      type: z.literal('method').meta({ description: 'Filter by HTTP method.' }),\n      pattern: z\n        .union([z.enum(httpMethods), z.instanceof(RegExp)])\n        .meta({ description: 'HTTP method to match, as one of the `HttpMethod` values or a regex.' }),\n    }),\n    byPattern(\n      'contentType',\n      \"Filter by response or request content type: `'application/json'`, `'application/xml'`, etc.\",\n      'Content type to match (case-sensitive). Can be a literal string or regex pattern.',\n    ),\n    byPattern(\n      'schemaName',\n      'Filter by schema component name (TypeScript or JSON schema). Matches schemas in `#/components/schemas`.',\n      'Schema name to match (case-sensitive). Can be a literal string or regex pattern.',\n    ),\n  ])\n  .meta({ description: 'Pattern filter that matches operations or schemas by tag, operationId, path, method, content type, or schema name.' })\n\n/**\n * @see https://kubb.dev/docs/5.x/reference/plugin-options#include\n */\nexport const includeSchema = z.array(filterSchema).meta({ description: 'Restricts generation to operations or schemas matching at least one entry.' })\n\n/**\n * @see https://kubb.dev/docs/5.x/reference/plugin-options#exclude\n */\nexport const excludeSchema = z.array(filterSchema).meta({ description: 'Skips matching operations or schemas during generation.' })\n\n/**\n * Builds the `override` option from a plugin's options schema, with partial `options` and no `override` key.\n * @see https://kubb.dev/docs/5.x/reference/plugin-options#override\n */\nexport function overrideSchema<TShape extends z.ZodRawShape>(options: z.ZodObject<TShape, z.core.$ZodObjectConfig>) {\n  const { override: _override, ...shape } = options.shape\n\n  return z\n    .array(\n      z.intersection(\n        filterSchema,\n        z.object({\n          options: z\n            .object(shape)\n            .partial()\n            .superRefine((options, ctx) => refineGroup(options as GroupedOptions, ctx))\n            .meta({ description: 'Options merged on top of the plugin options when the filter matches.' }),\n        }),\n      ),\n    )\n    .meta({ description: 'Filters paired with partial options. The first matching entry wins.' })\n}\n\n/**\n * Mirrors core's `ResolverPatch<T>`.\n * @see https://kubb.dev/docs/5.x/reference/plugin-options#resolver\n */\nexport function resolverSchema<T extends Resolver = Resolver>() {\n  return z\n    .custom<ResolverPatch<T>>(\n      (value) => isObject(value) && Object.values(value).every((member) => member === undefined || typeof member === 'function' || isObject(member)),\n      { message: 'Expected a resolver object of methods and method namespaces' },\n    )\n    .meta({ description: \"Partial resolver whose methods replace the plugin's naming and path defaults.\" })\n}\n\n/**\n * @see https://kubb.dev/docs/5.x/reference/plugin-options#macros\n */\nexport const macrosSchema = z\n  .array(z.custom<Macro>(isMacro, { message: 'Expected a macro object with a name and function hooks' }))\n  .meta({ description: 'Named AST transforms that run before the generators.' })\n"],"mappings":"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"}

package/dist/rolldown-runtime-qbf5tadS.cjs

@@ -0,0 +1,38 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+Object.defineProperty(exports, "__name", {
+	enumerable: true,
+	get: function() {
+		return __name;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/kit",
-  "version": "5.7.0",
+  "version": "5.8.0",
   "description": "Authoring toolkit for Kubb plugins, generators, adapters, resolvers, and renderers.",
   "keywords": [
     "codegen",
@@ -56,6 +56,11 @@
       "import": "./dist/testing.js",
       "require": "./dist/testing.cjs"
     },
+    "./options": {
+      "types": "./dist/options.d.ts",
+      "import": "./dist/options.js",
+      "require": "./dist/options.cjs"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -63,11 +68,20 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/ast": "5.7.0",
-    "@kubb/core": "5.7.0"
+    "@kubb/ast": "5.8.0",
+    "@kubb/core": "5.8.0"
   },
   "devDependencies": {
-    "@internals/utils": "0.0.1"
+    "@internals/utils": "0.0.1",
+    "zod": "^4.6.5"
+  },
+  "peerDependencies": {
+    "zod": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "zod": {
+      "optional": true
+    }
   },
   "engines": {
     "node": ">=22"