@kubb/ast 5.0.0-beta.63 → 5.0.0-beta.64

package/src/defineNode.ts

@@ -1,102 +0,0 @@
-import type { BaseNode, NodeKind } from './nodes/base.ts'
-
-/**
- * Visitor callback names, one per traversable node kind, in traversal order.
- * Kept in sync with the keys of `Visitor` in `visitor.ts`.
- */
-export const visitorKeys = ['input', 'output', 'operation', 'schema', 'property', 'parameter', 'response'] as const
-
-/**
- * One of the {@link visitorKeys} callback names.
- */
-export type VisitorKey = (typeof visitorKeys)[number]
-
-/**
- * Distributive `Omit` that preserves each member of a union.
- *
- * @example
- * ```ts
- * type A = { kind: 'a'; keep: string; drop: number }
- * type B = { kind: 'b'; keep: boolean; drop: number }
- * type Result = DistributiveOmit<A | B, 'drop'>
- * // -> { kind: 'a'; keep: string } | { kind: 'b'; keep: boolean }
- * ```
- */
-export type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never
-
-/**
- * Builds a type guard that matches nodes of the given `kind`.
- */
-function isKind<T extends BaseNode>(kind: NodeKind) {
-  return (node: unknown): node is T => (node as BaseNode | undefined)?.kind === kind
-}
-
-/**
- * The single definition derived from one {@link defineNode} call: the node's
- * `create` builder, its `is` guard, and the traversal metadata the registry
- * collects into the visitor tables.
- */
-export type NodeDef<TNode extends BaseNode = BaseNode, TInput = never> = {
-  /**
-   * Node discriminator this definition owns.
-   */
-  kind: NodeKind
-  /**
-   * Builds a node from its input, applying `defaults` and the optional `build` hook.
-   */
-  create: (input: TInput) => TNode
-  /**
-   * Type guard matching this node kind.
-   */
-  is: (node: unknown) => node is TNode
-  /**
-   * Child node fields in traversal order. Feeds `VISITOR_KEYS`.
-   */
-  children?: ReadonlyArray<string>
-  /**
-   * Visitor callback name. Feeds `VISITOR_KEY_BY_KIND`.
-   */
-  visitorKey?: VisitorKey
-}
-
-type DefineNodeConfig<TNode extends BaseNode, TInput, TBuilt extends object> = {
-  kind: TNode['kind']
-  defaults?: Partial<TNode>
-  build?: (input: TInput) => TBuilt
-  children?: ReadonlyArray<string>
-  visitorKey?: VisitorKey
-}
-
-/**
- * Defines a node once and derives its `create` builder, `is` guard, and traversal
- * metadata. `create` merges `defaults`, the `build` hook (or the raw input), and the
- * `kind`, so node construction lives in one place without scattered `as` casts.
- *
- * @example Simple node
- * ```ts
- * const importDef = defineNode<ImportNode>({ kind: 'Import' })
- * const createImport = importDef.create
- * ```
- *
- * @example Node with a build hook
- * ```ts
- * const propertyDef = defineNode<PropertyNode, UserPropertyNode>({
- *   kind: 'Property',
- *   build: (props) => ({ ...props, required: props.required ?? false }),
- *   children: ['schema'],
- *   visitorKey: 'property',
- * })
- * ```
- */
-export function defineNode<TNode extends BaseNode, TInput = Omit<TNode, 'kind'>, TBuilt extends object = Omit<TNode, 'kind'>>(
-  config: DefineNodeConfig<TNode, TInput, TBuilt>,
-): NodeDef<TNode, TInput> {
-  const { kind, defaults, build, children, visitorKey } = config
-
-  function create(input: TInput): TNode {
-    const base = build ? build(input) : input
-    return { ...defaults, ...(base as object), kind } as TNode
-  }
-
-  return { kind, create, is: isKind<TNode>(kind), children, visitorKey }
-}

package/src/definePrinter.ts

@@ -1,258 +0,0 @@
-import type { SchemaNode, SchemaNodeByType, SchemaType } from './nodes/index.ts'
-
-/**
- * Runtime context passed as `this` to printer handlers.
- *
- * `this.transform` dispatches to node-level handlers from `nodes`.
- *
- * @example
- * ```ts
- * const context: PrinterHandlerContext<string, {}> = {
- *   options: {},
- *   transform: () => 'value',
- * }
- * ```
- */
-type PrinterHandlerContext<TOutput, TOptions extends object> = {
-  /**
-   * Recursively transform a nested `SchemaNode` to `TOutput` using the node-level handlers.
-   * Use `this.transform` inside `nodes` handlers and inside the `print` override.
-   */
-  transform: (node: SchemaNode) => TOutput | null
-  /**
-   * Options for this printer instance.
-   */
-  options: TOptions
-}
-
-/**
- * Handler for one schema node type.
- *
- * Use a regular function (not an arrow function) if you need `this`.
- *
- * @example
- * ```ts
- * const handler: PrinterHandler<string, {}, 'string'> = function () {
- *   return 'string'
- * }
- * ```
- */
-type PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (
-  this: PrinterHandlerContext<TOutput, TOptions>,
-  node: SchemaNodeByType[T],
-) => TOutput | null
-
-/**
- * Partial map of per-node-type handler overrides for a printer.
- *
- * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`).
- * Supply only the handlers you want to replace. The printer's built-in
- * defaults fill in the rest.
- *
- * @example
- * ```ts
- * pluginZod({
- *   printer: {
- *     nodes: {
- *       date(): string {
- *         return 'z.string().date()'
- *       },
- *     } satisfies PrinterPartial<string, PrinterZodOptions>,
- *   },
- * })
- * ```
- */
-export type PrinterPartial<TOutput, TOptions extends object> = Partial<{
-  [K in SchemaType]: PrinterHandler<TOutput, TOptions, K>
-}>
-
-/**
- * Generic shape used by `definePrinter`.
- *
- * - `TName` unique string identifier (e.g. `'zod'`, `'ts'`)
- * - `TOptions` options passed to and stored on the printer instance
- * - `TOutput` the type emitted by node handlers
- * - `TPrintOutput` type returned by public `print` (defaults to `TOutput`)
- *
- * @example
- * ```ts
- * type MyPrinter = PrinterFactoryOptions<'my', { strict: boolean }, string>
- * ```
- */
-export type PrinterFactoryOptions<TName extends string = string, TOptions extends object = object, TOutput = unknown, TPrintOutput = TOutput> = {
-  name: TName
-  options: TOptions
-  output: TOutput
-  printOutput: TPrintOutput
-}
-
-/**
- * Printer instance returned by a printer factory.
- *
- * @example
- * ```ts
- * const printer = definePrinter((options: {}) => ({ name: 'x', options, nodes: {} }))({})
- * ```
- */
-export type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {
-  /**
-   * Unique identifier supplied at creation time.
-   */
-  name: T['name']
-  /**
-   * Options for this printer instance.
-   */
-  options: T['options']
-  /**
-   * Node-level dispatcher, converts a `SchemaNode` directly to `TOutput` using the `nodes` handlers.
-   * Always dispatches through the `nodes` map. Never calls the `print` override.
-   * Reach for it when you need the raw output (e.g. `ts.TypeNode`) without declaration wrapping.
-   */
-  transform: (node: SchemaNode) => T['output'] | null
-  /**
-   * Public printer. If the builder provides a root-level `print`, this calls that
-   * higher-level function (which may produce full declarations).
-   * Otherwise, falls back to the node-level dispatcher.
-   */
-  print: (node: SchemaNode) => T['printOutput'] | null
-}
-
-/**
- * Builder function passed to `definePrinter`.
- *
- * It receives resolved options and returns:
- * - `name`
- * - `options`
- * - `nodes` handlers
- * - optional top-level `print` override
- *
- * @example
- * ```ts
- * const build = (options: {}) => ({ name: 'x' as const, options, nodes: {} })
- * ```
- */
-type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) => {
-  name: T['name']
-  /**
-   * Options to store on the printer.
-   */
-  options: T['options']
-  nodes: Partial<{
-    [K in SchemaType]: PrinterHandler<T['output'], T['options'], K>
-  }>
-  /**
-   * Optional root-level print override. When provided, becomes the public `printer.print`.
-   * Use `this.transform(node)` inside this function to dispatch to the node-level handlers (`nodes`),
-   * not the override itself, so recursion is safe.
-   */
-  print?: (this: PrinterHandlerContext<T['output'], T['options']>, node: SchemaNode) => T['printOutput'] | null
-}
-/**
- * Defines a schema printer: a function that takes a `SchemaNode` and emits
- * code in your target language. Each plugin that produces code from schemas
- * (TypeScript types, Zod schemas, Faker factories) ships a printer built
- * with this helper.
- *
- * The builder receives resolved options and returns:
- *
- * - `name` unique identifier for the printer.
- * - `options` stored on the returned printer instance.
- * - `nodes` map of `SchemaType` → handler. Handlers return the rendered
- *   output (a string, a TypeScript AST node, ...) for that schema type.
- * - `print` (optional), top-level override exposed as `printer.print`.
- *   Use `this.transform(node)` inside it to dispatch to `nodes` recursively.
- *
- * Without a `print` override, `printer.print` falls back to `printer.transform`
- * (the node-level dispatcher).
- *
- * @example Tiny Zod printer
- * ```ts
- * import { definePrinter, type PrinterFactoryOptions } from '@kubb/ast'
- *
- * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
- *
- * export const zodPrinter = definePrinter<PrinterZod>((options) => ({
- *   name: 'zod',
- *   options: { strict: options.strict ?? true },
- *   nodes: {
- *     string: () => 'z.string()',
- *     object(node) {
- *       const props = node.properties
- *         .map((p) => `${p.name}: ${this.transform(p.schema)}`)
- *         .join(', ')
- *       return `z.object({ ${props} })`
- *     },
- *   },
- * }))
- * ```
- */
-export function definePrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T> {
-  return createPrinterFactory<SchemaNode, SchemaType, SchemaNodeByType>((node) => node.type)(build) as (options?: T['options']) => Printer<T>
-}
-
-/**
- * Generic printer factory behind `definePrinter`. Pass a `getKey` function that maps a node to its
- * handler key, and it returns a `definePrinter`-style helper for that node and key type. `definePrinter`
- * itself is this factory keyed by `node.type`.
- *
- * @example Key a printer by `node.kind` instead of `node.type`
- * ```ts
- * const defineFunctionPrinter = createPrinterFactory<FunctionParamNode, FunctionParamKind, Partial<Record<FunctionParamKind, FunctionParamNode>>>(
- *   (node) => node.kind,
- * )
- * ```
- */
-export function createPrinterFactory<TNode, TKey extends string, TNodeByKey extends Partial<Record<TKey, TNode>>>(getKey: (node: TNode) => TKey | null) {
-  return function <T extends PrinterFactoryOptions>(
-    build: (options: T['options']) => {
-      name: T['name']
-      options: T['options']
-      nodes: Partial<{
-        [K in TKey]: (
-          this: {
-            transform: (node: TNode) => T['output'] | null
-            options: T['options']
-          },
-          node: TNodeByKey[K],
-        ) => T['output'] | null
-      }>
-      print?: (
-        this: {
-          transform: (node: TNode) => T['output'] | null
-          options: T['options']
-        },
-        node: TNode,
-      ) => T['printOutput'] | null
-    },
-  ): (options?: T['options']) => {
-    name: T['name']
-    options: T['options']
-    transform: (node: TNode) => T['output'] | null
-    print: (node: TNode) => T['printOutput'] | null
-  } {
-    return (options) => {
-      const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? ({} as T['options']))
-
-      const context = {
-        options: resolvedOptions,
-        transform: (node: TNode): T['output'] | null => {
-          const key = getKey(node)
-          if (key === null) return null
-
-          const handler = nodes[key]
-
-          if (!handler) return null
-
-          return (handler as (this: typeof context, node: TNode) => T['output'] | null).call(context, node)
-        },
-      }
-
-      return {
-        name,
-        options: resolvedOptions,
-        transform: context.transform,
-        print: (printOverride ? printOverride.bind(context) : context.transform) as (node: TNode) => T['printOutput'] | null,
-      }
-    }
-  }
-}

package/src/dialect.ts

@@ -1,86 +0,0 @@
-import type { Node } from './nodes/index.ts'
-
-/**
- * The spec-specific questions a schema parser answers while turning a source document into Kubb
- * AST nodes. The rest of the pipeline is generic JSON Schema, so this is the one seam where
- * OpenAPI, AsyncAPI, and plain JSON Schema differ.
- */
-export type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {
-  /**
-   * Whether the schema is nullable.
-   */
-  isNullable(schema?: TSchema): boolean
-  /**
-   * Whether the value is a `$ref` pointer.
-   */
-  isReference(value?: unknown): value is TRef
-  /**
-   * Whether the schema carries a discriminator for polymorphism.
-   */
-  isDiscriminator(value?: unknown): value is TDiscriminated
-  /**
-   * Whether the schema is binary data, converted to a `blob` node.
-   */
-  isBinary(schema: TSchema): boolean
-  /**
-   * Resolves a local `$ref` against the document, or nullish when it cannot.
-   */
-  resolveRef<TResolved>(document: TDocument, ref: string): TResolved | null | undefined
-}
-
-/**
- * How a dialect collapses structurally identical schemas into shared definitions. The contract is
- * generic over the plan and context types, which the adapter supplies. The mechanics live in the
- * adapter, not here, so `@kubb/ast` carries no dedupe logic. The returned plan owns the rewriting
- * behavior, so callers interact with one object.
- */
-export type Dedupe<TPlan = unknown, TContext = unknown> = {
-  /**
-   * Scans a forest of nodes and produces a plan describing which shapes to share.
-   */
-  plan(roots: ReadonlyArray<Node>, context: TContext): TPlan
-}
-
-/**
- * A spec adapter's dialect. `name` identifies it in logs and diagnostics, `schema` holds the
- * spec-specific schema questions the parser answers, and `dedupe` is the schema-sharing seam.
- */
-export type Dialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown, TDedupe extends Dedupe = Dedupe> = {
-  /**
-   * Identifies the dialect in logs and diagnostics.
-   */
-  name: string
-  /**
-   * The spec-specific schema behavior. See {@link SchemaDialect}.
-   */
-  schema: SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>
-  /**
-   * The schema-sharing behavior. See {@link Dedupe}.
-   */
-  dedupe: TDedupe
-}
-
-/**
- * Types a {@link Dialect} for an adapter. Adds no runtime behavior and only pins the
- * dialect's type for inference.
- *
- * @example
- * ```ts
- * export const oasDialect = defineDialect({
- *   name: 'oas',
- *   schema: {
- *     isNullable,
- *     isReference,
- *     isDiscriminator,
- *     isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
- *     resolveRef,
- *   },
- *   dedupe: { plan },
- * })
- * ```
- */
-export function defineDialect<TSchema, TRef, TDiscriminated, TDocument, TDedupe extends Dedupe>(
-  dialect: Dialect<TSchema, TRef, TDiscriminated, TDocument, TDedupe>,
-): Dialect<TSchema, TRef, TDiscriminated, TDocument, TDedupe> {
-  return dialect
-}

package/src/factory.ts

@@ -1,44 +0,0 @@
-import type { Node } from './nodes/index.ts'
-
-// Node constructors, grouped under the `factory` namespace the way the TypeScript compiler exposes
-// `ts.factory.createX`. Aggregating them here lets `export * as factory from './factory.ts'` in the
-// barrel surface every `createX` alongside the `createFile`/`update` helpers from a single module.
-export { createArrowFunction, createBreak, createConst, createFunction, createJsx, createText, createType } from './nodes/code.ts'
-export { createContent } from './nodes/content.ts'
-export { createExport, createFile, createImport, createSource } from './nodes/file.ts'
-export type { UserFileNode } from './nodes/file.ts'
-export { createFunctionParameter, createFunctionParameters, createIndexedAccessType, createObjectBindingPattern, createTypeLiteral } from './nodes/function.ts'
-export { createInput } from './nodes/input.ts'
-export { createOperation } from './nodes/operation.ts'
-export { createOutput } from './nodes/output.ts'
-export { createParameter } from './nodes/parameter.ts'
-export { createProperty } from './nodes/property.ts'
-export { createRequestBody } from './nodes/requestBody.ts'
-export { createResponse } from './nodes/response.ts'
-export { createSchema } from './nodes/schema.ts'
-
-/**
- * Identity-preserving node update: returns `node` unchanged when every field in
- * `changes` already equals (by reference) the current value, otherwise a new node
- * with the changes applied.
- *
- * Mirrors the TypeScript compiler's `factory.updateX` contract. Pair it with the
- * structural sharing in {@link transform} so a no-op rewrite does not allocate and
- * downstream passes can detect "nothing changed" by identity. Comparison is shallow,
- * so a structurally equal but newly allocated array or object counts as a change.
- *
- * @example
- * ```ts
- * update(node, { name: node.name })        // -> same `node` reference
- * update(node, { name: 'renamed' })        // -> new node, `name` replaced
- * ```
- */
-export function update<T extends Node>(node: T, changes: Partial<T>): T {
-  for (const key in changes) {
-    if (changes[key] !== node[key as keyof T]) {
-      return { ...node, ...changes }
-    }
-  }
-
-  return node
-}

package/src/guards.ts

@@ -1,28 +0,0 @@
-import type { HttpOperationNode, OperationNode, SchemaNode, SchemaNodeByType } from './nodes/index.ts'
-
-/**
- * Narrows a `SchemaNode` to the variant that matches `type`.
- *
- * @example
- * ```ts
- * const schema = createSchema({ type: 'string' })
- * const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | null
- * ```
- */
-export function narrowSchema<T extends SchemaNode['type']>(node: SchemaNode | undefined, type: T): SchemaNodeByType[T] | null {
-  return node?.type === type ? (node as SchemaNodeByType[T]) : null
-}
-
-/**
- * Narrows an `OperationNode` to an `HttpOperationNode` so `method` and `path` are present.
- *
- * @example
- * ```ts
- * if (isHttpOperationNode(node)) {
- *   console.log(node.method, node.path)
- * }
- * ```
- */
-export function isHttpOperationNode(node: OperationNode): node is HttpOperationNode {
-  return node.protocol === 'http' || (node.method !== undefined && node.path !== undefined)
-}

package/src/index.ts

@@ -1,13 +0,0 @@
-export { schemaTypes } from './constants.ts'
-export { defineDialect } from './dialect.ts'
-export { isHttpOperationNode, narrowSchema } from './guards.ts'
-export { applyMacros, composeMacros, defineMacro } from './defineMacro.ts'
-export { defineNode } from './defineNode.ts'
-export { optionality } from './optionality.ts'
-export { createPrinterFactory, definePrinter } from './definePrinter.ts'
-export { signatureOf } from './signature.ts'
-export { collect, transform, walk } from './visitor.ts'
-
-export * as factory from './factory.ts'
-export * from './registry.ts'
-export type * from './types.ts'

package/src/infer.ts

@@ -1,132 +0,0 @@
-import type {
-  ArraySchemaNode,
-  DateSchemaNode,
-  DatetimeSchemaNode,
-  EnumSchemaNode,
-  IntersectionSchemaNode,
-  NumberSchemaNode,
-  ObjectSchemaNode,
-  RefSchemaNode,
-  ScalarSchemaNode,
-  SchemaNode,
-  StringSchemaNode,
-  TimeSchemaNode,
-  UnionSchemaNode,
-  UrlSchemaNode,
-} from './nodes/index.ts'
-
-/**
- * Options that control how the adapter parser maps OpenAPI schemas to AST nodes.
- */
-export type ParserOptions = {
-  /**
-   * How `format: 'date-time'` schemas are represented downstream.
-   * - `false` falls through to a plain `string` (no validation).
-   * - `'string'` emits a datetime string node.
-   * - `'stringOffset'` emits a datetime node with timezone offset.
-   * - `'stringLocal'` emits a local datetime node.
-   * - `'date'` emits a `date` node (JavaScript `Date` object).
-   */
-  dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date'
-  /**
-   * How `type: 'integer'` (and `format: 'int64'`) maps to TypeScript.
-   * - `'bigint'` is exact for 64-bit IDs, but does not round-trip through JSON.
-   * - `'number'` fits most JSON APIs. Loses precision above `Number.MAX_SAFE_INTEGER`.
-   *
-   * @default 'bigint'
-   */
-  integerType?: 'number' | 'bigint'
-  /**
-   * AST type used when a schema's type cannot be inferred from the spec
-   * (`additionalProperties: true`, missing `type`, ...).
-   */
-  unknownType: 'any' | 'unknown' | 'void'
-  /**
-   * AST type used for completely empty schemas (`{}`).
-   */
-  emptySchemaType: 'any' | 'unknown' | 'void'
-  /**
-   * Suffix appended to derived enum names when Kubb has to invent one
-   * (typically for inline enums on object properties).
-   */
-  enumSuffix: 'enum' | (string & {})
-}
-
-/**
- * Maps each `dateType` option value to the AST node produced by `format: 'date-time'`.
- */
-type DateTimeNodeByDateType = {
-  date: DateSchemaNode
-  string: DatetimeSchemaNode
-  stringOffset: DatetimeSchemaNode
-  stringLocal: DatetimeSchemaNode
-  false: StringSchemaNode
-}
-
-/**
- * Resolves the AST node produced by `format: 'date-time'` based on the `dateType` option.
- */
-type ResolveDateTimeNode<TDateType extends ParserOptions['dateType']> = DateTimeNodeByDateType[TDateType extends keyof DateTimeNodeByDateType
-  ? TDateType
-  : 'string']
-
-/**
- * Ordered list of `[schema-shape, SchemaNode]` pairs.
- * `InferSchemaNode` walks this tuple in order and returns the first matching node type.
- */
-type SchemaNodeMap<TDateType extends ParserOptions['dateType'] = 'string'> = [
-  [{ $ref: string }, RefSchemaNode],
-  [{ allOf: ReadonlyArray<unknown>; properties: object }, IntersectionSchemaNode],
-  [{ allOf: readonly [unknown, unknown, ...Array<unknown>] }, IntersectionSchemaNode],
-  [{ allOf: ReadonlyArray<unknown> }, SchemaNode],
-  [{ oneOf: ReadonlyArray<unknown> }, UnionSchemaNode],
-  [{ anyOf: ReadonlyArray<unknown> }, UnionSchemaNode],
-  [{ const: null }, ScalarSchemaNode],
-  [{ const: string | number | boolean }, EnumSchemaNode],
-  [{ type: ReadonlyArray<string> }, UnionSchemaNode],
-  [{ type: 'array'; enum: ReadonlyArray<unknown> }, ArraySchemaNode],
-  [{ enum: ReadonlyArray<unknown> }, EnumSchemaNode],
-  [{ type: 'enum' }, EnumSchemaNode],
-  [{ type: 'union' }, UnionSchemaNode],
-  [{ type: 'intersection' }, IntersectionSchemaNode],
-  [{ type: 'tuple' }, ArraySchemaNode],
-  [{ type: 'ref' }, RefSchemaNode],
-  [{ type: 'datetime' }, DatetimeSchemaNode],
-  [{ type: 'date' }, DateSchemaNode],
-  [{ type: 'time' }, TimeSchemaNode],
-  [{ type: 'url' }, UrlSchemaNode],
-  [{ type: 'object' }, ObjectSchemaNode],
-  [{ additionalProperties: boolean | {} }, ObjectSchemaNode],
-  [{ type: 'array' }, ArraySchemaNode],
-  [{ items: object }, ArraySchemaNode],
-  [{ prefixItems: ReadonlyArray<unknown> }, ArraySchemaNode],
-  [{ type: string; format: 'date-time' }, ResolveDateTimeNode<TDateType>],
-  [{ type: string; format: 'date' }, DateSchemaNode],
-  [{ type: string; format: 'time' }, TimeSchemaNode],
-  [{ format: 'date-time' }, ResolveDateTimeNode<TDateType>],
-  [{ format: 'date' }, DateSchemaNode],
-  [{ format: 'time' }, TimeSchemaNode],
-  [{ type: 'string' }, StringSchemaNode],
-  [{ type: 'number' }, NumberSchemaNode],
-  [{ type: 'integer' }, NumberSchemaNode],
-  [{ type: 'bigint' }, NumberSchemaNode],
-  [{ type: string }, ScalarSchemaNode],
-  [{ minLength: number }, StringSchemaNode],
-  [{ maxLength: number }, StringSchemaNode],
-  [{ pattern: string }, StringSchemaNode],
-  [{ minimum: number }, NumberSchemaNode],
-  [{ maximum: number }, NumberSchemaNode],
-]
-
-/**
- * Infers the matching AST `SchemaNode` type from an input schema shape.
- */
-export type InferSchemaNode<
-  TSchema extends object,
-  TDateType extends ParserOptions['dateType'] = 'string',
-  TEntries extends ReadonlyArray<[object, SchemaNode]> = SchemaNodeMap<TDateType>,
-> = TEntries extends [infer TEntry extends [object, SchemaNode], ...infer TRest extends ReadonlyArray<[object, SchemaNode]>]
-  ? TSchema extends TEntry[0]
-    ? TEntry[1]
-    : InferSchemaNode<TSchema, TDateType, TRest>
-  : SchemaNode

package/src/macros/index.ts

@@ -1,3 +0,0 @@
-export { macroDiscriminatorEnum } from './macroDiscriminatorEnum.ts'
-export { macroEnumName } from './macroEnumName.ts'
-export { macroSimplifyUnion } from './macroSimplifyUnion.ts'