@kubb/ast 5.0.0-alpha.21 → 5.0.0-alpha.23

package/src/factory.ts

@@ -2,16 +2,32 @@ import type { InferSchemaNode } from './infer.ts'
 import type {
   FunctionParameterNode,
   FunctionParametersNode,
-  ObjectBindingParameterNode,
   ObjectSchemaNode,
   OperationNode,
+  ParameterGroupNode,
   ParameterNode,
   PropertyNode,
   ResponseNode,
   RootNode,
   SchemaNode,
+  TypeNode,
 } from './nodes/index.ts'
-import { syncOptionality } from './utils.ts'
+
+/**
+ * Syncs property/parameter schema optionality flags from `required` and `schema.nullable`.
+ *
+ * - `optional` is set for non-required, non-nullable schemas.
+ * - `nullish` is set for non-required, nullable schemas.
+ */
+export function syncOptionality(schema: SchemaNode, required: boolean): SchemaNode {
+  const nullable = schema.nullable ?? false
+
+  return {
+    ...schema,
+    optional: !required && !nullable ? true : undefined,
+    nullish: !required && nullable ? true : undefined,
+  }
+}
 
 /**
  * Distributive `Omit` that preserves each member of a union.
@@ -156,7 +172,7 @@ export function createProperty(props: Pick<PropertyNode, 'name' | 'schema'> & Pa
     ...props,
     kind: 'Property',
     required,
-    schema: syncOptionality(required, props.schema),
+    schema: syncOptionality(props.schema, required),
   }
 }
 
@@ -194,7 +210,7 @@ export function createParameter(
     ...props,
     kind: 'Parameter',
     required,
-    schema: syncOptionality(required, props.schema),
+    schema: syncOptionality(props.schema, required),
   }
 }
 
@@ -219,33 +235,6 @@ export function createResponse(
   }
 }
 
-/**
- * Creates a single-property object schema used as a discriminator literal.
- *
- * @example
- * ```ts
- * createDiscriminantNode({ propertyName: 'type', value: 'dog' })
- * // -> { type: 'object', properties: [{ name: 'type', required: true, schema: enum('dog') }] }
- * ```
- */
-export function createDiscriminantNode({ propertyName, value }: { propertyName: string; value: string }): SchemaNode {
-  return createSchema({
-    type: 'object',
-    primitive: 'object',
-    properties: [
-      createProperty({
-        name: propertyName,
-        schema: createSchema({
-          type: 'enum',
-          primitive: 'string',
-          enumValues: [value],
-        }),
-        required: true,
-      }),
-    ],
-  })
-}
-
 /**
  * Creates a `FunctionParameterNode`.
  *
@@ -253,24 +242,24 @@ export function createDiscriminantNode({ propertyName, value }: { propertyName:
  *
  * @example Required typed param
  * ```ts
- * createFunctionParameter({ name: 'petId', type: 'string' })
+ * createFunctionParameter({ name: 'petId', type: createTypeNode({ variant: 'reference', name: 'string' }) })
  * // → petId: string
  * ```
  *
  * @example Optional param
  * ```ts
- * createFunctionParameter({ name: 'params', type: 'QueryParams', optional: true })
+ * createFunctionParameter({ name: 'params', type: createTypeNode({ variant: 'reference', name: 'QueryParams' }), optional: true })
  * // → params?: QueryParams
  * ```
  *
  * @example Param with default (implicitly optional; cannot combine with `optional: true`)
  * ```ts
- * createFunctionParameter({ name: 'config', type: 'RequestConfig', default: '{}' })
+ * createFunctionParameter({ name: 'config', type: createTypeNode({ variant: 'reference', name: 'RequestConfig' }), default: '{}' })
  * // → config: RequestConfig = {}
  * ```
  */
 export function createFunctionParameter(
-  props: { name: string; type?: string; rest?: boolean } & ({ optional: true; default?: never } | { optional?: false; default?: string }),
+  props: { name: string; type?: TypeNode; rest?: boolean } & ({ optional: true; default?: never } | { optional?: false; default?: string }),
 ): FunctionParameterNode {
   return {
     optional: false,
@@ -280,14 +269,45 @@ export function createFunctionParameter(
 }
 
 /**
- * Creates an `ObjectBindingParameterNode` for object-destructured parameter groups.
+ * Creates a {@link TypeNode} representing a language-agnostic structured type expression.
+ *
+ * Use `variant: 'struct'` for inline anonymous types and `variant: 'member'` for a single
+ * named field accessed from a group type. Each language's printer renders the variant
+ * into its own syntax (TypeScript, Python, C#, Kotlin, …).
+ *
+ * @example Reference type (TypeScript: `QueryParams`)
+ * ```ts
+ * createTypeNode({ variant: 'reference', name: 'QueryParams' })
+ * ```
+ *
+ * @example Struct type (TypeScript: `{ petId: string }`)
+ * ```ts
+ * createTypeNode({ variant: 'struct', properties: [{ name: 'petId', optional: false, type: createTypeNode({ variant: 'reference', name: 'string' }) }] })
+ * ```
+ *
+ * @example Member type (TypeScript: `DeletePetPathParams['petId']`)
+ * ```ts
+ * createTypeNode({ variant: 'member', base: 'DeletePetPathParams', key: 'petId' })
+ * ```
+ */
+export function createTypeNode(
+  props:
+    | { variant: 'reference'; name: string }
+    | { variant: 'struct'; properties: Array<{ name: string; optional: boolean; type: TypeNode }> }
+    | { variant: 'member'; base: string; key: string },
+): TypeNode {
+  return { ...props, kind: 'Type' } as TypeNode
+}
+
+/**
+ * Creates a `ParameterGroupNode` representing a group of related parameters treated as a unit.
  *
- * @example Destructured object param
+ * @example Grouped param (TypeScript declaration)
  * ```ts
- * createObjectBindingParameter({
+ * createParameterGroup({
  *   properties: [
- *     createFunctionParameter({ name: 'id', type: 'string', optional: false }),
- *     createFunctionParameter({ name: 'name', type: 'string', optional: true }),
+ *     createFunctionParameter({ name: 'id', type: createTypeNode({ variant: 'reference', name: 'string' }), optional: false }),
+ *     createFunctionParameter({ name: 'name', type: createTypeNode({ variant: 'reference', name: 'string' }), optional: true }),
  *   ],
  *   default: '{}',
  * })
@@ -295,22 +315,22 @@ export function createFunctionParameter(
  * // call        → { id, name }
  * ```
  *
- * @example Inline mode — children emitted as individual top-level parameters
+ * @example Inline (spread) — children emitted as individual top-level parameters
  * ```ts
- * createObjectBindingParameter({
- *   properties: [createFunctionParameter({ name: 'petId', type: 'string', optional: false })],
+ * createParameterGroup({
+ *   properties: [createFunctionParameter({ name: 'petId', type: createTypeNode({ variant: 'reference', name: 'string' }), optional: false })],
  *   inline: true,
  * })
  * // declaration → petId: string
  * // call        → petId
  * ```
  */
-export function createObjectBindingParameter(
-  props: Pick<ObjectBindingParameterNode, 'properties'> & Partial<Omit<ObjectBindingParameterNode, 'kind' | 'properties'>>,
-): ObjectBindingParameterNode {
+export function createParameterGroup(
+  props: Pick<ParameterGroupNode, 'properties'> & Partial<Omit<ParameterGroupNode, 'kind' | 'properties'>>,
+): ParameterGroupNode {
   return {
     ...props,
-    kind: 'ObjectBindingParameter',
+    kind: 'ParameterGroup',
   }
 }
 
@@ -321,8 +341,8 @@ export function createObjectBindingParameter(
  * ```ts
  * createFunctionParameters({
  *   params: [
- *     createFunctionParameter({ name: 'petId', type: 'string', optional: false }),
- *     createFunctionParameter({ name: 'config', type: 'RequestConfig', optional: false, default: '{}' }),
+ *     createFunctionParameter({ name: 'petId', type: createTypeNode({ variant: 'reference', name: 'string' }), optional: false }),
+ *     createFunctionParameter({ name: 'config', type: createTypeNode({ variant: 'reference', name: 'RequestConfig' }), optional: false, default: '{}' }),
  *   ],
  * })
  * ```

package/src/guards.ts

@@ -3,8 +3,8 @@ import type {
   FunctionParametersNode,
   Node,
   NodeKind,
-  ObjectBindingParameterNode,
   OperationNode,
+  ParameterGroupNode,
   ParameterNode,
   PropertyNode,
   ResponseNode,
@@ -87,9 +87,9 @@ export const isResponseNode = isKind<ResponseNode>('Response')
 export const isFunctionParameterNode = isKind<FunctionParameterNode>('FunctionParameter')
 
 /**
- * Returns `true` when the input is an `ObjectBindingParameterNode`.
+ * Returns `true` when the input is a `ParameterGroupNode`.
  */
-export const isObjectBindingParameterNode = isKind<ObjectBindingParameterNode>('ObjectBindingParameter')
+export const isParameterGroupNode = isKind<ParameterGroupNode>('ParameterGroup')
 
 /**
  * Returns `true` when the input is a `FunctionParametersNode`.

package/src/index.ts

@@ -1,32 +1,25 @@
-export { httpMethods, mediaTypes, nodeKinds, SCALAR_PRIMITIVE_TYPES, schemaTypes } from './constants.ts'
+export type { ScalarPrimitive } from './constants.ts'
+export { httpMethods, isScalarPrimitive, mediaTypes, schemaTypes } from './constants.ts'
 export {
-  createDiscriminantNode,
   createFunctionParameter,
   createFunctionParameters,
-  createObjectBindingParameter,
   createOperation,
   createParameter,
+  createParameterGroup,
   createProperty,
   createResponse,
   createRoot,
   createSchema,
+  createTypeNode,
+  syncOptionality,
 } from './factory.ts'
-export {
-  isFunctionParameterNode,
-  isFunctionParametersNode,
-  isObjectBindingParameterNode,
-  isOperationNode,
-  isParameterNode,
-  isPropertyNode,
-  isResponseNode,
-  isRootNode,
-  isSchemaNode,
-  narrowSchema,
-} from './guards.ts'
-export type { InferSchema, InferSchemaNode, ParserOptions } from './infer.ts'
-export { defineFunctionPrinter, definePrinter, functionPrinter } from './printers/index.ts'
-export { buildRefMap, extractRefName, refMapToObject, resolveRef } from './refs.ts'
+export { isOperationNode, isSchemaNode, narrowSchema } from './guards.ts'
+export type { ParserOptions } from './infer.ts'
+export type { PrinterFactoryOptions } from './printer.ts'
+export { createPrinterFactory, definePrinter } from './printer.ts'
+export { extractRefName } from './refs.ts'
 export { childName, collectImports, enumPropName, findDiscriminator } from './resolvers.ts'
-export { mergeAdjacentObjects, resolveNames, setDiscriminatorEnum, setEnumName, simplifyUnion } from './transformers.ts'
-export { caseParams, isStringType, syncOptionality } from './utils.ts'
+export { mergeAdjacentObjects, setDiscriminatorEnum, setEnumName, simplifyUnion } from './transformers.ts'
+export type { OperationParamsResolver } from './utils.ts'
+export { caseParams, createDiscriminantNode, createOperationParams, isStringType } from './utils.ts'
 export { collect, composeTransformers, transform, walk } from './visitor.ts'

package/src/nodes/base.ts

@@ -14,8 +14,9 @@ export type NodeKind =
   | 'Parameter'
   | 'Response'
   | 'FunctionParameter'
-  | 'ObjectBindingParameter'
+  | 'ParameterGroup'
   | 'FunctionParameters'
+  | 'Type'
 
 /**
  * Base shape shared by all AST nodes.

package/src/nodes/function.ts

@@ -1,15 +1,69 @@
 import type { BaseNode } from './base.ts'
 
+/**
+ * AST node representing a language-agnostic type expression produced during parameter resolution.
+ * Each language printer renders the variant into its own syntax.
+ *
+ * - `struct` — an inline anonymous type grouping named fields.
+ *   TypeScript renders as `{ petId: string; name?: string }`, Python as a `TypedDict` reference.
+ * - `member` — a single named field accessed from a named group type.
+ *   TypeScript renders as `PathParams['petId']`, C# as `PathParams.PetId`.
+ */
+export type TypeNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Type'
+} & (
+    | {
+        /**
+         * Reference variant — a plain type name or identifier.
+         * TypeScript renders as-is, e.g. `string`, `QueryParams`, `Partial<Config>`.
+         */
+        variant: 'reference'
+        /**
+         * The full type name string, e.g. `'string'`, `'QueryParams'`, `'Partial<Config>'`.
+         */
+        name: string
+      }
+    | {
+        /**
+         * Struct variant — an inline anonymous type grouping named fields.
+         * TypeScript renders as `{ key: Type; other?: OtherType }`.
+         */
+        variant: 'struct'
+        /**
+         * Properties of the struct type.
+         */
+        properties: Array<{ name: string; optional: boolean; type: TypeNode }>
+      }
+    | {
+        /**
+         * Member variant — a single named field accessed from a group type.
+         * TypeScript renders as `Base['key']`.
+         */
+        variant: 'member'
+        /**
+         * Base type name, e.g. `'DeletePetPathParams'`.
+         */
+        base: string
+        /**
+         * The field name to access, e.g. `'petId'`.
+         */
+        key: string
+      }
+  )
+
 /**
  * AST node for one function parameter.
  *
  * @example Required parameter
  * `name: Type`
  *
- * @example Optional param
+ * @example Optional parameter
  * `name?: Type`
  *
- * @example Parameter with default
+ * @example Parameter with default value
  * `name: Type = defaultValue`
  *
  * @example Rest parameter
@@ -25,73 +79,89 @@ export type FunctionParameterNode = BaseNode & {
    */
   name: string
   /**
-   * TypeScript type text, for example, `"string"` or `"Pet[]"`.
-   * Omit for untyped JavaScript output.
+   * Type annotation as a structured {@link TypeNode}.
+   * Omit for untyped output.
+   *
+   * @example Reference type node
+   * `{ kind: 'Type', variant: 'reference', name: 'string' }` → `petId: string`
+   *
+   * @example Struct type node
+   * `{ kind: 'Type', variant: 'struct', properties: [...] }` → `{ key: Type; other?: OtherType }`
+   *
+   * @example Member type node
+   * `{ kind: 'Type', variant: 'member', base: 'PathParams', key: 'petId' }` → `PathParams['petId']`
    */
-  type?: string
+  type?: TypeNode
   /**
-   * When `true` the parameter is emitted as a rest parameter (`...name`).
-   * @default false
+   * When `true` the parameter is emitted as a rest parameter.
+   *
+   * @example Rest parameter
+   * `...name: Type[]`
    */
   rest?: boolean
 } /**
- * Optional parameter, rendered with `?` in declarations.
- * Cannot be combined with `default` because defaulted parameters are already optional.
- * @example `name?: Type`
+ * Optional parameter — rendered with `?` and may be omitted by the caller.
+ * Cannot be combined with `default` because a defaulted parameter is already optional.
  */ & (
     | { optional: true; default?: never }
     /**
-     * Required parameter, or parameter with a default value.
-     * @example Required: `name: Type`
-     * @example With default: `name: Type = default`
+     * Required parameter, or a parameter with a default value.
+     *
+     * @example Required
+     * `name: Type`
+     *
+     * @example With default
+     * `name: Type = default`
      */
     | { optional?: false; default?: string }
   )
 
 /**
- * AST node for object-destructured function parameters.
+ * AST node for a group of related function parameters treated as a single unit.
  *
- * This node renders as `{ key1, key2 }: { key1: Type1; key2: Type2 } = {}` in declarations,
- * or as individual top-level parameters when `inline` is `true`.
+ * Each language printer decides how to render this group:
+ * - TypeScript/JS: destructured object `{ key1, key2 }: { key1: Type1; key2: Type2 } = {}`
+ * - Python: keyword-only args or a typed dict parameter
+ * - C# / Kotlin: named record / data-class parameter
  *
- * This replaces `mode: 'object'` and `mode: 'inlineSpread'` from the old `FunctionParams` API.
+ * When `inline` is `true`, the group is spread as individual top-level parameters
+ * rather than wrapped in a single grouped construct.
  *
- * @example Object destructuring with auto-computed type (declaration)
+ * @example Grouped destructuring
  * `{ id, name }: { id: string; name: string } = {}`
  *
- * @example Inline (spread) — children emitted as individual top-level params
+ * @example Inline (spread as individual parameters)
  * `id: string, name: string`
  */
-export type ObjectBindingParameterNode = BaseNode & {
+export type ParameterGroupNode = BaseNode & {
   /**
    * Node kind.
    */
-  kind: 'ObjectBindingParameter'
+  kind: 'ParameterGroup'
   /**
-   * The individual parameters that form the destructured object.
-   * Rendered as `{ key1, key2 }` in declarations, or spread inline when `inline` is `true`.
+   * The individual parameters that form the group.
+   * Rendered as a destructured object or spread inline when `inline` is `true`.
    */
   properties: Array<FunctionParameterNode>
   /**
-   * Optional type text for the full object parameter.
-   * When absent, the printer auto-computes `{ key1: Type1; key2: Type2 }` from `properties`.
+   * Optional explicit type annotation for the whole group.
+   * When absent, printers auto-compute it from `properties`.
    */
-  type?: string
+  type?: TypeNode
   /**
    * When `true`, `properties` are emitted as individual top-level parameters instead of
-   * being wrapped in a destructuring pattern (`{ key1, key2 }`).
+   * being wrapped in a single grouped construct.
    *
-   * Equivalent to `mode: 'inlineSpread'` in the legacy `FunctionParams` API.
    * @default false
    */
   inline?: boolean
   /**
-   * Whether the full object binding is optional.
+   * Whether the group as a whole is optional.
    * If omitted, printers infer this from child properties.
    */
   optional?: boolean
   /**
-   * Default value for the object group, written verbatim after `=`.
+   * Default value for the group, written verbatim after `=`.
    * Commonly `'{}'` to allow omitting the argument entirely.
    */
   default?: string
@@ -117,15 +187,15 @@ export type FunctionParametersNode = BaseNode & {
   /**
    * Ordered parameter nodes.
    */
-  params: Array<FunctionParameterNode | ObjectBindingParameterNode>
+  params: ReadonlyArray<FunctionParameterNode | ParameterGroupNode>
 }
 
 /**
- * The three function-signature AST node variants.
+ * The four function-signature AST node variants.
  */
-export type FunctionNode = FunctionParameterNode | ObjectBindingParameterNode | FunctionParametersNode
+export type FunctionNode = FunctionParameterNode | ParameterGroupNode | FunctionParametersNode | TypeNode
 
 /**
  * Handler map keys — one per `FunctionNode` kind.
  */
-export type FunctionNodeType = 'functionParameter' | 'objectBindingParameter' | 'functionParameters'
+export type FunctionNodeType = 'functionParameter' | 'parameterGroup' | 'functionParameters' | 'type'

package/src/nodes/index.ts

@@ -7,7 +7,7 @@ import type { RootNode } from './root.ts'
 import type { SchemaNode } from './schema.ts'
 
 export type { BaseNode, NodeKind } from './base.ts'
-export type { FunctionNode, FunctionNodeType, FunctionParameterNode, FunctionParametersNode, ObjectBindingParameterNode } from './function.ts'
+export type { FunctionNode, FunctionNodeType, FunctionParameterNode, FunctionParametersNode, ParameterGroupNode, TypeNode } from './function.ts'
 export type { HttpStatusCode, MediaType, StatusCode } from './http.ts'
 export type { HttpMethod, OperationNode } from './operation.ts'
 export type { ParameterLocation, ParameterNode } from './parameter.ts'

package/src/nodes/operation.ts

@@ -35,8 +35,8 @@ export type OperationNode = BaseNode & {
    */
   method: HttpMethod
   /**
-   * Express-style path string, for example `/pets/:petId`.
-   * OpenAPI `{param}` parts are converted to `:param`.
+   * OpenAPI-style path string, for example `/pets/{petId}`.
+   * Path parameters retain the `{param}` notation from the original spec.
    */
   path: string
   /**
@@ -78,6 +78,11 @@ export type OperationNode = BaseNode & {
      * Set when a referenced schema has `readOnly` fields that should be omitted in request types.
      */
     keysToOmit?: Array<string>
+    /**
+     * Whether the request body is required (`requestBody.required: true` in the spec).
+     * When `false` or absent, the generated `data` parameter should be optional.
+     */
+    required?: boolean
   }
   /**
    * Operation responses.

package/src/nodes/schema.ts

@@ -475,11 +475,11 @@ export type ScalarSchemaNode = SchemaNodeBase & {
 
 /**
  * URL schema node.
- * Can include an Express-style path template for template literal types.
+ * Can include an OpenAPI-style path template for template literal types.
  *
  * @example
  * ```ts
- * const urlSchema: UrlSchemaNode = { kind: 'Schema', type: 'url', path: '/pets/:petId' }
+ * const urlSchema: UrlSchemaNode = { kind: 'Schema', type: 'url', path: '/pets/{petId}' }
  * ```
  */
 export type UrlSchemaNode = SchemaNodeBase & {
@@ -488,7 +488,7 @@ export type UrlSchemaNode = SchemaNodeBase & {
    */
   type: 'url'
   /**
-   * Express-style path template, for example, `'/pets/:petId'`.
+   * OpenAPI-style path template, for example, `'/pets/{petId}'`.
    */
   path?: string
 }

package/src/{printers/printer.ts → printer.ts}

@@ -1,4 +1,4 @@
-import type { SchemaNode, SchemaNodeByType, SchemaType } from '../nodes/index.ts'
+import type { SchemaNode, SchemaNodeByType, SchemaType } from './nodes/index.ts'
 
 /**
  * Runtime context passed as `this` to printer handlers.

package/src/transformers.ts

@@ -1,9 +1,8 @@
-import { SCALAR_PRIMITIVE_TYPES } from './constants.ts'
+import { isScalarPrimitive } from './constants.ts'
 import { createProperty, createSchema } from './factory.ts'
 import { narrowSchema } from './guards.ts'
 import type { SchemaNode } from './nodes/schema.ts'
 import { enumPropName } from './resolvers.ts'
-import { transform } from './visitor.ts'
 
 /**
  * Replaces a discriminator property's schema with a string enum of allowed values.
@@ -108,9 +107,7 @@ export function mergeAdjacentObjects(members: Array<SchemaNode>): Array<SchemaNo
  * ```
  */
 export function simplifyUnion(members: Array<SchemaNode>): Array<SchemaNode> {
-  const scalarPrimitives = new Set(
-    members.filter((member) => SCALAR_PRIMITIVE_TYPES.has(member.type as typeof SCALAR_PRIMITIVE_TYPES extends Set<infer T> ? T : never)).map((m) => m.type),
-  )
+  const scalarPrimitives = new Set(members.filter((member) => isScalarPrimitive(member.type)).map((m) => m.type))
 
   if (!scalarPrimitives.size) {
     return members
@@ -157,40 +154,3 @@ export function setEnumName(propNode: SchemaNode, parentName: string | null | un
 
   return propNode
 }
-
-/**
- * Walks a schema tree and resolves `ref`/`enum` names through callbacks.
- */
-export function resolveNames({
-  node,
-  nameMapping,
-  resolveName,
-  resolveEnumName,
-}: {
-  node: SchemaNode
-  nameMapping: Map<string, string>
-  resolveName: (ref: string) => string | undefined
-  resolveEnumName?: (name: string) => string | undefined
-}): SchemaNode {
-  return transform(node, {
-    schema(schemaNode) {
-      const schemaRef = narrowSchema(schemaNode, 'ref')
-
-      if (schemaRef && (schemaRef.ref || schemaRef.name)) {
-        const rawRef = schemaRef.ref ?? schemaRef.name!
-        const resolved = resolveName(nameMapping.get(rawRef) ?? rawRef)
-        if (resolved) {
-          return { ...schemaNode, name: resolved }
-        }
-      }
-
-      const schemaEnum = narrowSchema(schemaNode, 'enum')
-      if (schemaEnum?.name) {
-        const resolved = (resolveEnumName ?? resolveName)(schemaEnum.name)
-        if (resolved) {
-          return { ...schemaNode, name: resolved }
-        }
-      }
-    },
-  }) as SchemaNode
-}

package/src/types.ts

@@ -20,9 +20,9 @@ export type {
   Node,
   NodeKind,
   NumberSchemaNode,
-  ObjectBindingParameterNode,
   ObjectSchemaNode,
   OperationNode,
+  ParameterGroupNode,
   ParameterLocation,
   ParameterNode,
   PrimitiveSchemaType,
@@ -40,9 +40,10 @@ export type {
   StatusCode,
   StringSchemaNode,
   TimeSchemaNode,
+  TypeNode,
   UnionSchemaNode,
   UrlSchemaNode,
 } from './nodes/index.ts'
-export type { Printer, PrinterFactoryOptions } from './printers/printer.ts'
+export type { Printer, PrinterFactoryOptions } from './printer.ts'
 export type { RefMap } from './refs.ts'
 export type { AsyncVisitor, CollectOptions, CollectVisitor, ParentOf, TransformOptions, Visitor, VisitorContext, WalkOptions } from './visitor.ts'