@kubb/plugin-ts 5.0.0-alpha.22 → 5.0.0-alpha.23

package/src/generators/typeGeneratorLegacy.tsx

@@ -47,20 +47,20 @@ function buildLegacyResponsesSchemaNode({ node, resolver }: BuildOperationSchema
   const responseSchema =
     successResponses.length > 0
       ? successResponses.length === 1
-        ? createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, successResponses[0]!.statusCode) })
+        ? createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, successResponses[0]!.statusCode) })
         : createSchema({
             type: 'union',
-            members: successResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, res.statusCode) })),
+            members: successResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
           })
       : createSchema({ type: 'any' })
 
   const errorsSchema =
     errorResponses.length > 0
       ? errorResponses.length === 1
-        ? createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, errorResponses[0]!.statusCode) })
+        ? createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, errorResponses[0]!.statusCode) })
         : createSchema({
             type: 'union',
-            members: errorResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, res.statusCode) })),
+            members: errorResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
           })
       : createSchema({ type: 'any' })
 
@@ -71,37 +71,40 @@ function buildLegacyResponsesSchemaNode({ node, resolver }: BuildOperationSchema
       createProperty({
         name: 'Request',
         required: true,
-        schema: createSchema({ type: 'ref', name: resolver.resolveDataTypedName(node) }),
+        schema: createSchema({ type: 'ref', name: resolver.resolveDataName(node) }),
       }),
     )
   }
 
-  if (node.parameters.some((p) => p.in === 'query') && resolver.resolveQueryParamsTypedName) {
+  const queryParam = node.parameters.find((p) => p.in === 'query')
+  if (queryParam) {
     properties.push(
       createProperty({
         name: 'QueryParams',
         required: true,
-        schema: createSchema({ type: 'ref', name: resolver.resolveQueryParamsTypedName(node) }),
+        schema: createSchema({ type: 'ref', name: resolver.resolveQueryParamsName(node, queryParam) }),
       }),
     )
   }
 
-  if (node.parameters.some((p) => p.in === 'path') && resolver.resolvePathParamsTypedName) {
+  const pathParam = node.parameters.find((p) => p.in === 'path')
+  if (pathParam) {
     properties.push(
       createProperty({
         name: 'PathParams',
         required: true,
-        schema: createSchema({ type: 'ref', name: resolver.resolvePathParamsTypedName(node) }),
+        schema: createSchema({ type: 'ref', name: resolver.resolvePathParamsName(node, pathParam) }),
       }),
     )
   }
 
-  if (node.parameters.some((p) => p.in === 'header') && resolver.resolveHeaderParamsTypedName) {
+  const headerParam = node.parameters.find((p) => p.in === 'header')
+  if (headerParam) {
     properties.push(
       createProperty({
         name: 'HeaderParams',
         required: true,
-        schema: createSchema({ type: 'ref', name: resolver.resolveHeaderParamsTypedName(node) }),
+        schema: createSchema({ type: 'ref', name: resolver.resolveHeaderParamsName(node, headerParam) }),
       }),
     )
   }
@@ -122,12 +125,12 @@ function buildLegacyResponseUnionSchemaNode({ node, resolver }: BuildOperationSc
   }
 
   if (successResponses.length === 1) {
-    return createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, successResponses[0]!.statusCode) })
+    return createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, successResponses[0]!.statusCode) })
   }
 
   return createSchema({
     type: 'union',
-    members: successResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, res.statusCode) })),
+    members: successResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
   })
 }
 
@@ -156,8 +159,8 @@ function nameUnnamedEnums(node: SchemaNode, parentName: string): SchemaNode {
 export const typeGeneratorLegacy = defineGenerator<PluginTs>({
   name: 'typescript-legacy',
   type: 'react',
-  Operation({ node, adapter, options, config }) {
-    const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, resolver, transformers = [] } = options
+  Operation({ node, adapter, options, config, resolver }) {
+    const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, transformers = [] } = options
 
     const root = path.resolve(config.root, config.output.path)
     const mode = getMode(path.resolve(root, output.path))
@@ -168,13 +171,11 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
     function renderSchemaType({
       node: schemaNode,
       name,
-      typedName,
       description,
       keysToOmit,
     }: {
       node: SchemaNode | null
       name: string
-      typedName: string
       description?: string
       keysToOmit?: Array<string>
     }) {
@@ -195,7 +196,6 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
             imports.map((imp) => <File.Import key={[name, imp.path, imp.isTypeOnly].join('-')} root={file.path} path={imp.path} name={imp.name} isTypeOnly />)}
           <Type
             name={name}
-            typedName={typedName}
             node={transformedNode}
             description={description}
             enumType={enumType}
@@ -222,7 +222,6 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
       return renderSchemaType({
         node: res.schema ? nameUnnamedEnums(res.schema, baseResponseName) : res.schema,
         name: responseName,
-        typedName: resolver.resolveResponseStatusTypedName(node, res.statusCode),
         description: res.description,
         keysToOmit: res.keysToOmit,
       })
@@ -232,7 +231,6 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
       ? renderSchemaType({
           node: nameUnnamedEnums(node.requestBody.schema, resolverTsLegacy.resolveDataName(node)),
           name: resolver.resolveDataName(node),
-          typedName: resolver.resolveDataTypedName(node),
           description: node.requestBody.description ?? node.requestBody.schema.description,
           keysToOmit: node.requestBody.keysToOmit,
         })
@@ -241,23 +239,20 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
     const legacyParamTypes = [
       pathParams.length > 0
         ? renderSchemaType({
-            node: buildGroupedParamsSchema({ params: pathParams, parentName: resolverTsLegacy.resolvePathParamsName!(node) }),
-            name: resolver.resolvePathParamsName!(node),
-            typedName: resolver.resolvePathParamsTypedName!(node),
+            node: buildGroupedParamsSchema({ params: pathParams, parentName: resolverTsLegacy.resolvePathParamsName(node, pathParams[0]!) }),
+            name: resolver.resolvePathParamsName(node, pathParams[0]!),
           })
         : null,
       queryParams.length > 0
         ? renderSchemaType({
-            node: buildGroupedParamsSchema({ params: queryParams, parentName: resolverTsLegacy.resolveQueryParamsName!(node) }),
-            name: resolver.resolveQueryParamsName!(node),
-            typedName: resolver.resolveQueryParamsTypedName!(node),
+            node: buildGroupedParamsSchema({ params: queryParams, parentName: resolverTsLegacy.resolveQueryParamsName(node, queryParams[0]!) }),
+            name: resolver.resolveQueryParamsName(node, queryParams[0]!),
           })
         : null,
       headerParams.length > 0
         ? renderSchemaType({
-            node: buildGroupedParamsSchema({ params: headerParams, parentName: resolverTsLegacy.resolveHeaderParamsName!(node) }),
-            name: resolver.resolveHeaderParamsName!(node),
-            typedName: resolver.resolveHeaderParamsTypedName!(node),
+            node: buildGroupedParamsSchema({ params: headerParams, parentName: resolverTsLegacy.resolveHeaderParamsName(node, headerParams[0]!) }),
+            name: resolver.resolveHeaderParamsName(node, headerParams[0]!),
           })
         : null,
     ]
@@ -265,13 +260,11 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
     const legacyResponsesType = renderSchemaType({
       node: buildLegacyResponsesSchemaNode({ node, resolver }),
       name: resolver.resolveResponsesName(node),
-      typedName: resolver.resolveResponsesTypedName(node),
     })
 
     const legacyResponseType = renderSchemaType({
       node: buildLegacyResponseUnionSchemaNode({ node, resolver }),
       name: resolver.resolveResponseName(node),
-      typedName: resolver.resolveResponseTypedName(node),
     })
 
     return (
@@ -290,8 +283,8 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
       </File>
     )
   },
-  Schema({ node, adapter, options, config }) {
-    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, resolver, transformers = [] } = options
+  Schema({ node, adapter, options, config, resolver }) {
+    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, transformers = [] } = options
 
     const root = path.resolve(config.root, config.output.path)
     const mode = getMode(path.resolve(root, output.path))
@@ -309,12 +302,10 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
 
     const isEnumSchema = !!narrowSchema(node, schemaTypes.enum)
 
-    const typedName =
-      ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyTypedName(node, enumTypeSuffix) : resolver.resolveTypedName(node.name)
+    const name = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveName(node.name)
 
     const type = {
-      name: resolver.resolveName(node.name),
-      typedName,
+      name,
       file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group }),
     } as const
 
@@ -332,7 +323,6 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
           ))}
         <Type
           name={type.name}
-          typedName={type.typedName}
           node={transformedNode}
           enumType={enumType}
           enumTypeSuffix={enumTypeSuffix}

package/src/index.ts

@@ -1,2 +1,14 @@
+export { Enum } from './components/Enum.tsx'
+export { Type } from './components/Type.tsx'
+
+export { typeGenerator } from './generators/typeGenerator.tsx'
+
 export { pluginTs, pluginTsName } from './plugin.ts'
-export type { PluginTs } from './types.ts'
+
+export { functionPrinter } from './printers/functionPrinter.ts'
+export { printerTs } from './printers/printerTs.ts'
+
+export { resolverTs } from './resolvers/resolverTs.ts'
+export { resolverTsLegacy } from './resolvers/resolverTsLegacy.ts'
+
+export type { PluginTs, ResolverTs } from './types.ts'

package/src/plugin.ts

@@ -1,7 +1,8 @@
 import path from 'node:path'
+import { camelCase } from '@internals/utils'
 import { walk } from '@kubb/ast'
-import { createPlugin, getBarrelFiles, renderOperation, renderSchema } from '@kubb/core'
-import { getPreset } from './presets.ts'
+import { createPlugin, type Group, getBarrelFiles, getPreset, renderOperation, renderSchema } from '@kubb/core'
+import { presets } from './presets.ts'
 import type { PluginTs } from './types.ts'
 
 /**
@@ -45,7 +46,9 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
     generators: userGenerators = [],
   } = options
 
-  const { resolver, transformers, generators } = getPreset(compatibilityPreset, {
+  const preset = getPreset({
+    preset: compatibilityPreset,
+    presets: presets,
     resolvers: userResolvers,
     transformers: userTransformers,
     generators: userGenerators,
@@ -56,40 +59,54 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
 
   return {
     name: pluginTsName,
-    options: {
-      output,
-      optionalType,
-      group,
-      arrayType,
-      enumType,
-      enumTypeSuffix,
-      enumKeyCasing,
-      syntaxType,
-      paramsCasing,
-      resolver,
-      transformers,
+    get resolver() {
+      return preset.resolver
+    },
+    get options() {
+      return {
+        output,
+        optionalType,
+        group: group
+          ? ({
+              ...options.group,
+              name: (ctx) => {
+                if (options.group?.type === 'path') {
+                  return `${ctx.group.split('/')[1]}`
+                }
+                return `${camelCase(ctx.group)}Controller`
+              },
+            } as Group)
+          : undefined,
+        arrayType,
+        enumType,
+        enumTypeSuffix,
+        enumKeyCasing,
+        syntaxType,
+        paramsCasing,
+        transformers: preset.transformers,
+      }
     },
     resolvePath(baseName, pathMode, options) {
       if (!resolvePathWarning) {
-        this.driver.events.emit('warn', 'Do not use resolvePath for pluginTs, use resolverTs.resolvePath instead')
+        this.events.emit('warn', 'Do not use resolvePath for pluginTs, use resolverTs.resolvePath instead')
         resolvePathWarning = true
       }
 
-      return resolver.resolvePath(
+      return this.plugin.resolver.resolvePath(
         { baseName, pathMode, tag: options?.group?.tag, path: options?.group?.path },
-        { root: path.resolve(this.config.root, this.config.output.path), output, group },
+        { root: path.resolve(this.config.root, this.config.output.path), output, group: this.plugin.options.group },
       )
     },
     resolveName(name, type) {
       if (!resolveNameWarning) {
-        this.driver.events.emit('warn', 'Do not use resolveName for pluginTs, use resolverTs.default instead')
+        this.events.emit('warn', 'Do not use resolveName for pluginTs, use resolverTs.default instead')
         resolveNameWarning = true
       }
 
-      return resolver.default(name, type)
+      return this.plugin.resolver.default(name, type)
     },
     async install() {
-      const { config, fabric, plugin, adapter, rootNode, driver, openInStudio } = this
+      const { config, fabric, plugin, adapter, rootNode, driver, openInStudio, resolver } = this
 
       const root = path.resolve(config.root, config.output.path)
 
@@ -102,7 +119,7 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
       await walk(rootNode, {
         depth: 'shallow',
         async schema(schemaNode) {
-          const writeTasks = generators.map(async (generator) => {
+          const writeTasks = preset.generators.map(async (generator) => {
             if (generator.type === 'react' && generator.version === '2') {
               const options = resolver.resolveOptions(schemaNode, { options: plugin.options, exclude, include, override })
 
@@ -112,6 +129,7 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
 
               await renderSchema(schemaNode, {
                 options,
+                resolver,
                 adapter,
                 config,
                 fabric,
@@ -125,7 +143,7 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
           await Promise.all(writeTasks)
         },
         async operation(operationNode) {
-          const writeTasks = generators.map(async (generator) => {
+          const writeTasks = preset.generators.map(async (generator) => {
             if (generator.type === 'react' && generator.version === '2') {
               const options = resolver.resolveOptions(operationNode, { options: plugin.options, exclude, include, override })
 
@@ -135,6 +153,7 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
 
               await renderOperation(operationNode, {
                 options,
+                resolver,
                 adapter,
                 config,
                 fabric,

package/src/presets.ts

@@ -1,8 +1,9 @@
-import type { Visitor } from '@kubb/ast/types'
-import { type CompatibilityPreset, definePreset, definePresets, type Generator, getPreset as getCorePreset } from '@kubb/core'
-import { typeGenerator, typeGeneratorLegacy } from './generators/index.ts'
-import { resolverTs, resolverTsLegacy } from './resolvers/index.ts'
-import type { PluginTs, ResolverTs } from './types.ts'
+import { definePresets } from '@kubb/core'
+import { typeGenerator } from './generators/typeGenerator.tsx'
+import { typeGeneratorLegacy } from './generators/typeGeneratorLegacy.tsx'
+import { resolverTs } from './resolvers/resolverTs.ts'
+import { resolverTsLegacy } from './resolvers/resolverTsLegacy.ts'
+import type { ResolverTs } from './types.ts'
 
 /**
  * Built-in preset registry for `@kubb/plugin-ts`.
@@ -11,33 +12,14 @@ import type { PluginTs, ResolverTs } from './types.ts'
  * - `kubbV4` — uses `resolverTsLegacy` and `typeGeneratorLegacy` (Kubb v4 naming conventions).
  */
 export const presets = definePresets<ResolverTs>({
-  default: definePreset('default', { resolvers: [resolverTs], generators: [typeGenerator] }),
-  kubbV4: definePreset('kubbV4', { resolvers: [resolverTsLegacy], generators: [typeGeneratorLegacy] }),
+  default: {
+    name: 'default',
+    resolvers: [resolverTs],
+    generators: [typeGenerator],
+  },
+  kubbV4: {
+    name: 'kubbV4',
+    resolvers: [resolverTsLegacy],
+    generators: [typeGeneratorLegacy],
+  },
 })
-
-type GetPresetOptions = {
-  resolvers: Array<ResolverTs>
-  transformers: Array<Visitor>
-  generators: Array<Generator<PluginTs>>
-}
-
-/**
- * Resolves a compatibility preset for `plugin-ts`, merging user-supplied resolvers,
- * transformers, and generators on top of the built-in preset defaults.
- *
- * `resolverTs` is always prepended to the resolver list as the baseline.
- *
- * @example
- * ```ts
- * const preset = getPreset('kubbV4', { resolvers: [], transformers: [], generators: [] })
- * ```
- */
-export function getPreset(preset: CompatibilityPreset, { resolvers, transformers, generators }: GetPresetOptions) {
-  return getCorePreset({
-    preset,
-    presets,
-    resolvers: [resolverTs, ...(resolvers ?? [])],
-    transformers,
-    generators,
-  })
-}

package/src/printers/functionPrinter.ts

@@ -0,0 +1,194 @@
+import type { PrinterFactoryOptions } from '@kubb/ast'
+import { createPrinterFactory } from '@kubb/ast'
+import type { FunctionNode, FunctionNodeType, FunctionParameterNode, FunctionParametersNode, ParameterGroupNode, TypeNode } from '@kubb/ast/types'
+
+/**
+ * Maps each function-printer handler key to its concrete node type.
+ */
+export type FunctionNodeByType = {
+  functionParameter: FunctionParameterNode
+  parameterGroup: ParameterGroupNode
+  functionParameters: FunctionParametersNode
+  type: TypeNode
+}
+
+const kindToHandlerKey = {
+  FunctionParameter: 'functionParameter',
+  ParameterGroup: 'parameterGroup',
+  FunctionParameters: 'functionParameters',
+  Type: 'type',
+} satisfies Record<string, FunctionNodeType>
+
+/**
+ * Creates a function-parameter printer factory.
+ *
+ * Uses `createPrinterFactory` and dispatches handlers by `node.kind`
+ * (for function nodes) rather than by `node.type` (for schema nodes).
+ */
+export const defineFunctionPrinter = createPrinterFactory<FunctionNode, FunctionNodeType, FunctionNodeByType>((node) => kindToHandlerKey[node.kind])
+
+export type FunctionPrinterOptions = {
+  /**
+   * Rendering modes supported by `functionPrinter`.
+   *
+   * | Mode          | Output example                              | Use case                        |
+   * |---------------|---------------------------------------------|---------------------------------|
+   * | `declaration` | `id: string, config: Config = {}`           | Function parameter declaration |
+   * | `call`        | `id, { method, url }`                       | Function call arguments |
+   * | `keys`        | `{ id, config }`                            | Key names only (destructuring) |
+   * | `values`      | `{ id: id, config: config }`                | Key/value object entries |
+   */
+  mode: 'declaration' | 'call' | 'keys' | 'values'
+  /**
+   * Optional transformation applied to every parameter name before printing.
+   */
+  transformName?: (name: string) => string
+  /**
+   * Optional transformation applied to every type string before printing.
+   */
+  transformType?: (type: string) => string
+}
+
+type DefaultPrinter = PrinterFactoryOptions<'functionParameters', FunctionPrinterOptions, string>
+
+function rank(param: FunctionParameterNode | ParameterGroupNode): number {
+  if (param.kind === 'ParameterGroup') {
+    if (param.default) return 2
+    const isOptional = param.optional ?? param.properties.every((p) => p.optional || p.default !== undefined)
+    return isOptional ? 1 : 0
+  }
+  if (param.rest) return 3
+  if (param.default) return 2
+  return param.optional ? 1 : 0
+}
+
+function sortParams(params: ReadonlyArray<FunctionParameterNode | ParameterGroupNode>): Array<FunctionParameterNode | ParameterGroupNode> {
+  return [...params].sort((a, b) => rank(a) - rank(b))
+}
+
+function sortChildParams(params: Array<FunctionParameterNode>): Array<FunctionParameterNode> {
+  return [...params].sort((a, b) => rank(a) - rank(b))
+}
+
+/**
+ * Default function-signature printer.
+ * Covers the four standard output modes used across Kubb plugins.
+ *
+ * @example
+ * ```ts
+ * const printer = functionPrinter({ mode: 'declaration' })
+ *
+ * const sig = createFunctionParameters({
+ *   params: [
+ *     createFunctionParameter({ name: 'petId', type: 'string', optional: false }),
+ *     createFunctionParameter({ name: 'config', type: 'Config', optional: false, default: '{}' }),
+ *   ],
+ * })
+ *
+ * printer.print(sig)  // → "petId: string, config: Config = {}"
+ * ```
+ */
+export const functionPrinter = defineFunctionPrinter<DefaultPrinter>((options) => ({
+  name: 'functionParameters',
+  options,
+  nodes: {
+    type(node) {
+      if (node.variant === 'member') {
+        return `${node.base}['${node.key}']`
+      }
+      if (node.variant === 'struct') {
+        const parts = node.properties.map((p) => {
+          const typeStr = this.transform(p.type)
+          return p.optional ? `${p.name}?: ${typeStr}` : `${p.name}: ${typeStr}`
+        })
+        return `{ ${parts.join('; ')} }`
+      }
+      if (node.variant === 'reference') {
+        return node.name
+      }
+      return null
+    },
+    functionParameter(node) {
+      const { mode, transformName, transformType } = this.options
+      const name = transformName ? transformName(node.name) : node.name
+
+      const rawType = node.type ? this.transform(node.type) : undefined
+      const type = rawType != null && transformType ? transformType(rawType) : rawType
+
+      if (mode === 'keys' || mode === 'values') {
+        return node.rest ? `...${name}` : name
+      }
+
+      if (mode === 'call') {
+        return node.rest ? `...${name}` : name
+      }
+
+      if (node.rest) {
+        return type ? `...${name}: ${type}` : `...${name}`
+      }
+      if (type) {
+        if (node.optional) return `${name}?: ${type}`
+        return node.default ? `${name}: ${type} = ${node.default}` : `${name}: ${type}`
+      }
+      return node.default ? `${name} = ${node.default}` : name
+    },
+    parameterGroup(node) {
+      const { mode, transformName, transformType } = this.options
+      const sorted = sortChildParams(node.properties)
+      const isOptional = node.optional ?? sorted.every((p) => p.optional || p.default !== undefined)
+
+      if (node.inline) {
+        return sorted
+          .map((p) => this.transform(p))
+          .filter(Boolean)
+          .join(', ')
+      }
+
+      if (mode === 'keys' || mode === 'values') {
+        const keys = sorted.map((p) => p.name).join(', ')
+        return `{ ${keys} }`
+      }
+
+      if (mode === 'call') {
+        const keys = sorted.map((p) => p.name).join(', ')
+        return `{ ${keys} }`
+      }
+
+      const names = sorted.map((p) => {
+        const n = transformName ? transformName(p.name) : p.name
+
+        return n
+      })
+
+      const nameStr = names.length ? `{ ${names.join(', ')} }` : undefined
+      if (!nameStr) return null
+
+      let typeAnnotation: string | undefined = node.type ? (this.transform(node.type) ?? undefined) : undefined
+      if (!typeAnnotation) {
+        const typeParts = sorted
+          .filter((p) => p.type)
+          .map((p) => {
+            const rawT = p.type ? this.transform(p.type) : undefined
+            const t = rawT != null && transformType ? transformType(rawT) : rawT
+            return p.optional || p.default !== undefined ? `${p.name}?: ${t}` : `${p.name}: ${t}`
+          })
+        typeAnnotation = typeParts.length ? `{ ${typeParts.join('; ')} }` : undefined
+      }
+
+      if (typeAnnotation) {
+        if (isOptional) return `${nameStr}: ${typeAnnotation} = ${node.default ?? '{}'}`
+        return node.default ? `${nameStr}: ${typeAnnotation} = ${node.default}` : `${nameStr}: ${typeAnnotation}`
+      }
+
+      return node.default ? `${nameStr} = ${node.default}` : nameStr
+    },
+    functionParameters(node) {
+      const sorted = sortParams(node.params)
+
+      return sorted
+        .map((p) => this.transform(p))
+        .filter(Boolean)
+        .join(', ')
+    },
+  },
+}))

package/src/printers/printerTs.ts

@@ -37,7 +37,7 @@ type TsOptions = {
    * When set, `printer.print(node)` produces a full `type Name = …` declaration.
    * When omitted, `printer.print(node)` returns the raw type node.
    */
-  typeName?: string
+  name?: string
 
   /**
    * JSDoc `@description` comment added to the generated type or interface declaration.
@@ -272,7 +272,7 @@ export const printerTs = definePrinter<TsPrinter>((options) => {
 
         const resolvedName =
           ENUM_TYPES_WITH_KEY_SUFFIX.has(this.options.enumType) && this.options.enumTypeSuffix
-            ? this.options.resolver.resolveEnumKeyTypedName(node as unknown as SchemaNode, this.options.enumTypeSuffix)
+            ? this.options.resolver.resolveEnumKeyName(node as unknown as SchemaNode, this.options.enumTypeSuffix)
             : this.options.resolver.default(node.name, 'type')
 
         return factory.createTypeReferenceNode(resolvedName, undefined)
@@ -360,16 +360,16 @@ export const printerTs = definePrinter<TsPrinter>((options) => {
         type = factory.createUnionDeclaration({ nodes: [type, factory.keywordTypeNodes.undefined] })
       }
 
-      // Without typeName, return the type node as-is (no declaration wrapping).
-      const { typeName, syntaxType = 'type', description, keysToOmit } = this.options
-      if (!typeName) {
+      // Without name, return the type node as-is (no declaration wrapping).
+      const { name, syntaxType = 'type', description, keysToOmit } = this.options
+      if (!name) {
         return safePrint(type)
       }
 
       const useTypeGeneration = syntaxType === 'type' || type.kind === factory.syntaxKind.union || !!keysToOmit?.length
 
       const typeNode = factory.createTypeDeclaration({
-        name: typeName,
+        name,
         isExportable: true,
         type: keysToOmit?.length
           ? factory.createOmitDeclaration({