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

package/src/utils.ts

@@ -1,21 +1,22 @@
 import { camelCase, isValidVarName } from '@internals/utils'
 
+import { createFunctionParameter, createFunctionParameters, createParameterGroup, createProperty, createSchema, createTypeNode } from './factory.ts'
 import { narrowSchema } from './guards.ts'
-import type { ParameterNode, SchemaNode } from './nodes/index.ts'
+import type { FunctionParameterNode, FunctionParametersNode, OperationNode, ParameterGroupNode, ParameterNode, SchemaNode, TypeNode } from './nodes/index.ts'
 import type { SchemaType } from './nodes/schema.ts'
 
 const plainStringTypes = new Set<SchemaType>(['string', 'uuid', 'email', 'url', 'datetime'] as const)
 
 /**
- * Returns `true` when a schema is emitted as a plain TypeScript `string`.
+ * Returns `true` when a schema is emitted as a plain `string` type.
  *
  * - `string`, `uuid`, `email`, `url`, `datetime` are always plain strings.
  * - `date` and `time` are plain strings when their `representation` is `'string'` rather than `'date'`.
  *
  * @example
  * ```ts
- * isStringType(createSchema({ type: 'uuid' })) // true
- * isStringType(createSchema({ type: 'date', representation: 'date' })) // false
+ * isStringType(createSchema({ type: 'uuid' }))                          // true
+ * isStringType(createSchema({ type: 'date', representation: 'date' }))  // false
  * ```
  */
 export function isStringType(node: SchemaNode): boolean {
@@ -61,17 +62,367 @@ export function caseParams(params: Array<ParameterNode>, casing: 'camelcase' | u
 }
 
 /**
- * Syncs property/parameter schema optionality flags from `required` and `schema.nullable`.
+ * Creates a single-property object schema used as a discriminator literal.
  *
- * - `optional` is set for non-required, non-nullable schemas.
- * - `nullish` is set for non-required, nullable schemas.
+ * @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,
+      }),
+    ],
+  })
+}
+
+/**
+ * Named type for a group of parameters (query or header) emitted as a single typed parameter.
+ */
+export type ParamGroupType = {
+  /**
+   * TypeNode for the group type.
+   */
+  type: TypeNode
+  /**
+   * Whether the parameter group is optional.
+   */
+  optional: boolean
+}
+
+/**
+ * Resolver interface for {@link createOperationParams}.
+ *
+ * `ResolverTs` from `@kubb/plugin-ts` satisfies this interface and can be passed directly.
+ */
+export type OperationParamsResolver = {
+  /**
+   * Resolves the type name for an individual parameter.
+   *
+   * @example Individual path parameter name
+   * `resolver.resolveParamName(node, param) // → 'DeletePetPathPetId'`
+   */
+  resolveParamName(node: OperationNode, param: ParameterNode): string
+  /**
+   * Resolves the request body type name.
+   *
+   * @example Request body type name
+   * `resolver.resolveDataName(node) // → 'CreatePetData'`
+   */
+  resolveDataName(node: OperationNode): string
+  /**
+   * Resolves the grouped path parameters type name.
+   * When the return value equals `resolveParamName`, no indexed access is emitted.
+   *
+   * @example Grouped path params type name
+   * `resolver.resolvePathParamsName(node, param) // → 'DeletePetPathParams'`
+   */
+  resolvePathParamsName(node: OperationNode, param: ParameterNode): string
+  /**
+   * Resolves the grouped query parameters type name.
+   * When the return value equals `resolveParamName`, an inline struct type is emitted instead.
+   *
+   * @example Grouped query params type name
+   * `resolver.resolveQueryParamsName(node, param) // → 'FindPetsByStatusQueryParams'`
+   */
+  resolveQueryParamsName(node: OperationNode, param: ParameterNode): string
+  /**
+   * Resolves the grouped header parameters type name.
+   * When the return value equals `resolveParamName`, an inline struct type is emitted instead.
+   *
+   * @example Grouped header params type name
+   * `resolver.resolveHeaderParamsName(node, param) // → 'DeletePetHeaderParams'`
+   */
+  resolveHeaderParamsName(node: OperationNode, param: ParameterNode): string
+}
+
+/**
+ * Options for {@link createOperationParams}.
  */
-export function syncOptionality(required: boolean, schema: SchemaNode): SchemaNode {
-  const nullable = schema.nullable ?? false
+export type CreateOperationParamsOptions = {
+  /**
+   * How all operation parameters are grouped in the function signature.
+   * - `'object'` wraps all params into a single destructured object `{ petId, data, params }`
+   * - `'inline'` emits each param category as a separate top-level parameter
+   */
+  paramsType: 'object' | 'inline'
+  /**
+   * How path parameters are emitted when `paramsType` is `'inline'`.
+   * - `'object'` groups them as `{ petId, storeId }: PathParams`
+   * - `'inline'` spreads them as individual parameters `petId: string, storeId: string`
+   * - `'inlineSpread'` emits a single rest parameter `...pathParams: PathParams`
+   */
+  pathParamsType: 'object' | 'inline' | 'inlineSpread'
+  /**
+   * Converts parameter names to camelCase before output.
+   */
+  paramsCasing?: 'camelcase'
+  /**
+   * Resolver for parameter and request body type names.
+   * Pass `ResolverTs` from `@kubb/plugin-ts` directly.
+   * When omitted, falls back to the schema primitive or `'unknown'`.
+   */
+  resolver?: OperationParamsResolver
+  /**
+   * Default value for the path parameters binding when `pathParamsType` is `'object'`.
+   * Falls back to `'{}'` when all path params are optional.
+   */
+  pathParamsDefault?: string
+  /**
+   * Extra parameters appended after the standard operation parameters.
+   *
+   * @example Plugin-specific trailing parameter
+   * ```ts
+   * extraParams: [createFunctionParameter({ name: 'options', type: 'Partial<RequestOptions>', default: '{}' })]
+   * ```
+   */
+  extraParams?: Array<FunctionParameterNode | ParameterGroupNode>
+  /**
+   * Override the default parameter names used for body, query, header, and rest-path groups.
+   *
+   * Useful when targeting languages or frameworks with different naming conventions.
+   *
+   * @default { data: 'data', params: 'params', headers: 'headers', path: 'pathParams' }
+   */
+  paramNames?: {
+    /**
+     * Name for the request body parameter.
+     * @default 'data'
+     */
+    data?: string
+    /**
+     * Name for the query parameters group parameter.
+     * @default 'params'
+     */
+    params?: string
+    /**
+     * Name for the header parameters group parameter.
+     * @default 'headers'
+     */
+    headers?: string
+    /**
+     * Name for the rest path-parameters parameter when `pathParamsType` is `'inlineSpread'`.
+     * @default 'pathParams'
+     */
+    path?: string
+  }
+  /**
+   * Applies a uniform transformation to every resolved type name before it is used
+   * in a parameter node. Use this for framework-level type wrappers.
+   *
+   * @example Vue Query — wrap every parameter type with `MaybeRefOrGetter`
+   * `typeWrapper: (t) => \`MaybeRefOrGetter<${t}>\``
+   */
+  typeWrapper?: (type: string) => string
+}
 
-  return {
-    ...schema,
-    optional: !required && !nullable ? true : undefined,
-    nullish: !required && nullable ? true : undefined,
+function resolveType({ node, param, resolver }: { node: OperationNode; param: ParameterNode; resolver: OperationParamsResolver | undefined }): TypeNode {
+  if (!resolver) {
+    return createTypeNode({ variant: 'reference', name: param.schema.primitive ?? 'unknown' })
   }
+
+  const individualName = resolver.resolveParamName(node, param)
+
+  const groupLocation = param.in === 'path' || param.in === 'query' || param.in === 'header' ? param.in : undefined
+
+  const groupResolvers = {
+    path: resolver.resolvePathParamsName,
+    query: resolver.resolveQueryParamsName,
+    header: resolver.resolveHeaderParamsName,
+  } as const
+
+  const groupName = groupLocation ? groupResolvers[groupLocation].call(resolver, node, param) : undefined
+
+  if (groupName && groupName !== individualName) {
+    return createTypeNode({ variant: 'member', base: groupName, key: param.name })
+  }
+
+  return createTypeNode({ variant: 'reference', name: individualName })
+}
+
+/**
+ * Converts an {@link OperationNode} into a {@link FunctionParametersNode}.
+ *
+ * Centralizes the per-plugin `getParams()` pattern. Provide a `resolver` for
+ * type resolution and `extraParams` for plugin-specific trailing parameters.
+ *
+ * @example
+ * ```ts
+ * const params = createOperationParams(node, {
+ *   paramsType: 'inline',
+ *   pathParamsType: 'inline',
+ *   resolver: tsResolver,
+ *   extraParams: [createFunctionParameter({ name: 'options', type: createTypeNode({ variant: 'reference', name: 'Partial<RequestOptions>' }), default: '{}' })],
+ * })
+ * ```
+ */
+export function createOperationParams(node: OperationNode, options: CreateOperationParamsOptions): FunctionParametersNode {
+  const { paramsType, pathParamsType, paramsCasing, resolver, pathParamsDefault, extraParams = [], paramNames, typeWrapper } = options
+
+  const dataName = paramNames?.data ?? 'data'
+  const paramsName = paramNames?.params ?? 'params'
+  const headersName = paramNames?.headers ?? 'headers'
+  const pathName = paramNames?.path ?? 'pathParams'
+
+  const wrapType = (type: string): TypeNode => createTypeNode({ variant: 'reference', name: typeWrapper ? typeWrapper(type) : type })
+  // Only reference TypeNodes are wrapped (they hold a plain type name string).
+  // Member and struct TypeNodes are pre-resolved structured expressions and are passed through unchanged.
+  const wrapTypeNode = (type: TypeNode): TypeNode => (type.variant === 'reference' ? wrapType(type.name) : type)
+
+  const casedParams = caseParams(node.parameters, paramsCasing)
+  const pathParams = casedParams.filter((p) => p.in === 'path')
+  const queryParams = casedParams.filter((p) => p.in === 'query')
+  const headerParams = casedParams.filter((p) => p.in === 'header')
+
+  const bodyType = node.requestBody?.schema ? wrapType(resolver?.resolveDataName(node) ?? 'unknown') : undefined
+  const bodyRequired = node.requestBody?.required ?? false
+
+  const queryGroupType = resolver ? resolveGroupType({ node, params: queryParams, groupMethod: resolver.resolveQueryParamsName, resolver }) : undefined
+  const headerGroupType = resolver ? resolveGroupType({ node, params: headerParams, groupMethod: resolver.resolveHeaderParamsName, resolver }) : undefined
+
+  const params: Array<FunctionParameterNode | ParameterGroupNode> = []
+
+  if (paramsType === 'object') {
+    const children: Array<FunctionParameterNode> = [
+      ...pathParams.map((p) => {
+        const type = resolveType({ node, param: p, resolver })
+        return createFunctionParameter({ name: p.name, type: wrapTypeNode(type), optional: !p.required })
+      }),
+      ...(bodyType ? [createFunctionParameter({ name: dataName, type: bodyType, optional: !bodyRequired })] : []),
+      ...buildGroupParam({ name: paramsName, node, params: queryParams, groupType: queryGroupType, resolver, wrapType }),
+      ...buildGroupParam({ name: headersName, node, params: headerParams, groupType: headerGroupType, resolver, wrapType }),
+    ]
+
+    if (children.length) {
+      params.push(createParameterGroup({ properties: children, default: children.every((c) => c.optional) ? '{}' : undefined }))
+    }
+  } else {
+    if (pathParams.length) {
+      if (pathParamsType === 'inlineSpread') {
+        const spreadType = resolver?.resolvePathParamsName(node, pathParams[0]!) ?? undefined
+        params.push(createFunctionParameter({ name: pathName, type: spreadType ? wrapType(spreadType) : undefined, rest: true }))
+      } else {
+        const pathChildren = pathParams.map((p) => {
+          const type = resolveType({ node, param: p, resolver })
+          return createFunctionParameter({ name: p.name, type: wrapTypeNode(type), optional: !p.required })
+        })
+        params.push(
+          createParameterGroup({
+            properties: pathChildren,
+            inline: pathParamsType === 'inline',
+            default: pathParamsDefault ?? (pathChildren.every((c) => c.optional) ? '{}' : undefined),
+          }),
+        )
+      }
+    }
+
+    if (bodyType) {
+      params.push(createFunctionParameter({ name: dataName, type: bodyType, optional: !bodyRequired }))
+    }
+
+    params.push(...buildGroupParam({ name: paramsName, node, params: queryParams, groupType: queryGroupType, resolver, wrapType }))
+    params.push(...buildGroupParam({ name: headersName, node, params: headerParams, groupType: headerGroupType, resolver, wrapType }))
+  }
+
+  params.push(...extraParams)
+
+  return createFunctionParameters({ params })
+}
+
+/**
+ * Builds a single {@link FunctionParameterNode} for a query or header group.
+ * Returns an empty array when there are no params to emit.
+ *
+ * If a pre-resolved `groupType` is provided it emits `name: GroupType`.
+ * Otherwise, it builds an inline struct from the individual params.
+ */
+function buildGroupParam({
+  name,
+  node,
+  params,
+  groupType,
+  resolver,
+  wrapType,
+}: {
+  name: string
+  node: OperationNode
+  params: Array<ParameterNode>
+  groupType: ParamGroupType | undefined
+  resolver: OperationParamsResolver | undefined
+  wrapType: (type: string) => TypeNode
+}): Array<FunctionParameterNode> {
+  if (groupType) {
+    const type = groupType.type.variant === 'reference' ? wrapType(groupType.type.name) : groupType.type
+    return [createFunctionParameter({ name, type, optional: groupType.optional })]
+  }
+  if (params.length) {
+    return [
+      createFunctionParameter({
+        name,
+        type: toStructType({ node, params, resolver }),
+        optional: params.every((p) => !p.required),
+      }),
+    ]
+  }
+  return []
+}
+
+/**
+ * Derives a {@link ParamGroupType} from the resolver's group method.
+ * Returns `undefined` when the group name equals the individual param name (no real group).
+ */
+function resolveGroupType({
+  node,
+  params,
+  groupMethod,
+  resolver,
+}: {
+  node: OperationNode
+  params: Array<ParameterNode>
+  groupMethod: (_node: OperationNode, _param: ParameterNode) => string
+  resolver: OperationParamsResolver
+}): ParamGroupType | undefined {
+  if (!params.length) {
+    return undefined
+  }
+  const firstParam = params[0]!
+  const groupName = groupMethod.call(resolver, node, firstParam)
+  if (groupName === resolver.resolveParamName(node, firstParam)) {
+    return undefined
+  }
+  const allOptional = params.every((p) => !p.required)
+  return { type: createTypeNode({ variant: 'reference', name: groupName }), optional: allOptional }
+}
+
+/**
+ * Builds a {@link TypeNode} with `variant: 'struct'` for an inline anonymous type grouping named fields.
+ *
+ * Used when query or header parameters have no dedicated group type name.
+ * Each language printer renders this appropriately (TypeScript: `{ petId: string; name?: string }`).
+ */
+function toStructType({
+  node,
+  params,
+  resolver,
+}: {
+  node: OperationNode
+  params: Array<ParameterNode>
+  resolver: OperationParamsResolver | undefined
+}): TypeNode {
+  return createTypeNode({
+    variant: 'struct',
+    properties: params.map((p) => ({ name: p.name, optional: !p.required, type: resolveType({ node, param: p, resolver }) })),
+  })
 }

package/src/visitor.ts

@@ -288,8 +288,9 @@ function getChildren(node: Node, recurse: boolean): Array<Node> {
     case 'Response':
       return node.schema ? [node.schema] : []
     case 'FunctionParameter':
-    case 'ObjectBindingParameter':
+    case 'ParameterGroup':
     case 'FunctionParameters':
+    case 'Type':
       return []
   }
 }
@@ -342,7 +343,7 @@ async function _walk(node: Node, visitor: AsyncVisitor, recurse: boolean, limit:
       await limit(() => visitor.response?.(node, { parent: parent as ParentOf<ResponseNode> }))
       break
     case 'FunctionParameter':
-    case 'ObjectBindingParameter':
+    case 'ParameterGroup':
     case 'FunctionParameters':
       break
   }
@@ -457,8 +458,9 @@ export function transform(node: Node, options: TransformOptions): Node {
       }
     }
     case 'FunctionParameter':
-    case 'ObjectBindingParameter':
+    case 'ParameterGroup':
     case 'FunctionParameters':
+    case 'Type':
       return node
   }
 }
@@ -546,7 +548,7 @@ export function collect<T>(node: Node, options: CollectOptions<T>): Array<T> {
       v = visitor.response?.(node, { parent: parent as ParentOf<ResponseNode> })
       break
     case 'FunctionParameter':
-    case 'ObjectBindingParameter':
+    case 'ParameterGroup':
     case 'FunctionParameters':
       break
   }

package/src/printers/functionPrinter.ts

@@ -1,196 +0,0 @@
-import type { FunctionNode, FunctionNodeType } from '../nodes/function.ts'
-import type { FunctionParameterNode, FunctionParametersNode, ObjectBindingParameterNode } from '../nodes/index.ts'
-import type { PrinterFactoryOptions } from './printer.ts'
-import { createPrinterFactory } from './printer.ts'
-
-/**
- * Maps each function-printer handler key to its concrete node type.
- */
-export type FunctionNodeByType = {
-  functionParameter: FunctionParameterNode
-  objectBindingParameter: ObjectBindingParameterNode
-  functionParameters: FunctionParametersNode
-}
-
-const kindToHandlerKey = {
-  FunctionParameter: 'functionParameter',
-  ObjectBindingParameter: 'objectBindingParameter',
-  FunctionParameters: 'functionParameters',
-} satisfies Record<string, FunctionNodeType>
-
-/**
- * Creates a function-parameter printer factory.
- *
- * This wrapper uses `createPrinterFactory` and dispatches handlers by `node.kind`
- * (for function nodes) rather than by `node.type` (for schema nodes).
- *
- * @example
- * ```ts
- * type MyPrinter = PrinterFactoryOptions<'my', { mode: 'declaration' | 'call' }, string>
- *
- * export const myPrinter = defineFunctionPrinter<MyPrinter>((options) => ({
- *   name: 'my',
- *   options,
- *   nodes: {
- *     functionParameter(node) {
- *       return options.mode === 'declaration' && node.type ? `${node.name}: ${node.type}` : node.name
- *     },
- *     objectBindingParameter(node) {
- *       const inner = node.properties.map(p => this.transform(p)).filter(Boolean).join(', ')
- *       return `{ ${inner} }`
- *     },
- *     functionParameters(node) {
- *       return node.params.map(p => this.transform(p)).filter(Boolean).join(', ')
- *     },
- *   },
- * }))
- * ```
- */
-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 | ObjectBindingParameterNode): number {
-  if (param.kind === 'ObjectBindingParameter') {
-    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: Array<FunctionParameterNode | ObjectBindingParameterNode>): Array<FunctionParameterNode | ObjectBindingParameterNode> {
-  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: {
-    functionParameter(node) {
-      const { mode, transformName, transformType } = this.options
-      const name = transformName ? transformName(node.name) : node.name
-      const type = node.type && transformType ? transformType(node.type) : node.type
-
-      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
-    },
-    objectBindingParameter(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 = node.type
-      if (!typeAnnotation) {
-        const typeParts = sorted
-          .filter((p) => p.type)
-          .map((p) => {
-            const t = transformType && p.type ? transformType(p.type) : p.type!
-            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/index.ts

@@ -1,3 +0,0 @@
-export { defineFunctionPrinter, functionPrinter } from './functionPrinter.ts'
-export type { Printer, PrinterFactoryOptions } from './printer.ts'
-export { createPrinterFactory, definePrinter } from './printer.ts'