@kubb/plugin-ts 5.1.0-canary.20261023T200213 → 5.1.0

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["createRequire","isNonNullable","syncSchemaRef","factory.createEnumDeclaration","File","parserTs","ast","syncSchemaRef","ast","ast","File","factory","ast","factory.createTypeReferenceNode","factory.createUrlTemplateType","factory.dateOrStringNode","factory.constToTypeNode","factory.createUnionDeclaration","isStringType","factory.createIntersectionDeclaration","factory.createTypeLiteralNode","factory.buildMemberNodes","factory.createArrayDeclaration","factory.buildTupleNode","factory.buildPropertyType","syncSchemaRef","factory.createPropertySignature","factory.appendJSDocToNode","factory.buildIndexSignatures","factory.wrapNullableOptional","parserTs","factory.createOmitDeclaration","factory.isUnionTypeNode","factory.createTypeDeclaration","defineGenerator","jsxRenderer","ast","File","createResolver","defineExtension","Resolver"],"sources":["../../../internals/utils/src/casing.ts","../../../internals/utils/src/reserved.ts","../../../internals/utils/src/strings.ts","../../../internals/utils/src/fs.ts","../src/factory.ts","../src/components/Enum.tsx","../../../internals/shared/src/operation.ts","../../../internals/shared/src/resolver.ts","../../../internals/shared/src/group.ts","../../../internals/shared/src/schemaTraversal.ts","../src/utils.ts","../src/components/Type.tsx","../src/printers/printerTs.ts","../src/generators/typeGenerator.tsx","../kubb-extension.json","../package.json","../src/resolvers/resolverTs.ts","../src/plugin.ts","../src/printers/functionParams.ts","../src/printers/functionPrinter.ts"],"sourcesContent":["type Options = {\n  /**\n   * Text prepended before casing is applied.\n   */\n  prefix?: string\n  /**\n   * Text appended before casing is applied.\n   */\n  suffix?: string\n}\n\n/**\n * Shared implementation for camelCase and PascalCase conversion.\n * Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)\n * and capitalizes each word according to `pascal`.\n *\n * When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.\n */\nfunction convert(text: string, pascal: boolean): string {\n  return text\n    .trim()\n    .replace(/([a-z\\d])([A-Z])/g, '$1 $2')\n    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')\n    .replace(/(\\d)([a-z])/g, '$1 $2')\n    .split(/[\\s\\-_./\\\\:]+/)\n    .filter(Boolean)\n    .map((word, i) => {\n      if (word.length > 1 && word === word.toUpperCase()) return word\n      const head = i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()\n      return head + word.slice(1)\n    })\n    .join('')\n    .replace(/[^a-zA-Z0-9]/g, '')\n}\n\n// Plugins resolve the same names over and over (about 47,000 calls for a 1,000 schema spec), so\n// results are kept. Clearing at the limit bounds the memory a long-running process spends on it.\nconst cache = new Map<string, string>()\nconst cacheLimit = 10_000\n\nfunction toCamelOrPascal(text: string, pascal: boolean): string {\n  const key = `${pascal ? 'P' : 'c'}${text}`\n  const cached = cache.get(key)\n  if (cached !== undefined) return cached\n\n  const result = convert(text, pascal)\n  if (cache.size >= cacheLimit) cache.clear()\n  cache.set(key, result)\n  return result\n}\n\n/**\n * Converts `text` to camelCase.\n *\n * @example Word boundaries\n * `camelCase('hello-world') // 'helloWorld'`\n *\n * @example With a prefix\n * `camelCase('tag', { prefix: 'create' }) // 'createTag'`\n */\nexport function camelCase(text: string, { prefix = '', suffix = '' }: Options = {}): string {\n  return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false)\n}\n\n/**\n * Converts `text` to PascalCase.\n *\n * @example Word boundaries\n * `pascalCase('hello-world') // 'HelloWorld'`\n *\n * @example With a suffix\n * `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`\n */\nexport function pascalCase(text: string, { prefix = '', suffix = '' }: Options = {}): string {\n  return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true)\n}\n\n/**\n * Uppercases only the first character of `text`, leaving the rest untouched.\n * Unlike {@link pascalCase} it never re-splits word boundaries or strips characters.\n *\n * @example\n * `capitalize('getPetById') // 'GetPetById'`\n */\nexport function capitalize(text: string): string {\n  return `${text.charAt(0).toUpperCase()}${text.slice(1)}`\n}\n\n/**\n * Converts `text` to snake_case.\n *\n * @example From camelCase\n * `snakeCase('helloWorld') // 'hello_world'`\n *\n * @example From mixed separators\n * `snakeCase('Hello-World') // 'hello_world'`\n */\nexport function snakeCase(text: string, { prefix = '', suffix = '' }: Options = {}): string {\n  const processed = `${prefix} ${text} ${suffix}`.trim()\n  return processed\n    .replace(/([a-z])([A-Z])/g, '$1_$2')\n    .replace(/[\\s\\-.]+/g, '_')\n    .replace(/[^a-zA-Z0-9_]/g, '')\n    .toLowerCase()\n    .split('_')\n    .filter(Boolean)\n    .join('_')\n}\n\n/**\n * Converts `text` to SCREAMING_SNAKE_CASE.\n *\n * @example From camelCase\n * `screamingSnakeCase('helloWorld') // 'HELLO_WORLD'`\n */\nexport function screamingSnakeCase(text: string, { prefix = '', suffix = '' }: Options = {}): string {\n  return snakeCase(text, { prefix, suffix }).toUpperCase()\n}\n","/**\n * JavaScript and Java reserved words.\n * @link https://github.com/jonschlinkert/reserved/blob/master/index.js\n */\nconst reservedWords = new Set([\n  'abstract',\n  'arguments',\n  'boolean',\n  'break',\n  'byte',\n  'case',\n  'catch',\n  'char',\n  'class',\n  'const',\n  'continue',\n  'debugger',\n  'default',\n  'delete',\n  'do',\n  'double',\n  'else',\n  'enum',\n  'eval',\n  'export',\n  'extends',\n  'false',\n  'final',\n  'finally',\n  'float',\n  'for',\n  'function',\n  'goto',\n  'if',\n  'implements',\n  'import',\n  'in',\n  'instanceof',\n  'int',\n  'interface',\n  'let',\n  'long',\n  'native',\n  'new',\n  'null',\n  'package',\n  'private',\n  'protected',\n  'public',\n  'return',\n  'short',\n  'static',\n  'super',\n  'switch',\n  'synchronized',\n  'this',\n  'throw',\n  'throws',\n  'transient',\n  'true',\n  'try',\n  'typeof',\n  'var',\n  'void',\n  'volatile',\n  'while',\n  'with',\n  'yield',\n  'Array',\n  'Date',\n  'hasOwnProperty',\n  'Infinity',\n  'isFinite',\n  'isNaN',\n  'isPrototypeOf',\n  'length',\n  'Math',\n  'name',\n  'NaN',\n  'Number',\n  'Object',\n  'prototype',\n  'String',\n  'toString',\n  'undefined',\n  'valueOf',\n] as const)\n\n/**\n * Returns `true` when `name` is a syntactically valid JavaScript variable name.\n *\n * @example\n * ```ts\n * isValidVarName('status')  // true\n * isValidVarName('class')   // false (reserved word)\n * isValidVarName('42foo')   // false (starts with digit)\n * ```\n */\nexport function isValidVarName(name: string): boolean {\n  if (!name || reservedWords.has(name as 'valueOf')) {\n    return false\n  }\n  return isIdentifier(name)\n}\n\n/**\n * Returns `name` when it's a syntactically valid JavaScript variable name,\n * otherwise prefixes it with `_` so the result is a valid identifier.\n *\n * Useful for sanitizing OpenAPI schema names or operation IDs that start with\n * a digit (e.g. `409`, `504AccountCancel`) before using them as exported\n * variable, type, or function names.\n *\n * @example\n * ```ts\n * ensureValidVarName('409')             // '_409'\n * ensureValidVarName('504AccountCancel') // '_504AccountCancel'\n * ensureValidVarName('Pet')              // 'Pet'\n * ensureValidVarName('class')            // '_class'\n * ```\n */\nexport function ensureValidVarName(name: string): string {\n  if (!name || isValidVarName(name)) {\n    return name\n  }\n  return `_${name}`\n}\n\n/**\n * Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.\n *\n * Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys\n * even though they are not valid variable names, so use this (not {@link isValidVarName}) when\n * deciding whether an object key needs quoting.\n *\n * @example\n * ```ts\n * isIdentifier('name')   // true\n * isIdentifier('x-total')// false\n * ```\n */\nexport function isIdentifier(name: string): boolean {\n  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name)\n}\n","/**\n * Wraps a value in single quotes for emitting a single-quoted JavaScript string literal, escaping\n * any backslash or single quote in the content.\n *\n * @example\n * ```ts\n * singleQuote('foo')      // \"'foo'\"\n * singleQuote(\"o'clock\")  // \"'o\\\\'clock'\"\n * ```\n */\nexport function singleQuote(value: string | number | boolean | undefined | null): string {\n  if (value === undefined || value === null) return \"''\"\n  const escaped = String(value).replace(/\\\\/g, '\\\\\\\\').replace(/'/g, \"\\\\'\")\n\n  return `'${escaped}'`\n}\n\n/**\n * Strips a single matching pair of `\"...\"`, `'...'`, or `` `...` `` from both ends of `text`.\n * Returns the string unchanged when no balanced quote pair is found.\n *\n * @example\n * ```ts\n * trimQuotes('\"hello\"') // 'hello'\n * trimQuotes('hello')   // 'hello'\n * ```\n */\nexport function trimQuotes(text: string): string {\n  if (text.length >= 2) {\n    const first = text[0]\n    const last = text[text.length - 1]\n    if ((first === '\"' && last === '\"') || (first === \"'\" && last === \"'\") || (first === '`' && last === '`')) {\n      return text.slice(1, -1)\n    }\n  }\n  return text\n}\n\n/**\n * Serializes a primitive to a single-quoted string literal, stripping any surrounding quotes first.\n *\n * Escaping runs through `JSON.stringify`, then the result switches to single quotes so the generated\n * code matches the repo style without a formatter.\n *\n * @example\n * ```ts\n * stringify('hello')   // \"'hello'\"\n * stringify('\"hello\"') // \"'hello'\"\n * ```\n */\nexport function stringify(value: string | number | boolean | undefined): string {\n  if (value === undefined || value === null) return \"''\"\n  const json = JSON.stringify(trimQuotes(value.toString()))\n  const inner = json.slice(1, -1).replace(/\\\\\"/g, '\"').replace(/'/g, \"\\\\'\")\n  return `'${inner}'`\n}\n\n/**\n * Escapes an `@` at the start of a line, so a multi-line description can't start a new JSDoc tag.\n * Editors render `\\@` as `@` in hovers.\n *\n * @example\n * ```ts\n * jsDocEscape('intro\\n@example value') // 'intro\\n\\\\@example value'\n * ```\n */\nexport function jsDocEscape(input: unknown): string {\n  return `${input}`.replace(/^(\\s*)@/gm, '$1\\\\@')\n}\n\n/**\n * Escapes characters that are not allowed inside JS string literals, covering quotes, backslashes,\n * and the Unicode line terminators U+2028 and U+2029.\n *\n * @see http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4\n *\n * @example\n * ```ts\n * jsStringEscape('say \"hi\"\\nbye') // 'say \\\\\"hi\\\\\"\\\\nbye'\n * ```\n */\nexport function jsStringEscape(input: unknown): string {\n  return `${input}`.replace(/[\"'\\\\\\n\\r\\u2028\\u2029]/g, (character) => {\n    switch (character) {\n      case '\"':\n      case \"'\":\n      case '\\\\':\n        return `\\\\${character}`\n      case '\\n':\n        return '\\\\n'\n      case '\\r':\n        return '\\\\r'\n      case '\\u2028':\n        return '\\\\u2028'\n      case '\\u2029':\n        return '\\\\u2029'\n      default:\n        return ''\n    }\n  })\n}\n\n/**\n * Converts a pattern string into a `new RegExp(...)` constructor call or a regex literal string.\n * Inline flags expressed as a `^(?im)` prefix are extracted and applied to the resulting expression.\n * Pass `null` as the second argument to emit a `/pattern/flags` literal instead.\n *\n * @example\n * ```ts\n * toRegExpString('^(?im)foo')       // 'new RegExp(\"^foo\", \"im\")'\n * toRegExpString('^(?im)foo', null) // '/^foo/im'\n * ```\n */\nexport function toRegExpString(text: string, func: string | null = 'RegExp'): string {\n  const raw = trimQuotes(text)\n\n  const match = raw.match(/^\\^(\\(\\?([igmsuy]+)\\))/i)\n  const replacementTarget = match?.[1] ?? ''\n  const matchedFlags = match?.[2]\n  const cleaned = raw\n    .replace(/^\\\\?\\//, '')\n    .replace(/\\\\?\\/$/, '')\n    .replace(replacementTarget, '')\n\n  const { source, flags } = new RegExp(cleaned, matchedFlags)\n\n  if (func === null) return `/${source}/${flags}`\n\n  return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ''})`\n}\n\n/**\n * Renders a dotted path or string array as an optional-chaining accessor expression rooted at\n * `accessor`. Returns `null` for an empty path.\n *\n * @example\n * ```ts\n * getNestedAccessor('pagination.next.id', 'lastPage')\n * // \"lastPage?.['pagination']?.['next']?.['id']\"\n * ```\n */\nexport function getNestedAccessor(param: string | Array<string>, accessor: string): string | null {\n  const parts = Array.isArray(param) ? param : param.split('.')\n  if (parts.length === 0 || (parts.length === 1 && parts[0] === '')) return null\n  return `${accessor}?.['${`${parts.join(\"']?.['\")}']`}`\n}\n","import { posix } from 'node:path'\nimport { camelCase } from './casing.ts'\n\nfunction toSlash(p: string): string {\n  if (p.startsWith('\\\\\\\\?\\\\')) return p\n  return p.replaceAll('\\\\', '/')\n}\n\n/**\n * Returns the relative path from `rootDir` to `filePath`, always using forward slashes\n * and prefixed with `./` when not already traversing upward.\n *\n * @example\n * ```ts\n * getRelativePath('/src/components', '/src/components/Button.tsx') // './Button.tsx'\n * getRelativePath('/src/components', '/src/utils/helpers.ts')      // '../utils/helpers.ts'\n * ```\n */\nexport function getRelativePath(rootDir: string, filePath: string): string {\n  const relativePath = posix.relative(toSlash(rootDir), toSlash(filePath))\n\n  return relativePath.startsWith('../') ? relativePath : `./${relativePath}`\n}\n\n/**\n * Builds a nested file path from a dotted name. Splits on dots that precede a letter\n * (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases\n * every earlier segment, applies `caseLast` to the final segment, and joins with `/`.\n *\n * Empty segments are dropped before joining. They arise when the name starts with a dot\n * followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to\n * an empty string). Without this a leading `/` would form, which `path.resolve` reads as an\n * absolute path, letting generated files escape the configured output directory.\n *\n * @example Nested path from a dotted name\n * `toFilePath('pet.petId') // 'pet/petId'`\n *\n * @example PascalCase the final segment\n * `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`\n *\n * @example Suffix applied to the final segment only\n * `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`\n */\nexport function toFilePath(name: string, caseLast: (part: string) => string = camelCase): string {\n  const parts = name.split(/\\.(?=[a-zA-Z])/)\n  return parts\n    .map((part, i) => (i === parts.length - 1 ? caseLast(part) : camelCase(part)))\n    .filter(Boolean)\n    .join('/')\n}\n","import { createRequire } from 'node:module'\nimport { camelCase, pascalCase, screamingSnakeCase, snakeCase } from '@internals/utils'\nimport { syncSchemaRef } from 'kubb/kit'\nimport type { ast } from 'kubb/kit'\nimport type ts from '@typescript/typescript6'\n\n/**\n * Loaded with `require`, not `import`. When ESM imports a CommonJS package, Node keeps a second\n * copy of its source to detect named exports, and for TypeScript that copy is about 9 MB.\n */\nconst typescript: typeof ts = createRequire(import.meta.url)('@typescript/typescript6')\n\nconst { SyntaxKind, factory } = typescript\n\nfunction isNumber(value: unknown): value is number {\n  return typeof value === 'number' && !Number.isNaN(value)\n}\n\n// https://ts-ast-viewer.com/\n\n/**\n * TypeScript AST modifiers for the `export` keyword.\n */\nexport const modifiers = {\n  export: factory.createModifier(typescript.SyntaxKind.ExportKeyword),\n} as const\n\nexport const isUnionTypeNode = typescript.isUnionTypeNode\n\nexport function isNonNullable<T>(value: T | null | undefined): value is T {\n  return value !== null && value !== undefined\n}\n\nfunction isValidIdentifier(str: string): boolean {\n  if (!str.length || str.trim() !== str) {\n    return false\n  }\n\n  // Mirrors `typescript.isIdentifierText`, which is not in the public type declarations.\n  // Walking by code point with `isIdentifierStart`/`isIdentifierPart` rejects\n  // invalid names such as private identifiers (`#FOO`), forcing `propertyName`\n  // to quote them.\n  let ch = str.codePointAt(0)!\n  if (!typescript.isIdentifierStart(ch, typescript.ScriptTarget.Latest)) {\n    return false\n  }\n  for (let i = ch > 0xffff ? 2 : 1; i < str.length; i += ch > 0xffff ? 2 : 1) {\n    ch = str.codePointAt(i)!\n    if (!typescript.isIdentifierPart(ch, typescript.ScriptTarget.Latest)) {\n      return false\n    }\n  }\n  return true\n}\n\nfunction propertyName(name: string | ts.PropertyName): ts.PropertyName {\n  if (typeof name === 'string') {\n    const isValid = isValidIdentifier(name)\n    return isValid ? factory.createIdentifier(name) : factory.createStringLiteral(name)\n  }\n  return name\n}\n\nconst questionToken = factory.createToken(typescript.SyntaxKind.QuestionToken)\n\n/**\n * Creates a question token for optional type annotations.\n * Pass `true` to use the cached token, or provide a pre-created token.\n */\nfunction createQuestionToken(token?: boolean | ts.QuestionToken) {\n  if (!token) {\n    return undefined\n  }\n  if (token === true) {\n    return questionToken\n  }\n  return token\n}\n\n/**\n * Creates a TypeScript intersection type node from multiple type nodes.\n * Returns the single node if only one is provided, or wraps in parentheses if requested.\n */\nexport function createIntersectionDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode | null {\n  if (!nodes.length) {\n    return null\n  }\n\n  if (nodes.length === 1) {\n    return nodes[0] || null\n  }\n\n  const node = factory.createIntersectionTypeNode(nodes)\n\n  if (withParentheses) {\n    return factory.createParenthesizedType(node)\n  }\n\n  return node\n}\n\n/**\n * Creates a TypeScript array type node.\n * Use `arrayType: 'array'` for bracket syntax (`T[]`), or `'generic'` for `Array<T>`.\n *\n * @example Array bracket syntax\n * `createArrayDeclaration({ nodes: [stringType], arrayType: 'array' }) // → string[]`\n *\n * @example Generic Array syntax\n * `createArrayDeclaration({ nodes: [stringType], arrayType: 'generic' }) // → Array<string>`\n */\nexport function createArrayDeclaration({ nodes, arrayType = 'array' }: { nodes: Array<ts.TypeNode>; arrayType?: 'array' | 'generic' }): ts.TypeNode {\n  if (!nodes.length) {\n    return factory.createTupleTypeNode([])\n  }\n\n  if (nodes.length === 1) {\n    const node = nodes[0]!\n    if (arrayType === 'generic') {\n      return factory.createTypeReferenceNode(factory.createIdentifier('Array'), [node])\n    }\n    return factory.createArrayTypeNode(node)\n  }\n\n  // For union types (multiple nodes), respect arrayType preference\n  const unionType = factory.createUnionTypeNode(nodes)\n  if (arrayType === 'generic') {\n    return factory.createTypeReferenceNode(factory.createIdentifier('Array'), [unionType])\n  }\n  // For array syntax with unions, we need parentheses: (string | number)[]\n  return factory.createArrayTypeNode(factory.createParenthesizedType(unionType))\n}\n\n/**\n * Minimum nodes length of 2\n * @example Union type example\n * `string | number`\n */\nexport function createUnionDeclaration({ nodes, withParentheses }: { nodes: Array<ts.TypeNode>; withParentheses?: boolean }): ts.TypeNode {\n  if (!nodes.length) {\n    return keywordTypeNodes.any\n  }\n\n  if (nodes.length === 1) {\n    return nodes[0] as ts.TypeNode\n  }\n\n  const node = factory.createUnionTypeNode(nodes)\n\n  if (withParentheses) {\n    return factory.createParenthesizedType(node)\n  }\n\n  return node\n}\n\n/**\n * Creates a TypeScript property signature for object/interface members.\n * Supports optional markers, readonly modifiers, and type annotations.\n */\nexport function createPropertySignature({\n  readOnly,\n  modifiers = [],\n  name,\n  questionToken,\n  type,\n}: {\n  readOnly?: boolean\n  modifiers?: Array<ts.Modifier>\n  name: ts.PropertyName | string\n  questionToken?: ts.QuestionToken | boolean\n  type?: ts.TypeNode\n}) {\n  return factory.createPropertySignature(\n    [...modifiers, readOnly ? factory.createToken(typescript.SyntaxKind.ReadonlyKeyword) : undefined].filter(\n      (modifier): modifier is ts.Modifier => modifier !== undefined,\n    ),\n    propertyName(name),\n    createQuestionToken(questionToken),\n    type,\n  )\n}\n\n/**\n * Attaches JSDoc comments to an AST node as synthetic leading comments.\n * Filters out undefined comments before attaching.\n *\n * @see https://github.com/microsoft/TypeScript/issues/44151\n */\nexport function appendJSDocToNode<TNode extends ts.Node>({ node, comments }: { node: TNode; comments: Array<string | undefined> }) {\n  const filteredComments = comments.filter(Boolean)\n\n  if (!filteredComments.length) {\n    return node\n  }\n\n  // A description can span lines; each one needs its own ` * ` prefix.\n  const text = filteredComments\n    .flatMap((comment = '') => comment.split(/\\r?\\n/))\n    .reduce((acc = '', comment = '') => {\n      return `${acc}\\n * ${comment.replaceAll('*/', '*\\\\/')}`\n    }, '*')\n\n  // Use the node directly instead of spreading to avoid creating Unknown nodes\n  // TypeScript's addSyntheticLeadingComment accepts the node as-is\n  return typescript.addSyntheticLeadingComment(node, typescript.SyntaxKind.MultiLineCommentTrivia, `${text || '*'}\\n`, true)\n}\n\n/**\n * Creates a TypeScript index signature for dynamic property access.\n * Defines the key type (default: `string`) and value type on an object.\n */\nfunction createIndexSignature(\n  type: ts.TypeNode,\n  {\n    modifiers,\n    indexName = 'key',\n    indexType = factory.createKeywordTypeNode(typescript.SyntaxKind.StringKeyword),\n  }: {\n    indexName?: string\n    indexType?: ts.TypeNode\n    decorators?: Array<ts.Decorator>\n    modifiers?: Array<ts.Modifier>\n  } = {},\n) {\n  return factory.createIndexSignature(modifiers, [factory.createParameterDeclaration(undefined, undefined, indexName, undefined, indexType)], type)\n}\n\n/**\n * Creates a TypeScript type declaration as either a type alias or interface.\n * Intelligently selects the syntax based on the type structure and attaches JSDoc comments.\n */\nexport function createTypeDeclaration({\n  syntax,\n  isExportable,\n  comments,\n  name,\n  type,\n}: {\n  syntax: 'type' | 'interface'\n  comments: Array<string | undefined>\n  isExportable?: boolean\n  name: string | ts.Identifier\n  type: ts.TypeNode\n}) {\n  if (syntax === 'interface' && typescript.isTypeLiteralNode(type)) {\n    const node = factory.createInterfaceDeclaration(isExportable ? [modifiers.export] : [], name, undefined, undefined, [...type.members])\n\n    return appendJSDocToNode({\n      node,\n      comments,\n    })\n  }\n\n  const node = factory.createTypeAliasDeclaration(isExportable ? [modifiers.export] : [], name, undefined, type)\n\n  return appendJSDocToNode({\n    node,\n    comments,\n  })\n}\n\n/**\n * Converts an enum member value to a literal expression. Numbers become numeric literals (negatives use a prefix\n * minus, as `createNumericLiteral` rejects them) unless `asNumber` is `false`, which emits the string form.\n */\nfunction valueToExpression(value: string | number | boolean, asNumber = isNumber(value)): ts.Expression {\n  if (typeof value === 'boolean') {\n    return value ? factory.createTrue() : factory.createFalse()\n  }\n  if (asNumber && isNumber(value)) {\n    return value < 0\n      ? factory.createPrefixUnaryExpression(SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value)))\n      : factory.createNumericLiteral(value)\n  }\n  return factory.createStringLiteral(value.toString())\n}\n\n/**\n * Apply casing transformation to enum keys\n */\nfunction applyEnumKeyCasing(key: string, casing: 'screamingSnakeCase' | 'snakeCase' | 'pascalCase' | 'camelCase' | 'none' = 'none'): string {\n  if (casing === 'none') {\n    return key\n  }\n  if (casing === 'screamingSnakeCase') {\n    return screamingSnakeCase(key)\n  }\n  if (casing === 'snakeCase') {\n    return snakeCase(key)\n  }\n  if (casing === 'pascalCase') {\n    return pascalCase(key)\n  }\n  if (casing === 'camelCase') {\n    return camelCase(key)\n  }\n  return key\n}\n\n/**\n * Creates a TypeScript enum declaration or equivalent construct in various formats.\n * Returns a tuple of [name node, type node] - name node may be undefined for certain types.\n *\n * @example\n * ```ts\n * const [name, type] = createEnumDeclaration({\n *   type: 'enum',\n *   name: 'petType',\n *   typeName: 'PetType',\n *   enums: [['cat', 'cat', 'A cat'], ['dog', 'dog']],\n * })\n * ```\n */\nexport function createEnumDeclaration({\n  type = 'enum',\n  name,\n  typeName,\n  enums,\n  enumKeyCasing = 'none',\n}: {\n  /**\n   * Choose to use `enum`, `asConst`, `constEnum`, or `literal` for enums.\n   * - `enum`: TypeScript enum\n   * - `asConst`: const object asserted with `as const` (the caller decides the const name casing)\n   * - `constEnum`: const enum\n   * - `literal`: literal union type\n   * @default `'enum'`\n   */\n  type?: 'enum' | 'asConst' | 'constEnum' | 'literal' | 'inlineLiteral'\n  /**\n   * Enum name in camelCase.\n   */\n  name: string\n  /**\n   * Enum name in PascalCase.\n   */\n  typeName: string\n  enums: Array<[key: string | number, value: string | number | boolean, description?: string]>\n  /**\n   * Choose the casing for enum key names.\n   * @default 'none'\n   */\n  enumKeyCasing?: 'screamingSnakeCase' | 'snakeCase' | 'pascalCase' | 'camelCase' | 'none'\n}): [name: ts.Node | undefined, type: ts.Node] {\n  if (type === 'literal' || type === 'inlineLiteral') {\n    return [\n      undefined,\n      factory.createTypeAliasDeclaration(\n        [factory.createToken(typescript.SyntaxKind.ExportKeyword)],\n        factory.createIdentifier(typeName),\n        undefined,\n        factory.createUnionTypeNode(\n          enums\n            .map(([_key, value]) => {\n              if (isNumber(value)) {\n                if (value < 0) {\n                  return factory.createLiteralTypeNode(\n                    factory.createPrefixUnaryExpression(typescript.SyntaxKind.MinusToken, factory.createNumericLiteral(Math.abs(value))),\n                  )\n                }\n                return factory.createLiteralTypeNode(factory.createNumericLiteral(value?.toString()))\n              }\n\n              if (typeof value === 'boolean') {\n                return factory.createLiteralTypeNode(value ? factory.createTrue() : factory.createFalse())\n              }\n              if (value !== null && value !== undefined) {\n                return factory.createLiteralTypeNode(factory.createStringLiteral(value.toString()))\n              }\n\n              return undefined\n            })\n            .filter((node): node is ts.LiteralTypeNode => node !== undefined),\n        ),\n      ),\n    ]\n  }\n\n  if (type === 'enum' || type === 'constEnum') {\n    return [\n      undefined,\n      factory.createEnumDeclaration(\n        [\n          factory.createToken(typescript.SyntaxKind.ExportKeyword),\n          type === 'constEnum' ? factory.createToken(typescript.SyntaxKind.ConstKeyword) : undefined,\n        ].filter(\n          (modifier): modifier is ts.ModifierToken<ts.SyntaxKind.ExportKeyword> | ts.ModifierToken<ts.SyntaxKind.ConstKeyword> => modifier !== undefined,\n        ),\n        factory.createIdentifier(typeName),\n        enums\n          .map(([key, value, description]) => {\n            const initializer = valueToExpression(value, Number.parseInt(value.toString(), 10) === value)\n\n            if (isNumber(Number.parseInt(key.toString(), 10))) {\n              const casingKey = applyEnumKeyCasing(`${typeName}_${key}`, enumKeyCasing)\n              return appendJSDocToNode({ node: factory.createEnumMember(propertyName(casingKey), initializer), comments: [description] })\n            }\n\n            if (key !== null && key !== undefined) {\n              const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing)\n              return appendJSDocToNode({ node: factory.createEnumMember(propertyName(casingKey), initializer), comments: [description] })\n            }\n\n            return undefined\n          })\n          .filter((member): member is ts.EnumMember => member !== undefined),\n      ),\n    ]\n  }\n\n  // used when using `as const` instead of an TypeScript enum.\n  // name is already cased by the caller (camelCase or pascalCase, driven by enum.constCasing).\n  // typeName carries the typeSuffix for the type alias, so we use name for the const identifier.\n  const identifierName = name\n\n  // When there are no enum items (empty or all-null enum), don't generate a runtime const.\n  // Return undefined for nameNode so the barrel won't try to export a non-existent symbol.\n  // Use `never` as the type alias to keep references valid without creating a broken const.\n  if (enums.length === 0) {\n    return [\n      undefined,\n      factory.createTypeAliasDeclaration(\n        [factory.createToken(typescript.SyntaxKind.ExportKeyword)],\n        factory.createIdentifier(typeName),\n        undefined,\n        factory.createKeywordTypeNode(typescript.SyntaxKind.NeverKeyword),\n      ),\n    ]\n  }\n\n  return [\n    factory.createVariableStatement(\n      [factory.createToken(typescript.SyntaxKind.ExportKeyword)],\n      factory.createVariableDeclarationList(\n        [\n          factory.createVariableDeclaration(\n            factory.createIdentifier(identifierName),\n            undefined,\n            undefined,\n            factory.createAsExpression(\n              factory.createObjectLiteralExpression(\n                enums\n                  .map(([key, value, description]) => {\n                    const initializer = valueToExpression(value)\n\n                    if (key !== null && key !== undefined) {\n                      const casingKey = applyEnumKeyCasing(key.toString(), enumKeyCasing)\n                      return appendJSDocToNode({ node: factory.createPropertyAssignment(propertyName(casingKey), initializer), comments: [description] })\n                    }\n\n                    return undefined\n                  })\n                  .filter((property): property is ts.PropertyAssignment => property !== undefined),\n                true,\n              ),\n              factory.createTypeReferenceNode(factory.createIdentifier('const'), undefined),\n            ),\n          ),\n        ],\n        typescript.NodeFlags.Const,\n      ),\n    ),\n    factory.createTypeAliasDeclaration(\n      [factory.createToken(typescript.SyntaxKind.ExportKeyword)],\n      factory.createIdentifier(typeName),\n      undefined,\n      factory.createIndexedAccessTypeNode(\n        factory.createParenthesizedType(factory.createTypeQueryNode(factory.createIdentifier(identifierName), undefined)),\n        factory.createTypeOperatorNode(typescript.SyntaxKind.KeyOfKeyword, factory.createTypeQueryNode(factory.createIdentifier(identifierName), undefined)),\n      ),\n    ),\n  ]\n}\n\n/**\n * Creates a TypeScript `Omit<T, Keys>` type reference node.\n * Optionally wraps the type in `NonNullable<T>` if `nonNullable` is true.\n */\nexport function createOmitDeclaration({ keys, type, nonNullable }: { keys: Array<string> | string; type: ts.TypeNode; nonNullable?: boolean }) {\n  const node = nonNullable ? factory.createTypeReferenceNode(factory.createIdentifier('NonNullable'), [type]) : type\n\n  if (Array.isArray(keys)) {\n    return factory.createTypeReferenceNode(factory.createIdentifier('Omit'), [\n      node,\n      factory.createUnionTypeNode(\n        keys.map((key) => {\n          return factory.createLiteralTypeNode(factory.createStringLiteral(key))\n        }),\n      ),\n    ])\n  }\n\n  return factory.createTypeReferenceNode(factory.createIdentifier('Omit'), [node, factory.createLiteralTypeNode(factory.createStringLiteral(keys))])\n}\n\n/**\n * Pre-built TypeScript keyword type nodes for common primitive types.\n * Use these to avoid repeatedly creating the same type nodes.\n */\nexport const keywordTypeNodes = {\n  any: factory.createKeywordTypeNode(typescript.SyntaxKind.AnyKeyword),\n  unknown: factory.createKeywordTypeNode(typescript.SyntaxKind.UnknownKeyword),\n  void: factory.createKeywordTypeNode(typescript.SyntaxKind.VoidKeyword),\n  number: factory.createKeywordTypeNode(typescript.SyntaxKind.NumberKeyword),\n  integer: factory.createKeywordTypeNode(typescript.SyntaxKind.NumberKeyword),\n  bigint: factory.createKeywordTypeNode(typescript.SyntaxKind.BigIntKeyword),\n  object: factory.createKeywordTypeNode(typescript.SyntaxKind.ObjectKeyword),\n  string: factory.createKeywordTypeNode(typescript.SyntaxKind.StringKeyword),\n  boolean: factory.createKeywordTypeNode(typescript.SyntaxKind.BooleanKeyword),\n  undefined: factory.createKeywordTypeNode(typescript.SyntaxKind.UndefinedKeyword),\n  null: factory.createLiteralTypeNode(factory.createToken(typescript.SyntaxKind.NullKeyword)),\n  never: factory.createKeywordTypeNode(typescript.SyntaxKind.NeverKeyword),\n} as const\n\n/**\n * Converts a path like '/pet/{petId}/uploadImage' to a template literal type\n * like `/pet/${string}/uploadImage`\n */\n/**\n * Converts an OAS-style path (e.g. `/pets/{petId}`) or an Express-style path\n * (e.g. `/pets/:petId`) to a TypeScript template literal type\n * like `` `/pets/${string}` ``.\n */\nexport function createUrlTemplateType(path: string): ts.TypeNode {\n  // normalized Express `:param` → OAS `{param}` so a single regex handles both.\n  const normalized = path.replace(/:([^/]+)/g, '{$1}')\n\n  if (!normalized.includes('{')) {\n    return factory.createLiteralTypeNode(factory.createStringLiteral(normalized))\n  }\n\n  const segments = normalized.split(/(\\{[^}]+\\})/)\n  const parts: Array<string> = []\n  const parameterIndices: Array<number> = []\n\n  segments.forEach((segment) => {\n    if (segment.startsWith('{') && segment.endsWith('}')) {\n      parameterIndices.push(parts.length)\n      parts.push(segment)\n    } else if (segment) {\n      parts.push(segment)\n    }\n  })\n\n  const head = typescript.factory.createTemplateHead(parts[0] || '')\n  const templateSpans: Array<ts.TemplateLiteralTypeSpan> = []\n\n  parameterIndices.forEach((paramIndex, i) => {\n    const isLast = i === parameterIndices.length - 1\n    const nextPart = parts[paramIndex + 1] || ''\n    const literal = isLast ? typescript.factory.createTemplateTail(nextPart) : typescript.factory.createTemplateMiddle(nextPart)\n    templateSpans.push(typescript.factory.createTemplateLiteralTypeSpan(keywordTypeNodes.string, literal))\n  })\n\n  return typescript.factory.createTemplateLiteralType(head, templateSpans)\n}\n\n/**\n * Creates a TypeScript type literal node (anonymous object type).\n */\nexport const createTypeLiteralNode = factory.createTypeLiteralNode\n\n/**\n * Creates a TypeScript type reference node (e.g., `Array<string>`, `Record<K, V>`).\n */\nexport const createTypeReferenceNode = factory.createTypeReferenceNode\n\n// ─── Printer helpers ──────────────────────────────────────────────────────────\n\n/**\n * Converts a primitive const value to a TypeScript literal type node.\n * Handles negative numbers via a prefix unary expression.\n */\nexport function constToTypeNode(value: string | number | boolean, format: 'string' | 'number' | 'boolean'): ts.TypeNode | undefined {\n  if (format === 'boolean') {\n    return factory.createLiteralTypeNode(value === true ? factory.createTrue() : factory.createFalse())\n  }\n  const literal = format === 'number' && typeof value === 'number' ? value : String(value)\n  return factory.createLiteralTypeNode(valueToExpression(literal) as ts.LiteralTypeNode['literal'])\n}\n\n/**\n * Returns a `Date` reference type node when `representation` is `'date'`, otherwise falls back to `string`.\n */\nexport function dateOrStringNode(node: { representation?: string }): ts.TypeNode {\n  return node.representation === 'date' ? createTypeReferenceNode(factory.createIdentifier('Date')) : keywordTypeNodes.string\n}\n\n/**\n * Maps an array of `SchemaNode`s through the printer, filtering out `null` and `undefined` results.\n */\nexport function buildMemberNodes(\n  members: Array<ast.SchemaNode> | undefined,\n  print: (node: ast.SchemaNode) => ts.TypeNode | null | undefined,\n): Array<ts.TypeNode> {\n  return (members ?? []).map(print).filter(isNonNullable)\n}\n\n/**\n * Builds a TypeScript tuple type node from an array schema's `items`,\n * applying min/max slice and optional/rest element rules.\n */\nexport function buildTupleNode(node: ast.ArraySchemaNode, print: (node: ast.SchemaNode) => ts.TypeNode | null | undefined): ts.TypeNode {\n  let items = (node.items ?? []).map(print).filter(isNonNullable)\n\n  const restNode = node.rest ? (print(node.rest) ?? undefined) : undefined\n  const { min, max } = node\n\n  if (max !== undefined) {\n    items = items.slice(0, max)\n    if (items.length < max && restNode) {\n      items = [...items, ...Array(max - items.length).fill(restNode)]\n    }\n  }\n\n  if (min !== undefined) {\n    items = items.map((item, i) => (i >= min ? factory.createOptionalTypeNode(item) : item))\n  }\n\n  if (max === undefined && restNode) {\n    items.push(factory.createRestTypeNode(factory.createArrayTypeNode(restNode)))\n  }\n\n  return factory.createTupleTypeNode(items)\n}\n\n/**\n * Appends `| null` and then `| undefined` to a type when requested.\n */\nexport function wrapNullableOptional(type: ts.TypeNode, nullable: boolean, addsUndefined: boolean): ts.TypeNode {\n  const withNullable = nullable ? createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] }) : type\n  return addsUndefined ? createUnionDeclaration({ nodes: [withNullable, keywordTypeNodes.undefined] }) : withNullable\n}\n\n/**\n * Applies `nullable` and optional/nullish `| undefined` union modifiers to a property's resolved base type.\n */\nexport function buildPropertyType(\n  schema: ast.SchemaNode,\n  baseType: ts.TypeNode,\n  optionalType: 'questionToken' | 'undefined' | 'questionTokenAndUndefined',\n  optional?: boolean,\n): ts.TypeNode {\n  const addsUndefined = optionalType === 'undefined' || optionalType === 'questionTokenAndUndefined'\n  const meta = syncSchemaRef(schema)\n\n  return wrapNullableOptional(baseType, !!meta.nullable, addsUndefined && !!(optional || meta.nullish || meta.optional))\n}\n\nconst indexSignaturePrinter = typescript.createPrinter()\nconst indexSignatureSource = typescript.createSourceFile('', '', typescript.ScriptTarget.Latest)\n\n/**\n * Creates a TypeScript index signature for `additionalProperties` and `patternProperties` on an\n * object schema node. TypeScript allows only one string index signature and its value must be\n * assignable from every named property, so both keywords collapse into a single signature: the\n * union of all value types (deduplicated), or `unknown` when the object also has fixed properties.\n * The key regex of `patternProperties` cannot be expressed by an index signature and is dropped.\n */\nexport function buildIndexSignatures(\n  node: { additionalProperties?: ast.SchemaNode | boolean; patternProperties?: Record<string, ast.SchemaNode> },\n  propertyCount: number,\n  print: (node: ast.SchemaNode) => ts.TypeNode | null | undefined,\n): Array<ts.TypeElement> {\n  const valueTypes: Array<ts.TypeNode> = []\n\n  if (node.additionalProperties && node.additionalProperties !== true) {\n    valueTypes.push(print(node.additionalProperties) ?? keywordTypeNodes.unknown)\n  } else if (node.additionalProperties === true) {\n    valueTypes.push(keywordTypeNodes.unknown)\n  }\n\n  for (const schema of Object.values(node.patternProperties ?? {})) {\n    const patternType = print(schema) ?? keywordTypeNodes.unknown\n    valueTypes.push(schema.nullable ? createUnionDeclaration({ nodes: [patternType, keywordTypeNodes.null] }) : patternType)\n  }\n\n  if (valueTypes.length === 0) return []\n\n  const seen = new Set<string>()\n  const distinct = valueTypes.filter((type) => {\n    const key = indexSignaturePrinter.printNode(typescript.EmitHint.Unspecified, type, indexSignatureSource)\n    return seen.has(key) ? false : (seen.add(key), true)\n  })\n\n  return [createIndexSignature(propertyCount > 0 ? keywordTypeNodes.unknown : createUnionDeclaration({ nodes: distinct }))]\n}\n","import { camelCase, trimQuotes } from '@internals/utils'\nimport type { ast } from 'kubb/kit'\nimport { parserTs } from '@kubb/parser-ts'\nimport { File } from 'kubb/jsx'\nimport type { KubbReactNode } from 'kubb/jsx'\nimport * as factory from '../factory.ts'\nimport type { PluginTs, ResolverTs } from '../types.ts'\n\ntype EnumOptions = PluginTs['resolvedOptions']['enum']\n\ntype Props = {\n  node: ast.EnumSchemaNode\n  enum: EnumOptions\n  resolver: ResolverTs\n  key?: string | number | null\n}\n\n/**\n * Resolves the runtime identifier name and the TypeScript type name for an enum schema node.\n *\n * The raw `node.name` may be a YAML key such as `\"enumNames.Type\"` which is not a\n * valid TypeScript identifier. The resolver normalizes it. For inline enum properties the adapter\n * already emits a PascalCase+suffix name, so resolution is typically a no-op.\n *\n * When `constCasing` is `'pascalCase'` and `typeSuffix` is empty, the const and the type\n * resolve to the same name, which TypeScript merges into a single value+type declaration.\n */\nexport function getEnumNames({ node, enum: enumOptions, resolver }: { node: ast.EnumSchemaNode; enum: EnumOptions; resolver: ResolverTs }): {\n  enumName: string\n  typeName: string\n} {\n  const resolved = resolver.name(node.name!)\n  const enumName = enumOptions.constCasing === 'pascalCase' ? resolved : camelCase(node.name!)\n  const typeName = enumOptions.type === 'asConst' ? resolver.enum.keyName(node, enumOptions.typeSuffix) : resolved\n\n  return { enumName, typeName }\n}\n\n/**\n * Renders the enum declaration(s) for a single named `EnumSchemaNode`.\n *\n * Depending on `enum.type` this may emit:\n * - A runtime object (`asConst`) plus a `typeof` type alias\n * - A `const enum` or plain `enum` declaration (`constEnum` / `enum`)\n * - A union literal type alias (`literal`)\n *\n * The emitted `File.Source` nodes carry the resolved names so that the barrel\n * index picks up the correct export identifiers.\n */\nexport function Enum({ node, enum: enumOptions, resolver }: Props): KubbReactNode {\n  const { enumName, typeName } = getEnumNames({ node, enum: enumOptions, resolver })\n\n  const [nameNode, typeNode] = factory.createEnumDeclaration({\n    name: enumName,\n    typeName,\n    enums: (node.namedEnumValues?.map((v) => [trimQuotes(v.name.toString()), v.value, v.description]) ??\n      node.enumValues?.filter((v): v is NonNullable<typeof v> => v !== null && v !== undefined).map((v) => [trimQuotes(v.toString()), v]) ??\n      []) as Array<[string | number, string | number | boolean, string?]>,\n    type: enumOptions.type,\n    enumKeyCasing: enumOptions.keyCasing,\n  })\n\n  // When the const and the type share a name (pascalCase const + empty typeSuffix) they merge into\n  // one declaration. The const carries the barrel export, so keep the type alias in the file but out\n  // of the barrel to avoid re-exporting the name a second time as `export type { … }`.\n  const namesMerge = !!nameNode && enumName === typeName\n\n  return (\n    <>\n      {nameNode && (\n        <File.Source name={enumName} isExportable isIndexable isTypeOnly={false}>\n          {parserTs().print(nameNode)}\n        </File.Source>\n      )}\n      <File.Source\n        name={typeName}\n        isIndexable={!namesMerge}\n        isExportable={!namesMerge && enumOptions.type !== 'inlineLiteral'}\n        isTypeOnly={['asConst', 'literal', undefined].includes(enumOptions.type)}\n      >\n        {parserTs().print(typeNode)}\n      </File.Source>\n    </>\n  )\n}\n","import { ast, type Group, type NodeCache, type Output, type Resolver, type ResolverFileParams, Url } from 'kubb/kit'\n\n/**\n * Builds the `ResolverFileParams` every operation generator passes to\n * `resolver.file`: a file named `name`, tagged by the operation's first\n * tag (or `'default'`), at the operation's path. Centralizes the entry object\n * that was repeated at dozens of call sites across the client and query plugins.\n *\n * @example\n * ```ts\n * resolver.file(operationFileEntry(node, node.operationId), { root, output, group })\n * ```\n */\nexport function operationFileEntry(node: ast.OperationNode, name: string, extname: ResolverFileParams['extname'] = '.ts'): ResolverFileParams {\n  return {\n    name,\n    extname,\n    tag: node.tags[0] ?? 'default',\n    path: node.path,\n  }\n}\n\n/**\n * Resolves a dependency plugin's generated file for `node.operationId`, cached in `cache` (the\n * current node's `ctx.cache`) under the resolver's own plugin name. Several dependents reading the\n * same dependency for the same operation in one pass (a query plugin's several hook generators, the\n * MCP handler, ...) share one computed name and path instead of each calling `resolver.file` again.\n *\n * @example Cache `plugin-ts`'s file for the current operation\n * ```ts\n * const fileTs = resolveDependencyOperationFile({ cache: ctx.cache, node, resolver: tsResolver, root, output })\n * ```\n */\nexport function resolveDependencyOperationFile(options: {\n  cache: NodeCache\n  node: ast.OperationNode\n  resolver: Pick<Resolver, 'file' | 'pluginName'>\n  root: string\n  output: Output\n  group?: Group | null\n}): ast.FileNode {\n  const { cache, node, resolver, root, output, group } = options\n\n  return cache.ensureItem(`${resolver.pluginName}:operationFile`, () =>\n    resolver.file({ ...operationFileEntry(node, node.operationId), root, output, group: group ?? undefined }),\n  )\n}\n\nexport type ContentTypeInfo = {\n  contentTypes: string[]\n  isMultipleContentTypes: boolean\n  contentTypeUnion: string\n  defaultContentType: string\n  hasFormData: boolean\n}\n\nexport type RequestConfigResolver = {\n  response: {\n    body(node: ast.OperationNode): string\n  }\n}\n\nexport type ResponseStatusNameResolver = {\n  response: {\n    status(node: ast.OperationNode, statusCode: ast.StatusCode): string\n  }\n}\n\nexport type ResponseNameResolver = ResponseStatusNameResolver & {\n  response: {\n    response(node: ast.OperationNode): string\n  }\n}\n\nexport type OperationTypeNameResolver = RequestConfigResolver &\n  ResponseNameResolver & {\n    param: {\n      path(node: ast.OperationNode, param: ast.ParameterNode): string\n      query(node: ast.OperationNode, param: ast.ParameterNode): string\n      headers(node: ast.OperationNode, param: ast.ParameterNode): string\n    }\n  }\n\nexport type OperationCommentLink = 'pathTemplate' | 'urlPath' | false | ((node: ast.OperationNode) => string | undefined)\n\nexport type BuildOperationCommentsOptions = {\n  link?: OperationCommentLink\n  linkPosition?: 'beforeDeprecated' | 'afterDeprecated'\n  splitLines?: boolean\n}\n\ntype ResponseLike = {\n  statusCode: ast.StatusCode | number | string\n}\n\nexport type OperationParameterGroups = Record<ast.ParameterNode['in'], Array<ast.ParameterNode>>\n\nexport type ResolveOperationTypeNameOptions = {\n  responseStatusNames?: boolean | 'error'\n  exclude?: ReadonlyArray<string | undefined>\n  order?: 'params-first' | 'body-response-first'\n  /**\n   * Include the individual `Path`/`Query`/`Headers` group type names. Set to `false` for clients\n   * that reference the grouped `Options` type instead of the per-group types.\n   */\n  includeParams?: boolean\n}\n\nfunction getOperationLink(node: ast.OperationNode, link: OperationCommentLink): string | null {\n  if (!link) {\n    return null\n  }\n\n  if (typeof link === 'function') {\n    return link(node) ?? null\n  }\n\n  return node.path ? `{@link ${Url.toPath(node.path)}}` : null\n}\n\n/**\n * Derives the shared `ContentTypeInfo` shape from a list of content types, tracking whether several\n * are present and the union, default, and form-data flags the client uses to pick one.\n */\nfunction buildContentTypeInfo(contentTypes: string[]): ContentTypeInfo {\n  const isMultipleContentTypes = contentTypes.length > 1\n\n  return {\n    contentTypes,\n    isMultipleContentTypes,\n    contentTypeUnion: isMultipleContentTypes ? contentTypes.map((ct) => JSON.stringify(ct)).join(' | ') : '',\n    defaultContentType: contentTypes[0] ?? 'application/json',\n    hasFormData: contentTypes.some((ct) => ct === 'multipart/form-data'),\n  }\n}\n\nexport function getContentTypeInfo(node: ast.OperationNode): ContentTypeInfo {\n  return buildContentTypeInfo(node.requestBody?.content?.map((e) => e.contentType) ?? [])\n}\n\n/**\n * The request-body counterpart for the primary success response: the content types it documents and\n * whether several are present, so the client can let a caller pick which one to accept.\n */\nexport function getResponseContentTypeInfo(node: ast.OperationNode): ContentTypeInfo {\n  return buildContentTypeInfo(getPrimarySuccessResponse(node)?.content?.map((e) => e.contentType) ?? [])\n}\n\nexport type ResponseType = 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' | 'stream'\n\n/**\n * Reads the single base content type of an operation's primary success response, lowercased and\n * stripped of any `; charset=...` suffix. Returns `undefined` when the response declares zero or\n * more than one content type, since neither case has a single type to act on.\n */\nfunction getPrimarySuccessContentType(node: ast.OperationNode): string | undefined {\n  const contentTypes = getPrimarySuccessResponse(node)?.content?.map((entry) => entry.contentType) ?? []\n  if (contentTypes.length !== 1) return undefined\n  return contentTypes[0]!.split(';')[0]!.trim().toLowerCase()\n}\n\n/**\n * Whether an operation streams its primary success response as Server-Sent Events\n * (`text/event-stream`). The client generator uses this to return a typed event stream instead of a\n * one-shot `RequestResult`.\n */\nexport function isEventStream(node: ast.OperationNode): boolean {\n  return getPrimarySuccessContentType(node) === 'text/event-stream'\n}\n\n/**\n * Derives the default `responseType` for an operation from its primary success response.\n *\n * Returns a value only when that response declares a single non-JSON content type. `text/event-stream`\n * and other binary types (`application/octet-stream`, `application/pdf`, `image/*`, `audio/*`,\n * `video/*`) map to a stream or `'blob'`, and other `text/*` maps to `'text'`. Otherwise `undefined`,\n * leaving the runtime client's `Content-Type` auto-detection in charge.\n */\nexport function getResponseType(node: ast.OperationNode): ResponseType | undefined {\n  const baseType = getPrimarySuccessContentType(node)\n  if (!baseType) return undefined\n\n  if (baseType === 'application/json' || baseType.endsWith('+json') || baseType === 'text/json') return undefined\n  if (baseType === 'text/event-stream') return 'stream'\n  if (baseType.startsWith('text/')) return 'text'\n  if (baseType === 'application/octet-stream' || baseType === 'application/pdf' || /^(image|audio|video)\\//.test(baseType)) return 'blob'\n  return undefined\n}\n\n/**\n * Maps a content type to the PascalCase suffix used to name per-content-type variants\n * (e.g. `application/json` → `Json`, `application/xml` → `Xml`, `multipart/form-data` → `FormData`).\n */\nfunction getContentTypeSuffix(contentType: string): string {\n  const baseType = contentType.split(';')[0]!.trim()\n  if (baseType === 'application/json') return 'Json'\n  if (baseType === 'multipart/form-data') return 'FormData'\n  if (baseType === 'application/x-www-form-urlencoded') return 'FormUrlEncoded'\n  const subtype = baseType.split('/').pop() ?? baseType\n  const parts = subtype.split(/[^a-zA-Z0-9]+/).filter(Boolean)\n  if (parts.length === 0) return 'Unknown'\n  return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join('')\n}\n\n/**\n * Appends a content-type suffix to a base name, keeping a trailing `Data` segment last\n * (e.g. `AddPetData` + `Json` → `AddPetJsonData`, `AddPetStatus200` + `Xml` → `AddPetStatus200Xml`).\n */\nexport function getPerContentTypeName(baseName: string, suffix: string): string {\n  if (baseName.endsWith('Data')) {\n    return suffix.endsWith('Data') ? baseName.slice(0, -4) + suffix : `${baseName.slice(0, -4)}${suffix}Data`\n  }\n  return baseName + suffix\n}\n\nexport type ContentVariantInput = { contentType: string; schema?: ast.SchemaNode | null; keysToOmit?: Array<string> | null }\nexport type ContentVariant = { name: string; suffix: string; schema: ast.SchemaNode; keysToOmit?: Array<string> | null; contentType: string }\n\n/**\n * Resolves per-content-type variant names for a set of content entries, deduplicating suffix\n * collisions with a numeric counter. Entries without a schema are skipped. The returned `suffix` is\n * the final (possibly counter-augmented) value, so callers can derive parallel names in another\n * namespace (e.g. plugin-faker deriving the matching plugin-ts type name).\n */\nexport function resolveContentTypeVariants(entries: Array<ContentVariantInput>, baseName: string): Array<ContentVariant> {\n  const usedNames = new Set<string>()\n  return entries\n    .filter((entry) => entry.schema)\n    .map((entry) => {\n      const baseSuffix = getContentTypeSuffix(entry.contentType)\n      let suffix = baseSuffix\n      let name = getPerContentTypeName(baseName, suffix)\n      let counter = 2\n      while (usedNames.has(name)) {\n        suffix = `${baseSuffix}${counter++}`\n        name = getPerContentTypeName(baseName, suffix)\n      }\n      usedNames.add(name)\n      return { name, suffix, schema: entry.schema!, keysToOmit: entry.keysToOmit, contentType: entry.contentType }\n    })\n}\n\n// The request groups come from the grouped params, so `config` drops the data-shape keys to stay\n// assignable to `Options`, which omits them from `RequestConfig`.\nconst requestConfigBaseType = `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`\n\nexport function buildRequestConfigType(node: ast.OperationNode): string {\n  const request = getContentTypeInfo(node)\n  const response = getResponseContentTypeInfo(node)\n\n  // Only the ambiguous side is offered: a single-type side has nothing to pick, so it stays baked in\n  // the generated call.\n  const members = [\n    request.isMultipleContentTypes ? `request?: ${request.contentTypeUnion}` : null,\n    response.isMultipleContentTypes ? `response?: ${response.contentTypeUnion}` : null,\n  ].filter(Boolean)\n\n  return members.length ? `${requestConfigBaseType} & { contentType?: { ${members.join('; ')} } }` : requestConfigBaseType\n}\n\n/**\n * Builds the `client?:` option type shared by the generated query hooks (`useQuery`,\n * `useInfiniteQuery`, `useSWR`, ...). Unlike {@link buildRequestConfigType}, it never adds a\n * `contentType?:` member: query hooks wrap GET operations, which carry no request body to select a\n * content type for.\n */\nexport function buildClientOptionType(): string {\n  return requestConfigBaseType\n}\n\nexport type RequestGroups = {\n  path: boolean\n  query: boolean\n  body: boolean\n  headers: boolean\n}\n\n/**\n * Which of the grouped request options an operation carries.\n */\nexport function getRequestGroups(node: ast.OperationNode): RequestGroups {\n  const { path, query, header } = getOperationParameters(node)\n  return {\n    path: path.length > 0,\n    query: query.length > 0,\n    body: Boolean(node.requestBody?.content?.[0]?.schema),\n    headers: header.length > 0,\n  }\n}\n\nexport type RequestGroupOptionality = {\n  groups: RequestGroups\n  hasRequiredPath: boolean\n  hasRequiredQuery: boolean\n  hasRequiredHeader: boolean\n  /**\n   * Whether the grouped request parameter can default to `{}`. True only when no group carries a\n   * required member, so every member is safe to omit.\n   */\n  isOptional: boolean\n}\n\n/**\n * Resolves which grouped request options an operation carries together with whether each group\n * holds a required member. The grouped parameter stays optional only when nothing inside it is\n * required, matching the generated `RequestConfig` type.\n */\nexport function getRequestGroupOptionality(node: ast.OperationNode): RequestGroupOptionality {\n  const groups = getRequestGroups(node)\n  const { path, query, header } = getOperationParameters(node)\n  const hasRequiredPath = path.some((param) => param.required)\n  const hasRequiredQuery = query.some((param) => param.required)\n  const hasRequiredHeader = header.some((param) => param.required)\n\n  return {\n    groups,\n    hasRequiredPath,\n    hasRequiredQuery,\n    hasRequiredHeader,\n    isOptional: !hasRequiredPath && !hasRequiredQuery && !hasRequiredHeader && !groups.body,\n  }\n}\n\nexport type RequestOptionsNameResolver = RequestConfigResolver & {\n  response: {\n    options(node: ast.OperationNode): string\n  }\n}\n\n/**\n * Builds the grouped `{ path, query, body, headers }` parameter for a generated client\n * function, typed from the operation's `Options` (minus `url`). Only the groups the\n * operation actually has are destructured. The trailing `config` parameter carries the\n * runtime `RequestConfig` overrides plus `client`.\n */\nexport function buildRequestParamsSignature(\n  node: ast.OperationNode,\n  resolver: RequestOptionsNameResolver,\n  options: { isConfigurable?: boolean } = {},\n): { signature: string; groups: RequestGroups } {\n  const { isConfigurable = true } = options\n  const { groups, isOptional } = getRequestGroupOptionality(node)\n\n  const names = (['path', 'query', 'body', 'headers'] as const).filter((key) => groups[key])\n\n  const firstParam = names.length > 0 ? `{ ${names.join(', ')} }: ${resolver.response.options(node)}${isOptional ? ' = {}' : ''}` : null\n  const configParam = isConfigurable ? `config: ${buildRequestConfigType(node)} = {}` : null\n\n  return {\n    signature: [firstParam, configParam].filter(Boolean).join(', '),\n    groups,\n  }\n}\n\nexport function buildOperationComments(node: ast.OperationNode, options: BuildOperationCommentsOptions = {}): Array<string> {\n  const { link = 'pathTemplate', linkPosition = 'afterDeprecated', splitLines = false } = options\n  const linkComment = getOperationLink(node, link)\n  const comments =\n    linkPosition === 'beforeDeprecated'\n      ? [node.description && `@description ${node.description}`, node.summary && `@summary ${node.summary}`, linkComment, node.deprecated && '@deprecated']\n      : [node.description && `@description ${node.description}`, node.summary && `@summary ${node.summary}`, node.deprecated && '@deprecated', linkComment]\n\n  const filteredComments = comments.filter((comment): comment is string => Boolean(comment))\n\n  if (!splitLines) {\n    return filteredComments\n  }\n\n  return filteredComments.flatMap((text) => text.split(/\\r?\\n/).map((line) => line.trim())).filter((comment): comment is string => Boolean(comment))\n}\n\nconst operationParameterGroupsByNode = new WeakMap<ast.OperationNode, OperationParameterGroups>()\n\n/**\n * Groups an operation's parameters by location (`path`/`query`/`header`/`cookie`), deduping each\n * group by name. Every plugin generator visiting the same `OperationNode` shares one AST instance\n * (see `KubbDriver`), so the result is cached per node to avoid re-filtering and re-deduping the\n * same parameters once per plugin.\n */\nexport function getOperationParameters(node: ast.OperationNode): OperationParameterGroups {\n  const cached = operationParameterGroupsByNode.get(node)\n  if (cached) return cached\n\n  // A malformed spec can declare the same name twice within one location. Both would resolve to the\n  // same output property, so emitting both would yield an object type with a duplicate member,\n  // which TypeScript rejects. Keep the first.\n  const group = (location: ast.ParameterNode['in']) => {\n    const seen = new Set<string>()\n\n    return node.parameters.filter((param) => {\n      if (param.in !== location || seen.has(param.name)) return false\n      seen.add(param.name)\n      return true\n    })\n  }\n\n  const groups: OperationParameterGroups = { path: group('path'), query: group('query'), header: group('header'), cookie: group('cookie') }\n\n  operationParameterGroupsByNode.set(node, groups)\n  return groups\n}\n\n/**\n * Builds the combined `{ body, path, query, headers }` options object schema for an operation,\n * referencing the already-resolved body and grouped param names. Shared by `@kubb/plugin-ts`'s\n * `Options` type and `@kubb/plugin-zod`'s inferred options schema, so both printers emit the same\n * shape from the same inputs. `primitive: 'object'` is a no-op for the TS printer and tells the Zod\n * printer to emit `z.object(…)` rather than a record.\n */\nexport function buildOptionsSchema(node: ast.OperationNode, resolver: OperationTypeNameResolver): ast.SchemaNode {\n  const { path, query, header } = getOperationParameters(node)\n  const hasBody = Boolean(node.requestBody?.content?.[0]?.schema)\n  const createNever = () => ast.factory.createSchema({ type: 'never', primitive: undefined, optional: true })\n  const groups = [\n    { name: 'path', params: path, resolve: resolver.param.path },\n    { name: 'query', params: query, resolve: resolver.param.query },\n    { name: 'headers', params: header, resolve: resolver.param.headers },\n  ] as const\n\n  // NOTE(v5-stable): the fields were renamed from the legacy beta shape\n  // (`data`/`pathParams`/`queryParams`/`headerParams`) to `body`/`path`/`query`/`headers` so the\n  // type matches the runtime client. Drop this note once v5 leaves beta.\n  return ast.factory.createSchema({\n    type: 'object',\n    primitive: 'object',\n    deprecated: node.deprecated,\n    properties: [\n      ast.factory.createProperty({\n        name: 'body',\n        required: hasBody,\n        schema: hasBody ? ast.factory.createSchema({ type: 'ref', name: resolver.response.body(node) }) : createNever(),\n      }),\n      ...groups.map(({ name, params, resolve }) => {\n        const required = params.some((param) => param.required)\n\n        return ast.factory.createProperty({\n          name,\n          required,\n          schema:\n            params.length > 0\n              ? ast.factory.createSchema({ type: 'ref', name: resolve.call(resolver.param, node, params[0]!), optional: !required })\n              : createNever(),\n        })\n      }),\n    ],\n  })\n}\n\n/**\n * The schema a status occupies in the `<Name>Responses` record. A status that documents several\n * content types becomes a `{ contentType; data }` union so the runtime can surface the negotiated type\n * on `result.parsed`, while the standalone `<Name>StatusNNN` alias stays the plain body union that the\n * query hooks and `result.data` use.\n */\nfunction buildResponseRecordEntry(node: ast.OperationNode, res: ast.ResponseNode, resolver: ResponseStatusNameResolver): ast.SchemaNode {\n  const statusName = resolver.response.status(node, res.statusCode)\n  const variants = (res.content ?? []).filter((entry) => entry.schema)\n  if (variants.length <= 1) {\n    return ast.factory.createSchema({ type: 'ref', name: statusName })\n  }\n\n  return ast.factory.createSchema({\n    type: 'union',\n    members: resolveContentTypeVariants(variants, statusName).map((variant) =>\n      ast.factory.createSchema({\n        type: 'object',\n        primitive: 'object',\n        properties: [\n          ast.factory.createProperty({\n            name: 'contentType',\n            required: true,\n            schema: ast.factory.createSchema({ type: 'enum', enumValues: [variant.contentType] }),\n          }),\n          ast.factory.createProperty({\n            name: 'data',\n            required: true,\n            schema: ast.factory.createSchema({ type: 'ref', name: variant.name }),\n          }),\n        ],\n      }),\n    ),\n  })\n}\n\n/**\n * Builds the per-status `<Name>Responses` record for an operation, referencing the already-resolved\n * `<Name>StatusNNN` names. Shared by `@kubb/plugin-ts`'s `Responses` type and `@kubb/plugin-zod`'s\n * inferred responses schema, so both emit the same shape from the same inputs.\n *\n * Always emits the keyed record, even when an operation declares no responses. An operation with no\n * responses renders as an empty object, which keeps every consumer's import (for example the axios\n * SDK's `RequestResult<XResponses>`) resolvable instead of pointing at a missing export.\n */\nexport function buildResponses(node: ast.OperationNode, resolver: ResponseStatusNameResolver): ast.SchemaNode {\n  return ast.factory.createSchema({\n    type: 'object',\n    primitive: 'object',\n    properties: node.responses.map((res) =>\n      ast.factory.createProperty({\n        name: String(res.statusCode),\n        required: true,\n        schema: buildResponseRecordEntry(node, res, resolver),\n      }),\n    ),\n  })\n}\n\nexport function getStatusCodeNumber(statusCode: ast.StatusCode | number | string): number | null {\n  const code = Number(statusCode)\n\n  return Number.isNaN(code) ? null : code\n}\n\nexport function isSuccessStatusCode(statusCode: ast.StatusCode | number | string): boolean {\n  const code = getStatusCodeNumber(statusCode)\n\n  return code !== null && code >= 200 && code < 300\n}\n\nexport function isErrorStatusCode(statusCode: ast.StatusCode | number | string): boolean {\n  const code = getStatusCodeNumber(statusCode)\n\n  return code !== null && code >= 400\n}\n\nexport function getSuccessResponses<TResponse extends ResponseLike>(responses: ReadonlyArray<TResponse>): Array<TResponse> {\n  return responses.filter((response) => isSuccessStatusCode(response.statusCode))\n}\n\nexport function getOperationSuccessResponses(node: ast.OperationNode): Array<ast.ResponseNode> {\n  return getSuccessResponses(node.responses)\n}\n\nexport function getPrimarySuccessResponse(node: ast.OperationNode): ast.ResponseNode | null {\n  return getOperationSuccessResponses(node)[0] ?? null\n}\n\nexport function resolveErrorNames(node: ast.OperationNode, resolver: ResponseStatusNameResolver): string[] {\n  return node.responses.filter((response) => isErrorStatusCode(response.statusCode)).map((response) => resolver.response.status(node, response.statusCode))\n}\n\nexport function resolveSuccessNames(node: ast.OperationNode, resolver: ResponseStatusNameResolver): string[] {\n  return node.responses.filter((response) => isSuccessStatusCode(response.statusCode)).map((response) => resolver.response.status(node, response.statusCode))\n}\n\nexport function resolveStatusCodeNames(node: ast.OperationNode, resolver: ResponseStatusNameResolver): string[] {\n  return node.responses.map((response) => resolver.response.status(node, response.statusCode))\n}\n\nconst typeNamesByResolver = new WeakMap<OperationTypeNameResolver, Map<string, string[]>>()\n\nexport function resolveOperationTypeNames(\n  node: ast.OperationNode,\n  resolver: OperationTypeNameResolver,\n  options: ResolveOperationTypeNameOptions = {},\n): string[] {\n  const cacheKey = `${node.operationId}\\0${options.order ?? ''}\\0${options.responseStatusNames ?? ''}\\0${options.includeParams === false ? 'noparams' : ''}\\0${(options.exclude ?? []).join(',')}`\n  let byResolver = typeNamesByResolver.get(resolver)\n  if (byResolver) {\n    const cached = byResolver.get(cacheKey)\n    if (cached) return cached\n  } else {\n    byResolver = new Map()\n    typeNamesByResolver.set(resolver, byResolver)\n  }\n\n  const { path, query, header } = getOperationParameters(node)\n  const responseStatusNames =\n    options.responseStatusNames === 'error'\n      ? resolveErrorNames(node, resolver)\n      : options.responseStatusNames === false\n        ? []\n        : resolveStatusCodeNames(node, resolver)\n  const exclude = new Set(options.exclude ?? [])\n  const paramNames =\n    options.includeParams === false\n      ? []\n      : [\n          ...path.map((param) => resolver.param.path(node, param)),\n          ...query.map((param) => resolver.param.query(node, param)),\n          ...header.map((param) => resolver.param.headers(node, param)),\n        ]\n  const bodyAndResponseNames = [node.requestBody?.content?.[0]?.schema ? resolver.response.body(node) : null, resolver.response.response(node)]\n  const names =\n    options.order === 'body-response-first'\n      ? [...bodyAndResponseNames, ...paramNames, ...responseStatusNames]\n      : [...paramNames, ...bodyAndResponseNames, ...responseStatusNames]\n\n  const result = names.filter((name): name is string => Boolean(name) && !exclude.has(name as string))\n  byResolver.set(cacheKey, result)\n  return result\n}\n\nexport function resolveResponseTypes(node: ast.OperationNode, resolver: ResponseNameResolver): Array<[statusCode: number | 'default', typeName: string]> {\n  const types: Array<[number | 'default', string]> = []\n\n  for (const response of node.responses) {\n    if (response.statusCode === 'default') {\n      types.push(['default', resolver.response.response(node)])\n      continue\n    }\n\n    const code = getStatusCodeNumber(response.statusCode)\n    if (code === null) {\n      continue\n    }\n\n    types.push([code, isSuccessStatusCode(code) ? resolver.response.response(node) : resolver.response.status(node, response.statusCode)])\n  }\n\n  return types\n}\n","import { toFilePath } from '@internals/utils'\nimport type { ast, Resolver, ResolverFile } from 'kubb/kit'\n\n/**\n * The `param` namespace shared by the schema-producing plugins (ts, zod, faker):\n * per-parameter names plus the grouped `Path`/`Query`/`Headers` names, all routed\n * through the plugin's top-level `name` casing.\n */\nexport type OperationParamResolver = {\n  name(this: Resolver, node: ast.OperationNode, param: ast.ParameterNode): string\n  path(this: Resolver, node: ast.OperationNode): string\n  query(this: Resolver, node: ast.OperationNode): string\n  headers(this: Resolver, node: ast.OperationNode): string\n}\n\n/**\n * The `response` namespace shared by the schema-producing plugins: per-status,\n * body, and combined response names, all routed through the plugin's top-level\n * `name` casing.\n */\nexport type OperationResponseResolver = {\n  status(this: Resolver, node: ast.OperationNode, statusCode: ast.StatusCode): string\n  body(this: Resolver, node: ast.OperationNode): string\n  responses(this: Resolver, node: ast.OperationNode): string\n  response(this: Resolver, node: ast.OperationNode): string\n}\n\n/**\n * Resolves a single operation parameter name with the\n * `<operationId> <in> <name>` template.\n *\n * @example\n * `operationParamName.call(resolver, node, param) // → 'DeletePetPathPetId'`\n */\nfunction operationParamName(this: Resolver, node: ast.OperationNode, param: ast.ParameterNode): string {\n  return this.name(`${node.operationId} ${param.in} ${param.name}`)\n}\n\n/**\n * Builds the shared `param` namespace. Spread the result into `createResolver`\n * and override individual methods next to it when a plugin deviates.\n *\n * @example\n * ```ts\n * createResolver<PluginTs>({ param: createOperationParamResolver(), ... })\n * ```\n */\nexport function createOperationParamResolver(): OperationParamResolver {\n  return {\n    name: operationParamName,\n    path(node) {\n      return this.name(`${node.operationId} Path`)\n    },\n    query(node) {\n      return this.name(`${node.operationId} Query`)\n    },\n    headers(node) {\n      return this.name(`${node.operationId} Headers`)\n    },\n  }\n}\n\n/**\n * Builds the shared `response` namespace. Spread the result into\n * `createResolver` and add plugin-specific methods (`options`, `error`) next\n * to it.\n *\n * @example\n * ```ts\n * createResolver<PluginTs>({ response: { ...createOperationResponseResolver(), options(node) {...} }, ... })\n * ```\n */\nexport function createOperationResponseResolver(): OperationResponseResolver {\n  return {\n    status(node, statusCode) {\n      return this.name(`${node.operationId} Status ${statusCode}`)\n    },\n    body(node) {\n      return this.name(`${node.operationId} Body`)\n    },\n    responses(node) {\n      return this.name(`${node.operationId} Responses`)\n    },\n    response(node) {\n      return this.name(`${node.operationId} Response`)\n    },\n  }\n}\n\n/**\n * Builds a resolver `file` override whose base name runs every path segment\n * through `toFilePath`, casing the final segment with `caseLast`.\n *\n * @example\n * ```ts\n * createResolver<PluginTs>({ file: createCasedFile(pascalCase), ... })\n * ```\n */\nexport function createCasedFile(caseLast: (part: string) => string): ResolverFile {\n  return {\n    baseName({ name, extname }) {\n      return `${toFilePath(name, caseLast)}${extname}`\n    },\n  }\n}\n","import { camelCase } from '@internals/utils'\nimport type { Group } from 'kubb/kit'\n\n/**\n * Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the\n * shared default naming so every plugin groups output consistently:\n *\n * - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).\n * - other groups use the camelCased group (`pet store` → `petStore`).\n *\n * A user-provided `group.name` always wins over the default namer, so callers stay in\n * control of their output folders. Returns `null` when grouping is disabled, matching the\n * per-plugin convention.\n *\n * @param group - The user-supplied group option, or `undefined` to disable grouping.\n *\n * @example\n * ```ts\n * createGroupConfig(group) // shared across every plugin\n * ```\n */\nexport function createGroupConfig(group: Group | undefined): Group | null {\n  if (!group) {\n    return null\n  }\n\n  const defaultName = (ctx: { group: string }): string => {\n    if (group.type === 'path') {\n      return `${ctx.group.split('/')[1]}`\n    }\n\n    return camelCase(ctx.group)\n  }\n\n  return {\n    ...group,\n    name: group.name ? group.name : defaultName,\n  } satisfies Group\n}\n","import type { ast } from 'kubb/kit'\n\n/**\n * Converts a child schema to printer output. Plugins instantiate it with their own output type:\n * `string` for the zod and faker printers, `ts.TypeNode` for the TypeScript printer. A printer's\n * `this.transform` fits directly, so its `null` for an empty result carries through to `output`.\n */\nexport type SchemaTransform<TOutput> = (schema: ast.SchemaNode) => TOutput\n\n/**\n * A union or intersection member, or an array or tuple item, paired with its transformed output.\n */\nexport type MappedSchema<TOutput> = {\n  /**\n   * The original child schema, kept so the printer can read its metadata for leaf formatting.\n   */\n  schema: ast.SchemaNode\n  /**\n   * The child schema after being run through the transform.\n   */\n  output: TOutput\n}\n\n/**\n * An object property paired with its transformed output.\n */\nexport type MappedProperty<TOutput> = {\n  /**\n   * The property name as written on the schema, before any identifier quoting.\n   */\n  name: string\n  /**\n   * The original property node, kept so the printer can read `required`, `schema`, and metadata.\n   */\n  property: ast.PropertyNode\n  /**\n   * The property schema after being run through the transform.\n   */\n  output: TOutput\n}\n\n/**\n * Maps each property of an object schema to its transformed output. Pairs every result with the\n * original property so the printer keeps full control over modifiers, getters, and key syntax.\n *\n * @example\n * ```ts\n * const entries = mapSchemaProperties(node, (schema) => this.transform(schema))\n * // entries: [{ name: 'id', property, output: 'z.number()' }, ...]\n * ```\n */\nexport function mapSchemaProperties<TOutput>(node: ast.ObjectSchemaNode, transform: SchemaTransform<TOutput>): Array<MappedProperty<TOutput>> {\n  return node.properties.map((property) => ({ name: property.name, property, output: transform(property.schema) }))\n}\n\n/**\n * Maps each member of a union or intersection schema to its transformed output, pairing every\n * result with the original member.\n */\nexport function mapSchemaMembers<TOutput>(\n  node: ast.UnionSchemaNode | ast.IntersectionSchemaNode,\n  transform: SchemaTransform<TOutput>,\n): Array<MappedSchema<TOutput>> {\n  return (node.members ?? []).map((schema) => ({ schema, output: transform(schema) }))\n}\n\n/**\n * Maps each item of an array or tuple schema to its transformed output, pairing every result with\n * the original item.\n */\nexport function mapSchemaItems<TOutput>(node: ast.ArraySchemaNode, transform: SchemaTransform<TOutput>): Array<MappedSchema<TOutput>> {\n  return (node.items ?? []).map((schema) => ({ schema, output: transform(schema) }))\n}\n","import { isSuccessStatusCode } from '@internals/shared'\nimport { jsDocEscape, stringify } from '@internals/utils'\nimport { ast, syncSchemaRef } from 'kubb/kit'\nimport type { ResolverTs } from './types.ts'\n\n/**\n * Resolves the type name an enum schema is referenced by. An enum emitted as a `const` object\n * with a `typeSuffix` uses its suffixed key alias (e.g. `StatusKey`); every other schema uses its\n * plain resolved name.\n */\ntype EnumTypeNameProps = {\n  resolver: ResolverTs\n  name: string\n  enumOptions: { type?: string; typeSuffix?: string } | undefined\n  isEnum: boolean\n}\n\nexport function enumTypeName({ resolver, name, enumOptions, isEnum }: EnumTypeNameProps): string {\n  return isEnum && enumOptions?.type === 'asConst' && enumOptions.typeSuffix ? resolver.enum.keyName({ name }, enumOptions.typeSuffix) : resolver.name(name)\n}\n\n/**\n * Tells whether a `const` (single-value enum) should render as a bare literal type (`'active'`)\n * rather than a named enum reference or a runtime enum declaration.\n *\n * The parser folds `const` into a single-value enum node. The adapter decides which schemas are\n * named enums and lists them in `enumSchemaNames`, and references to those names get suffixed (for\n * example `StatusKey`). A const renders as a literal only when the adapter has not registered it as\n * a named enum, which keeps the declaration and its references in sync across adapter versions.\n */\nexport function isInlineConstEnum(node: ast.EnumSchemaNode, enumSchemaNames?: ReadonlySet<string>): boolean {\n  const isConst = (node.namedEnumValues ?? node.enumValues ?? []).length === 1\n  return isConst && !(node.name && enumSchemaNames?.has(node.name))\n}\n\n/**\n * Collects JSDoc annotation strings for a schema node.\n *\n * Only uses official JSDoc tags from https://jsdoc.app/: `@description`, `@deprecated`, `@default`, `@example`, `@type`.\n * Constraint metadata (min/max length, pattern, multipleOf, min/maxProperties) is emitted as plain-text lines.\n\n */\nfunction isSchemaOptional(schema: ast.SchemaNode): boolean {\n  return Boolean(('optional' in schema && schema.optional) || ('nullish' in schema && schema.nullish))\n}\n\nfunction formatExample(value: unknown): string {\n  if (value === null || typeof value !== 'object') {\n    return String(value)\n  }\n\n  const rendered = JSON.stringify(value) ?? String(value)\n  return rendered.replaceAll('*/', '*\\\\/')\n}\n\nexport function buildPropertyJSDocComments(schema: ast.SchemaNode, optional?: boolean): Array<string | undefined> {\n  const meta = syncSchemaRef(schema)\n\n  const isArray = meta?.primitive === 'array'\n\n  const hasDescription = meta && 'description' in meta && meta.description\n\n  const formatComment =\n    meta && 'format' in meta && meta.format\n      ? hasDescription\n        ? // Empty line between description and format\n          [' ', `Format: \\`${meta.format}\\``]\n        : ['@description', `Format: \\`${meta.format}\\``]\n      : []\n\n  // OAS 3.1 carries schema examples as an `examples` array, one `@example` line each.\n  const exampleValues = meta?.examples ?? []\n\n  const comments = [\n    hasDescription ? `@description ${jsDocEscape(meta.description)}` : null,\n    ...formatComment,\n    meta && 'deprecated' in meta && meta.deprecated ? '@deprecated' : null,\n    // minItems/maxItems on arrays should not be emitted as @minLength/@maxLength\n    !isArray && meta && 'min' in meta && meta.min !== undefined ? `@minLength ${meta.min}` : null,\n    !isArray && meta && 'max' in meta && meta.max !== undefined ? `@maxLength ${meta.max}` : null,\n    meta && 'pattern' in meta && meta.pattern ? `@pattern ${meta.pattern}` : null,\n    meta && 'default' in meta && meta.default !== undefined\n      ? `@default ${'primitive' in meta && meta.primitive === 'string' && typeof meta.default === 'string' ? stringify(meta.default) : formatExample(meta.default)}`\n      : null,\n    ...exampleValues.map((example) => `@example ${formatExample(example)}`),\n  ].filter(Boolean)\n\n  // `@type` merely repeats the TypeScript type already sitting next to the property, so it only\n  // earns its place inside a comment block that exists for another reason. Bare, it would just\n  // add bytes with no information a reader can't already see in the signature.\n  const typeTag =\n    comments.length && meta && 'primitive' in meta && meta.primitive\n      ? [`@type ${meta.primitive}`, (optional ?? isSchemaOptional(schema)) ? ' | undefined' : null].filter(Boolean).join('')\n      : null\n\n  return [...comments, typeTag].filter(Boolean)\n}\n\ntype BuildParamsSchemaOptions = {\n  params: Array<ast.ParameterNode>\n}\n\ntype BuildOperationSchemaOptions = {\n  resolver: ResolverTs\n}\n\n/**\n * Builds the object schema for a group of parameters sharing one `in` location (path, query, or\n * header), embedding each param's own schema (and JSDoc) directly rather than referencing a\n * separate per-param type — the group itself is the only type these params get exported as.\n */\nexport function buildParams({ params }: BuildParamsSchemaOptions): ast.SchemaNode {\n  return ast.factory.createSchema({\n    type: 'object',\n    properties: params.map((param) =>\n      ast.factory.createProperty({\n        name: param.name,\n        required: param.required,\n        schema: ast.factory.createSchema({ ...param.schema, optional: !param.required }),\n      }),\n    ),\n  })\n}\n\nexport function buildResponseUnion(node: ast.OperationNode, { resolver }: BuildOperationSchemaOptions): ast.SchemaNode | null {\n  const allWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema))\n  // Only 2xx responses, so an `unknown` error body cannot erase the success typing. Falls back to all responses when no 2xx has a schema.\n  const successWithSchema = allWithSchema.filter((res) => isSuccessStatusCode(res.statusCode))\n  const responsesWithSchema = successWithSchema.length > 0 ? successWithSchema : allWithSchema\n\n  if (responsesWithSchema.length === 0) {\n    return null\n  }\n\n  return ast.factory.createSchema({\n    type: 'union',\n    members: responsesWithSchema.map((res) => ast.factory.createSchema({ type: 'ref', name: resolver.response.status(node, res.statusCode) })),\n  })\n}\n","import { ast } from 'kubb/kit'\nimport { File } from 'kubb/jsx'\nimport type { KubbReactNode } from 'kubb/jsx'\nimport type { PrinterTsFactory } from '../printers/printerTs.ts'\nimport type { PluginTs, ResolverTs } from '../types.ts'\nimport { isInlineConstEnum } from '../utils.ts'\nimport { Enum, getEnumNames } from './Enum.tsx'\n\ntype Props = {\n  name: string\n  node: ast.SchemaNode\n  /**\n   * Pre-configured printer instance created by the generator.\n   * Created with `printerTs({ ..., nodes: options.printer?.nodes })`.\n   */\n  printer: ast.Printer<PrinterTsFactory>\n  enum: PluginTs['resolvedOptions']['enum']\n  resolver: ResolverTs\n}\n\nexport function Type({ name, node, printer, enum: enumOptions, resolver }: Props): KubbReactNode {\n  const enumSchemaNodes = ast.collectSync<ast.EnumSchemaNode>(node, {\n    schema(n): ast.EnumSchemaNode | undefined {\n      const enumNode = ast.narrowSchema(n, ast.schemaTypes.enum)\n      // Skip an inline `const` (single-value enum the adapter did not register): it renders as a\n      // literal, so it gets no runtime enum declaration.\n      if (enumNode?.name && !isInlineConstEnum(enumNode, printer.options.enumSchemaNames)) return enumNode\n    },\n  })\n\n  const output = printer.print(node)\n\n  if (!output) {\n    return\n  }\n\n  const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {\n    return {\n      node,\n      ...getEnumNames({ node, enum: enumOptions, resolver }),\n    }\n  })\n\n  // Skip enum exports when using inlineLiteral\n  const shouldExportEnums = enumOptions.type !== 'inlineLiteral'\n  const shouldExportType = enumOptions.type === 'inlineLiteral' || enums.every((item) => item.typeName !== name)\n\n  return (\n    <>\n      {shouldExportEnums && enums.map(({ node }) => <Enum key={node.name} node={node} enum={enumOptions} resolver={resolver} />)}\n      {shouldExportType && (\n        <File.Source name={name} isTypeOnly isExportable isIndexable>\n          {output}\n        </File.Source>\n      )}\n    </>\n  )\n}\n","import { mapSchemaItems, mapSchemaProperties } from '@internals/shared'\nimport { ast, isStringType, syncSchemaRef } from 'kubb/kit'\nimport { parserTs } from '@kubb/parser-ts'\nimport type ts from '@typescript/typescript6'\nimport * as factory from '../factory.ts'\nimport type { PluginTs, ResolverTs } from '../types.ts'\nimport { buildPropertyJSDocComments, enumTypeName, isInlineConstEnum } from '../utils.ts'\n\nconst { isNonNullable } = factory\n\n/**\n * Partial map of node-type overrides for the TypeScript printer.\n *\n * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`). The function\n * replaces the built-in handler for that node type. Use `this.transform` to\n * recurse into nested schema nodes, and `this.options` to read printer options.\n *\n * @example Override the `date` handler\n * ```ts\n * pluginTs({\n *   printer: {\n *     nodes: {\n *       date(node) {\n *         return ts.factory.createTypeReferenceNode('Date', [])\n *       },\n *     },\n *   },\n * })\n * ```\n */\nexport type PrinterTsNodes = ast.PrinterPartial<ts.TypeNode, PrinterTsOptions>\n\nexport type PrinterTsOptions = {\n  /**\n   * Mark parameters as optional with `?` or `| undefined`.\n   * - `'questionToken'` adds `?` to properties\n   * - `'undefined'` adds `| undefined` to types\n   *\n   * @default `'questionToken'`\n   */\n  optionalType: PluginTs['resolvedOptions']['optionalType']\n  /**\n   * Array representation style.\n   * - `'array'` uses bracket notation (`T[]`)\n   * - `'generic'` uses generic syntax (`Array<T>`)\n   *\n   * @default `'array'`\n   */\n  arrayType: PluginTs['resolvedOptions']['arrayType']\n  /**\n   * Grouped enum settings. The printer emits references to enums, not the enum declarations, so only\n   * `type` (the output format) and `typeSuffix` (the enum key reference suffix) matter here.\n   * `constCasing` and `keyCasing` are ignored.\n   */\n  enum: PluginTs['resolvedOptions']['enum']\n  /**\n   * Syntax for generated declarations.\n   * - `'type'` generates type aliases\n   * - `'interface'` generates interface declarations\n   *\n   * @default `'type'`\n   */\n  syntaxType?: PluginTs['resolvedOptions']['syntaxType']\n  /**\n   * Exported name for the type declaration.\n   * When omitted, returns only the raw type node.\n   */\n  name?: string\n\n  /**\n   * JSDoc comment to attach to the generated type.\n   */\n  description?: string\n  /**\n   * Properties to exclude using `Omit<Type, Keys>`.\n   * Forces type alias syntax regardless of `syntaxType` setting.\n   */\n  keysToOmit?: Array<string> | null\n  /**\n   * Transforms raw schema names into valid TypeScript identifiers.\n   */\n  resolver: ResolverTs\n  /**\n   * Schema names that represent enums for suffixed key references.\n   */\n  enumSchemaNames?: Set<string>\n  /**\n   * Custom handler map for node type overrides.\n   */\n  nodes?: PrinterTsNodes\n}\n\n/**\n * TypeScript printer factory options: maps `SchemaNode` → `ts.TypeNode` (raw) or `ts.Node` (full declaration).\n */\nexport type PrinterTsFactory = ast.PrinterFactoryOptions<'typescript', PrinterTsOptions, ts.TypeNode, string>\n\ntype PrinterTs = PrinterTsFactory\n\n/**\n * TypeScript type printer built with `definePrinter`.\n *\n * Converts a `SchemaNode` AST node into a TypeScript AST node:\n * - **`printer.print(node)`** — when `options.typeName` is set, returns a full\n *   `type Name = …` or `interface Name { … }` declaration (`ts.Node`).\n *   Without `typeName`, returns the raw `ts.TypeNode` for the schema.\n *\n * Dispatches on `node.type` to the appropriate handler in `nodes`. Options are closed\n * over per printer instance, so each call to `printerTs(options)` produces an independent printer.\n *\n * @example Raw type node (no `typeName`)\n * ```ts\n * const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enum: { type: 'inlineLiteral' } })\n * const typeNode = printer.print(schemaNode) // ts.TypeNode\n * ```\n *\n * @example Full declaration (with `typeName`)\n * ```ts\n * const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enum: { type: 'inlineLiteral' }, typeName: 'MyType' })\n * const declaration = printer.print(schemaNode) // ts.TypeAliasDeclaration | ts.InterfaceDeclaration\n * ```\n */\nexport const printerTs = ast.createPrinter<PrinterTs>((options) => {\n  const addsUndefined = options.optionalType === 'undefined' || options.optionalType === 'questionTokenAndUndefined'\n\n  return {\n    name: 'typescript',\n    options,\n    nodes: {\n      any: () => factory.keywordTypeNodes.any,\n      unknown: () => factory.keywordTypeNodes.unknown,\n      void: () => factory.keywordTypeNodes.void,\n      never: () => factory.keywordTypeNodes.never,\n      boolean: () => factory.keywordTypeNodes.boolean,\n      null: () => factory.keywordTypeNodes.null,\n      blob: () => factory.createTypeReferenceNode('Blob', []),\n      string: () => factory.keywordTypeNodes.string,\n      uuid: () => factory.keywordTypeNodes.string,\n      email: () => factory.keywordTypeNodes.string,\n      url: (node) => {\n        if (node.path) {\n          return factory.createUrlTemplateType(node.path)\n        }\n        return factory.keywordTypeNodes.string\n      },\n      ipv4: () => factory.keywordTypeNodes.string,\n      ipv6: () => factory.keywordTypeNodes.string,\n      datetime: () => factory.keywordTypeNodes.string,\n      number: () => factory.keywordTypeNodes.number,\n      integer: () => factory.keywordTypeNodes.number,\n      bigint: () => factory.keywordTypeNodes.bigint,\n      date: factory.dateOrStringNode,\n      time: factory.dateOrStringNode,\n      ref(node) {\n        if (!node.name) {\n          return null\n        }\n        // `node.name` may have been overridden (e.g. by the single-member allOf flatten using the\n        // property-derived child name), so resolve the target through `resolveRefName` instead.\n        const refName = ast.resolveRefName(node)\n        if (!refName) {\n          return null\n        }\n\n        // When a Key suffix is configured, enum refs must use the suffixed name (e.g. `StatusKey`)\n        // so the reference matches what the enum file actually exports.\n        const name = node.ref\n          ? enumTypeName({\n              resolver: this.options.resolver,\n              name: refName,\n              enumOptions: this.options.enum,\n              isEnum: !!this.options.enumSchemaNames?.has(refName),\n            })\n          : refName\n\n        return factory.createTypeReferenceNode(name, undefined)\n      },\n      enum(node) {\n        const values = ast.getSchemaLiteralValues(node)\n\n        // A `const` (single-value enum) the adapter did not register as a named enum emits the bare\n        // literal regardless of `enum.type`, matching how its references resolve.\n        if (this.options.enum.type === 'inlineLiteral' || !node.name || isInlineConstEnum(node, this.options.enumSchemaNames)) {\n          const literalNodes = values\n            .filter((v): v is string | number | boolean => v !== null && v !== undefined)\n            .map((value) => factory.constToTypeNode(value, typeof value as 'string' | 'number' | 'boolean'))\n            .filter(isNonNullable)\n\n          return factory.createUnionDeclaration({ withParentheses: true, nodes: literalNodes })\n        }\n\n        const resolvedName = enumTypeName({ resolver: this.options.resolver, name: node.name, enumOptions: this.options.enum, isEnum: true })\n\n        return factory.createTypeReferenceNode(resolvedName, undefined)\n      },\n      union(node) {\n        const members = node.members ?? []\n\n        const hasStringLiteral = members.some((m) => {\n          const enumNode = ast.narrowSchema(m, ast.schemaTypes.enum)\n          return enumNode?.primitive === 'string'\n        })\n        const hasPlainString = members.some((m) => isStringType(m))\n\n        if (hasStringLiteral && hasPlainString) {\n          const memberNodes = members\n            .map((m) => {\n              if (isStringType(m)) {\n                return factory.createIntersectionDeclaration({\n                  nodes: [factory.keywordTypeNodes.string, factory.createTypeLiteralNode([])],\n                  withParentheses: true,\n                })\n              }\n\n              return this.transform(m)\n            })\n            .filter(isNonNullable)\n\n          return factory.createUnionDeclaration({ withParentheses: true, nodes: memberNodes })\n        }\n\n        return factory.createUnionDeclaration({ withParentheses: true, nodes: factory.buildMemberNodes(members, this.transform) })\n      },\n      intersection(node) {\n        return factory.createIntersectionDeclaration({ withParentheses: true, nodes: factory.buildMemberNodes(node.members, this.transform) })\n      },\n      array(node) {\n        const itemNodes = mapSchemaItems(node, (item) => this.transform(item))\n          .map(({ output }) => output)\n          .filter(isNonNullable)\n\n        return factory.createArrayDeclaration({ nodes: itemNodes, arrayType: this.options.arrayType })\n      },\n      tuple(node) {\n        return factory.buildTupleNode(node, this.transform)\n      },\n      object(node) {\n        const { transform, options } = this\n\n        const addsQuestionToken = options.optionalType === 'questionToken' || options.optionalType === 'questionTokenAndUndefined'\n\n        const propertyNodes: Array<ts.TypeElement> = mapSchemaProperties(node, (schema) => transform(schema)).map(({ name, property, output }) => {\n          const baseType = output ?? factory.keywordTypeNodes.unknown\n          const optional = !property.required || !!property.schema.optional || !!property.schema.nullish\n          const type = factory.buildPropertyType(property.schema, baseType, options.optionalType, optional)\n          const propMeta = syncSchemaRef(property.schema)\n\n          const propertyNode = factory.createPropertySignature({\n            questionToken: optional ? addsQuestionToken : false,\n            name,\n            type,\n            readOnly: propMeta?.readOnly,\n          })\n\n          return factory.appendJSDocToNode({ node: propertyNode, comments: buildPropertyJSDocComments(property.schema, optional) })\n        })\n\n        const allElements = [...propertyNodes, ...factory.buildIndexSignatures(node, propertyNodes.length, transform)]\n\n        if (!allElements.length) {\n          return factory.keywordTypeNodes.object\n        }\n\n        return factory.createTypeLiteralNode(allElements)\n      },\n      ...options.nodes,\n    },\n    print(node) {\n      const { name, syntaxType = 'type', description, keysToOmit } = this.options\n\n      const transformed = this.transform(node)\n      if (!transformed) return null\n\n      // For ref nodes, structural metadata lives on node.schema rather than the ref node itself.\n      const meta = syncSchemaRef(node)\n\n      // Without name, apply modifiers inline and return.\n      if (!name) {\n        const result = factory.wrapNullableOptional(transformed, !!meta.nullable, !!(meta.nullish || meta.optional) && addsUndefined)\n        return parserTs().print(result)\n      }\n\n      // When keysToOmit is present, wrap with Omit first, then apply nullable/optional\n      // modifiers so they are not swallowed by NonNullable inside createOmitDeclaration.\n      const inner = (() => {\n        const omitted: ts.TypeNode = keysToOmit?.length\n          ? factory.createOmitDeclaration({ keys: keysToOmit, type: transformed, nonNullable: true })\n          : transformed\n        // For named type declarations (type aliases), optional/nullish always produces | undefined\n        // regardless of optionalType — the questionToken ? modifier only applies to object properties.\n        return factory.wrapNullableOptional(omitted, !!meta.nullable, !!(meta.nullish || meta.optional))\n      })()\n\n      const useTypeGeneration = syntaxType === 'type' || factory.isUnionTypeNode(inner) || !!keysToOmit?.length\n\n      const typeNode = factory.createTypeDeclaration({\n        name,\n        isExportable: true,\n        type: inner,\n        syntax: useTypeGeneration ? 'type' : 'interface',\n        comments: buildPropertyJSDocComments({\n          ...meta,\n          description,\n        }),\n      })\n\n      return parserTs().print(typeNode)\n    },\n  }\n})\n","import { buildOptionsSchema, buildResponses, getOperationParameters, resolveContentTypeVariants } from '@internals/shared'\nimport { ast, defineGenerator } from 'kubb/kit'\nimport { File, jsxRenderer } from 'kubb/jsx'\nimport { Type } from '../components/Type.tsx'\nimport { printerTs } from '../printers/printerTs.ts'\nimport type { PluginTs } from '../types'\nimport { buildParams, buildResponseUnion, enumTypeName, isInlineConstEnum } from '../utils.ts'\n\n/**\n * Built-in generator for `@kubb/plugin-ts`. Emits one TypeScript file per\n * schema in the spec plus per-operation request, response, and parameter\n * types. Drop-replace with a custom `Generator<PluginTs>` to change how\n * TypeScript output is produced.\n */\nexport const typeGenerator = defineGenerator<PluginTs>({\n  name: 'typescript',\n  renderer: jsxRenderer,\n  schema(node, ctx) {\n    const { enum: enumOptions, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options\n    const { config, resolver, root } = ctx\n\n    if (!node.name) {\n      return\n    }\n    // Build a set of schema names that are enums so the ref handler and the imports\n    // name callback can use the suffixed type name (e.g. `StatusKey`) for those refs.\n    const enumSchemaNames = new Set<string>(ctx.meta.enumNames)\n    const importName = (schemaName: string) => enumTypeName({ resolver, name: schemaName, enumOptions, isEnum: enumSchemaNames.has(schemaName) })\n\n    const imports = resolver.imports({ node, root, output, group: group ?? undefined, name: importName })\n\n    const enumNode = ast.narrowSchema(node, ast.schemaTypes.enum)\n    // An inline `const` (single-value enum the adapter did not register) renders as a literal type,\n    // so it keeps its plain name instead of the suffixed enum-key name.\n    const isEnumSchema = !!enumNode && !isInlineConstEnum(enumNode, enumSchemaNames)\n\n    const meta = {\n      name: enumOptions.type === 'asConst' && isEnumSchema ? resolver.enum.keyName(node, enumOptions.typeSuffix) : resolver.name(node.name),\n      file: resolver.file({ name: node.name, extname: '.ts', root, output, group: group ?? undefined }),\n    } as const\n\n    const schemaPrinter = printerTs({\n      optionalType,\n      arrayType,\n      enum: enumOptions,\n      name: meta.name,\n      syntaxType,\n      description: node.description,\n      resolver,\n      enumSchemaNames,\n      nodes: printer?.nodes,\n    })\n\n    return (\n      <File\n        baseName={meta.file.baseName}\n        path={meta.file.path}\n        meta={meta.file.meta}\n        banner={resolver.default.banner(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}\n        footer={resolver.default.footer(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}\n      >\n        {imports.map((imp) => (\n          <File.Import key={[node.name, imp.path, imp.isTypeOnly].join('-')} root={meta.file.path} path={imp.path} name={imp.name} isTypeOnly />\n        ))}\n        <Type name={meta.name} node={node} enum={enumOptions} resolver={resolver} printer={schemaPrinter} />\n      </File>\n    )\n  },\n  operation(node, ctx) {\n    const { enum: enumOptions, optionalType, arrayType, syntaxType, group, output, printer } = ctx.options\n    const { config, resolver, root } = ctx\n\n    const meta = {\n      file: resolver.file({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path, root, output, group: group ?? undefined }),\n    } as const\n\n    // Build a set of schema names that are enums so the ref handler and the imports\n    // name callback can use the suffixed type name (e.g. `StatusKey`) for those refs.\n    const enumSchemaNames = new Set<string>(ctx.meta.enumNames)\n    const importName = (schemaName: string) => enumTypeName({ resolver, name: schemaName, enumOptions, isEnum: enumSchemaNames.has(schemaName) })\n\n    function renderSchemaType({ schema, name, keysToOmit }: { schema: ast.SchemaNode | null; name: string; keysToOmit?: Array<string> | null }) {\n      if (!schema) return null\n\n      const imports = resolver.imports({ node: schema, root, output, group: group ?? undefined, name: importName })\n\n      const schemaPrinter = printerTs({\n        optionalType,\n        arrayType,\n        enum: enumOptions,\n        name,\n        syntaxType,\n        description: schema.description,\n        keysToOmit,\n        resolver,\n        enumSchemaNames,\n        nodes: printer?.nodes,\n      })\n\n      return (\n        <>\n          {imports.map((imp) => (\n            <File.Import key={[name, imp.path, imp.isTypeOnly].join('-')} root={meta.file.path} path={imp.path} name={imp.name} isTypeOnly />\n          ))}\n          <Type name={name} node={schema} enum={enumOptions} resolver={resolver} printer={schemaPrinter} />\n        </>\n      )\n    }\n\n    /**\n     * Emits an individual type per content type plus a plain union alias under `baseName`. Shared by\n     * the request body and multi-content-type responses. The response record discriminates these\n     * variants by content type in {@link buildResponses}; the standalone alias stays a plain union so\n     * query hooks and `result.data` keep the bare body.\n     */\n    function buildContentTypeVariants(\n      entries: Array<{ contentType: string; schema?: ast.SchemaNode | null; keysToOmit?: Array<string> | null }>,\n      baseName: string,\n      decorate?: (schema: ast.SchemaNode) => ast.SchemaNode,\n    ) {\n      const variants = resolveContentTypeVariants(entries, baseName)\n      const unionSchema = ast.factory.createSchema({\n        type: 'union',\n        members: variants.map((variant) => ast.factory.createSchema({ type: 'ref', name: variant.name })),\n      })\n      return (\n        <>\n          {variants.map((variant) =>\n            renderSchemaType({\n              schema: decorate ? decorate(variant.schema) : variant.schema,\n              name: variant.name,\n              keysToOmit: variant.keysToOmit,\n            }),\n          )}\n          {renderSchemaType({ schema: unionSchema, name: baseName })}\n        </>\n      )\n    }\n\n    const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node)\n\n    const paramGroupTypes = [\n      pathParams.length > 0 && renderSchemaType({ schema: buildParams({ params: pathParams }), name: resolver.param.path(node, pathParams[0]!) }),\n      queryParams.length > 0 && renderSchemaType({ schema: buildParams({ params: queryParams }), name: resolver.param.query(node, queryParams[0]!) }),\n      headerParams.length > 0 && renderSchemaType({ schema: buildParams({ params: headerParams }), name: resolver.param.headers(node, headerParams[0]!) }),\n    ]\n\n    const requestBodyContent = node.requestBody?.content ?? []\n\n    function buildRequestType() {\n      if (requestBodyContent.length === 0) return null\n      if (requestBodyContent.length === 1) {\n        const entry = requestBodyContent[0]!\n        if (!entry.schema) return null\n        return renderSchemaType({\n          schema: {\n            ...entry.schema,\n            description: node.requestBody!.description ?? entry.schema.description,\n          },\n          name: resolver.response.body(node),\n          keysToOmit: entry.keysToOmit,\n        })\n      }\n      // Multiple content types — generate individual types + union alias\n      return buildContentTypeVariants(requestBodyContent, resolver.response.body(node), (schema) => ({\n        ...schema,\n        description: node.requestBody!.description ?? schema.description,\n      }))\n    }\n\n    const requestType = buildRequestType()\n\n    const responseTypes = node.responses.map((res) => {\n      const variants = (res.content ?? []).filter((entry) => entry.schema)\n      // Multiple content types for a single status code — generate per-variant types + a plain union.\n      // The `<Name>Responses` record discriminates them by content type (see buildResponses).\n      if (variants.length > 1) {\n        return buildContentTypeVariants(variants, resolver.response.status(node, res.statusCode))\n      }\n      const primary = variants[0] ?? res.content?.[0]\n      return renderSchemaType({\n        schema: primary?.schema ?? null,\n        name: resolver.response.status(node, res.statusCode),\n        keysToOmit: primary?.keysToOmit,\n      })\n    })\n\n    const optionsType = renderSchemaType({\n      schema: buildOptionsSchema(node, resolver),\n      name: resolver.response.options(node),\n    })\n\n    const responsesType = renderSchemaType({\n      schema: buildResponses(node, resolver),\n      name: resolver.response.responses(node),\n    })\n\n    function buildResponseType() {\n      const hasSchema = (res: ast.ResponseNode) => (res.content ?? []).some((entry) => entry.schema)\n      if (!node.responses.some(hasSchema)) {\n        return null\n      }\n\n      const responseName = resolver.response.response(node)\n\n      const responsesWithSchema = node.responses.filter(hasSchema)\n      const importedNames = new Set(\n        responsesWithSchema.flatMap((res) =>\n          (res.content ?? []).flatMap((entry) => (entry.schema ? ast.collectImportedRefNames(entry.schema).map(importName) : [])),\n        ),\n      )\n\n      if (importedNames.has(responseName)) {\n        return null\n      }\n\n      return renderSchemaType({\n        schema: {\n          ...buildResponseUnion(node, { resolver })!,\n          description: 'Union of all possible responses',\n        },\n        name: responseName,\n      })\n    }\n\n    const responseType = buildResponseType()\n\n    return (\n      <File\n        baseName={meta.file.baseName}\n        path={meta.file.path}\n        meta={meta.file.meta}\n        banner={resolver.default.banner(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}\n        footer={resolver.default.footer(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}\n      >\n        {paramGroupTypes}\n        {responseTypes}\n        {requestType}\n        {optionsType}\n        {responsesType}\n        {responseType}\n      </File>\n    )\n  },\n})\n","","","import { createCasedFile, createOperationParamResolver, createOperationResponseResolver } from '@internals/shared'\nimport { ensureValidVarName, pascalCase } from '@internals/utils'\nimport { createResolver } from 'kubb/kit'\nimport type { PluginTs } from '../types.ts'\n\n/**\n * Default resolver used by `@kubb/plugin-ts`. Decides the names and file paths\n * for every generated TypeScript type. Import this in other plugins that need\n * to reference the exact names `plugin-ts` produces without duplicating the\n * casing/file-layout rules.\n *\n * The `default` helpers are supplied by `createResolver`. This plugin overrides the top-level `name`\n * to use PascalCase for value and type names and `file` to write PascalCase file paths (dotted names\n * become `/`-joined), and groups the operation-specific naming under the `param`, `response`, and\n * `enum` namespaces.\n *\n * @example Resolve a type and file name\n * ```ts\n * import { resolverTs } from '@kubb/plugin-ts'\n *\n * resolverTs.name('list pets')                     // 'ListPets'\n * resolverTs.response.status(node, 200)            // 'ListPetsStatus200'\n * ```\n */\nexport const resolverTs = createResolver<PluginTs>({\n  pluginName: 'plugin-ts',\n  name(name) {\n    return ensureValidVarName(pascalCase(name))\n  },\n  file: createCasedFile(pascalCase),\n  param: createOperationParamResolver(),\n  response: {\n    ...createOperationResponseResolver(),\n    options(node) {\n      return this.name(`${node.operationId} Options`)\n    },\n  },\n  enum: {\n    keyName(node, enumTypeSuffix = 'key') {\n      return `${this.name(node.name ?? '')}${enumTypeSuffix}`\n    },\n  },\n})\n","import { createGroupConfig } from '@internals/shared'\nimport { addGenerator, defineExtension, Resolver, setMacros, setResolver } from 'kubb/kit'\nimport { compatibility } from '../kubb-extension.json'\nimport { version } from '../package.json'\nimport { typeGenerator } from './generators/typeGenerator.tsx'\nimport { resolverTs } from './resolvers/resolverTs.ts'\nimport type { PluginTs } from './types.ts'\n\n/**\n * Canonical plugin name for `@kubb/plugin-ts`. Used for driver lookups and\n * cross-plugin dependency references.\n */\nexport const pluginTsName = 'plugin-ts' satisfies PluginTs['name']\n\n/**\n * Generates TypeScript `type` aliases and `interface` declarations from an\n * OpenAPI spec. The foundation that every other Kubb plugin builds on:\n * clients, query hooks, mocks, and validators all reference the names this\n * plugin produces.\n *\n * @example\n * ```ts\n * import { defineConfig } from 'kubb/config'\n * import { pluginTs } from '@kubb/plugin-ts'\n *\n * export default defineConfig({\n *   input: './petStore.yaml',\n *   output: { path: './src/gen' },\n *   plugins: [\n *     pluginTs({\n *       output: { path: './types' },\n *       enum: { type: 'asConst' },\n *       optionalType: 'questionTokenAndUndefined',\n *     }),\n *   ],\n * })\n * ```\n */\nexport const pluginTs = defineExtension<PluginTs>({\n  kind: 'plugin',\n  meta: { name: pluginTsName, version, compatibility },\n  setup(options) {\n    const {\n      output = { path: 'types', barrel: { type: 'named' } },\n      group,\n      exclude = [],\n      include,\n      override = [],\n      enum: enumOptions = {},\n      optionalType = 'questionToken',\n      arrayType = 'array',\n      syntaxType = 'type',\n      printer,\n      resolver: userResolver,\n      macros: userMacros,\n    } = options\n\n    const resolvedEnum = {\n      type: enumOptions.type ?? 'asConst',\n      constCasing: enumOptions.constCasing ?? 'camelCase',\n      typeSuffix: enumOptions.typeSuffix ?? 'Key',\n      keyCasing: enumOptions.keyCasing ?? 'none',\n    }\n\n    setResolver(userResolver ? Resolver.merge(resolverTs, userResolver) : resolverTs)\n    if (userMacros?.length) {\n      setMacros(userMacros)\n    }\n    addGenerator(typeGenerator)\n\n    return {\n      output,\n      exclude,\n      include,\n      override,\n      optionalType,\n      group: createGroupConfig(group),\n      arrayType,\n      enum: resolvedEnum,\n      syntaxType,\n      printer,\n    }\n  },\n})\n\nexport default pluginTs\n","/**\n * A type expression used as a function parameter type annotation.\n *\n * - a plain `string` is a type reference rendered as-is, e.g. `'string'`, `'QueryParams'`, `'Partial<Config>'`\n * - a {@link TypeLiteralNode} is an inline anonymous type, e.g. `{ petId: string; name?: string }`\n * - an {@link IndexedAccessTypeNode} is a single field accessed from a named type, e.g. `PathParams['petId']`\n */\nexport type TypeExpression = string | TypeLiteralNode | IndexedAccessTypeNode\n\n/**\n * An inline anonymous object type grouping named fields.\n * Renders as `{ key: Type; other?: OtherType }`.\n */\nexport type TypeLiteralNode = {\n  kind: 'TypeLiteral'\n  /**\n   * Members of the object type, rendered in order.\n   */\n  members: Array<{\n    /**\n     * Member key.\n     */\n    name: string\n    /**\n     * Member type expression.\n     */\n    type: TypeExpression\n    /**\n     * Whether the member is optional, rendered with `?`.\n     */\n    optional?: boolean\n  }>\n}\n\n/**\n * A single field accessed from a named group type. Renders as `target['key']`.\n */\nexport type IndexedAccessTypeNode = {\n  kind: 'IndexedAccessType'\n  /**\n   * Name of the type being indexed, e.g. `'GetPetPathParams'`.\n   */\n  target: string\n  /**\n   * Field key to access, e.g. `'petId'`.\n   */\n  key: string\n}\n\n/**\n * An object destructuring binding, used as the name of a grouped function parameter.\n * Renders as `{ id, name }` or `{ id: renamed }` when `propertyName` differs.\n */\nexport type ObjectBindingPatternNode = {\n  kind: 'ObjectBindingPattern'\n  /**\n   * Bound elements, rendered in order.\n   */\n  elements: Array<{\n    /**\n     * Local binding name.\n     */\n    name: string\n    /**\n     * Source key when it differs from the binding name, rendered as `propertyName: name`.\n     */\n    propertyName?: string\n  }>\n}\n\n/**\n * One function parameter.\n *\n * A simple parameter has a `string` name. A destructured group has an\n * {@link ObjectBindingPatternNode} name paired with a {@link TypeLiteralNode} type.\n *\n * @example Required parameter\n * `name: Type`\n *\n * @example Optional parameter\n * `name?: Type`\n *\n * @example Parameter with default value\n * `name: Type = defaultValue`\n *\n * @example Rest parameter\n * `...name: Type[]`\n *\n * @example Destructured group\n * `{ id, name? }: { id: string; name?: string } = {}`\n */\nexport type FunctionParameterNode = {\n  kind: 'FunctionParameter'\n  /**\n   * Parameter name, or an {@link ObjectBindingPatternNode} for a destructured group.\n   */\n  name: string | ObjectBindingPatternNode\n  /**\n   * Type annotation as a {@link TypeExpression}. Omit for untyped output.\n   */\n  type?: TypeExpression\n  /**\n   * Whether the parameter is optional, rendered with `?`.\n   */\n  optional?: boolean\n  /**\n   * Default value, written verbatim after `=`. Commonly `'{}'` for a destructured group.\n   */\n  default?: string\n  /**\n   * When `true` the parameter is emitted as a rest parameter, e.g. `...name: Type[]`.\n   */\n  rest?: boolean\n}\n\n/**\n * A complete function parameter list.\n *\n * Printers are responsible for sorting (`required` → `optional` → `defaulted`).\n */\nexport type FunctionParametersNode = {\n  kind: 'FunctionParameters'\n  /**\n   * Ordered parameter nodes.\n   */\n  params: ReadonlyArray<FunctionParameterNode>\n}\n\n/**\n * Narrows a {@link TypeExpression} to a {@link TypeLiteralNode}.\n */\nexport function isTypeLiteral(type: TypeExpression): type is TypeLiteralNode {\n  return typeof type !== 'string' && type.kind === 'TypeLiteral'\n}\n\n/**\n * Narrows a {@link TypeExpression} to an {@link IndexedAccessTypeNode}.\n */\nexport function isIndexedAccessType(type: TypeExpression): type is IndexedAccessTypeNode {\n  return typeof type !== 'string' && type.kind === 'IndexedAccessType'\n}\n\n/**\n * Creates a {@link TypeLiteralNode} representing an inline anonymous object type.\n *\n * @example\n * ```ts\n * createTypeLiteral({ members: [{ name: 'petId', type: 'string', optional: false }] })\n * // { petId: string }\n * ```\n */\nexport function createTypeLiteral(props: Omit<TypeLiteralNode, 'kind'>): TypeLiteralNode {\n  return { kind: 'TypeLiteral', ...props }\n}\n\n/**\n * Creates an {@link IndexedAccessTypeNode} representing a single field accessed from a named type.\n *\n * @example\n * ```ts\n * createIndexedAccessType({ target: 'DeletePetPathParams', key: 'petId' })\n * // DeletePetPathParams['petId']\n * ```\n */\nexport function createIndexedAccessType(props: Omit<IndexedAccessTypeNode, 'kind'>): IndexedAccessTypeNode {\n  return { kind: 'IndexedAccessType', ...props }\n}\n\n/**\n * Creates an {@link ObjectBindingPatternNode} for a destructured parameter binding.\n *\n * @example\n * ```ts\n * createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })\n * // { id, name }\n * ```\n */\nexport function createObjectBindingPattern(props: Omit<ObjectBindingPatternNode, 'kind'>): ObjectBindingPatternNode {\n  return { kind: 'ObjectBindingPattern', ...props }\n}\n\n/**\n * Plain property descriptor for a destructured group built by {@link createFunctionParameter}.\n */\ntype FunctionParameterProperty = {\n  name: string\n  type: TypeExpression\n  optional?: boolean\n}\n\ntype FunctionParameterInput =\n  | { name: string | ObjectBindingPatternNode; type?: TypeExpression; optional?: boolean; default?: string; rest?: boolean }\n  | { properties: Array<FunctionParameterProperty>; optional?: boolean; default?: string }\n\n/**\n * Creates a {@link FunctionParameterNode}. `optional` defaults to `false`.\n * Passing `properties` builds a destructured group: an {@link ObjectBindingPatternNode} name\n * paired with a {@link TypeLiteralNode} type.\n *\n * @example Optional param\n * ```ts\n * createFunctionParameter({ name: 'params', type: 'QueryParams', optional: true })\n * // → params?: QueryParams\n * ```\n *\n * @example Destructured group\n * ```ts\n * createFunctionParameter({ properties: [{ name: 'id', type: 'string' }, { name: 'name', type: 'string', optional: true }], default: '{}' })\n * // → { id, name }: { id: string; name?: string } = {}\n * ```\n */\nexport function createFunctionParameter(input: FunctionParameterInput): FunctionParameterNode {\n  if ('properties' in input) {\n    return {\n      kind: 'FunctionParameter',\n      name: createObjectBindingPattern({ elements: input.properties.map((p) => ({ name: p.name })) }),\n      type: createTypeLiteral({ members: input.properties.map((p) => ({ name: p.name, type: p.type, optional: p.optional ?? false })) }),\n      optional: input.optional ?? false,\n      ...(input.default !== undefined ? { default: input.default } : {}),\n    }\n  }\n  return { kind: 'FunctionParameter', optional: false, ...input }\n}\n\n/**\n * Creates a {@link FunctionParametersNode} from an ordered list of parameters.\n *\n * @example\n * ```ts\n * const empty = createFunctionParameters()\n * // { params: [] }\n * ```\n */\nexport function createFunctionParameters(props: Partial<Omit<FunctionParametersNode, 'kind'>> = {}): FunctionParametersNode {\n  return { kind: 'FunctionParameters', params: [], ...props }\n}\n","/**\n * Ordering priority for function parameters: lower = sorted earlier.\n */\nconst PARAM_RANK = { required: 0, optional: 1, withDefault: 2, rest: 3 } as const\n\nimport { isIndexedAccessType, isTypeLiteral } from './functionParams.ts'\nimport type { FunctionParameterNode, FunctionParametersNode, ObjectBindingPatternNode, TypeExpression } from './functionParams.ts'\n\n/**\n * Renders a {@link TypeExpression} to its TypeScript source.\n *\n * - a `string` is a type reference, returned as-is\n * - an `IndexedAccessType` becomes `objectType['indexType']`\n * - a `TypeLiteral` becomes `{ key: Type; key?: Type }`\n *\n * `transformType` is applied once to the fully rendered type, matching how the\n * printer wrapped reference types before the `ts.factory` model.\n */\nexport function renderType(type: TypeExpression, transformType?: (type: string) => string): string {\n  const rendered = renderTypeExpression(type)\n  return transformType ? transformType(rendered) : rendered\n}\n\n/**\n * Renders an object-type key, quoting it as a string literal when it is not a valid\n * identifier so `{ 'content-type': string }` stays valid TypeScript.\n */\nfunction renderKey(name: string): string {\n  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : JSON.stringify(name)\n}\n\nfunction renderMembers(members: Array<{ key: string; type: string; optional?: boolean }>): string {\n  return `{ ${members.map((member) => `${renderKey(member.key)}${member.optional ? '?' : ''}: ${member.type}`).join('; ')} }`\n}\n\nfunction renderTypeExpression(type: TypeExpression): string {\n  if (typeof type === 'string') return type\n  if (isIndexedAccessType(type)) return `${type.target}['${type.key}']`\n\n  return renderMembers(type.members.map((member) => ({ key: member.name, type: renderTypeExpression(member.type), optional: member.optional })))\n}\n\nexport type FunctionPrinterOptions = {\n  /**\n   * Rendering modes supported by `functionPrinter`.\n   *\n   * | Mode          | Output example                    | Use case                       |\n   * |---------------|-----------------------------------|--------------------------------|\n   * | `declaration` | `id: string, config: Config = {}` | Function parameter declaration |\n   * | `call`        | `id, { method, url }`             | Function call arguments        |\n   */\n  mode: 'declaration' | 'call'\n  /**\n   * Optional transformation applied to every parameter name before printing.\n   */\n  transformName?: (name: string) => string\n  /**\n   * Optional transformation applied to every type string before printing.\n   */\n  transformType?: (type: string) => string\n}\n\nfunction groupMembers(param: FunctionParameterNode): ReadonlyArray<{ name: string; optional?: boolean }> | null {\n  if (typeof param.name === 'string') return null\n  return param.type && isTypeLiteral(param.type) ? param.type.members : []\n}\n\nfunction rank(param: FunctionParameterNode): number {\n  if (param.rest) return PARAM_RANK.rest\n  if (param.default) return PARAM_RANK.withDefault\n  const members = groupMembers(param)\n  if (members) return members.every((m) => m.optional) ? PARAM_RANK.optional : PARAM_RANK.required\n  return param.optional ? PARAM_RANK.optional : PARAM_RANK.required\n}\n\n/**\n * Orders a destructured group's binding elements and type members together,\n * required fields first, matching how grouped children were sorted before.\n */\ntype GroupMember = { name: string; propertyName?: string; type?: TypeExpression; optional?: boolean }\n\nfunction sortedGroupMembers(name: ObjectBindingPatternNode, type: TypeExpression | undefined): Array<GroupMember> {\n  const members = type && isTypeLiteral(type) ? type.members : []\n  const memberRank = (optional?: boolean) => (optional ? PARAM_RANK.optional : PARAM_RANK.required)\n  return name.elements\n    .map((element, index) => ({\n      name: element.name,\n      propertyName: element.propertyName,\n      type: members[index]?.type,\n      optional: members[index]?.optional,\n    }))\n    .toSorted((a, b) => memberRank(a.optional) - memberRank(b.optional))\n}\n\n/**\n * Renders one binding element: the local name, prefixed with its source key when the\n * binding renames the property, as in `{ petId: id }`.\n */\nfunction renderBindingMember(member: GroupMember, transformName?: (name: string) => string): string {\n  const local = transformName ? transformName(member.name) : member.name\n  return member.propertyName ? `${member.propertyName}: ${local}` : local\n}\n\n/**\n * Renders the type annotation of a destructured group. An inline object type is\n * rendered from the already-sorted members so its key order matches the binding;\n * a reference type is rendered as-is.\n */\nfunction renderGroupType(type: TypeExpression | undefined, sorted: Array<GroupMember>, transformType?: (type: string) => string): string | undefined {\n  if (!type) return undefined\n  if (!isTypeLiteral(type)) return renderType(type)\n\n  const typed = sorted.filter((member) => member.type !== undefined)\n  if (!typed.length) return undefined\n  return renderMembers(\n    typed.map((member) => ({ key: member.propertyName ?? member.name, type: renderType(member.type!, transformType), optional: member.optional })),\n  )\n}\n\nfunction printParameter(node: FunctionParameterNode, options: FunctionPrinterOptions): string {\n  const { mode, transformName, transformType } = options\n  const bindingName = node.name\n\n  if (mode === 'call') {\n    if (typeof bindingName !== 'string') {\n      const keys = sortedGroupMembers(bindingName, node.type)\n        .map((member) => renderBindingMember(member))\n        .join(', ')\n      return `{ ${keys} }`\n    }\n    const name = transformName ? transformName(bindingName) : bindingName\n    return node.rest ? `...${name}` : name\n  }\n\n  if (typeof bindingName !== 'string') {\n    const sorted = sortedGroupMembers(bindingName, node.type)\n    const binding = `{ ${sorted.map((member) => renderBindingMember(member, transformName)).join(', ')} }`\n    const allOptional = sorted.every((member) => member.optional)\n    const type = renderGroupType(node.type, sorted, transformType)\n    if (type) {\n      if (allOptional) return `${binding}: ${type} = ${node.default ?? '{}'}`\n      return node.default ? `${binding}: ${type} = ${node.default}` : `${binding}: ${type}`\n    }\n    return node.default ? `${binding} = ${node.default}` : binding\n  }\n\n  const name = transformName ? transformName(bindingName) : bindingName\n  const type = node.type ? renderType(node.type, transformType) : undefined\n\n  if (node.rest) {\n    return type ? `...${name}: ${type}` : `...${name}`\n  }\n  if (type) {\n    if (node.optional) return `${name}?: ${type}`\n    return node.default ? `${name}: ${type} = ${node.default}` : `${name}: ${type}`\n  }\n  return node.default ? `${name} = ${node.default}` : name\n}\n\n/**\n * Default function-signature printer. Renders a parameter list in one of two modes:\n * `declaration` for the function signature and `call` for the call arguments.\n *\n * @example\n * ```ts\n * const printer = functionPrinter({ mode: 'declaration' })\n *\n * const sig = createFunctionParameters({\n *   params: [\n *     createFunctionParameter({ name: 'petId', type: 'string', optional: false }),\n *     createFunctionParameter({ name: 'config', type: 'Config', optional: false, default: '{}' }),\n *   ],\n * })\n *\n * printer.print(sig)  // → \"petId: string, config: Config = {}\"\n * ```\n */\nexport function functionPrinter(options: FunctionPrinterOptions) {\n  return {\n    name: 'functionParameters' as const,\n    options,\n    print(node: FunctionParametersNode): string {\n      // `toSorted` is a stable sort, so equal-rank params keep their declared order.\n      return node.params\n        .toSorted((a, b) => rank(a) - rank(b))\n        .map((p) => printParameter(p, options))\n        .filter(Boolean)\n        .join(', ')\n    },\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.cjs","names":["isNonNullable","generate","syncSchemaRef","factory.createEnumDeclaration","File","ast","syncSchemaRef","ast","ast","File","factory","factory.print","factory.createRaw","parserTs","ast","factory.createTypeReferenceNode","factory.createUrlTemplateType","factory.dateOrStringNode","factory.constToTypeNode","factory.createUnionDeclaration","isStringType","factory.createIntersectionDeclaration","factory.createTypeLiteralNode","factory.buildMemberNodes","factory.createArrayDeclaration","factory.buildTupleNode","factory.buildPropertyType","syncSchemaRef","factory.createPropertySignature","factory.appendJSDocToNode","factory.buildIndexSignatures","factory.wrapNullableOptional","factory.createOmitDeclaration","factory.createTypeDeclaration","defineGenerator","jsxRenderer","ast","File","createResolver","defineExtension","Resolver"],"sources":["../../../internals/utils/src/casing.ts","../../../internals/utils/src/reserved.ts","../../../internals/utils/src/strings.ts","../../../internals/utils/src/fs.ts","../src/factory.ts","../src/components/Enum.tsx","../../../internals/shared/src/operation.ts","../../../internals/shared/src/resolver.ts","../../../internals/shared/src/group.ts","../../../internals/shared/src/schemaTraversal.ts","../src/utils.ts","../src/components/Type.tsx","../src/printers/printerTs.ts","../src/generators/typeGenerator.tsx","../kubb-extension.json","../package.json","../src/resolvers/resolverTs.ts","../src/plugin.ts","../src/printers/functionParams.ts","../src/printers/functionPrinter.ts"],"sourcesContent":["type Options = {\n  /**\n   * Text prepended before casing is applied.\n   */\n  prefix?: string\n  /**\n   * Text appended before casing is applied.\n   */\n  suffix?: string\n}\n\n/**\n * Shared implementation for camelCase and PascalCase conversion.\n * Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)\n * and capitalizes each word according to `pascal`.\n *\n * When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.\n */\nfunction convert(text: string, pascal: boolean): string {\n  return text\n    .trim()\n    .replace(/([a-z\\d])([A-Z])/g, '$1 $2')\n    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')\n    .replace(/(\\d)([a-z])/g, '$1 $2')\n    .split(/[\\s\\-_./\\\\:]+/)\n    .filter(Boolean)\n    .map((word, i) => {\n      if (word.length > 1 && word === word.toUpperCase()) return word\n      const head = i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()\n      return head + word.slice(1)\n    })\n    .join('')\n    .replace(/[^a-zA-Z0-9]/g, '')\n}\n\n// Plugins resolve the same names over and over (about 47,000 calls for a 1,000 schema spec), so\n// results are kept. Clearing at the limit bounds the memory a long-running process spends on it.\nconst cache = new Map<string, string>()\nconst cacheLimit = 10_000\n\nfunction toCamelOrPascal(text: string, pascal: boolean): string {\n  const key = `${pascal ? 'P' : 'c'}${text}`\n  const cached = cache.get(key)\n  if (cached !== undefined) return cached\n\n  const result = convert(text, pascal)\n  if (cache.size >= cacheLimit) cache.clear()\n  cache.set(key, result)\n  return result\n}\n\n/**\n * Converts `text` to camelCase.\n *\n * @example Word boundaries\n * `camelCase('hello-world') // 'helloWorld'`\n *\n * @example With a prefix\n * `camelCase('tag', { prefix: 'create' }) // 'createTag'`\n */\nexport function camelCase(text: string, { prefix = '', suffix = '' }: Options = {}): string {\n  return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false)\n}\n\n/**\n * Converts `text` to PascalCase.\n *\n * @example Word boundaries\n * `pascalCase('hello-world') // 'HelloWorld'`\n *\n * @example With a suffix\n * `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`\n */\nexport function pascalCase(text: string, { prefix = '', suffix = '' }: Options = {}): string {\n  return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true)\n}\n\n/**\n * Uppercases only the first character of `text`, leaving the rest untouched.\n * Unlike {@link pascalCase} it never re-splits word boundaries or strips characters.\n *\n * @example\n * `capitalize('getPetById') // 'GetPetById'`\n */\nexport function capitalize(text: string): string {\n  return `${text.charAt(0).toUpperCase()}${text.slice(1)}`\n}\n\n/**\n * Converts `text` to snake_case.\n *\n * @example From camelCase\n * `snakeCase('helloWorld') // 'hello_world'`\n *\n * @example From mixed separators\n * `snakeCase('Hello-World') // 'hello_world'`\n */\nexport function snakeCase(text: string, { prefix = '', suffix = '' }: Options = {}): string {\n  const processed = `${prefix} ${text} ${suffix}`.trim()\n  return processed\n    .replace(/([a-z])([A-Z])/g, '$1_$2')\n    .replace(/[\\s\\-.]+/g, '_')\n    .replace(/[^a-zA-Z0-9_]/g, '')\n    .toLowerCase()\n    .split('_')\n    .filter(Boolean)\n    .join('_')\n}\n\n/**\n * Converts `text` to SCREAMING_SNAKE_CASE.\n *\n * @example From camelCase\n * `screamingSnakeCase('helloWorld') // 'HELLO_WORLD'`\n */\nexport function screamingSnakeCase(text: string, { prefix = '', suffix = '' }: Options = {}): string {\n  return snakeCase(text, { prefix, suffix }).toUpperCase()\n}\n","/**\n * JavaScript and Java reserved words.\n * @link https://github.com/jonschlinkert/reserved/blob/master/index.js\n */\nconst reservedWords = new Set([\n  'abstract',\n  'arguments',\n  'boolean',\n  'break',\n  'byte',\n  'case',\n  'catch',\n  'char',\n  'class',\n  'const',\n  'continue',\n  'debugger',\n  'default',\n  'delete',\n  'do',\n  'double',\n  'else',\n  'enum',\n  'eval',\n  'export',\n  'extends',\n  'false',\n  'final',\n  'finally',\n  'float',\n  'for',\n  'function',\n  'goto',\n  'if',\n  'implements',\n  'import',\n  'in',\n  'instanceof',\n  'int',\n  'interface',\n  'let',\n  'long',\n  'native',\n  'new',\n  'null',\n  'package',\n  'private',\n  'protected',\n  'public',\n  'return',\n  'short',\n  'static',\n  'super',\n  'switch',\n  'synchronized',\n  'this',\n  'throw',\n  'throws',\n  'transient',\n  'true',\n  'try',\n  'typeof',\n  'var',\n  'void',\n  'volatile',\n  'while',\n  'with',\n  'yield',\n  'Array',\n  'Date',\n  'hasOwnProperty',\n  'Infinity',\n  'isFinite',\n  'isNaN',\n  'isPrototypeOf',\n  'length',\n  'Math',\n  'name',\n  'NaN',\n  'Number',\n  'Object',\n  'prototype',\n  'String',\n  'toString',\n  'undefined',\n  'valueOf',\n] as const)\n\n/**\n * Returns `true` when `name` is a syntactically valid JavaScript variable name.\n *\n * @example\n * ```ts\n * isValidVarName('status')  // true\n * isValidVarName('class')   // false (reserved word)\n * isValidVarName('42foo')   // false (starts with digit)\n * ```\n */\nexport function isValidVarName(name: string): boolean {\n  if (!name || reservedWords.has(name as 'valueOf')) {\n    return false\n  }\n  return isIdentifier(name)\n}\n\n/**\n * Returns `name` when it's a syntactically valid JavaScript variable name,\n * otherwise prefixes it with `_` so the result is a valid identifier.\n *\n * Useful for sanitizing OpenAPI schema names or operation IDs that start with\n * a digit (e.g. `409`, `504AccountCancel`) before using them as exported\n * variable, type, or function names.\n *\n * @example\n * ```ts\n * ensureValidVarName('409')             // '_409'\n * ensureValidVarName('504AccountCancel') // '_504AccountCancel'\n * ensureValidVarName('Pet')              // 'Pet'\n * ensureValidVarName('class')            // '_class'\n * ```\n */\nexport function ensureValidVarName(name: string): string {\n  if (!name || isValidVarName(name)) {\n    return name\n  }\n  return `_${name}`\n}\n\n/**\n * Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.\n *\n * Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys\n * even though they are not valid variable names, so use this (not {@link isValidVarName}) when\n * deciding whether an object key needs quoting.\n *\n * @example\n * ```ts\n * isIdentifier('name')   // true\n * isIdentifier('x-total')// false\n * ```\n */\nexport function isIdentifier(name: string): boolean {\n  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name)\n}\n","/**\n * Wraps a value in single quotes for emitting a single-quoted JavaScript string literal, escaping\n * any backslash or single quote in the content.\n *\n * @example\n * ```ts\n * singleQuote('foo')      // \"'foo'\"\n * singleQuote(\"o'clock\")  // \"'o\\\\'clock'\"\n * ```\n */\nexport function singleQuote(value: string | number | boolean | undefined | null): string {\n  if (value === undefined || value === null) return \"''\"\n  const escaped = String(value).replace(/\\\\/g, '\\\\\\\\').replace(/'/g, \"\\\\'\")\n\n  return `'${escaped}'`\n}\n\n/**\n * Strips a single matching pair of `\"...\"`, `'...'`, or `` `...` `` from both ends of `text`.\n * Returns the string unchanged when no balanced quote pair is found.\n *\n * @example\n * ```ts\n * trimQuotes('\"hello\"') // 'hello'\n * trimQuotes('hello')   // 'hello'\n * ```\n */\nexport function trimQuotes(text: string): string {\n  if (text.length >= 2) {\n    const first = text[0]\n    const last = text[text.length - 1]\n    if ((first === '\"' && last === '\"') || (first === \"'\" && last === \"'\") || (first === '`' && last === '`')) {\n      return text.slice(1, -1)\n    }\n  }\n  return text\n}\n\n/**\n * Serializes a primitive to a single-quoted string literal, stripping any surrounding quotes first.\n *\n * Escaping runs through `JSON.stringify`, then the result switches to single quotes so the generated\n * code matches the repo style without a formatter.\n *\n * @example\n * ```ts\n * stringify('hello')   // \"'hello'\"\n * stringify('\"hello\"') // \"'hello'\"\n * ```\n */\nexport function stringify(value: string | number | boolean | undefined): string {\n  if (value === undefined || value === null) return \"''\"\n  const json = JSON.stringify(trimQuotes(value.toString()))\n  const inner = json.slice(1, -1).replace(/\\\\\"/g, '\"').replace(/'/g, \"\\\\'\")\n  return `'${inner}'`\n}\n\n/**\n * Escapes an `@` at the start of a line, so a multi-line description can't start a new JSDoc tag.\n * Editors render `\\@` as `@` in hovers.\n *\n * @example\n * ```ts\n * jsDocEscape('intro\\n@example value') // 'intro\\n\\\\@example value'\n * ```\n */\nexport function jsDocEscape(input: unknown): string {\n  return `${input}`.replace(/^(\\s*)@/gm, '$1\\\\@')\n}\n\n/**\n * Escapes characters that are not allowed inside JS string literals, covering quotes, backslashes,\n * and the Unicode line terminators U+2028 and U+2029.\n *\n * @see http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4\n *\n * @example\n * ```ts\n * jsStringEscape('say \"hi\"\\nbye') // 'say \\\\\"hi\\\\\"\\\\nbye'\n * ```\n */\nexport function jsStringEscape(input: unknown): string {\n  return `${input}`.replace(/[\"'\\\\\\n\\r\\u2028\\u2029]/g, (character) => {\n    switch (character) {\n      case '\"':\n      case \"'\":\n      case '\\\\':\n        return `\\\\${character}`\n      case '\\n':\n        return '\\\\n'\n      case '\\r':\n        return '\\\\r'\n      case '\\u2028':\n        return '\\\\u2028'\n      case '\\u2029':\n        return '\\\\u2029'\n      default:\n        return ''\n    }\n  })\n}\n\n/**\n * Converts a pattern string into a `new RegExp(...)` constructor call or a regex literal string.\n * Inline flags expressed as a `^(?im)` prefix are extracted and applied to the resulting expression.\n * Pass `null` as the second argument to emit a `/pattern/flags` literal instead.\n *\n * @example\n * ```ts\n * toRegExpString('^(?im)foo')       // 'new RegExp(\"^foo\", \"im\")'\n * toRegExpString('^(?im)foo', null) // '/^foo/im'\n * ```\n */\nexport function toRegExpString(text: string, func: string | null = 'RegExp'): string {\n  const raw = trimQuotes(text)\n\n  const match = raw.match(/^\\^(\\(\\?([igmsuy]+)\\))/i)\n  const replacementTarget = match?.[1] ?? ''\n  const matchedFlags = match?.[2]\n  const cleaned = raw\n    .replace(/^\\\\?\\//, '')\n    .replace(/\\\\?\\/$/, '')\n    .replace(replacementTarget, '')\n\n  const { source, flags } = new RegExp(cleaned, matchedFlags)\n\n  if (func === null) return `/${source}/${flags}`\n\n  return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ''})`\n}\n\n/**\n * Renders a dotted path or string array as an optional-chaining accessor expression rooted at\n * `accessor`. Returns `null` for an empty path.\n *\n * @example\n * ```ts\n * getNestedAccessor('pagination.next.id', 'lastPage')\n * // \"lastPage?.['pagination']?.['next']?.['id']\"\n * ```\n */\nexport function getNestedAccessor(param: string | Array<string>, accessor: string): string | null {\n  const parts = Array.isArray(param) ? param : param.split('.')\n  if (parts.length === 0 || (parts.length === 1 && parts[0] === '')) return null\n  return `${accessor}?.['${`${parts.join(\"']?.['\")}']`}`\n}\n","import { posix } from 'node:path'\nimport { camelCase } from './casing.ts'\n\nfunction toSlash(p: string): string {\n  if (p.startsWith('\\\\\\\\?\\\\')) return p\n  return p.replaceAll('\\\\', '/')\n}\n\n/**\n * Returns the relative path from `rootDir` to `filePath`, always using forward slashes\n * and prefixed with `./` when not already traversing upward.\n *\n * @example\n * ```ts\n * getRelativePath('/src/components', '/src/components/Button.tsx') // './Button.tsx'\n * getRelativePath('/src/components', '/src/utils/helpers.ts')      // '../utils/helpers.ts'\n * ```\n */\nexport function getRelativePath(rootDir: string, filePath: string): string {\n  const relativePath = posix.relative(toSlash(rootDir), toSlash(filePath))\n\n  return relativePath.startsWith('../') ? relativePath : `./${relativePath}`\n}\n\n/**\n * Builds a nested file path from a dotted name. Splits on dots that precede a letter\n * (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases\n * every earlier segment, applies `caseLast` to the final segment, and joins with `/`.\n *\n * Empty segments are dropped before joining. They arise when the name starts with a dot\n * followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to\n * an empty string). Without this a leading `/` would form, which `path.resolve` reads as an\n * absolute path, letting generated files escape the configured output directory.\n *\n * @example Nested path from a dotted name\n * `toFilePath('pet.petId') // 'pet/petId'`\n *\n * @example PascalCase the final segment\n * `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`\n *\n * @example Suffix applied to the final segment only\n * `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`\n */\nexport function toFilePath(name: string, caseLast: (part: string) => string = camelCase): string {\n  const parts = name.split(/\\.(?=[a-zA-Z])/)\n  return parts\n    .map((part, i) => (i === parts.length - 1 ? caseLast(part) : camelCase(part)))\n    .filter(Boolean)\n    .join('/')\n}\n","import { camelCase, pascalCase, screamingSnakeCase, snakeCase } from '@internals/utils'\nimport { syncSchemaRef } from 'kubb/kit'\nimport type { ast } from 'kubb/kit'\nimport { generate } from 'yuku-codegen'\n\n/**\n * A TS-ESTree node, the AST shape `yuku-codegen` prints. Nodes built here carry no source positions.\n */\nexport type TsNode = { type: string; [key: string]: unknown }\n\nfunction isNumber(value: unknown): value is number {\n  return typeof value === 'number' && !Number.isNaN(value)\n}\n\nexport function isNonNullable<T>(value: T | null | undefined): value is T {\n  return value !== null && value !== undefined\n}\n\n/**\n * Prints `node` as TypeScript source with single quotes and two-space indentation.\n */\nexport function print(node: TsNode): string {\n  return generate(node as unknown as Parameters<typeof generate>[0], { quotes: 'single' }).code\n}\n\n/**\n * Wraps already printed TypeScript, such as a user override result, so it can sit inside a node tree.\n * Parentheses keep a union or function type intact when it lands inside an array or intersection.\n */\nexport function createRaw(text: string): TsNode {\n  const name = { type: 'TSTypeReference', typeName: identifier(text), typeArguments: null }\n  return /[|&?]|=>/.test(text) ? { type: 'TSParenthesizedType', typeAnnotation: name } : name\n}\n\nfunction identifier(name: string): TsNode {\n  return { type: 'Identifier', name }\n}\n\nfunction literal(value: string | number | boolean): TsNode {\n  return { type: 'Literal', value }\n}\n\nfunction createLiteralType(value: string | number | boolean): TsNode {\n  return { type: 'TSLiteralType', literal: literal(value) }\n}\n\n/**\n * Whether `name` can be written as a bare property name instead of a quoted string.\n */\nfunction isValidIdentifier(name: string): boolean {\n  return /^[\\p{ID_Start}$_][\\p{ID_Continue}$‌‍]*$/u.test(name)\n}\n\n/**\n * A property or enum member name, quoted when it is not a valid identifier.\n */\nfunction propertyName(name: string): TsNode {\n  return isValidIdentifier(name) ? identifier(name) : literal(name)\n}\n\n/**\n * Indents every non-empty line of `text` by two spaces.\n */\nfunction indent(text: string): string {\n  return text\n    .split('\\n')\n    .map((line) => (line ? `  ${line}` : line))\n    .join('\\n')\n}\n\n/**\n * Creates a TypeScript intersection type.\n * Returns the single type if only one is provided. `yuku-codegen` adds the parentheses a union member needs.\n */\nexport function createIntersectionDeclaration({ nodes, withParentheses }: { nodes: Array<TsNode>; withParentheses?: boolean }): TsNode | null {\n  if (!nodes.length) {\n    return null\n  }\n\n  if (nodes.length === 1) {\n    return nodes[0] || null\n  }\n\n  const node = { type: 'TSIntersectionType', types: nodes }\n\n  return withParentheses ? { type: 'TSParenthesizedType', typeAnnotation: node } : node\n}\n\n/**\n * Creates a TypeScript array type.\n * Use `arrayType: 'array'` for bracket syntax (`T[]`), or `'generic'` for `Array<T>`.\n *\n * @example Array bracket syntax\n * `createArrayDeclaration({ nodes: [string], arrayType: 'array' }) // → string[]`\n *\n * @example Generic Array syntax\n * `createArrayDeclaration({ nodes: [string], arrayType: 'generic' }) // → Array<string>`\n */\nexport function createArrayDeclaration({ nodes, arrayType = 'array' }: { nodes: Array<TsNode>; arrayType?: 'array' | 'generic' }): TsNode {\n  if (!nodes.length) {\n    return { type: 'TSTupleType', elementTypes: [] }\n  }\n\n  const node = nodes.length === 1 ? nodes[0]! : { type: 'TSUnionType', types: nodes }\n\n  return arrayType === 'generic' ? createTypeReferenceNode('Array', [node]) : { type: 'TSArrayType', elementType: node }\n}\n\n/**\n * Minimum nodes length of 2\n * @example Union type example\n * `string | number`\n */\nexport function createUnionDeclaration({ nodes, withParentheses }: { nodes: Array<TsNode>; withParentheses?: boolean }): TsNode {\n  if (!nodes.length) {\n    return keywordTypeNodes.any\n  }\n\n  if (nodes.length === 1) {\n    return nodes[0]!\n  }\n\n  const node = { type: 'TSUnionType', types: nodes }\n\n  return withParentheses ? { type: 'TSParenthesizedType', typeAnnotation: node } : node\n}\n\n/**\n * Creates a TypeScript property signature for object/interface members.\n * Supports optional markers, readonly modifiers, and type annotations.\n */\nexport function createPropertySignature({\n  readOnly,\n  name,\n  questionToken,\n  type,\n}: {\n  readOnly?: boolean\n  name: string\n  questionToken?: boolean\n  type?: TsNode\n}): TsNode {\n  return {\n    type: 'TSPropertySignature',\n    key: propertyName(name),\n    computed: false,\n    optional: !!questionToken,\n    readonly: !!readOnly,\n    static: false,\n    typeAnnotation: type ? { type: 'TSTypeAnnotation', typeAnnotation: type } : null,\n  }\n}\n\n/**\n * Attaches a JSDoc block built from `comments` to `node`, dropping empty comments.\n */\nexport function appendJSDocToNode<TNode extends TsNode>({ node, comments }: { node: TNode; comments: Array<string | undefined> }): TNode {\n  const lines = comments.filter(Boolean).flatMap((comment = '') => comment.split(/\\r?\\n/))\n\n  if (!lines.length) {\n    return node\n  }\n\n  // `yuku-codegen` prints the comment text as is, so a `*/` inside it would end the block early\n  const value = `*\\n${lines.map((line) => ` * ${line.replaceAll('*/', '*\\\\/')}`.trimEnd()).join('\\n')}\\n `\n\n  return { ...node, comments: [{ type: 'Block', value, position: 'before', sameLine: false }] }\n}\n\n/**\n * Creates a TypeScript type literal (anonymous object type) with one member per line.\n */\nexport function createTypeLiteralNode(members: Array<TsNode>): TsNode {\n  return { type: 'TSTypeLiteral', members }\n}\n\n/**\n * Creates a TypeScript type reference (e.g., `Array<string>`, `Record<K, V>`).\n */\nexport function createTypeReferenceNode(name: string, typeArguments?: Array<TsNode>): TsNode {\n  return {\n    type: 'TSTypeReference',\n    typeName: identifier(name),\n    typeArguments: typeArguments?.length ? { type: 'TSTypeParameterInstantiation', params: typeArguments } : null,\n  }\n}\n\nfunction exportNamed(declaration: TsNode, exportKind: 'type' | 'value'): TsNode {\n  return { type: 'ExportNamedDeclaration', declaration, specifiers: [], source: null, attributes: [], exportKind }\n}\n\n/**\n * Prints a TypeScript type declaration as either a type alias or interface.\n * Uses interface syntax only when requested and the type is an object literal, and attaches JSDoc comments.\n */\nexport function createTypeDeclaration({\n  syntax,\n  isExportable,\n  comments,\n  name,\n  type,\n}: {\n  syntax: 'type' | 'interface'\n  comments: Array<string | undefined>\n  isExportable?: boolean\n  name: string\n  type: TsNode\n}): string {\n  const declaration =\n    syntax === 'interface' && type.type === 'TSTypeLiteral'\n      ? {\n          type: 'TSInterfaceDeclaration',\n          declare: false,\n          id: identifier(name),\n          typeParameters: null,\n          extends: [],\n          body: { type: 'TSInterfaceBody', body: type.members },\n        }\n      : { type: 'TSTypeAliasDeclaration', declare: false, id: identifier(name), typeParameters: null, typeAnnotation: type }\n\n  return print(appendJSDocToNode({ node: isExportable ? exportNamed(declaration, 'type') : declaration, comments }))\n}\n\n/**\n * Converts an enum member value to a literal. Numbers become numeric literals unless `asNumber` is `false`,\n * which emits the string form.\n */\nfunction valueToExpression(value: string | number | boolean, asNumber = isNumber(value)): TsNode {\n  return literal(typeof value === 'boolean' || (asNumber && isNumber(value)) ? value : value.toString())\n}\n\n/**\n * Apply casing transformation to enum keys\n */\nfunction applyEnumKeyCasing(key: string, casing: 'screamingSnakeCase' | 'snakeCase' | 'pascalCase' | 'camelCase' | 'none' = 'none'): string {\n  if (casing === 'none') {\n    return key\n  }\n  if (casing === 'screamingSnakeCase') {\n    return screamingSnakeCase(key)\n  }\n  if (casing === 'snakeCase') {\n    return snakeCase(key)\n  }\n  if (casing === 'pascalCase') {\n    return pascalCase(key)\n  }\n  if (casing === 'camelCase') {\n    return camelCase(key)\n  }\n  return key\n}\n\n/**\n * Creates a TypeScript enum declaration or equivalent construct in various formats.\n * Returns a tuple of [name declaration, type declaration] - the name declaration may be undefined for certain types.\n *\n * @example\n * ```ts\n * const [name, type] = createEnumDeclaration({\n *   type: 'enum',\n *   name: 'petType',\n *   typeName: 'PetType',\n *   enums: [['cat', 'cat', 'A cat'], ['dog', 'dog']],\n * })\n * ```\n */\nexport function createEnumDeclaration({\n  type = 'enum',\n  name,\n  typeName,\n  enums,\n  enumKeyCasing = 'none',\n}: {\n  /**\n   * Choose to use `enum`, `asConst`, `constEnum`, or `literal` for enums.\n   * - `enum`: TypeScript enum\n   * - `asConst`: const object asserted with `as const` (the caller decides the const name casing)\n   * - `constEnum`: const enum\n   * - `literal`: literal union type\n   * @default `'enum'`\n   */\n  type?: 'enum' | 'asConst' | 'constEnum' | 'literal' | 'inlineLiteral'\n  /**\n   * Enum name in camelCase.\n   */\n  name: string\n  /**\n   * Enum name in PascalCase.\n   */\n  typeName: string\n  enums: Array<[key: string | number, value: string | number | boolean, description?: string]>\n  /**\n   * Choose the casing for enum key names.\n   * @default 'none'\n   */\n  enumKeyCasing?: 'screamingSnakeCase' | 'snakeCase' | 'pascalCase' | 'camelCase' | 'none'\n}): [name: string | undefined, type: string] {\n  const typeAlias = (annotation: TsNode) => createTypeDeclaration({ syntax: 'type', isExportable: true, name: typeName, comments: [], type: annotation })\n\n  if (type === 'literal' || type === 'inlineLiteral') {\n    const members = enums\n      .map(([_key, value]) => (isNonNullable(value) ? { type: 'TSLiteralType', literal: valueToExpression(value) } : undefined))\n      .filter(isNonNullable)\n\n    return [undefined, typeAlias(members.length ? createUnionDeclaration({ nodes: members }) : keywordTypeNodes.never)]\n  }\n\n  if (type === 'enum' || type === 'constEnum') {\n    const members = enums\n      .map(([key, value, description]) => {\n        const initializer = valueToExpression(value, Number.parseInt(value.toString(), 10) === value)\n        const memberName = isNumber(Number.parseInt(key.toString(), 10)) ? `${typeName}_${key}` : key?.toString()\n        if (memberName === undefined) return undefined\n\n        const id = propertyName(applyEnumKeyCasing(memberName, enumKeyCasing))\n        return appendJSDocToNode({ node: { type: 'TSEnumMember', id, initializer }, comments: [description] })\n      })\n      .filter(isNonNullable)\n\n    const declaration = {\n      type: 'TSEnumDeclaration',\n      declare: false,\n      const: type === 'constEnum',\n      id: identifier(typeName),\n      body: { type: 'TSEnumBody', members },\n    }\n\n    return [undefined, print(exportNamed(declaration, 'value'))]\n  }\n\n  // used when using `as const` instead of an TypeScript enum.\n  // name is already cased by the caller (camelCase or pascalCase, driven by enum.constCasing).\n  // typeName carries the typeSuffix for the type alias, so we use name for the const identifier.\n  const identifierName = name\n\n  // When there are no enum items (empty or all-null enum), don't generate a runtime const.\n  // Return undefined for nameNode so the barrel won't try to export a non-existent symbol.\n  // Use `never` as the type alias to keep references valid without creating a broken const.\n  if (enums.length === 0) {\n    return [undefined, typeAlias(keywordTypeNodes.never)]\n  }\n\n  // `yuku-codegen` prints object literals on one line, so each property prints on its own and the lines join here\n  const properties = enums\n    .map(([key, value, description]) => {\n      if (key === null || key === undefined) return undefined\n\n      const property = {\n        type: 'Property',\n        kind: 'init',\n        key: propertyName(applyEnumKeyCasing(key.toString(), enumKeyCasing)),\n        value: valueToExpression(value),\n        computed: false,\n        method: false,\n        shorthand: false,\n      }\n      return print(appendJSDocToNode({ node: property, comments: [description] }))\n    })\n    .filter(isNonNullable)\n\n  const query = { type: 'TSTypeQuery', exprName: identifier(identifierName), typeArguments: null }\n\n  return [\n    `export const ${identifierName} = {\\n${properties.map(indent).join(',\\n')},\\n} as const;`,\n    typeAlias({\n      type: 'TSIndexedAccessType',\n      objectType: { type: 'TSParenthesizedType', typeAnnotation: query },\n      indexType: { type: 'TSTypeOperator', operator: 'keyof', typeAnnotation: query },\n    }),\n  ]\n}\n\n/**\n * Creates a TypeScript `Omit<T, Keys>` type reference.\n * Optionally wraps the type in `NonNullable<T>` if `nonNullable` is true.\n */\nexport function createOmitDeclaration({ keys, type, nonNullable }: { keys: Array<string> | string; type: TsNode; nonNullable?: boolean }): TsNode {\n  const node = nonNullable ? createTypeReferenceNode('NonNullable', [type]) : type\n\n  return createTypeReferenceNode('Omit', [node, createUnionDeclaration({ nodes: [keys].flat().map(createLiteralType) })])\n}\n\n/**\n * TypeScript keyword types for common primitive types.\n */\nexport const keywordTypeNodes = {\n  any: { type: 'TSAnyKeyword' },\n  unknown: { type: 'TSUnknownKeyword' },\n  void: { type: 'TSVoidKeyword' },\n  number: { type: 'TSNumberKeyword' },\n  integer: { type: 'TSNumberKeyword' },\n  bigint: { type: 'TSBigIntKeyword' },\n  object: { type: 'TSObjectKeyword' },\n  string: { type: 'TSStringKeyword' },\n  boolean: { type: 'TSBooleanKeyword' },\n  undefined: { type: 'TSUndefinedKeyword' },\n  null: { type: 'TSNullKeyword' },\n  never: { type: 'TSNeverKeyword' },\n} as const satisfies Record<string, TsNode>\n\n/**\n * Converts an OAS-style path (e.g. `/pets/{petId}`) or an Express-style path\n * (e.g. `/pets/:petId`) to a TypeScript template literal type\n * like `` `/pets/${string}` ``.\n */\nexport function createUrlTemplateType(path: string): TsNode {\n  // normalized Express `:param` → OAS `{param}` so a single regex handles both.\n  const normalized = path.replace(/:([^/]+)/g, '{$1}')\n\n  if (!normalized.includes('{')) {\n    return createLiteralType(normalized)\n  }\n\n  const segments = normalized.split(/\\{[^}]+\\}/)\n  // `yuku-codegen` escapes the cooked text itself when no raw text is given\n  const quasis = segments.map((cooked, i) => ({ type: 'TemplateElement', value: { cooked }, tail: i === segments.length - 1 }))\n\n  return { type: 'TSTemplateLiteralType', quasis, types: segments.slice(1).map(() => keywordTypeNodes.string) }\n}\n\n// ─── Printer helpers ──────────────────────────────────────────────────────────\n\n/**\n * Converts a primitive const value to a TypeScript literal type.\n */\nexport function constToTypeNode(value: string | number | boolean, format: 'string' | 'number' | 'boolean'): TsNode | undefined {\n  if (format === 'boolean') {\n    return createLiteralType(value === true)\n  }\n  return createLiteralType(format === 'number' && typeof value === 'number' ? value : String(value))\n}\n\n/**\n * Returns a `Date` reference type when `representation` is `'date'`, otherwise falls back to `string`.\n */\nexport function dateOrStringNode(node: { representation?: string }): TsNode {\n  return node.representation === 'date' ? createTypeReferenceNode('Date') : keywordTypeNodes.string\n}\n\n/**\n * Maps an array of `SchemaNode`s through the printer, filtering out `null` and `undefined` results.\n */\nexport function buildMemberNodes(members: Array<ast.SchemaNode> | undefined, print: (node: ast.SchemaNode) => TsNode | null | undefined): Array<TsNode> {\n  return (members ?? []).map(print).filter(isNonNullable)\n}\n\n/**\n * Builds a TypeScript tuple type from an array schema's `items`,\n * applying min/max slice and optional/rest element rules.\n */\nexport function buildTupleNode(node: ast.ArraySchemaNode, print: (node: ast.SchemaNode) => TsNode | null | undefined): TsNode {\n  let items = (node.items ?? []).map(print).filter(isNonNullable)\n\n  const restNode = node.rest ? (print(node.rest) ?? undefined) : undefined\n  const { min, max } = node\n\n  if (max !== undefined) {\n    items = items.slice(0, max)\n    if (items.length < max && restNode) {\n      items = [...items, ...Array(max - items.length).fill(restNode)]\n    }\n  }\n\n  if (min !== undefined) {\n    items = items.map((item, i) => (i >= min ? { type: 'TSOptionalType', typeAnnotation: item } : item))\n  }\n\n  if (max === undefined && restNode) {\n    items.push({ type: 'TSRestType', typeAnnotation: { type: 'TSArrayType', elementType: restNode } })\n  }\n\n  return { type: 'TSTupleType', elementTypes: items }\n}\n\n/**\n * Appends `| null` and then `| undefined` to a type when requested.\n */\nexport function wrapNullableOptional(type: TsNode, nullable: boolean, addsUndefined: boolean): TsNode {\n  const withNullable = nullable ? createUnionDeclaration({ nodes: [type, keywordTypeNodes.null] }) : type\n  return addsUndefined ? createUnionDeclaration({ nodes: [withNullable, keywordTypeNodes.undefined] }) : withNullable\n}\n\n/**\n * Applies `nullable` and optional/nullish `| undefined` union modifiers to a property's resolved base type.\n */\nexport function buildPropertyType(\n  schema: ast.SchemaNode,\n  baseType: TsNode,\n  optionalType: 'questionToken' | 'undefined' | 'questionTokenAndUndefined',\n  optional?: boolean,\n): TsNode {\n  const addsUndefined = optionalType === 'undefined' || optionalType === 'questionTokenAndUndefined'\n  const meta = syncSchemaRef(schema)\n\n  return wrapNullableOptional(baseType, !!meta.nullable, addsUndefined && !!(optional || meta.nullish || meta.optional))\n}\n\n/**\n * Creates a TypeScript index signature for `additionalProperties` and `patternProperties` on an\n * object schema node. TypeScript allows only one string index signature and its value must be\n * assignable from every named property, so both keywords collapse into a single signature: the\n * union of all value types (deduplicated), or `unknown` when the object also has fixed properties.\n * The key regex of `patternProperties` cannot be expressed by an index signature and is dropped.\n */\nexport function buildIndexSignatures(\n  node: { additionalProperties?: ast.SchemaNode | boolean; patternProperties?: Record<string, ast.SchemaNode> },\n  propertyCount: number,\n  printNode: (node: ast.SchemaNode) => TsNode | null | undefined,\n): Array<TsNode> {\n  const valueTypes: Array<TsNode> = []\n\n  if (node.additionalProperties && node.additionalProperties !== true) {\n    valueTypes.push(printNode(node.additionalProperties) ?? keywordTypeNodes.unknown)\n  } else if (node.additionalProperties === true) {\n    valueTypes.push(keywordTypeNodes.unknown)\n  }\n\n  for (const schema of Object.values(node.patternProperties ?? {})) {\n    const patternType = printNode(schema) ?? keywordTypeNodes.unknown\n    valueTypes.push(schema.nullable ? createUnionDeclaration({ nodes: [patternType, keywordTypeNodes.null] }) : patternType)\n  }\n\n  if (valueTypes.length === 0) return []\n\n  // Deduplicate by printed text, since equal types are separate node objects\n  const distinct = [...new Map(valueTypes.map((type) => [print(type), type])).values()]\n  const valueType = propertyCount > 0 ? keywordTypeNodes.unknown : createUnionDeclaration({ nodes: distinct })\n\n  return [\n    {\n      type: 'TSIndexSignature',\n      parameters: [{ type: 'Identifier', name: 'key', typeAnnotation: { type: 'TSTypeAnnotation', typeAnnotation: keywordTypeNodes.string } }],\n      typeAnnotation: { type: 'TSTypeAnnotation', typeAnnotation: valueType },\n      readonly: false,\n      static: false,\n      accessibility: null,\n    },\n  ]\n}\n","import { camelCase, trimQuotes } from '@internals/utils'\nimport type { ast } from 'kubb/kit'\nimport { File } from 'kubb/jsx'\nimport type { KubbReactNode } from 'kubb/jsx'\nimport * as factory from '../factory.ts'\nimport type { PluginTs, ResolverTs } from '../types.ts'\n\ntype EnumOptions = PluginTs['resolvedOptions']['enum']\n\ntype Props = {\n  node: ast.EnumSchemaNode\n  enum: EnumOptions\n  resolver: ResolverTs\n  key?: string | number | null\n}\n\n/**\n * Resolves the runtime identifier name and the TypeScript type name for an enum schema node.\n *\n * The raw `node.name` may be a YAML key such as `\"enumNames.Type\"` which is not a\n * valid TypeScript identifier. The resolver normalizes it. For inline enum properties the adapter\n * already emits a PascalCase+suffix name, so resolution is typically a no-op.\n *\n * When `constCasing` is `'pascalCase'` and `typeSuffix` is empty, the const and the type\n * resolve to the same name, which TypeScript merges into a single value+type declaration.\n */\nexport function getEnumNames({ node, enum: enumOptions, resolver }: { node: ast.EnumSchemaNode; enum: EnumOptions; resolver: ResolverTs }): {\n  enumName: string\n  typeName: string\n} {\n  const resolved = resolver.name(node.name!)\n  const enumName = enumOptions.constCasing === 'pascalCase' ? resolved : camelCase(node.name!)\n  const typeName = enumOptions.type === 'asConst' ? resolver.enum.keyName(node, enumOptions.typeSuffix) : resolved\n\n  return { enumName, typeName }\n}\n\n/**\n * Renders the enum declaration(s) for a single named `EnumSchemaNode`.\n *\n * Depending on `enum.type` this may emit:\n * - A runtime object (`asConst`) plus a `typeof` type alias\n * - A `const enum` or plain `enum` declaration (`constEnum` / `enum`)\n * - A union literal type alias (`literal`)\n *\n * The emitted `File.Source` nodes carry the resolved names so that the barrel\n * index picks up the correct export identifiers.\n */\nexport function Enum({ node, enum: enumOptions, resolver }: Props): KubbReactNode {\n  const { enumName, typeName } = getEnumNames({ node, enum: enumOptions, resolver })\n\n  const [nameNode, typeNode] = factory.createEnumDeclaration({\n    name: enumName,\n    typeName,\n    enums: (node.namedEnumValues?.map((v) => [trimQuotes(v.name.toString()), v.value, v.description]) ??\n      node.enumValues?.filter((v): v is NonNullable<typeof v> => v !== null && v !== undefined).map((v) => [trimQuotes(v.toString()), v]) ??\n      []) as Array<[string | number, string | number | boolean, string?]>,\n    type: enumOptions.type,\n    enumKeyCasing: enumOptions.keyCasing,\n  })\n\n  // When the const and the type share a name (pascalCase const + empty typeSuffix) they merge into\n  // one declaration. The const carries the barrel export, so keep the type alias in the file but out\n  // of the barrel to avoid re-exporting the name a second time as `export type { … }`.\n  const namesMerge = !!nameNode && enumName === typeName\n\n  return (\n    <>\n      {nameNode && (\n        <File.Source name={enumName} pointer={node.pointer} isExportable isIndexable isTypeOnly={false}>\n          {nameNode}\n        </File.Source>\n      )}\n      <File.Source\n        name={typeName}\n        pointer={node.pointer}\n        isIndexable={!namesMerge}\n        isExportable={!namesMerge && enumOptions.type !== 'inlineLiteral'}\n        isTypeOnly={['asConst', 'literal', undefined].includes(enumOptions.type)}\n      >\n        {typeNode}\n      </File.Source>\n    </>\n  )\n}\n","import { ast, type Group, type NodeCache, type Output, type Resolver, type ResolverFileParams, Url } from 'kubb/kit'\n\n/**\n * Builds the `ResolverFileParams` every operation generator passes to\n * `resolver.file`: a file named `name`, tagged by the operation's first\n * tag (or `'default'`), at the operation's path. Centralizes the entry object\n * that was repeated at dozens of call sites across the client and query plugins.\n *\n * @example\n * ```ts\n * resolver.file(operationFileEntry(node, node.operationId), { root, output, group })\n * ```\n */\nexport function operationFileEntry(node: ast.OperationNode, name: string, extname: ResolverFileParams['extname'] = '.ts'): ResolverFileParams {\n  return {\n    name,\n    extname,\n    tag: node.tags[0] ?? 'default',\n    path: node.path,\n  }\n}\n\n/**\n * Resolves a dependency plugin's generated file for `node.operationId`, cached in `cache` (the\n * current node's `ctx.cache`) under the resolver's own plugin name. Several dependents reading the\n * same dependency for the same operation in one pass (a query plugin's several hook generators, the\n * MCP handler, ...) share one computed name and path instead of each calling `resolver.file` again.\n *\n * @example Cache `plugin-ts`'s file for the current operation\n * ```ts\n * const fileTs = resolveDependencyOperationFile({ cache: ctx.cache, node, resolver: tsResolver, root, output })\n * ```\n */\nexport function resolveDependencyOperationFile(options: {\n  cache: NodeCache\n  node: ast.OperationNode\n  resolver: Pick<Resolver, 'file' | 'pluginName'>\n  root: string\n  output: Output\n  group?: Group | null\n}): ast.FileNode {\n  const { cache, node, resolver, root, output, group } = options\n\n  return cache.ensureItem(`${resolver.pluginName}:operationFile`, () =>\n    resolver.file({ ...operationFileEntry(node, node.operationId), root, output, group: group ?? undefined }),\n  )\n}\n\nexport type ContentTypeInfo = {\n  contentTypes: string[]\n  isMultipleContentTypes: boolean\n  contentTypeUnion: string\n  defaultContentType: string\n  hasFormData: boolean\n}\n\nexport type RequestConfigResolver = {\n  response: {\n    body(node: ast.OperationNode): string\n  }\n}\n\nexport type ResponseStatusNameResolver = {\n  response: {\n    status(node: ast.OperationNode, statusCode: ast.StatusCode): string\n  }\n}\n\nexport type ResponseNameResolver = ResponseStatusNameResolver & {\n  response: {\n    response(node: ast.OperationNode): string\n  }\n}\n\nexport type OperationTypeNameResolver = RequestConfigResolver &\n  ResponseNameResolver & {\n    param: {\n      path(node: ast.OperationNode, param: ast.ParameterNode): string\n      query(node: ast.OperationNode, param: ast.ParameterNode): string\n      headers(node: ast.OperationNode, param: ast.ParameterNode): string\n    }\n  }\n\nexport type OperationCommentLink = 'pathTemplate' | 'urlPath' | false | ((node: ast.OperationNode) => string | undefined)\n\nexport type BuildOperationCommentsOptions = {\n  link?: OperationCommentLink\n  linkPosition?: 'beforeDeprecated' | 'afterDeprecated'\n  splitLines?: boolean\n}\n\ntype ResponseLike = {\n  statusCode: ast.StatusCode | number | string\n}\n\nexport type OperationParameterGroups = Record<ast.ParameterNode['in'], Array<ast.ParameterNode>>\n\nexport type ResolveOperationTypeNameOptions = {\n  responseStatusNames?: boolean | 'error'\n  exclude?: ReadonlyArray<string | undefined>\n  order?: 'params-first' | 'body-response-first'\n  /**\n   * Include the individual `Path`/`Query`/`Headers` group type names. Set to `false` for clients\n   * that reference the grouped `Options` type instead of the per-group types.\n   */\n  includeParams?: boolean\n}\n\nfunction getOperationLink(node: ast.OperationNode, link: OperationCommentLink): string | null {\n  if (!link) {\n    return null\n  }\n\n  if (typeof link === 'function') {\n    return link(node) ?? null\n  }\n\n  return node.path ? `{@link ${Url.toPath(node.path)}}` : null\n}\n\n/**\n * Derives the shared `ContentTypeInfo` shape from a list of content types, tracking whether several\n * are present and the union, default, and form-data flags the client uses to pick one.\n */\nfunction buildContentTypeInfo(contentTypes: string[]): ContentTypeInfo {\n  const isMultipleContentTypes = contentTypes.length > 1\n\n  return {\n    contentTypes,\n    isMultipleContentTypes,\n    contentTypeUnion: isMultipleContentTypes ? contentTypes.map((ct) => JSON.stringify(ct)).join(' | ') : '',\n    defaultContentType: contentTypes[0] ?? 'application/json',\n    hasFormData: contentTypes.some((ct) => ct === 'multipart/form-data'),\n  }\n}\n\nexport function getContentTypeInfo(node: ast.OperationNode): ContentTypeInfo {\n  return buildContentTypeInfo(node.requestBody?.content?.map((e) => e.contentType) ?? [])\n}\n\n/**\n * The request-body counterpart for the primary success response: the content types it documents and\n * whether several are present, so the client can let a caller pick which one to accept.\n */\nexport function getResponseContentTypeInfo(node: ast.OperationNode): ContentTypeInfo {\n  return buildContentTypeInfo(getPrimarySuccessResponse(node)?.content?.map((e) => e.contentType) ?? [])\n}\n\nexport type ResponseType = 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' | 'stream'\n\n/**\n * Reads the single base content type of an operation's primary success response, lowercased and\n * stripped of any `; charset=...` suffix. Returns `undefined` when the response declares zero or\n * more than one content type, since neither case has a single type to act on.\n */\nfunction getPrimarySuccessContentType(node: ast.OperationNode): string | undefined {\n  const contentTypes = getPrimarySuccessResponse(node)?.content?.map((entry) => entry.contentType) ?? []\n  if (contentTypes.length !== 1) return undefined\n  return contentTypes[0]!.split(';')[0]!.trim().toLowerCase()\n}\n\n/**\n * Whether an operation streams its primary success response as Server-Sent Events\n * (`text/event-stream`). The client generator uses this to return a typed event stream instead of a\n * one-shot `RequestResult`.\n */\nexport function isEventStream(node: ast.OperationNode): boolean {\n  return getPrimarySuccessContentType(node) === 'text/event-stream'\n}\n\n/**\n * Derives the default `responseType` for an operation from its primary success response.\n *\n * Returns a value only when that response declares a single non-JSON content type. `text/event-stream`\n * and other binary types (`application/octet-stream`, `application/pdf`, `image/*`, `audio/*`,\n * `video/*`) map to a stream or `'blob'`, and other `text/*` maps to `'text'`. Otherwise `undefined`,\n * leaving the runtime client's `Content-Type` auto-detection in charge.\n */\nexport function getResponseType(node: ast.OperationNode): ResponseType | undefined {\n  const baseType = getPrimarySuccessContentType(node)\n  if (!baseType) return undefined\n\n  if (baseType === 'application/json' || baseType.endsWith('+json') || baseType === 'text/json') return undefined\n  if (baseType === 'text/event-stream') return 'stream'\n  if (baseType.startsWith('text/')) return 'text'\n  if (baseType === 'application/octet-stream' || baseType === 'application/pdf' || /^(image|audio|video)\\//.test(baseType)) return 'blob'\n  return undefined\n}\n\n/**\n * Maps a content type to the PascalCase suffix used to name per-content-type variants\n * (e.g. `application/json` → `Json`, `application/xml` → `Xml`, `multipart/form-data` → `FormData`).\n */\nfunction getContentTypeSuffix(contentType: string): string {\n  const baseType = contentType.split(';')[0]!.trim()\n  if (baseType === 'application/json') return 'Json'\n  if (baseType === 'multipart/form-data') return 'FormData'\n  if (baseType === 'application/x-www-form-urlencoded') return 'FormUrlEncoded'\n  const subtype = baseType.split('/').pop() ?? baseType\n  const parts = subtype.split(/[^a-zA-Z0-9]+/).filter(Boolean)\n  if (parts.length === 0) return 'Unknown'\n  return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join('')\n}\n\n/**\n * Appends a content-type suffix to a base name, keeping a trailing `Data` segment last\n * (e.g. `AddPetData` + `Json` → `AddPetJsonData`, `AddPetStatus200` + `Xml` → `AddPetStatus200Xml`).\n */\nexport function getPerContentTypeName(baseName: string, suffix: string): string {\n  if (baseName.endsWith('Data')) {\n    return suffix.endsWith('Data') ? baseName.slice(0, -4) + suffix : `${baseName.slice(0, -4)}${suffix}Data`\n  }\n  return baseName + suffix\n}\n\nexport type ContentVariantInput = { contentType: string; schema?: ast.SchemaNode | null; keysToOmit?: Array<string> | null }\nexport type ContentVariant = { name: string; suffix: string; schema: ast.SchemaNode; keysToOmit?: Array<string> | null; contentType: string }\n\n/**\n * Resolves per-content-type variant names for a set of content entries, deduplicating suffix\n * collisions with a numeric counter. Entries without a schema are skipped. The returned `suffix` is\n * the final (possibly counter-augmented) value, so callers can derive parallel names in another\n * namespace (e.g. plugin-faker deriving the matching plugin-ts type name).\n */\nexport function resolveContentTypeVariants(entries: Array<ContentVariantInput>, baseName: string): Array<ContentVariant> {\n  const usedNames = new Set<string>()\n  return entries\n    .filter((entry) => entry.schema)\n    .map((entry) => {\n      const baseSuffix = getContentTypeSuffix(entry.contentType)\n      let suffix = baseSuffix\n      let name = getPerContentTypeName(baseName, suffix)\n      let counter = 2\n      while (usedNames.has(name)) {\n        suffix = `${baseSuffix}${counter++}`\n        name = getPerContentTypeName(baseName, suffix)\n      }\n      usedNames.add(name)\n      return { name, suffix, schema: entry.schema!, keysToOmit: entry.keysToOmit, contentType: entry.contentType }\n    })\n}\n\n// The request groups come from the grouped params, so `config` drops the data-shape keys to stay\n// assignable to `Options`, which omits them from `RequestConfig`.\nconst requestConfigBaseType = `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`\n\nexport function buildRequestConfigType(node: ast.OperationNode): string {\n  const request = getContentTypeInfo(node)\n  const response = getResponseContentTypeInfo(node)\n\n  // Only the ambiguous side is offered: a single-type side has nothing to pick, so it stays baked in\n  // the generated call.\n  const members = [\n    request.isMultipleContentTypes ? `request?: ${request.contentTypeUnion}` : null,\n    response.isMultipleContentTypes ? `response?: ${response.contentTypeUnion}` : null,\n  ].filter(Boolean)\n\n  return members.length ? `${requestConfigBaseType} & { contentType?: { ${members.join('; ')} } }` : requestConfigBaseType\n}\n\n/**\n * Builds the `client?:` option type shared by the generated query hooks (`useQuery`,\n * `useInfiniteQuery`, `useSWR`, ...). Unlike {@link buildRequestConfigType}, it never adds a\n * `contentType?:` member: query hooks wrap GET operations, which carry no request body to select a\n * content type for.\n */\nexport function buildClientOptionType(): string {\n  return requestConfigBaseType\n}\n\nexport type RequestGroups = {\n  path: boolean\n  query: boolean\n  body: boolean\n  headers: boolean\n}\n\n/**\n * Which of the grouped request options an operation carries.\n */\nexport function getRequestGroups(node: ast.OperationNode): RequestGroups {\n  const { path, query, header } = getOperationParameters(node)\n  return {\n    path: path.length > 0,\n    query: query.length > 0,\n    body: Boolean(node.requestBody?.content?.[0]?.schema),\n    headers: header.length > 0,\n  }\n}\n\nexport type RequestGroupOptionality = {\n  groups: RequestGroups\n  hasRequiredPath: boolean\n  hasRequiredQuery: boolean\n  hasRequiredHeader: boolean\n  /**\n   * Whether the grouped request parameter can default to `{}`. True only when no group carries a\n   * required member, so every member is safe to omit.\n   */\n  isOptional: boolean\n}\n\n/**\n * Resolves which grouped request options an operation carries together with whether each group\n * holds a required member. The grouped parameter stays optional only when nothing inside it is\n * required, matching the generated `RequestConfig` type.\n */\nexport function getRequestGroupOptionality(node: ast.OperationNode): RequestGroupOptionality {\n  const groups = getRequestGroups(node)\n  const { path, query, header } = getOperationParameters(node)\n  const hasRequiredPath = path.some((param) => param.required)\n  const hasRequiredQuery = query.some((param) => param.required)\n  const hasRequiredHeader = header.some((param) => param.required)\n\n  return {\n    groups,\n    hasRequiredPath,\n    hasRequiredQuery,\n    hasRequiredHeader,\n    isOptional: !hasRequiredPath && !hasRequiredQuery && !hasRequiredHeader && !groups.body,\n  }\n}\n\nexport type RequestOptionsNameResolver = RequestConfigResolver & {\n  response: {\n    options(node: ast.OperationNode): string\n  }\n}\n\n/**\n * Builds the grouped `{ path, query, body, headers }` parameter for a generated client\n * function, typed from the operation's `Options` (minus `url`). Only the groups the\n * operation actually has are destructured. The trailing `config` parameter carries the\n * runtime `RequestConfig` overrides plus `client`.\n */\nexport function buildRequestParamsSignature(\n  node: ast.OperationNode,\n  resolver: RequestOptionsNameResolver,\n  options: { isConfigurable?: boolean } = {},\n): { signature: string; groups: RequestGroups } {\n  const { isConfigurable = true } = options\n  const { groups, isOptional } = getRequestGroupOptionality(node)\n\n  const names = (['path', 'query', 'body', 'headers'] as const).filter((key) => groups[key])\n\n  const firstParam = names.length > 0 ? `{ ${names.join(', ')} }: ${resolver.response.options(node)}${isOptional ? ' = {}' : ''}` : null\n  const configParam = isConfigurable ? `config: ${buildRequestConfigType(node)} = {}` : null\n\n  return {\n    signature: [firstParam, configParam].filter(Boolean).join(', '),\n    groups,\n  }\n}\n\nexport function buildOperationComments(node: ast.OperationNode, options: BuildOperationCommentsOptions = {}): Array<string> {\n  const { link = 'pathTemplate', linkPosition = 'afterDeprecated', splitLines = false } = options\n  const linkComment = getOperationLink(node, link)\n  const comments =\n    linkPosition === 'beforeDeprecated'\n      ? [node.description && `@description ${node.description}`, node.summary && `@summary ${node.summary}`, linkComment, node.deprecated && '@deprecated']\n      : [node.description && `@description ${node.description}`, node.summary && `@summary ${node.summary}`, node.deprecated && '@deprecated', linkComment]\n\n  const filteredComments = comments.filter((comment): comment is string => Boolean(comment))\n\n  if (!splitLines) {\n    return filteredComments\n  }\n\n  return filteredComments.flatMap((text) => text.split(/\\r?\\n/).map((line) => line.trim())).filter((comment): comment is string => Boolean(comment))\n}\n\nconst operationParameterGroupsByNode = new WeakMap<ast.OperationNode, OperationParameterGroups>()\n\n/**\n * Groups an operation's parameters by location (`path`/`query`/`header`/`cookie`), deduping each\n * group by name. Every plugin generator visiting the same `OperationNode` shares one AST instance\n * (see `KubbDriver`), so the result is cached per node to avoid re-filtering and re-deduping the\n * same parameters once per plugin.\n */\nexport function getOperationParameters(node: ast.OperationNode): OperationParameterGroups {\n  const cached = operationParameterGroupsByNode.get(node)\n  if (cached) return cached\n\n  // A malformed spec can declare the same name twice within one location. Both would resolve to the\n  // same output property, so emitting both would yield an object type with a duplicate member,\n  // which TypeScript rejects. Keep the first.\n  const group = (location: ast.ParameterNode['in']) => {\n    const seen = new Set<string>()\n\n    return node.parameters.filter((param) => {\n      if (param.in !== location || seen.has(param.name)) return false\n      seen.add(param.name)\n      return true\n    })\n  }\n\n  const groups: OperationParameterGroups = { path: group('path'), query: group('query'), header: group('header'), cookie: group('cookie') }\n\n  operationParameterGroupsByNode.set(node, groups)\n  return groups\n}\n\n/**\n * Builds the combined `{ body, path, query, headers }` options object schema for an operation,\n * referencing the already-resolved body and grouped param names. Shared by `@kubb/plugin-ts`'s\n * `Options` type and `@kubb/plugin-zod`'s inferred options schema, so both printers emit the same\n * shape from the same inputs. `primitive: 'object'` is a no-op for the TS printer and tells the Zod\n * printer to emit `z.object(…)` rather than a record.\n */\nexport function buildOptionsSchema(node: ast.OperationNode, resolver: OperationTypeNameResolver): ast.SchemaNode {\n  const { path, query, header } = getOperationParameters(node)\n  const hasBody = Boolean(node.requestBody?.content?.[0]?.schema)\n  const createNever = () => ast.factory.createSchema({ type: 'never', primitive: undefined, optional: true })\n  const groups = [\n    { name: 'path', params: path, resolve: resolver.param.path },\n    { name: 'query', params: query, resolve: resolver.param.query },\n    { name: 'headers', params: header, resolve: resolver.param.headers },\n  ] as const\n\n  // NOTE(v5-stable): the fields were renamed from the legacy beta shape\n  // (`data`/`pathParams`/`queryParams`/`headerParams`) to `body`/`path`/`query`/`headers` so the\n  // type matches the runtime client. Drop this note once v5 leaves beta.\n  return ast.factory.createSchema({\n    type: 'object',\n    primitive: 'object',\n    deprecated: node.deprecated,\n    properties: [\n      ast.factory.createProperty({\n        name: 'body',\n        required: hasBody,\n        schema: hasBody ? ast.factory.createSchema({ type: 'ref', name: resolver.response.body(node) }) : createNever(),\n      }),\n      ...groups.map(({ name, params, resolve }) => {\n        const required = params.some((param) => param.required)\n\n        return ast.factory.createProperty({\n          name,\n          required,\n          schema:\n            params.length > 0\n              ? ast.factory.createSchema({ type: 'ref', name: resolve.call(resolver.param, node, params[0]!), optional: !required })\n              : createNever(),\n        })\n      }),\n    ],\n  })\n}\n\n/**\n * The schema a status occupies in the `<Name>Responses` record. A status that documents several\n * content types becomes a `{ contentType; data }` union so the runtime can surface the negotiated type\n * on `result.parsed`, while the standalone `<Name>StatusNNN` alias stays the plain body union that the\n * query hooks and `result.data` use.\n */\nfunction buildResponseRecordEntry(node: ast.OperationNode, res: ast.ResponseNode, resolver: ResponseStatusNameResolver): ast.SchemaNode {\n  const statusName = resolver.response.status(node, res.statusCode)\n  const variants = (res.content ?? []).filter((entry) => entry.schema)\n  if (variants.length <= 1) {\n    return ast.factory.createSchema({ type: 'ref', name: statusName })\n  }\n\n  return ast.factory.createSchema({\n    type: 'union',\n    members: resolveContentTypeVariants(variants, statusName).map((variant) =>\n      ast.factory.createSchema({\n        type: 'object',\n        primitive: 'object',\n        properties: [\n          ast.factory.createProperty({\n            name: 'contentType',\n            required: true,\n            schema: ast.factory.createSchema({ type: 'enum', enumValues: [variant.contentType] }),\n          }),\n          ast.factory.createProperty({\n            name: 'data',\n            required: true,\n            schema: ast.factory.createSchema({ type: 'ref', name: variant.name }),\n          }),\n        ],\n      }),\n    ),\n  })\n}\n\n/**\n * Builds the per-status `<Name>Responses` record for an operation, referencing the already-resolved\n * `<Name>StatusNNN` names. Shared by `@kubb/plugin-ts`'s `Responses` type and `@kubb/plugin-zod`'s\n * inferred responses schema, so both emit the same shape from the same inputs.\n *\n * Always emits the keyed record, even when an operation declares no responses. An operation with no\n * responses renders as an empty object, which keeps every consumer's import (for example the axios\n * SDK's `RequestResult<XResponses>`) resolvable instead of pointing at a missing export.\n */\nexport function buildResponses(node: ast.OperationNode, resolver: ResponseStatusNameResolver): ast.SchemaNode {\n  return ast.factory.createSchema({\n    type: 'object',\n    primitive: 'object',\n    properties: node.responses.map((res) =>\n      ast.factory.createProperty({\n        name: String(res.statusCode),\n        required: true,\n        schema: buildResponseRecordEntry(node, res, resolver),\n      }),\n    ),\n  })\n}\n\nexport function getStatusCodeNumber(statusCode: ast.StatusCode | number | string): number | null {\n  const code = Number(statusCode)\n\n  return Number.isNaN(code) ? null : code\n}\n\nexport function isSuccessStatusCode(statusCode: ast.StatusCode | number | string): boolean {\n  const code = getStatusCodeNumber(statusCode)\n\n  return code !== null && code >= 200 && code < 300\n}\n\nexport function isErrorStatusCode(statusCode: ast.StatusCode | number | string): boolean {\n  const code = getStatusCodeNumber(statusCode)\n\n  return code !== null && code >= 400\n}\n\nexport function getSuccessResponses<TResponse extends ResponseLike>(responses: ReadonlyArray<TResponse>): Array<TResponse> {\n  return responses.filter((response) => isSuccessStatusCode(response.statusCode))\n}\n\nexport function getOperationSuccessResponses(node: ast.OperationNode): Array<ast.ResponseNode> {\n  return getSuccessResponses(node.responses)\n}\n\nexport function getPrimarySuccessResponse(node: ast.OperationNode): ast.ResponseNode | null {\n  return getOperationSuccessResponses(node)[0] ?? null\n}\n\nexport function resolveErrorNames(node: ast.OperationNode, resolver: ResponseStatusNameResolver): string[] {\n  return node.responses.filter((response) => isErrorStatusCode(response.statusCode)).map((response) => resolver.response.status(node, response.statusCode))\n}\n\nexport function resolveSuccessNames(node: ast.OperationNode, resolver: ResponseStatusNameResolver): string[] {\n  return node.responses.filter((response) => isSuccessStatusCode(response.statusCode)).map((response) => resolver.response.status(node, response.statusCode))\n}\n\nexport function resolveStatusCodeNames(node: ast.OperationNode, resolver: ResponseStatusNameResolver): string[] {\n  return node.responses.map((response) => resolver.response.status(node, response.statusCode))\n}\n\nconst typeNamesByResolver = new WeakMap<OperationTypeNameResolver, Map<string, string[]>>()\n\nexport function resolveOperationTypeNames(\n  node: ast.OperationNode,\n  resolver: OperationTypeNameResolver,\n  options: ResolveOperationTypeNameOptions = {},\n): string[] {\n  const cacheKey = `${node.operationId}\\0${options.order ?? ''}\\0${options.responseStatusNames ?? ''}\\0${options.includeParams === false ? 'noparams' : ''}\\0${(options.exclude ?? []).join(',')}`\n  let byResolver = typeNamesByResolver.get(resolver)\n  if (byResolver) {\n    const cached = byResolver.get(cacheKey)\n    if (cached) return cached\n  } else {\n    byResolver = new Map()\n    typeNamesByResolver.set(resolver, byResolver)\n  }\n\n  const { path, query, header } = getOperationParameters(node)\n  const responseStatusNames =\n    options.responseStatusNames === 'error'\n      ? resolveErrorNames(node, resolver)\n      : options.responseStatusNames === false\n        ? []\n        : resolveStatusCodeNames(node, resolver)\n  const exclude = new Set(options.exclude ?? [])\n  const paramNames =\n    options.includeParams === false\n      ? []\n      : [\n          ...path.map((param) => resolver.param.path(node, param)),\n          ...query.map((param) => resolver.param.query(node, param)),\n          ...header.map((param) => resolver.param.headers(node, param)),\n        ]\n  const bodyAndResponseNames = [node.requestBody?.content?.[0]?.schema ? resolver.response.body(node) : null, resolver.response.response(node)]\n  const names =\n    options.order === 'body-response-first'\n      ? [...bodyAndResponseNames, ...paramNames, ...responseStatusNames]\n      : [...paramNames, ...bodyAndResponseNames, ...responseStatusNames]\n\n  const result = names.filter((name): name is string => Boolean(name) && !exclude.has(name as string))\n  byResolver.set(cacheKey, result)\n  return result\n}\n\nexport function resolveResponseTypes(node: ast.OperationNode, resolver: ResponseNameResolver): Array<[statusCode: number | 'default', typeName: string]> {\n  const types: Array<[number | 'default', string]> = []\n\n  for (const response of node.responses) {\n    if (response.statusCode === 'default') {\n      types.push(['default', resolver.response.response(node)])\n      continue\n    }\n\n    const code = getStatusCodeNumber(response.statusCode)\n    if (code === null) {\n      continue\n    }\n\n    types.push([code, isSuccessStatusCode(code) ? resolver.response.response(node) : resolver.response.status(node, response.statusCode)])\n  }\n\n  return types\n}\n","import { toFilePath } from '@internals/utils'\nimport type { ast, Resolver, ResolverFile } from 'kubb/kit'\n\n/**\n * The `param` namespace shared by the schema-producing plugins (ts, zod, faker):\n * per-parameter names plus the grouped `Path`/`Query`/`Headers` names, all routed\n * through the plugin's top-level `name` casing.\n */\nexport type OperationParamResolver = {\n  name(this: Resolver, node: ast.OperationNode, param: ast.ParameterNode): string\n  path(this: Resolver, node: ast.OperationNode): string\n  query(this: Resolver, node: ast.OperationNode): string\n  headers(this: Resolver, node: ast.OperationNode): string\n}\n\n/**\n * The `response` namespace shared by the schema-producing plugins: per-status,\n * body, and combined response names, all routed through the plugin's top-level\n * `name` casing.\n */\nexport type OperationResponseResolver = {\n  status(this: Resolver, node: ast.OperationNode, statusCode: ast.StatusCode): string\n  body(this: Resolver, node: ast.OperationNode): string\n  responses(this: Resolver, node: ast.OperationNode): string\n  response(this: Resolver, node: ast.OperationNode): string\n}\n\n/**\n * Resolves a single operation parameter name with the\n * `<operationId> <in> <name>` template.\n *\n * @example\n * `operationParamName.call(resolver, node, param) // → 'DeletePetPathPetId'`\n */\nfunction operationParamName(this: Resolver, node: ast.OperationNode, param: ast.ParameterNode): string {\n  return this.name(`${node.operationId} ${param.in} ${param.name}`)\n}\n\n/**\n * Builds the shared `param` namespace. Spread the result into `createResolver`\n * and override individual methods next to it when a plugin deviates.\n *\n * @example\n * ```ts\n * createResolver<PluginTs>({ param: createOperationParamResolver(), ... })\n * ```\n */\nexport function createOperationParamResolver(): OperationParamResolver {\n  return {\n    name: operationParamName,\n    path(node) {\n      return this.name(`${node.operationId} Path`)\n    },\n    query(node) {\n      return this.name(`${node.operationId} Query`)\n    },\n    headers(node) {\n      return this.name(`${node.operationId} Headers`)\n    },\n  }\n}\n\n/**\n * Builds the shared `response` namespace. Spread the result into\n * `createResolver` and add plugin-specific methods (`options`, `error`) next\n * to it.\n *\n * @example\n * ```ts\n * createResolver<PluginTs>({ response: { ...createOperationResponseResolver(), options(node) {...} }, ... })\n * ```\n */\nexport function createOperationResponseResolver(): OperationResponseResolver {\n  return {\n    status(node, statusCode) {\n      return this.name(`${node.operationId} Status ${statusCode}`)\n    },\n    body(node) {\n      return this.name(`${node.operationId} Body`)\n    },\n    responses(node) {\n      return this.name(`${node.operationId} Responses`)\n    },\n    response(node) {\n      return this.name(`${node.operationId} Response`)\n    },\n  }\n}\n\n/**\n * Builds a resolver `file` override whose base name runs every path segment\n * through `toFilePath`, casing the final segment with `caseLast`.\n *\n * @example\n * ```ts\n * createResolver<PluginTs>({ file: createCasedFile(pascalCase), ... })\n * ```\n */\nexport function createCasedFile(caseLast: (part: string) => string): ResolverFile {\n  return {\n    baseName({ name, extname }) {\n      return `${toFilePath(name, caseLast)}${extname}`\n    },\n  }\n}\n","import { camelCase } from '@internals/utils'\nimport type { Group } from 'kubb/kit'\n\n/**\n * Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the\n * shared default naming so every plugin groups output consistently:\n *\n * - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).\n * - other groups use the camelCased group (`pet store` → `petStore`).\n *\n * A user-provided `group.name` always wins over the default namer, so callers stay in\n * control of their output folders. Returns `null` when grouping is disabled, matching the\n * per-plugin convention.\n *\n * @param group - The user-supplied group option, or `undefined` to disable grouping.\n *\n * @example\n * ```ts\n * createGroupConfig(group) // shared across every plugin\n * ```\n */\nexport function createGroupConfig(group: Group | undefined): Group | null {\n  if (!group) {\n    return null\n  }\n\n  const defaultName = (ctx: { group: string }): string => {\n    if (group.type === 'path') {\n      return `${ctx.group.split('/')[1]}`\n    }\n\n    return camelCase(ctx.group)\n  }\n\n  return {\n    ...group,\n    name: group.name ? group.name : defaultName,\n  } satisfies Group\n}\n","import type { ast } from 'kubb/kit'\n\n/**\n * Converts a child schema to printer output. Plugins instantiate it with their own output type:\n * `string` for the zod and faker printers, `ts.TypeNode` for the TypeScript printer. A printer's\n * `this.transform` fits directly, so its `null` for an empty result carries through to `output`.\n */\nexport type SchemaTransform<TOutput> = (schema: ast.SchemaNode) => TOutput\n\n/**\n * A union or intersection member, or an array or tuple item, paired with its transformed output.\n */\nexport type MappedSchema<TOutput> = {\n  /**\n   * The original child schema, kept so the printer can read its metadata for leaf formatting.\n   */\n  schema: ast.SchemaNode\n  /**\n   * The child schema after being run through the transform.\n   */\n  output: TOutput\n}\n\n/**\n * An object property paired with its transformed output.\n */\nexport type MappedProperty<TOutput> = {\n  /**\n   * The property name as written on the schema, before any identifier quoting.\n   */\n  name: string\n  /**\n   * The original property node, kept so the printer can read `required`, `schema`, and metadata.\n   */\n  property: ast.PropertyNode\n  /**\n   * The property schema after being run through the transform.\n   */\n  output: TOutput\n}\n\n/**\n * Maps each property of an object schema to its transformed output. Pairs every result with the\n * original property so the printer keeps full control over modifiers, getters, and key syntax.\n *\n * @example\n * ```ts\n * const entries = mapSchemaProperties(node, (schema) => this.transform(schema))\n * // entries: [{ name: 'id', property, output: 'z.number()' }, ...]\n * ```\n */\nexport function mapSchemaProperties<TOutput>(node: ast.ObjectSchemaNode, transform: SchemaTransform<TOutput>): Array<MappedProperty<TOutput>> {\n  return node.properties.map((property) => ({ name: property.name, property, output: transform(property.schema) }))\n}\n\n/**\n * Maps each member of a union or intersection schema to its transformed output, pairing every\n * result with the original member.\n */\nexport function mapSchemaMembers<TOutput>(\n  node: ast.UnionSchemaNode | ast.IntersectionSchemaNode,\n  transform: SchemaTransform<TOutput>,\n): Array<MappedSchema<TOutput>> {\n  return (node.members ?? []).map((schema) => ({ schema, output: transform(schema) }))\n}\n\n/**\n * Maps each item of an array or tuple schema to its transformed output, pairing every result with\n * the original item.\n */\nexport function mapSchemaItems<TOutput>(node: ast.ArraySchemaNode, transform: SchemaTransform<TOutput>): Array<MappedSchema<TOutput>> {\n  return (node.items ?? []).map((schema) => ({ schema, output: transform(schema) }))\n}\n","import { isSuccessStatusCode } from '@internals/shared'\nimport { jsDocEscape, stringify } from '@internals/utils'\nimport { ast, syncSchemaRef } from 'kubb/kit'\nimport type { ResolverTs } from './types.ts'\n\n/**\n * Resolves the type name an enum schema is referenced by. An enum emitted as a `const` object\n * with a `typeSuffix` uses its suffixed key alias (e.g. `StatusKey`); every other schema uses its\n * plain resolved name.\n */\ntype EnumTypeNameProps = {\n  resolver: ResolverTs\n  name: string\n  enumOptions: { type?: string; typeSuffix?: string } | undefined\n  isEnum: boolean\n}\n\nexport function enumTypeName({ resolver, name, enumOptions, isEnum }: EnumTypeNameProps): string {\n  return isEnum && enumOptions?.type === 'asConst' && enumOptions.typeSuffix ? resolver.enum.keyName({ name }, enumOptions.typeSuffix) : resolver.name(name)\n}\n\n/**\n * Tells whether a `const` (single-value enum) should render as a bare literal type (`'active'`)\n * rather than a named enum reference or a runtime enum declaration.\n *\n * The parser folds `const` into a single-value enum node. The adapter decides which schemas are\n * named enums and lists them in `enumSchemaNames`, and references to those names get suffixed (for\n * example `StatusKey`). A const renders as a literal only when the adapter has not registered it as\n * a named enum, which keeps the declaration and its references in sync across adapter versions.\n */\nexport function isInlineConstEnum(node: ast.EnumSchemaNode, enumSchemaNames?: ReadonlySet<string>): boolean {\n  const isConst = (node.namedEnumValues ?? node.enumValues ?? []).length === 1\n  return isConst && !(node.name && enumSchemaNames?.has(node.name))\n}\n\n/**\n * Collects JSDoc annotation strings for a schema node.\n *\n * Only uses official JSDoc tags from https://jsdoc.app/: `@description`, `@deprecated`, `@default`, `@example`, `@type`.\n * Constraint metadata (min/max length, pattern, multipleOf, min/maxProperties) is emitted as plain-text lines.\n\n */\nfunction isSchemaOptional(schema: ast.SchemaNode): boolean {\n  return Boolean(('optional' in schema && schema.optional) || ('nullish' in schema && schema.nullish))\n}\n\nfunction formatExample(value: unknown): string {\n  if (value === null || typeof value !== 'object') {\n    return String(value)\n  }\n\n  const rendered = JSON.stringify(value) ?? String(value)\n  return rendered.replaceAll('*/', '*\\\\/')\n}\n\nexport function buildPropertyJSDocComments(schema: ast.SchemaNode, optional?: boolean): Array<string | undefined> {\n  const meta = syncSchemaRef(schema)\n\n  const isArray = meta?.primitive === 'array'\n\n  const hasDescription = meta && 'description' in meta && meta.description\n\n  const formatComment =\n    meta && 'format' in meta && meta.format\n      ? hasDescription\n        ? // Empty line between description and format\n          [' ', `Format: \\`${meta.format}\\``]\n        : ['@description', `Format: \\`${meta.format}\\``]\n      : []\n\n  // OAS 3.1 carries schema examples as an `examples` array, one `@example` line each.\n  const exampleValues = meta?.examples ?? []\n\n  const comments = [\n    hasDescription ? `@description ${jsDocEscape(meta.description)}` : null,\n    ...formatComment,\n    meta && 'deprecated' in meta && meta.deprecated ? '@deprecated' : null,\n    // minItems/maxItems on arrays should not be emitted as @minLength/@maxLength\n    !isArray && meta && 'min' in meta && meta.min !== undefined ? `@minLength ${meta.min}` : null,\n    !isArray && meta && 'max' in meta && meta.max !== undefined ? `@maxLength ${meta.max}` : null,\n    meta && 'pattern' in meta && meta.pattern ? `@pattern ${meta.pattern}` : null,\n    meta && 'default' in meta && meta.default !== undefined\n      ? `@default ${'primitive' in meta && meta.primitive === 'string' && typeof meta.default === 'string' ? stringify(meta.default) : formatExample(meta.default)}`\n      : null,\n    ...exampleValues.map((example) => `@example ${formatExample(example)}`),\n  ].filter(Boolean)\n\n  // `@type` merely repeats the TypeScript type already sitting next to the property, so it only\n  // earns its place inside a comment block that exists for another reason. Bare, it would just\n  // add bytes with no information a reader can't already see in the signature.\n  const typeTag =\n    comments.length && meta && 'primitive' in meta && meta.primitive\n      ? [`@type ${meta.primitive}`, (optional ?? isSchemaOptional(schema)) ? ' | undefined' : null].filter(Boolean).join('')\n      : null\n\n  return [...comments, typeTag].filter(Boolean)\n}\n\ntype BuildParamsSchemaOptions = {\n  params: Array<ast.ParameterNode>\n}\n\ntype BuildOperationSchemaOptions = {\n  resolver: ResolverTs\n}\n\n/**\n * Builds the object schema for a group of parameters sharing one `in` location (path, query, or\n * header), embedding each param's own schema (and JSDoc) directly rather than referencing a\n * separate per-param type — the group itself is the only type these params get exported as.\n */\nexport function buildParams({ params }: BuildParamsSchemaOptions): ast.SchemaNode {\n  return ast.factory.createSchema({\n    type: 'object',\n    // The group points at the `parameters` list that declares its first parameter.\n    pointer: params[0]?.pointer?.replace(/\\/\\d+$/, ''),\n    properties: params.map((param) =>\n      ast.factory.createProperty({\n        name: param.name,\n        required: param.required,\n        schema: ast.factory.createSchema({ ...param.schema, optional: !param.required }),\n      }),\n    ),\n  })\n}\n\nexport function buildResponseUnion(node: ast.OperationNode, { resolver }: BuildOperationSchemaOptions): ast.SchemaNode | null {\n  const allWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema))\n  // Only 2xx responses, so an `unknown` error body cannot erase the success typing. Falls back to all responses when no 2xx has a schema.\n  const successWithSchema = allWithSchema.filter((res) => isSuccessStatusCode(res.statusCode))\n  const responsesWithSchema = successWithSchema.length > 0 ? successWithSchema : allWithSchema\n\n  if (responsesWithSchema.length === 0) {\n    return null\n  }\n\n  return ast.factory.createSchema({\n    type: 'union',\n    members: responsesWithSchema.map((res) => ast.factory.createSchema({ type: 'ref', name: resolver.response.status(node, res.statusCode) })),\n  })\n}\n","import { ast } from 'kubb/kit'\nimport { File } from 'kubb/jsx'\nimport type { KubbReactNode } from 'kubb/jsx'\nimport type { PrinterTsFactory } from '../printers/printerTs.ts'\nimport type { PluginTs, ResolverTs } from '../types.ts'\nimport { isInlineConstEnum } from '../utils.ts'\nimport { Enum, getEnumNames } from './Enum.tsx'\n\ntype Props = {\n  name: string\n  node: ast.SchemaNode\n  /**\n   * Pre-configured printer instance created by the generator.\n   * Created with `printerTs({ ..., nodes: options.printer?.nodes })`.\n   */\n  printer: ast.Printer<PrinterTsFactory>\n  enum: PluginTs['resolvedOptions']['enum']\n  resolver: ResolverTs\n}\n\nexport function Type({ name, node, printer, enum: enumOptions, resolver }: Props): KubbReactNode {\n  const enumSchemaNodes = ast.collectSync<ast.EnumSchemaNode>(node, {\n    schema(n): ast.EnumSchemaNode | undefined {\n      const enumNode = ast.narrowSchema(n, ast.schemaTypes.enum)\n      // Skip an inline `const` (single-value enum the adapter did not register): it renders as a\n      // literal, so it gets no runtime enum declaration.\n      if (enumNode?.name && !isInlineConstEnum(enumNode, printer.options.enumSchemaNames)) return enumNode\n    },\n  })\n\n  const output = printer.print(node)\n\n  if (!output) {\n    return\n  }\n\n  const enums = [...new Map(enumSchemaNodes.map((n) => [n.name, n])).values()].map((node) => {\n    return {\n      node,\n      ...getEnumNames({ node, enum: enumOptions, resolver }),\n    }\n  })\n\n  // Skip enum exports when using inlineLiteral\n  const shouldExportEnums = enumOptions.type !== 'inlineLiteral'\n  const shouldExportType = enumOptions.type === 'inlineLiteral' || enums.every((item) => item.typeName !== name)\n\n  return (\n    <>\n      {shouldExportEnums && enums.map(({ node }) => <Enum key={node.name} node={node} enum={enumOptions} resolver={resolver} />)}\n      {shouldExportType && (\n        <File.Source name={name} pointer={node.pointer} isTypeOnly isExportable isIndexable>\n          {output}\n        </File.Source>\n      )}\n    </>\n  )\n}\n","import { mapSchemaItems, mapSchemaProperties } from '@internals/shared'\nimport { ast, isStringType, syncSchemaRef } from 'kubb/kit'\nimport { parserTs } from '@kubb/parser-ts'\nimport * as factory from '../factory.ts'\nimport type { PluginTs, ResolverTs } from '../types.ts'\nimport { buildPropertyJSDocComments, enumTypeName, isInlineConstEnum } from '../utils.ts'\n\nconst { isNonNullable } = factory\n\n/**\n * Partial map of node-type overrides for the TypeScript printer.\n *\n * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`). The function\n * replaces the built-in handler for that node type and returns the TypeScript type as a string.\n * Use `this.transform` to recurse into nested schema nodes, and `this.options` to read printer options.\n *\n * @example Override the `date` handler\n * ```ts\n * pluginTs({\n *   printer: {\n *     nodes: {\n *       date(node) {\n *         return 'Date'\n *       },\n *     },\n *   },\n * })\n * ```\n */\nexport type PrinterTsNodes = ast.PrinterPartial<string | DeprecatedTsNode, PrinterTsOptions>\n\n/** @deprecated A TypeScript compiler node returned by an override. Return a string; removed in the next major. */\ntype DeprecatedTsNode = { readonly kind: number }\n\nexport type PrinterTsOptions = {\n  /**\n   * Mark parameters as optional with `?` or `| undefined`.\n   * - `'questionToken'` adds `?` to properties\n   * - `'undefined'` adds `| undefined` to types\n   *\n   * @default `'questionToken'`\n   */\n  optionalType: PluginTs['resolvedOptions']['optionalType']\n  /**\n   * Array representation style.\n   * - `'array'` uses bracket notation (`T[]`)\n   * - `'generic'` uses generic syntax (`Array<T>`)\n   *\n   * @default `'array'`\n   */\n  arrayType: PluginTs['resolvedOptions']['arrayType']\n  /**\n   * Grouped enum settings. The printer emits references to enums, not the enum declarations, so only\n   * `type` (the output format) and `typeSuffix` (the enum key reference suffix) matter here.\n   * `constCasing` and `keyCasing` are ignored.\n   */\n  enum: PluginTs['resolvedOptions']['enum']\n  /**\n   * Syntax for generated declarations.\n   * - `'type'` generates type aliases\n   * - `'interface'` generates interface declarations\n   *\n   * @default `'type'`\n   */\n  syntaxType?: PluginTs['resolvedOptions']['syntaxType']\n  /**\n   * Exported name for the type declaration.\n   * When omitted, returns only the raw type node.\n   */\n  name?: string\n\n  /**\n   * JSDoc comment to attach to the generated type.\n   */\n  description?: string\n  /**\n   * Properties to exclude using `Omit<Type, Keys>`.\n   * Forces type alias syntax regardless of `syntaxType` setting.\n   */\n  keysToOmit?: Array<string> | null\n  /**\n   * Transforms raw schema names into valid TypeScript identifiers.\n   */\n  resolver: ResolverTs\n  /**\n   * Schema names that represent enums for suffixed key references.\n   */\n  enumSchemaNames?: Set<string>\n  /**\n   * Custom handler map for node type overrides.\n   */\n  nodes?: PrinterTsNodes\n}\n\n/**\n * TypeScript printer factory options: maps `SchemaNode` → a TS-ESTree node, printed to a type string or a full declaration string.\n */\nexport type PrinterTsFactory = ast.PrinterFactoryOptions<'typescript', PrinterTsOptions, factory.TsNode, string>\n\ntype PrinterTs = PrinterTsFactory\n\ntype HandlerContext = { transform: (node: ast.SchemaNode) => factory.TsNode | null }\n\n/**\n * Adapts user overrides, which work in strings, to the node-based printer: `this.transform` hands them printed\n * strings and their result is wrapped back into a node. A deprecated compiler node prints through `@kubb/parser-ts`.\n */\nfunction toNodeHandlers(nodes: PrinterTsNodes | undefined): ast.PrinterPartial<factory.TsNode, PrinterTsOptions> {\n  return Object.fromEntries(\n    Object.entries(nodes ?? {}).map(([type, handler]) => [\n      type,\n      function (this: HandlerContext, node: ast.SchemaNode) {\n        const transform = (child: ast.SchemaNode) => {\n          const output = this.transform(child)\n          return output ? factory.print(output) : null\n        }\n        const result = (handler as (this: unknown, node: ast.SchemaNode) => string | DeprecatedTsNode | null | undefined).call({ ...this, transform }, node)\n        if (result === null || result === undefined) return result\n        return factory.createRaw(\n          typeof result === 'string'\n            ? result\n            : parserTs()\n                .print(result as never)\n                .trimEnd(),\n        )\n      },\n    ]),\n  )\n}\n\n/**\n * TypeScript type printer built with `definePrinter`.\n *\n * Converts a `SchemaNode` AST node into TypeScript source:\n * - **`printer.print(node)`** — when `options.name` is set, returns a full\n *   `type Name = …` or `interface Name { … }` declaration.\n *   Without `name`, returns the type for the schema, such as `string | null`.\n *\n * Dispatches on `node.type` to the appropriate handler in `nodes`. Options are closed\n * over per printer instance, so each call to `printerTs(options)` produces an independent printer.\n *\n * @example Raw type node (no `typeName`)\n * ```ts\n * const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enum: { type: 'inlineLiteral' } })\n * const type = printer.print(schemaNode) // 'string | null'\n * ```\n *\n * @example Full declaration (with `typeName`)\n * ```ts\n * const printer = printerTs({ optionalType: 'questionToken', arrayType: 'array', enum: { type: 'inlineLiteral' }, typeName: 'MyType' })\n * const declaration = printer.print(schemaNode) // 'export type MyType = …'\n * ```\n */\nexport const printerTs = ast.createPrinter<PrinterTs>((options) => {\n  const addsUndefined = options.optionalType === 'undefined' || options.optionalType === 'questionTokenAndUndefined'\n\n  return {\n    name: 'typescript',\n    options,\n    nodes: {\n      any: () => factory.keywordTypeNodes.any,\n      unknown: () => factory.keywordTypeNodes.unknown,\n      void: () => factory.keywordTypeNodes.void,\n      never: () => factory.keywordTypeNodes.never,\n      boolean: () => factory.keywordTypeNodes.boolean,\n      null: () => factory.keywordTypeNodes.null,\n      blob: () => factory.createTypeReferenceNode('Blob'),\n      string: () => factory.keywordTypeNodes.string,\n      uuid: () => factory.keywordTypeNodes.string,\n      email: () => factory.keywordTypeNodes.string,\n      url: (node) => {\n        if (node.path) {\n          return factory.createUrlTemplateType(node.path)\n        }\n        return factory.keywordTypeNodes.string\n      },\n      ipv4: () => factory.keywordTypeNodes.string,\n      ipv6: () => factory.keywordTypeNodes.string,\n      datetime: () => factory.keywordTypeNodes.string,\n      number: () => factory.keywordTypeNodes.number,\n      integer: () => factory.keywordTypeNodes.number,\n      bigint: () => factory.keywordTypeNodes.bigint,\n      date: factory.dateOrStringNode,\n      time: factory.dateOrStringNode,\n      ref(node) {\n        if (!node.name) {\n          return null\n        }\n        // `node.name` may have been overridden (e.g. by the single-member allOf flatten using the\n        // property-derived child name), so resolve the target through `resolveRefName` instead.\n        const refName = ast.resolveRefName(node)\n        if (!refName) {\n          return null\n        }\n\n        // When a Key suffix is configured, enum refs must use the suffixed name (e.g. `StatusKey`)\n        // so the reference matches what the enum file actually exports.\n        const name = node.ref\n          ? enumTypeName({\n              resolver: this.options.resolver,\n              name: refName,\n              enumOptions: this.options.enum,\n              isEnum: !!this.options.enumSchemaNames?.has(refName),\n            })\n          : refName\n\n        return factory.createTypeReferenceNode(name)\n      },\n      enum(node) {\n        const values = ast.getSchemaLiteralValues(node)\n\n        // A `const` (single-value enum) the adapter did not register as a named enum emits the bare\n        // literal regardless of `enum.type`, matching how its references resolve.\n        if (this.options.enum.type === 'inlineLiteral' || !node.name || isInlineConstEnum(node, this.options.enumSchemaNames)) {\n          const literalNodes = values\n            .filter((v): v is string | number | boolean => v !== null && v !== undefined)\n            .map((value) => factory.constToTypeNode(value, typeof value as 'string' | 'number' | 'boolean'))\n            .filter(isNonNullable)\n\n          return factory.createUnionDeclaration({ nodes: literalNodes })\n        }\n\n        const resolvedName = enumTypeName({ resolver: this.options.resolver, name: node.name, enumOptions: this.options.enum, isEnum: true })\n\n        return factory.createTypeReferenceNode(resolvedName)\n      },\n      union(node) {\n        const members = node.members ?? []\n\n        const hasStringLiteral = members.some((m) => {\n          const enumNode = ast.narrowSchema(m, ast.schemaTypes.enum)\n          return enumNode?.primitive === 'string'\n        })\n        const hasPlainString = members.some((m) => isStringType(m))\n\n        if (hasStringLiteral && hasPlainString) {\n          const memberNodes = members\n            .map((m) => {\n              if (isStringType(m)) {\n                return factory.createIntersectionDeclaration({\n                  nodes: [factory.keywordTypeNodes.string, factory.createTypeLiteralNode([])],\n                })\n              }\n\n              return this.transform(m)\n            })\n            .filter(isNonNullable)\n\n          return factory.createUnionDeclaration({ nodes: memberNodes })\n        }\n\n        return factory.createUnionDeclaration({ nodes: factory.buildMemberNodes(members, this.transform) })\n      },\n      intersection(node) {\n        return factory.createIntersectionDeclaration({ nodes: factory.buildMemberNodes(node.members, this.transform) })\n      },\n      array(node) {\n        const itemNodes = mapSchemaItems(node, (item) => this.transform(item))\n          .map(({ output }) => output)\n          .filter(isNonNullable)\n\n        return factory.createArrayDeclaration({ nodes: itemNodes, arrayType: this.options.arrayType })\n      },\n      tuple(node) {\n        return factory.buildTupleNode(node, this.transform)\n      },\n      object(node) {\n        const { transform, options } = this\n\n        const addsQuestionToken = options.optionalType === 'questionToken' || options.optionalType === 'questionTokenAndUndefined'\n\n        const propertyNodes: Array<factory.TsNode> = mapSchemaProperties(node, (schema) => transform(schema)).map(({ name, property, output }) => {\n          const baseType = output ?? factory.keywordTypeNodes.unknown\n          const optional = !property.required || !!property.schema.optional || !!property.schema.nullish\n          const type = factory.buildPropertyType(property.schema, baseType, options.optionalType, optional)\n          const propMeta = syncSchemaRef(property.schema)\n\n          const propertyNode = factory.createPropertySignature({\n            questionToken: optional ? addsQuestionToken : false,\n            name,\n            type,\n            readOnly: propMeta?.readOnly,\n          })\n\n          return factory.appendJSDocToNode({ node: propertyNode, comments: buildPropertyJSDocComments(property.schema, optional) })\n        })\n\n        const allElements = [...propertyNodes, ...factory.buildIndexSignatures(node, propertyNodes.length, transform)]\n\n        if (!allElements.length) {\n          return factory.keywordTypeNodes.object\n        }\n\n        return factory.createTypeLiteralNode(allElements)\n      },\n      ...toNodeHandlers(options.nodes),\n    },\n    print(node) {\n      const { name, syntaxType = 'type', description, keysToOmit } = this.options\n\n      const transformed = this.transform(node)\n      if (!transformed) return null\n\n      // For ref nodes, structural metadata lives on node.schema rather than the ref node itself.\n      const meta = syncSchemaRef(node)\n\n      // Without name, apply modifiers inline and return.\n      if (!name) {\n        return factory.print(factory.wrapNullableOptional(transformed, !!meta.nullable, !!(meta.nullish || meta.optional) && addsUndefined))\n      }\n\n      // When keysToOmit is present, wrap with Omit first, then apply nullable/optional\n      // modifiers so they are not swallowed by NonNullable inside createOmitDeclaration.\n      const inner = (() => {\n        const omitted = keysToOmit?.length ? factory.createOmitDeclaration({ keys: keysToOmit, type: transformed, nonNullable: true }) : transformed\n        // For named type declarations (type aliases), optional/nullish always produces | undefined\n        // regardless of optionalType — the questionToken ? modifier only applies to object properties.\n        return factory.wrapNullableOptional(omitted, !!meta.nullable, !!(meta.nullish || meta.optional))\n      })()\n\n      const useTypeGeneration = syntaxType === 'type' || !!keysToOmit?.length\n\n      return factory.createTypeDeclaration({\n        name,\n        isExportable: true,\n        type: inner,\n        syntax: useTypeGeneration ? 'type' : 'interface',\n        comments: buildPropertyJSDocComments({\n          ...meta,\n          description,\n        }),\n      })\n    },\n  }\n})\n","import { buildOptionsSchema, buildResponses, getOperationParameters, resolveContentTypeVariants } from '@internals/shared'\nimport { ast, defineGenerator } from 'kubb/kit'\nimport { File, jsxRenderer } from 'kubb/jsx'\nimport { Type } from '../components/Type.tsx'\nimport { printerTs } from '../printers/printerTs.ts'\nimport type { PluginTs } from '../types'\nimport { buildParams, buildResponseUnion, enumTypeName, isInlineConstEnum } from '../utils.ts'\n\n/**\n * Built-in generator for `@kubb/plugin-ts`. Emits one TypeScript file per\n * schema in the spec plus per-operation request, response, and parameter\n * types. Drop-replace with a custom `Generator<PluginTs>` to change how\n * TypeScript output is produced.\n */\nexport const typeGenerator = defineGenerator<PluginTs>({\n  name: 'typescript',\n  renderer: jsxRenderer,\n  schema(node, ctx) {\n    const { enum: enumOptions, syntaxType, optionalType, arrayType, output, group, printer } = ctx.options\n    const { config, resolver, root } = ctx\n\n    if (!node.name) {\n      return\n    }\n    // Build a set of schema names that are enums so the ref handler and the imports\n    // name callback can use the suffixed type name (e.g. `StatusKey`) for those refs.\n    const enumSchemaNames = new Set<string>(ctx.meta.enumNames)\n    const importName = (schemaName: string) => enumTypeName({ resolver, name: schemaName, enumOptions, isEnum: enumSchemaNames.has(schemaName) })\n\n    const imports = resolver.imports({ node, root, output, group: group ?? undefined, name: importName })\n\n    const enumNode = ast.narrowSchema(node, ast.schemaTypes.enum)\n    // An inline `const` (single-value enum the adapter did not register) renders as a literal type,\n    // so it keeps its plain name instead of the suffixed enum-key name.\n    const isEnumSchema = !!enumNode && !isInlineConstEnum(enumNode, enumSchemaNames)\n\n    const meta = {\n      name: enumOptions.type === 'asConst' && isEnumSchema ? resolver.enum.keyName(node, enumOptions.typeSuffix) : resolver.name(node.name),\n      file: resolver.file({ name: node.name, extname: '.ts', root, output, group: group ?? undefined }),\n    } as const\n\n    const schemaPrinter = printerTs({\n      optionalType,\n      arrayType,\n      enum: enumOptions,\n      name: meta.name,\n      syntaxType,\n      description: node.description,\n      resolver,\n      enumSchemaNames,\n      nodes: printer?.nodes,\n    })\n\n    return (\n      <File\n        baseName={meta.file.baseName}\n        path={meta.file.path}\n        meta={meta.file.meta}\n        banner={resolver.default.banner(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}\n        footer={resolver.default.footer(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}\n      >\n        {imports.map((imp) => (\n          <File.Import key={[node.name, imp.path, imp.isTypeOnly].join('-')} root={meta.file.path} path={imp.path} name={imp.name} isTypeOnly />\n        ))}\n        <Type name={meta.name} node={node} enum={enumOptions} resolver={resolver} printer={schemaPrinter} />\n      </File>\n    )\n  },\n  operation(node, ctx) {\n    const { enum: enumOptions, optionalType, arrayType, syntaxType, group, output, printer } = ctx.options\n    const { config, resolver, root } = ctx\n\n    const meta = {\n      file: resolver.file({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path, root, output, group: group ?? undefined }),\n    } as const\n\n    // Build a set of schema names that are enums so the ref handler and the imports\n    // name callback can use the suffixed type name (e.g. `StatusKey`) for those refs.\n    const enumSchemaNames = new Set<string>(ctx.meta.enumNames)\n    const importName = (schemaName: string) => enumTypeName({ resolver, name: schemaName, enumOptions, isEnum: enumSchemaNames.has(schemaName) })\n\n    function renderSchemaType({ schema, name, keysToOmit }: { schema: ast.SchemaNode | null; name: string; keysToOmit?: Array<string> | null }) {\n      if (!schema) return null\n\n      const imports = resolver.imports({ node: schema, root, output, group: group ?? undefined, name: importName })\n\n      const schemaPrinter = printerTs({\n        optionalType,\n        arrayType,\n        enum: enumOptions,\n        name,\n        syntaxType,\n        description: schema.description,\n        keysToOmit,\n        resolver,\n        enumSchemaNames,\n        nodes: printer?.nodes,\n      })\n\n      return (\n        <>\n          {imports.map((imp) => (\n            <File.Import key={[name, imp.path, imp.isTypeOnly].join('-')} root={meta.file.path} path={imp.path} name={imp.name} isTypeOnly />\n          ))}\n          <Type name={name} node={schema} enum={enumOptions} resolver={resolver} printer={schemaPrinter} />\n        </>\n      )\n    }\n\n    /**\n     * Emits an individual type per content type plus a plain union alias under `baseName`. Shared by\n     * the request body and multi-content-type responses. The response record discriminates these\n     * variants by content type in {@link buildResponses}; the standalone alias stays a plain union so\n     * query hooks and `result.data` keep the bare body.\n     */\n    function buildContentTypeVariants(\n      entries: Array<{ contentType: string; schema?: ast.SchemaNode | null; keysToOmit?: Array<string> | null }>,\n      baseName: string,\n      pointer: string | undefined,\n      decorate?: (schema: ast.SchemaNode) => ast.SchemaNode,\n    ) {\n      const variants = resolveContentTypeVariants(entries, baseName)\n      const unionSchema = ast.factory.createSchema({\n        type: 'union',\n        pointer,\n        members: variants.map((variant) => ast.factory.createSchema({ type: 'ref', name: variant.name })),\n      })\n      return (\n        <>\n          {variants.map((variant) =>\n            renderSchemaType({\n              schema: decorate ? decorate(variant.schema) : variant.schema,\n              name: variant.name,\n              keysToOmit: variant.keysToOmit,\n            }),\n          )}\n          {renderSchemaType({ schema: unionSchema, name: baseName })}\n        </>\n      )\n    }\n\n    const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node)\n\n    const paramGroupTypes = [\n      pathParams.length > 0 && renderSchemaType({ schema: buildParams({ params: pathParams }), name: resolver.param.path(node, pathParams[0]!) }),\n      queryParams.length > 0 && renderSchemaType({ schema: buildParams({ params: queryParams }), name: resolver.param.query(node, queryParams[0]!) }),\n      headerParams.length > 0 && renderSchemaType({ schema: buildParams({ params: headerParams }), name: resolver.param.headers(node, headerParams[0]!) }),\n    ]\n\n    const requestBodyContent = node.requestBody?.content ?? []\n\n    function buildRequestType() {\n      if (requestBodyContent.length === 0) return null\n      if (requestBodyContent.length === 1) {\n        const entry = requestBodyContent[0]!\n        if (!entry.schema) return null\n        return renderSchemaType({\n          schema: {\n            ...entry.schema,\n            pointer: node.requestBody!.pointer ?? entry.schema.pointer,\n            description: node.requestBody!.description ?? entry.schema.description,\n          },\n          name: resolver.response.body(node),\n          keysToOmit: entry.keysToOmit,\n        })\n      }\n      // Multiple content types — generate individual types + union alias\n      return buildContentTypeVariants(requestBodyContent, resolver.response.body(node), node.requestBody!.pointer, (schema) => ({\n        ...schema,\n        description: node.requestBody!.description ?? schema.description,\n      }))\n    }\n\n    const requestType = buildRequestType()\n\n    const responseTypes = node.responses.map((res) => {\n      const variants = (res.content ?? []).filter((entry) => entry.schema)\n      // Multiple content types for a single status code — generate per-variant types + a plain union.\n      // The `<Name>Responses` record discriminates them by content type (see buildResponses).\n      if (variants.length > 1) {\n        return buildContentTypeVariants(variants, resolver.response.status(node, res.statusCode), res.pointer)\n      }\n      const primary = variants[0] ?? res.content?.[0]\n      return renderSchemaType({\n        schema: primary?.schema ? { ...primary.schema, pointer: res.pointer ?? primary.schema.pointer } : null,\n        name: resolver.response.status(node, res.statusCode),\n        keysToOmit: primary?.keysToOmit,\n      })\n    })\n\n    const optionsType = renderSchemaType({\n      schema: buildOptionsSchema(node, resolver),\n      name: resolver.response.options(node),\n    })\n\n    const responsesType = renderSchemaType({\n      schema: buildResponses(node, resolver),\n      name: resolver.response.responses(node),\n    })\n\n    function buildResponseType() {\n      const hasSchema = (res: ast.ResponseNode) => (res.content ?? []).some((entry) => entry.schema)\n      if (!node.responses.some(hasSchema)) {\n        return null\n      }\n\n      const responseName = resolver.response.response(node)\n\n      const responsesWithSchema = node.responses.filter(hasSchema)\n      const importedNames = new Set(\n        responsesWithSchema.flatMap((res) =>\n          (res.content ?? []).flatMap((entry) => (entry.schema ? ast.collectImportedRefNames(entry.schema).map(importName) : [])),\n        ),\n      )\n\n      if (importedNames.has(responseName)) {\n        return null\n      }\n\n      return renderSchemaType({\n        schema: {\n          ...buildResponseUnion(node, { resolver })!,\n          description: 'Union of all possible responses',\n        },\n        name: responseName,\n      })\n    }\n\n    const responseType = buildResponseType()\n\n    return (\n      <File\n        baseName={meta.file.baseName}\n        path={meta.file.path}\n        meta={meta.file.meta}\n        banner={resolver.default.banner(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}\n        footer={resolver.default.footer(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}\n      >\n        {paramGroupTypes}\n        {responseTypes}\n        {requestType}\n        {optionsType}\n        {responsesType}\n        {responseType}\n      </File>\n    )\n  },\n})\n","","","import { createCasedFile, createOperationParamResolver, createOperationResponseResolver } from '@internals/shared'\nimport { ensureValidVarName, pascalCase } from '@internals/utils'\nimport { createResolver } from 'kubb/kit'\nimport type { PluginTs } from '../types.ts'\n\n/**\n * Default resolver used by `@kubb/plugin-ts`. Decides the names and file paths\n * for every generated TypeScript type. Import this in other plugins that need\n * to reference the exact names `plugin-ts` produces without duplicating the\n * casing/file-layout rules.\n *\n * The `default` helpers are supplied by `createResolver`. This plugin overrides the top-level `name`\n * to use PascalCase for value and type names and `file` to write PascalCase file paths (dotted names\n * become `/`-joined), and groups the operation-specific naming under the `param`, `response`, and\n * `enum` namespaces.\n *\n * @example Resolve a type and file name\n * ```ts\n * import { resolverTs } from '@kubb/plugin-ts'\n *\n * resolverTs.name('list pets')                     // 'ListPets'\n * resolverTs.response.status(node, 200)            // 'ListPetsStatus200'\n * ```\n */\nexport const resolverTs = createResolver<PluginTs>({\n  pluginName: 'plugin-ts',\n  name(name) {\n    return ensureValidVarName(pascalCase(name))\n  },\n  file: createCasedFile(pascalCase),\n  param: createOperationParamResolver(),\n  response: {\n    ...createOperationResponseResolver(),\n    options(node) {\n      return this.name(`${node.operationId} Options`)\n    },\n  },\n  enum: {\n    keyName(node, enumTypeSuffix = 'key') {\n      return `${this.name(node.name ?? '')}${enumTypeSuffix}`\n    },\n  },\n})\n","import { createGroupConfig } from '@internals/shared'\nimport { addGenerator, defineExtension, Resolver, setMacros, setResolver } from 'kubb/kit'\nimport { compatibility } from '../kubb-extension.json'\nimport { version } from '../package.json'\nimport { typeGenerator } from './generators/typeGenerator.tsx'\nimport { resolverTs } from './resolvers/resolverTs.ts'\nimport type { PluginTs } from './types.ts'\n\n/**\n * Canonical plugin name for `@kubb/plugin-ts`. Used for driver lookups and\n * cross-plugin dependency references.\n */\nexport const pluginTsName = 'plugin-ts' satisfies PluginTs['name']\n\n/**\n * Generates TypeScript `type` aliases and `interface` declarations from an\n * OpenAPI spec. The foundation that every other Kubb plugin builds on:\n * clients, query hooks, mocks, and validators all reference the names this\n * plugin produces.\n *\n * @example\n * ```ts\n * import { defineConfig } from 'kubb/config'\n * import { pluginTs } from '@kubb/plugin-ts'\n *\n * export default defineConfig({\n *   input: './petStore.yaml',\n *   output: { path: './src/gen' },\n *   plugins: [\n *     pluginTs({\n *       output: { path: './types' },\n *       enum: { type: 'asConst' },\n *       optionalType: 'questionTokenAndUndefined',\n *     }),\n *   ],\n * })\n * ```\n */\nexport const pluginTs = defineExtension<PluginTs>({\n  kind: 'plugin',\n  meta: { name: pluginTsName, version, compatibility },\n  setup(options) {\n    const {\n      output = { path: 'types', barrel: { type: 'named' } },\n      group,\n      exclude = [],\n      include,\n      override = [],\n      enum: enumOptions = {},\n      optionalType = 'questionToken',\n      arrayType = 'array',\n      syntaxType = 'type',\n      printer,\n      resolver: userResolver,\n      macros: userMacros,\n    } = options\n\n    const resolvedEnum = {\n      type: enumOptions.type ?? 'asConst',\n      constCasing: enumOptions.constCasing ?? 'camelCase',\n      typeSuffix: enumOptions.typeSuffix ?? 'Key',\n      keyCasing: enumOptions.keyCasing ?? 'none',\n    }\n\n    setResolver(userResolver ? Resolver.merge(resolverTs, userResolver) : resolverTs)\n    if (userMacros?.length) {\n      setMacros(userMacros)\n    }\n    addGenerator(typeGenerator)\n\n    return {\n      output,\n      exclude,\n      include,\n      override,\n      optionalType,\n      group: createGroupConfig(group),\n      arrayType,\n      enum: resolvedEnum,\n      syntaxType,\n      printer,\n    }\n  },\n})\n\nexport default pluginTs\n","/**\n * A type expression used as a function parameter type annotation.\n *\n * - a plain `string` is a type reference rendered as-is, e.g. `'string'`, `'QueryParams'`, `'Partial<Config>'`\n * - a {@link TypeLiteralNode} is an inline anonymous type, e.g. `{ petId: string; name?: string }`\n * - an {@link IndexedAccessTypeNode} is a single field accessed from a named type, e.g. `PathParams['petId']`\n */\nexport type TypeExpression = string | TypeLiteralNode | IndexedAccessTypeNode\n\n/**\n * An inline anonymous object type grouping named fields.\n * Renders as `{ key: Type; other?: OtherType }`.\n */\nexport type TypeLiteralNode = {\n  kind: 'TypeLiteral'\n  /**\n   * Members of the object type, rendered in order.\n   */\n  members: Array<{\n    /**\n     * Member key.\n     */\n    name: string\n    /**\n     * Member type expression.\n     */\n    type: TypeExpression\n    /**\n     * Whether the member is optional, rendered with `?`.\n     */\n    optional?: boolean\n  }>\n}\n\n/**\n * A single field accessed from a named group type. Renders as `target['key']`.\n */\nexport type IndexedAccessTypeNode = {\n  kind: 'IndexedAccessType'\n  /**\n   * Name of the type being indexed, e.g. `'GetPetPathParams'`.\n   */\n  target: string\n  /**\n   * Field key to access, e.g. `'petId'`.\n   */\n  key: string\n}\n\n/**\n * An object destructuring binding, used as the name of a grouped function parameter.\n * Renders as `{ id, name }` or `{ id: renamed }` when `propertyName` differs.\n */\nexport type ObjectBindingPatternNode = {\n  kind: 'ObjectBindingPattern'\n  /**\n   * Bound elements, rendered in order.\n   */\n  elements: Array<{\n    /**\n     * Local binding name.\n     */\n    name: string\n    /**\n     * Source key when it differs from the binding name, rendered as `propertyName: name`.\n     */\n    propertyName?: string\n  }>\n}\n\n/**\n * One function parameter.\n *\n * A simple parameter has a `string` name. A destructured group has an\n * {@link ObjectBindingPatternNode} name paired with a {@link TypeLiteralNode} type.\n *\n * @example Required parameter\n * `name: Type`\n *\n * @example Optional parameter\n * `name?: Type`\n *\n * @example Parameter with default value\n * `name: Type = defaultValue`\n *\n * @example Rest parameter\n * `...name: Type[]`\n *\n * @example Destructured group\n * `{ id, name? }: { id: string; name?: string } = {}`\n */\nexport type FunctionParameterNode = {\n  kind: 'FunctionParameter'\n  /**\n   * Parameter name, or an {@link ObjectBindingPatternNode} for a destructured group.\n   */\n  name: string | ObjectBindingPatternNode\n  /**\n   * Type annotation as a {@link TypeExpression}. Omit for untyped output.\n   */\n  type?: TypeExpression\n  /**\n   * Whether the parameter is optional, rendered with `?`.\n   */\n  optional?: boolean\n  /**\n   * Default value, written verbatim after `=`. Commonly `'{}'` for a destructured group.\n   */\n  default?: string\n  /**\n   * When `true` the parameter is emitted as a rest parameter, e.g. `...name: Type[]`.\n   */\n  rest?: boolean\n}\n\n/**\n * A complete function parameter list.\n *\n * Printers are responsible for sorting (`required` → `optional` → `defaulted`).\n */\nexport type FunctionParametersNode = {\n  kind: 'FunctionParameters'\n  /**\n   * Ordered parameter nodes.\n   */\n  params: ReadonlyArray<FunctionParameterNode>\n}\n\n/**\n * Narrows a {@link TypeExpression} to a {@link TypeLiteralNode}.\n */\nexport function isTypeLiteral(type: TypeExpression): type is TypeLiteralNode {\n  return typeof type !== 'string' && type.kind === 'TypeLiteral'\n}\n\n/**\n * Narrows a {@link TypeExpression} to an {@link IndexedAccessTypeNode}.\n */\nexport function isIndexedAccessType(type: TypeExpression): type is IndexedAccessTypeNode {\n  return typeof type !== 'string' && type.kind === 'IndexedAccessType'\n}\n\n/**\n * Creates a {@link TypeLiteralNode} representing an inline anonymous object type.\n *\n * @example\n * ```ts\n * createTypeLiteral({ members: [{ name: 'petId', type: 'string', optional: false }] })\n * // { petId: string }\n * ```\n */\nexport function createTypeLiteral(props: Omit<TypeLiteralNode, 'kind'>): TypeLiteralNode {\n  return { kind: 'TypeLiteral', ...props }\n}\n\n/**\n * Creates an {@link IndexedAccessTypeNode} representing a single field accessed from a named type.\n *\n * @example\n * ```ts\n * createIndexedAccessType({ target: 'DeletePetPathParams', key: 'petId' })\n * // DeletePetPathParams['petId']\n * ```\n */\nexport function createIndexedAccessType(props: Omit<IndexedAccessTypeNode, 'kind'>): IndexedAccessTypeNode {\n  return { kind: 'IndexedAccessType', ...props }\n}\n\n/**\n * Creates an {@link ObjectBindingPatternNode} for a destructured parameter binding.\n *\n * @example\n * ```ts\n * createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })\n * // { id, name }\n * ```\n */\nexport function createObjectBindingPattern(props: Omit<ObjectBindingPatternNode, 'kind'>): ObjectBindingPatternNode {\n  return { kind: 'ObjectBindingPattern', ...props }\n}\n\n/**\n * Plain property descriptor for a destructured group built by {@link createFunctionParameter}.\n */\ntype FunctionParameterProperty = {\n  name: string\n  type: TypeExpression\n  optional?: boolean\n}\n\ntype FunctionParameterInput =\n  | { name: string | ObjectBindingPatternNode; type?: TypeExpression; optional?: boolean; default?: string; rest?: boolean }\n  | { properties: Array<FunctionParameterProperty>; optional?: boolean; default?: string }\n\n/**\n * Creates a {@link FunctionParameterNode}. `optional` defaults to `false`.\n * Passing `properties` builds a destructured group: an {@link ObjectBindingPatternNode} name\n * paired with a {@link TypeLiteralNode} type.\n *\n * @example Optional param\n * ```ts\n * createFunctionParameter({ name: 'params', type: 'QueryParams', optional: true })\n * // → params?: QueryParams\n * ```\n *\n * @example Destructured group\n * ```ts\n * createFunctionParameter({ properties: [{ name: 'id', type: 'string' }, { name: 'name', type: 'string', optional: true }], default: '{}' })\n * // → { id, name }: { id: string; name?: string } = {}\n * ```\n */\nexport function createFunctionParameter(input: FunctionParameterInput): FunctionParameterNode {\n  if ('properties' in input) {\n    return {\n      kind: 'FunctionParameter',\n      name: createObjectBindingPattern({ elements: input.properties.map((p) => ({ name: p.name })) }),\n      type: createTypeLiteral({ members: input.properties.map((p) => ({ name: p.name, type: p.type, optional: p.optional ?? false })) }),\n      optional: input.optional ?? false,\n      ...(input.default !== undefined ? { default: input.default } : {}),\n    }\n  }\n  return { kind: 'FunctionParameter', optional: false, ...input }\n}\n\n/**\n * Creates a {@link FunctionParametersNode} from an ordered list of parameters.\n *\n * @example\n * ```ts\n * const empty = createFunctionParameters()\n * // { params: [] }\n * ```\n */\nexport function createFunctionParameters(props: Partial<Omit<FunctionParametersNode, 'kind'>> = {}): FunctionParametersNode {\n  return { kind: 'FunctionParameters', params: [], ...props }\n}\n","/**\n * Ordering priority for function parameters: lower = sorted earlier.\n */\nconst PARAM_RANK = { required: 0, optional: 1, withDefault: 2, rest: 3 } as const\n\nimport { isIndexedAccessType, isTypeLiteral } from './functionParams.ts'\nimport type { FunctionParameterNode, FunctionParametersNode, ObjectBindingPatternNode, TypeExpression } from './functionParams.ts'\n\n/**\n * Renders a {@link TypeExpression} to its TypeScript source.\n *\n * - a `string` is a type reference, returned as-is\n * - an `IndexedAccessType` becomes `objectType['indexType']`\n * - a `TypeLiteral` becomes `{ key: Type; key?: Type }`\n *\n * `transformType` is applied once to the fully rendered type, matching how the\n * printer wrapped reference types before the `ts.factory` model.\n */\nexport function renderType(type: TypeExpression, transformType?: (type: string) => string): string {\n  const rendered = renderTypeExpression(type)\n  return transformType ? transformType(rendered) : rendered\n}\n\n/**\n * Renders an object-type key, quoting it as a string literal when it is not a valid\n * identifier so `{ 'content-type': string }` stays valid TypeScript.\n */\nfunction renderKey(name: string): string {\n  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : JSON.stringify(name)\n}\n\nfunction renderMembers(members: Array<{ key: string; type: string; optional?: boolean }>): string {\n  return `{ ${members.map((member) => `${renderKey(member.key)}${member.optional ? '?' : ''}: ${member.type}`).join('; ')} }`\n}\n\nfunction renderTypeExpression(type: TypeExpression): string {\n  if (typeof type === 'string') return type\n  if (isIndexedAccessType(type)) return `${type.target}['${type.key}']`\n\n  return renderMembers(type.members.map((member) => ({ key: member.name, type: renderTypeExpression(member.type), optional: member.optional })))\n}\n\nexport type FunctionPrinterOptions = {\n  /**\n   * Rendering modes supported by `functionPrinter`.\n   *\n   * | Mode          | Output example                    | Use case                       |\n   * |---------------|-----------------------------------|--------------------------------|\n   * | `declaration` | `id: string, config: Config = {}` | Function parameter declaration |\n   * | `call`        | `id, { method, url }`             | Function call arguments        |\n   */\n  mode: 'declaration' | 'call'\n  /**\n   * Optional transformation applied to every parameter name before printing.\n   */\n  transformName?: (name: string) => string\n  /**\n   * Optional transformation applied to every type string before printing.\n   */\n  transformType?: (type: string) => string\n}\n\nfunction groupMembers(param: FunctionParameterNode): ReadonlyArray<{ name: string; optional?: boolean }> | null {\n  if (typeof param.name === 'string') return null\n  return param.type && isTypeLiteral(param.type) ? param.type.members : []\n}\n\nfunction rank(param: FunctionParameterNode): number {\n  if (param.rest) return PARAM_RANK.rest\n  if (param.default) return PARAM_RANK.withDefault\n  const members = groupMembers(param)\n  if (members) return members.every((m) => m.optional) ? PARAM_RANK.optional : PARAM_RANK.required\n  return param.optional ? PARAM_RANK.optional : PARAM_RANK.required\n}\n\n/**\n * Orders a destructured group's binding elements and type members together,\n * required fields first, matching how grouped children were sorted before.\n */\ntype GroupMember = { name: string; propertyName?: string; type?: TypeExpression; optional?: boolean }\n\nfunction sortedGroupMembers(name: ObjectBindingPatternNode, type: TypeExpression | undefined): Array<GroupMember> {\n  const members = type && isTypeLiteral(type) ? type.members : []\n  const memberRank = (optional?: boolean) => (optional ? PARAM_RANK.optional : PARAM_RANK.required)\n  return name.elements\n    .map((element, index) => ({\n      name: element.name,\n      propertyName: element.propertyName,\n      type: members[index]?.type,\n      optional: members[index]?.optional,\n    }))\n    .toSorted((a, b) => memberRank(a.optional) - memberRank(b.optional))\n}\n\n/**\n * Renders one binding element: the local name, prefixed with its source key when the\n * binding renames the property, as in `{ petId: id }`.\n */\nfunction renderBindingMember(member: GroupMember, transformName?: (name: string) => string): string {\n  const local = transformName ? transformName(member.name) : member.name\n  return member.propertyName ? `${member.propertyName}: ${local}` : local\n}\n\n/**\n * Renders the type annotation of a destructured group. An inline object type is\n * rendered from the already-sorted members so its key order matches the binding;\n * a reference type is rendered as-is.\n */\nfunction renderGroupType(type: TypeExpression | undefined, sorted: Array<GroupMember>, transformType?: (type: string) => string): string | undefined {\n  if (!type) return undefined\n  if (!isTypeLiteral(type)) return renderType(type)\n\n  const typed = sorted.filter((member) => member.type !== undefined)\n  if (!typed.length) return undefined\n  return renderMembers(\n    typed.map((member) => ({ key: member.propertyName ?? member.name, type: renderType(member.type!, transformType), optional: member.optional })),\n  )\n}\n\nfunction printParameter(node: FunctionParameterNode, options: FunctionPrinterOptions): string {\n  const { mode, transformName, transformType } = options\n  const bindingName = node.name\n\n  if (mode === 'call') {\n    if (typeof bindingName !== 'string') {\n      const keys = sortedGroupMembers(bindingName, node.type)\n        .map((member) => renderBindingMember(member))\n        .join(', ')\n      return `{ ${keys} }`\n    }\n    const name = transformName ? transformName(bindingName) : bindingName\n    return node.rest ? `...${name}` : name\n  }\n\n  if (typeof bindingName !== 'string') {\n    const sorted = sortedGroupMembers(bindingName, node.type)\n    const binding = `{ ${sorted.map((member) => renderBindingMember(member, transformName)).join(', ')} }`\n    const allOptional = sorted.every((member) => member.optional)\n    const type = renderGroupType(node.type, sorted, transformType)\n    if (type) {\n      if (allOptional) return `${binding}: ${type} = ${node.default ?? '{}'}`\n      return node.default ? `${binding}: ${type} = ${node.default}` : `${binding}: ${type}`\n    }\n    return node.default ? `${binding} = ${node.default}` : binding\n  }\n\n  const name = transformName ? transformName(bindingName) : bindingName\n  const type = node.type ? renderType(node.type, transformType) : undefined\n\n  if (node.rest) {\n    return type ? `...${name}: ${type}` : `...${name}`\n  }\n  if (type) {\n    if (node.optional) return `${name}?: ${type}`\n    return node.default ? `${name}: ${type} = ${node.default}` : `${name}: ${type}`\n  }\n  return node.default ? `${name} = ${node.default}` : name\n}\n\n/**\n * Default function-signature printer. Renders a parameter list in one of two modes:\n * `declaration` for the function signature and `call` for the call arguments.\n *\n * @example\n * ```ts\n * const printer = functionPrinter({ mode: 'declaration' })\n *\n * const sig = createFunctionParameters({\n *   params: [\n *     createFunctionParameter({ name: 'petId', type: 'string', optional: false }),\n *     createFunctionParameter({ name: 'config', type: 'Config', optional: false, default: '{}' }),\n *   ],\n * })\n *\n * printer.print(sig)  // → \"petId: string, config: Config = {}\"\n * ```\n */\nexport function functionPrinter(options: FunctionPrinterOptions) {\n  return {\n    name: 'functionParameters' as const,\n    options,\n    print(node: FunctionParametersNode): string {\n      // `toSorted` is a stable sort, so equal-rank params keep their declared order.\n      return node.params\n        .toSorted((a, b) => rank(a) - rank(b))\n        .map((p) => printParameter(p, options))\n        .filter(Boolean)\n        .join(', ')\n    },\n  }\n}\n"],"mappings":"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"}