@kubb/adapter-oas 5.0.0-alpha.34 → 5.0.0-alpha.36

package/src/parser.ts

@@ -1,38 +1,5 @@
 import { URLPath } from '@internals/utils'
-import {
-  childName,
-  createDiscriminantNode,
-  createInput,
-  createOperation,
-  createParameter,
-  createProperty,
-  createResponse,
-  createSchema,
-  enumPropName,
-  extractRefName,
-  findDiscriminator,
-  mergeAdjacentObjects,
-  narrowSchema,
-  type ParserOptions,
-  setDiscriminatorEnum,
-  setEnumName,
-  simplifyUnion,
-  syncOptionality,
-} from '@kubb/ast'
-import type {
-  DistributiveOmit,
-  HttpMethod,
-  InputNode,
-  OperationNode,
-  ParameterLocation,
-  ParameterNode,
-  PrimitiveSchemaType,
-  PropertyNode,
-  ResponseNode,
-  ScalarSchemaType,
-  SchemaNode,
-  StatusCode,
-} from '@kubb/ast/types'
+import { ast } from '@kubb/core'
 import BaseOas from 'oas'
 import { DEFAULT_PARSER_OPTIONS, enumExtensionKeys, typeOptionMap } from './constants.ts'
 import { isDiscriminator, isNullable, isReference } from './guards.ts'
@@ -75,8 +42,8 @@ type SchemaContext = {
    * Normalized single type string (first element when OAS 3.1 multi-type array).
    */
   type: string | undefined
-  rawOptions: Partial<ParserOptions> | undefined
-  options: ParserOptions
+  rawOptions: Partial<ast.ParserOptions> | undefined
+  options: ast.ParserOptions
 }
 
 /**
@@ -117,8 +84,8 @@ function createSchemaParser(ctx: OasParserContext) {
    * Use `syncSchemaRef(node)` in printers to get a merged view of both.
    * Circular refs are detected via `resolvingRefs` and leave `schema` as `undefined`.
    */
-  function convertRef({ schema, name, nullable, defaultValue, rawOptions }: SchemaContext): SchemaNode {
-    let resolvedSchema: SchemaNode | undefined
+  function convertRef({ schema, name, nullable, defaultValue, rawOptions }: SchemaContext): ast.SchemaNode {
+    let resolvedSchema: ast.SchemaNode | undefined
     const refPath = schema.$ref
     if (refPath && !resolvingRefs.has(refPath)) {
       try {
@@ -133,10 +100,10 @@ function createSchemaParser(ctx: OasParserContext) {
       }
     }
 
-    return createSchema({
+    return ast.createSchema({
       ...buildSchemaNode(schema, name, nullable, defaultValue),
       type: 'ref',
-      name: extractRefName(schema.$ref!),
+      name: ast.extractRefName(schema.$ref!),
       ref: schema.$ref,
       schema: resolvedSchema,
     })
@@ -145,7 +112,7 @@ function createSchemaParser(ctx: OasParserContext) {
   /**
    * Converts an `allOf` schema into a flattened node or an `IntersectionSchemaNode`.
    */
-  function convertAllOf({ schema, name, nullable, defaultValue, rawOptions }: SchemaContext): SchemaNode {
+  function convertAllOf({ schema, name, nullable, defaultValue, rawOptions }: SchemaContext): ast.SchemaNode {
     if (
       schema.allOf!.length === 1 &&
       !schema.properties &&
@@ -158,7 +125,7 @@ function createSchemaParser(ctx: OasParserContext) {
       const mergedNullable = nullable || memberNode.nullable || undefined
       const mergedDefault = schema.default === null && mergedNullable ? undefined : (schema.default ?? memberNode.default)
 
-      return createSchema({
+      return ast.createSchema({
         ...memberNodeProps,
         name,
         title: schema.title ?? memberNode.title,
@@ -170,11 +137,11 @@ function createSchemaParser(ctx: OasParserContext) {
         default: mergedDefault,
         example: schema.example ?? memberNode.example,
         pattern: schema.pattern ?? ('pattern' in memberNode ? memberNode.pattern : undefined),
-      } as DistributiveOmit<SchemaNode, 'kind'>)
+      } as ast.DistributiveOmit<ast.SchemaNode, 'kind'>)
     }
 
     const filteredDiscriminantValues: Array<{ propertyName: string; value: string }> = []
-    const allOfMembers: Array<SchemaNode> = (schema.allOf as Array<SchemaObject | ReferenceObject>)
+    const allOfMembers: Array<ast.SchemaNode> = (schema.allOf as Array<SchemaObject | ReferenceObject>)
       .filter((item) => {
         if (!isReference(item) || !name) return true
         const deref = resolveRef<SchemaObject>(document, item.$ref)
@@ -185,7 +152,7 @@ function createSchemaParser(ctx: OasParserContext) {
         const inOneOf = parentUnion.some((oneOfItem) => isReference(oneOfItem) && oneOfItem.$ref === childRef)
         const inMapping = Object.values(deref.discriminator.mapping ?? {}).some((v) => v === childRef)
         if (inOneOf || inMapping) {
-          const discriminatorValue = findDiscriminator(deref.discriminator.mapping, childRef)
+          const discriminatorValue = ast.findDiscriminator(deref.discriminator.mapping, childRef)
           if (discriminatorValue) {
             filteredDiscriminantValues.push({ propertyName: deref.discriminator.propertyName, value: discriminatorValue })
           }
@@ -225,12 +192,12 @@ function createSchemaParser(ctx: OasParserContext) {
     }
 
     for (const { propertyName, value } of filteredDiscriminantValues) {
-      allOfMembers.push(createDiscriminantNode({ propertyName, value }))
+      allOfMembers.push(ast.createDiscriminantNode({ propertyName, value }))
     }
 
-    return createSchema({
+    return ast.createSchema({
       type: 'intersection',
-      members: [...mergeAdjacentObjects(allOfMembers.slice(0, syntheticStart)), ...mergeAdjacentObjects(allOfMembers.slice(syntheticStart))],
+      members: [...ast.mergeAdjacentObjects(allOfMembers.slice(0, syntheticStart)), ...ast.mergeAdjacentObjects(allOfMembers.slice(syntheticStart))],
       ...buildSchemaNode(schema, name, nullable, defaultValue),
     })
   }
@@ -238,16 +205,16 @@ function createSchemaParser(ctx: OasParserContext) {
   /**
    * Converts a `oneOf` / `anyOf` schema into a `UnionSchemaNode`.
    */
-  function convertUnion({ schema, name, nullable, defaultValue, rawOptions }: SchemaContext): SchemaNode {
-    function pickDiscriminatorPropertyNode(node: SchemaNode, propertyName: string): SchemaNode | null {
-      const objectNode = narrowSchema(node, 'object')
+  function convertUnion({ schema, name, nullable, defaultValue, rawOptions }: SchemaContext): ast.SchemaNode {
+    function pickDiscriminatorPropertyNode(node: ast.SchemaNode, propertyName: string): ast.SchemaNode | null {
+      const objectNode = ast.narrowSchema(node, 'object')
       const discriminatorProperty = objectNode?.properties?.find((property) => property.name === propertyName)
 
       if (!discriminatorProperty) {
         return null
       }
 
-      return createSchema({
+      return ast.createSchema({
         type: 'object',
         primitive: 'object',
         properties: [discriminatorProperty],
@@ -273,7 +240,7 @@ function createSchemaParser(ctx: OasParserContext) {
     if (sharedPropertiesNode || discriminator?.mapping) {
       const members = unionMembers.map((s) => {
         const ref = isReference(s) ? s.$ref : undefined
-        const discriminatorValue = findDiscriminator(discriminator?.mapping, ref)
+        const discriminatorValue = ast.findDiscriminator(discriminator?.mapping, ref)
         const memberNode = parseSchema({ schema: s as SchemaObject }, rawOptions)
 
         if (!discriminatorValue || !discriminator) {
@@ -282,7 +249,7 @@ function createSchemaParser(ctx: OasParserContext) {
 
         const narrowedDiscriminatorNode = sharedPropertiesNode
           ? pickDiscriminatorPropertyNode(
-              setDiscriminatorEnum({
+              ast.setDiscriminatorEnum({
                 node: sharedPropertiesNode,
                 propertyName: discriminator.propertyName,
                 values: [discriminatorValue],
@@ -291,13 +258,16 @@ function createSchemaParser(ctx: OasParserContext) {
             )
           : undefined
 
-        return createSchema({
+        return ast.createSchema({
           type: 'intersection',
-          members: [memberNode, narrowedDiscriminatorNode ?? createDiscriminantNode({ propertyName: discriminator.propertyName, value: discriminatorValue })],
+          members: [
+            memberNode,
+            narrowedDiscriminatorNode ?? ast.createDiscriminantNode({ propertyName: discriminator.propertyName, value: discriminatorValue }),
+          ],
         })
       })
 
-      const unionNode = createSchema({
+      const unionNode = ast.createSchema({
         type: 'union',
         ...unionBase,
         members,
@@ -307,28 +277,28 @@ function createSchemaParser(ctx: OasParserContext) {
         return unionNode
       }
 
-      return createSchema({
+      return ast.createSchema({
         type: 'intersection',
         ...buildSchemaNode(schema, name, nullable, defaultValue),
         members: [unionNode, sharedPropertiesNode],
       })
     }
 
-    return createSchema({
+    return ast.createSchema({
       type: 'union',
       ...unionBase,
-      members: simplifyUnion(unionMembers.map((s) => parseSchema({ schema: s as SchemaObject }, rawOptions))),
+      members: ast.simplifyUnion(unionMembers.map((s) => parseSchema({ schema: s as SchemaObject }, rawOptions))),
     })
   }
 
   /**
    * Converts an OAS 3.1 `const` schema into a null scalar or a single-value `EnumSchemaNode`.
    */
-  function convertConst({ schema, name, nullable, defaultValue }: SchemaContext): SchemaNode {
+  function convertConst({ schema, name, nullable, defaultValue }: SchemaContext): ast.SchemaNode {
     const constValue = schema.const
 
     if (constValue === null) {
-      return createSchema({
+      return ast.createSchema({
         type: 'null',
         primitive: 'null',
         name,
@@ -339,7 +309,7 @@ function createSchemaParser(ctx: OasParserContext) {
     }
 
     const constPrimitive = getPrimitiveType(typeof constValue === 'number' ? 'number' : typeof constValue === 'boolean' ? 'boolean' : 'string')
-    return createSchema({
+    return ast.createSchema({
       type: 'enum',
       primitive: constPrimitive,
       enumValues: [constValue as string | number | boolean],
@@ -351,11 +321,11 @@ function createSchemaParser(ctx: OasParserContext) {
    * Converts a format-annotated schema into a special-type `SchemaNode`.
    * Returns `null` when the format should fall through to string handling (`dateType: false`).
    */
-  function convertFormat({ schema, name, nullable, defaultValue, options }: SchemaContext): SchemaNode | null {
+  function convertFormat({ schema, name, nullable, defaultValue, options }: SchemaContext): ast.SchemaNode | null {
     const base = buildSchemaNode(schema, name, nullable, defaultValue)
 
     if (schema.format === 'int64') {
-      return createSchema({
+      return ast.createSchema({
         type: options.integerType === 'bigint' ? 'bigint' : 'integer',
         primitive: 'integer',
         ...base,
@@ -371,39 +341,39 @@ function createSchemaParser(ctx: OasParserContext) {
       if (!dateType) return null
 
       if (dateType.type === 'datetime') {
-        return createSchema({ ...base, primitive: 'string' as const, type: 'datetime', offset: dateType.offset, local: dateType.local })
+        return ast.createSchema({ ...base, primitive: 'string' as const, type: 'datetime', offset: dateType.offset, local: dateType.local })
       }
-      return createSchema({ ...base, primitive: 'string' as const, type: dateType.type, representation: dateType.representation })
+      return ast.createSchema({ ...base, primitive: 'string' as const, type: dateType.type, representation: dateType.representation })
     }
 
     const specialType = getSchemaType(schema.format!)
     if (!specialType) return null
 
-    const specialPrimitive: PrimitiveSchemaType = specialType === 'number' || specialType === 'integer' || specialType === 'bigint' ? specialType : 'string'
+    const specialPrimitive: ast.PrimitiveSchemaType = specialType === 'number' || specialType === 'integer' || specialType === 'bigint' ? specialType : 'string'
 
     if (specialType === 'number' || specialType === 'integer' || specialType === 'bigint') {
-      return createSchema({ ...base, primitive: specialPrimitive, type: specialType })
+      return ast.createSchema({ ...base, primitive: specialPrimitive, type: specialType })
     }
     if (specialType === 'url') {
-      return createSchema({ ...base, primitive: 'string' as const, type: 'url', min: schema.minLength, max: schema.maxLength })
+      return ast.createSchema({ ...base, primitive: 'string' as const, type: 'url', min: schema.minLength, max: schema.maxLength })
     }
     if (specialType === 'ipv4') {
-      return createSchema({ ...base, primitive: 'string' as const, type: 'ipv4' })
+      return ast.createSchema({ ...base, primitive: 'string' as const, type: 'ipv4' })
     }
     if (specialType === 'ipv6') {
-      return createSchema({ ...base, primitive: 'string' as const, type: 'ipv6' })
+      return ast.createSchema({ ...base, primitive: 'string' as const, type: 'ipv6' })
     }
     if (specialType === 'uuid' || specialType === 'email') {
-      return createSchema({ ...base, primitive: 'string' as const, type: specialType, min: schema.minLength, max: schema.maxLength })
+      return ast.createSchema({ ...base, primitive: 'string' as const, type: specialType, min: schema.minLength, max: schema.maxLength })
     }
 
-    return createSchema({ ...base, primitive: specialPrimitive, type: specialType as ScalarSchemaType })
+    return ast.createSchema({ ...base, primitive: specialPrimitive, type: specialType as ast.ScalarSchemaType })
   }
 
   /**
    * Converts an `enum` schema into an `EnumSchemaNode`.
    */
-  function convertEnum({ schema, name, nullable, type, rawOptions }: SchemaContext): SchemaNode {
+  function convertEnum({ schema, name, nullable, type, rawOptions }: SchemaContext): ast.SchemaNode {
     if (type === 'array') {
       return parseSchema({ schema: normalizeArrayEnum(schema), name }, rawOptions)
     }
@@ -438,7 +408,7 @@ function createSchemaParser(ctx: OasParserContext) {
         ? [...new Set((schema as Record<string, unknown>)[extensionKey] as Array<string | number>)]
         : [...new Set(filteredValues)]
 
-      return createSchema({
+      return ast.createSchema({
         ...enumBase,
         primitive: enumPrimitiveType,
         namedEnumValues: sourceValues.map((label, index) => ({
@@ -449,7 +419,7 @@ function createSchemaParser(ctx: OasParserContext) {
       })
     }
 
-    return createSchema({
+    return ast.createSchema({
       ...enumBase,
       enumValues: [...new Set(filteredValues)],
     })
@@ -458,26 +428,26 @@ function createSchemaParser(ctx: OasParserContext) {
   /**
    * Converts an object-like schema into an `ObjectSchemaNode`.
    */
-  function convertObject({ schema, name, nullable, defaultValue, rawOptions, options }: SchemaContext): SchemaNode {
-    const properties: Array<PropertyNode> = schema.properties
+  function convertObject({ schema, name, nullable, defaultValue, rawOptions, options }: SchemaContext): ast.SchemaNode {
+    const properties: Array<ast.PropertyNode> = schema.properties
       ? Object.entries(schema.properties).map(([propName, propSchema]) => {
           const required = Array.isArray(schema.required) ? schema.required.includes(propName) : !!schema.required
           const resolvedPropSchema = propSchema as SchemaObject
           const propNullable = isNullable(resolvedPropSchema)
 
-          const resolvedChildName = childName(name, propName)
+          const resolvedChildName = ast.childName(name, propName)
           const propNode = parseSchema({ schema: resolvedPropSchema, name: resolvedChildName }, rawOptions)
-          let schemaNode = setEnumName(propNode, name, propName, options.enumSuffix)
+          let schemaNode = ast.setEnumName(propNode, name, propName, options.enumSuffix)
 
-          const tupleNode = narrowSchema(schemaNode, 'tuple')
+          const tupleNode = ast.narrowSchema(schemaNode, 'tuple')
           if (tupleNode?.items) {
-            const namedItems = tupleNode.items.map((item) => setEnumName(item, name, propName, options.enumSuffix))
+            const namedItems = tupleNode.items.map((item) => ast.setEnumName(item, name, propName, options.enumSuffix))
             if (namedItems.some((item, i) => item !== tupleNode.items![i])) {
               schemaNode = { ...tupleNode, items: namedItems }
             }
           }
 
-          return createProperty({
+          return ast.createProperty({
             name: propName,
             schema: {
               ...schemaNode,
@@ -489,7 +459,7 @@ function createSchemaParser(ctx: OasParserContext) {
       : []
 
     const additionalProperties = schema.additionalProperties
-    let additionalPropertiesNode: SchemaNode | boolean | undefined
+    let additionalPropertiesNode: ast.SchemaNode | boolean | undefined
     if (additionalProperties === true) {
       additionalPropertiesNode = true
     } else if (additionalProperties && Object.keys(additionalProperties).length > 0) {
@@ -497,7 +467,7 @@ function createSchemaParser(ctx: OasParserContext) {
     } else if (additionalProperties === false) {
       additionalPropertiesNode = false
     } else if (additionalProperties) {
-      additionalPropertiesNode = createSchema({ type: typeOptionMap.get(options.unknownType)! })
+      additionalPropertiesNode = ast.createSchema({ type: typeOptionMap.get(options.unknownType)! })
     }
 
     const rawPatternProperties = 'patternProperties' in schema ? schema.patternProperties : undefined
@@ -507,13 +477,13 @@ function createSchemaParser(ctx: OasParserContext) {
           Object.entries(rawPatternProperties).map(([pattern, patternSchema]) => [
             pattern,
             patternSchema === true || (typeof patternSchema === 'object' && Object.keys(patternSchema).length === 0)
-              ? createSchema({ type: typeOptionMap.get(options.unknownType)! })
+              ? ast.createSchema({ type: typeOptionMap.get(options.unknownType)! })
               : parseSchema({ schema: patternSchema as SchemaObject }, rawOptions),
           ]),
         )
       : undefined
 
-    const objectNode: SchemaNode = createSchema({
+    const objectNode: ast.SchemaNode = ast.createSchema({
       type: 'object',
       primitive: 'object',
       properties,
@@ -527,8 +497,8 @@ function createSchemaParser(ctx: OasParserContext) {
     if (isDiscriminator(schema) && schema.discriminator.mapping) {
       const discPropName = schema.discriminator.propertyName
       const values = Object.keys(schema.discriminator.mapping)
-      const enumName = name ? enumPropName(name, discPropName, options.enumSuffix) : undefined
-      return setDiscriminatorEnum({ node: objectNode, propertyName: discPropName, values, enumName })
+      const enumName = name ? ast.enumPropName(name, discPropName, options.enumSuffix) : undefined
+      return ast.setDiscriminatorEnum({ node: objectNode, propertyName: discPropName, values, enumName })
     }
 
     return objectNode
@@ -537,11 +507,11 @@ function createSchemaParser(ctx: OasParserContext) {
   /**
    * Converts an OAS 3.1 `prefixItems` tuple into a `TupleSchemaNode`.
    */
-  function convertTuple({ schema, name, nullable, defaultValue, rawOptions }: SchemaContext): SchemaNode {
+  function convertTuple({ schema, name, nullable, defaultValue, rawOptions }: SchemaContext): ast.SchemaNode {
     const tupleItems = (schema.prefixItems ?? []).map((item) => parseSchema({ schema: item as SchemaObject }, rawOptions))
-    const rest = schema.items ? parseSchema({ schema: schema.items as SchemaObject }, rawOptions) : createSchema({ type: 'any' })
+    const rest = schema.items ? parseSchema({ schema: schema.items as SchemaObject }, rawOptions) : ast.createSchema({ type: 'any' })
 
-    return createSchema({
+    return ast.createSchema({
       type: 'tuple',
       primitive: 'array',
       items: tupleItems,
@@ -555,12 +525,12 @@ function createSchemaParser(ctx: OasParserContext) {
   /**
    * Converts a `type: 'array'` schema into an `ArraySchemaNode`.
    */
-  function convertArray({ schema, name, nullable, defaultValue, rawOptions, options }: SchemaContext): SchemaNode {
+  function convertArray({ schema, name, nullable, defaultValue, rawOptions, options }: SchemaContext): ast.SchemaNode {
     const rawItems = schema.items as SchemaObject | undefined
-    const itemName = rawItems?.enum?.length && name ? enumPropName(undefined, name, options.enumSuffix) : undefined
+    const itemName = rawItems?.enum?.length && name ? ast.enumPropName(undefined, name, options.enumSuffix) : undefined
     const items = rawItems ? [parseSchema({ schema: rawItems, name: itemName }, rawOptions)] : []
 
-    return createSchema({
+    return ast.createSchema({
       type: 'array',
       primitive: 'array',
       items,
@@ -574,8 +544,8 @@ function createSchemaParser(ctx: OasParserContext) {
   /**
    * Converts a `type: 'string'` schema into a `StringSchemaNode`.
    */
-  function convertString({ schema, name, nullable, defaultValue }: SchemaContext): SchemaNode {
-    return createSchema({
+  function convertString({ schema, name, nullable, defaultValue }: SchemaContext): ast.SchemaNode {
+    return ast.createSchema({
       type: 'string',
       primitive: 'string',
       min: schema.minLength,
@@ -588,8 +558,8 @@ function createSchemaParser(ctx: OasParserContext) {
   /**
    * Converts a `type: 'number'` or `type: 'integer'` schema.
    */
-  function convertNumeric({ schema, name, nullable, defaultValue }: SchemaContext, type: 'number' | 'integer'): SchemaNode {
-    return createSchema({
+  function convertNumeric({ schema, name, nullable, defaultValue }: SchemaContext, type: 'number' | 'integer'): ast.SchemaNode {
+    return ast.createSchema({
       type,
       primitive: type,
       min: schema.minimum,
@@ -604,8 +574,8 @@ function createSchemaParser(ctx: OasParserContext) {
   /**
    * Converts a `type: 'boolean'` schema.
    */
-  function convertBoolean({ schema, name, nullable, defaultValue }: SchemaContext): SchemaNode {
-    return createSchema({
+  function convertBoolean({ schema, name, nullable, defaultValue }: SchemaContext): ast.SchemaNode {
+    return ast.createSchema({
       type: 'boolean',
       primitive: 'boolean',
       ...buildSchemaNode(schema, name, nullable, defaultValue),
@@ -615,8 +585,8 @@ function createSchemaParser(ctx: OasParserContext) {
   /**
    * Converts an explicit `type: 'null'` schema.
    */
-  function convertNull({ schema, name, nullable }: SchemaContext): SchemaNode {
-    return createSchema({
+  function convertNull({ schema, name, nullable }: SchemaContext): ast.SchemaNode {
+    return ast.createSchema({
       type: 'null',
       primitive: 'null',
       name,
@@ -634,8 +604,8 @@ function createSchemaParser(ctx: OasParserContext) {
    * → octet-stream blob → multi-type array → constraint-inferred type → `enum` → object/array/tuple/scalar
    * → empty-schema fallback (`emptySchemaType` option).
    */
-  function parseSchema({ schema, name }: { schema: SchemaObject; name?: string | null }, rawOptions?: Partial<ParserOptions>): SchemaNode {
-    const options: ParserOptions = { ...DEFAULT_PARSER_OPTIONS, ...rawOptions }
+  function parseSchema({ schema, name }: { schema: SchemaObject; name?: string | null }, rawOptions?: Partial<ast.ParserOptions>): ast.SchemaNode {
+    const options: ast.ParserOptions = { ...DEFAULT_PARSER_OPTIONS, ...rawOptions }
     const flattenedSchema = flattenSchema(schema)
     if (flattenedSchema && flattenedSchema !== schema) {
       return parseSchema({ schema: flattenedSchema, name }, rawOptions)
@@ -661,7 +631,7 @@ function createSchemaParser(ctx: OasParserContext) {
     }
 
     if (schema.type === 'string' && schema.contentMediaType === 'application/octet-stream') {
-      return createSchema({ type: 'blob', primitive: 'string', ...buildSchemaNode(schema, name, nullable, defaultValue) })
+      return ast.createSchema({ type: 'blob', primitive: 'string', ...buildSchemaNode(schema, name, nullable, defaultValue) })
     }
 
     if (Array.isArray(schema.type) && schema.type.length > 1) {
@@ -669,7 +639,7 @@ function createSchemaParser(ctx: OasParserContext) {
       const arrayNullable = schema.type.includes('null') || nullable || undefined
 
       if (nonNullTypes.length > 1) {
-        return createSchema({
+        return ast.createSchema({
           type: 'union',
           members: nonNullTypes.map((t) => parseSchema({ schema: { ...schema, type: t } as SchemaObject, name }, rawOptions)),
           ...buildSchemaNode(schema, name, arrayNullable, defaultValue),
@@ -697,22 +667,22 @@ function createSchemaParser(ctx: OasParserContext) {
     if (type === 'null') return convertNull(ctx)
 
     const emptyType = typeOptionMap.get(options.emptySchemaType)!
-    return createSchema({ type: emptyType as ScalarSchemaType, name, title: schema.title, description: schema.description })
+    return ast.createSchema({ type: emptyType as ast.ScalarSchemaType, name, title: schema.title, description: schema.description })
   }
 
   /**
    * Converts a dereferenced OAS parameter object into a `ParameterNode`.
    */
-  function parseParameter(options: ParserOptions, param: Record<string, unknown>): ParameterNode {
+  function parseParameter(options: ast.ParserOptions, param: Record<string, unknown>): ast.ParameterNode {
     const required = (param['required'] as boolean | undefined) ?? false
 
-    const schema: SchemaNode = param['schema']
+    const schema: ast.SchemaNode = param['schema']
       ? parseSchema({ schema: param['schema'] as SchemaObject }, options)
-      : createSchema({ type: typeOptionMap.get(options.unknownType)! })
+      : ast.createSchema({ type: typeOptionMap.get(options.unknownType)! })
 
-    return createParameter({
+    return ast.createParameter({
       name: param['name'] as string,
-      in: param['in'] as ParameterLocation,
+      in: param['in'] as ast.ParameterLocation,
       schema: {
         ...schema,
         description: (param['description'] as string | undefined) ?? schema.description,
@@ -724,8 +694,8 @@ function createSchemaParser(ctx: OasParserContext) {
   /**
    * Converts an OAS `Operation` into an `OperationNode`.
    */
-  function parseOperation(options: ParserOptions, operation: Operation): OperationNode {
-    const parameters: Array<ParameterNode> = getParameters(document, operation).map((param) =>
+  function parseOperation(options: ast.ParserOptions, operation: Operation): ast.OperationNode {
+    const parameters: Array<ast.ParameterNode> = getParameters(document, operation).map((param) =>
       parseParameter(options, param as unknown as Record<string, unknown>),
     )
 
@@ -759,21 +729,21 @@ function createSchemaParser(ctx: OasParserContext) {
     const requestBody = requestBodySchemaNode
       ? {
           description: requestBodyDescription,
-          schema: syncOptionality(requestBodySchemaNode, requestBodyRequired),
+          schema: ast.syncOptionality(requestBodySchemaNode, requestBodyRequired),
           keysToOmit: requestBodyKeysToOmit?.length ? requestBodyKeysToOmit : undefined,
           required: requestBodyRequired || undefined,
           contentType: requestBodyContentType,
         }
       : undefined
 
-    const responses: Array<ResponseNode> = operation.getResponseStatusCodes().map((statusCode) => {
+    const responses: Array<ast.ResponseNode> = operation.getResponseStatusCodes().map((statusCode) => {
       const responseObj = operation.getResponseByStatusCode(statusCode)
       const responseSchema = getResponseSchema(document, operation, statusCode, { contentType: ctx.contentType })
 
       const schema =
         responseSchema && Object.keys(responseSchema).length > 0
           ? parseSchema({ schema: responseSchema }, options)
-          : createSchema({ type: typeOptionMap.get(options.emptySchemaType)! })
+          : ast.createSchema({ type: typeOptionMap.get(options.emptySchemaType)! })
 
       const description = typeof responseObj === 'object' && responseObj !== null && !Array.isArray(responseObj) ? responseObj.description : undefined
 
@@ -790,8 +760,8 @@ function createSchemaParser(ctx: OasParserContext) {
             .map(([key]) => key)
         : undefined
 
-      return createResponse({
-        statusCode: statusCode as StatusCode,
+      return ast.createResponse({
+        statusCode: statusCode as ast.StatusCode,
         description,
         schema,
         mediaType,
@@ -801,9 +771,9 @@ function createSchemaParser(ctx: OasParserContext) {
 
     const urlPath = new URLPath(operation.path)
 
-    return createOperation({
+    return ast.createOperation({
       operationId: operation.getOperationId(),
-      method: operation.method.toUpperCase() as HttpMethod,
+      method: operation.method.toUpperCase() as ast.HttpMethod,
       path: urlPath.path,
       tags: operation.getTags().map((tag) => tag.name),
       summary: operation.getSummary() || undefined,
@@ -827,7 +797,11 @@ function createSchemaParser(ctx: OasParserContext) {
  * parseSchema(ctx, { schema: { type: 'string', format: 'uuid' } })
  * ```
  */
-export function parseSchema(ctx: OasParserContext, { schema, name }: { schema: SchemaObject; name?: string }, options?: Partial<ParserOptions>): SchemaNode {
+export function parseSchema(
+  ctx: OasParserContext,
+  { schema, name }: { schema: SchemaObject; name?: string },
+  options?: Partial<ast.ParserOptions>,
+): ast.SchemaNode {
   return createSchemaParser(ctx).parseSchema({ schema, name }, options)
 }
 
@@ -846,26 +820,26 @@ export function parseSchema(ctx: OasParserContext, { schema, name }: { schema: S
  */
 export function parseOas(
   document: Document,
-  options: Partial<ParserOptions> & { contentType?: ContentType } = {},
-): { root: InputNode; nameMapping: Map<string, string> } {
+  options: Partial<ast.ParserOptions> & { contentType?: ContentType } = {},
+): { root: ast.InputNode; nameMapping: Map<string, string> } {
   const { contentType, ...parserOptions } = options
-  const mergedOptions: ParserOptions = { ...DEFAULT_PARSER_OPTIONS, ...parserOptions }
+  const mergedOptions: ast.ParserOptions = { ...DEFAULT_PARSER_OPTIONS, ...parserOptions }
 
   const { schemas: schemaObjects, nameMapping } = getSchemas(document, { contentType })
   const { parseSchema: _parseSchema, parseOperation: _parseOperation } = createSchemaParser({ document, contentType })
 
-  const schemas: Array<SchemaNode> = Object.entries(schemaObjects).map(([name, schema]) => _parseSchema({ schema, name }, mergedOptions))
+  const schemas: Array<ast.SchemaNode> = Object.entries(schemaObjects).map(([name, schema]) => _parseSchema({ schema, name }, mergedOptions))
 
   const baseOas = new BaseOas(document)
   const paths = baseOas.getPaths()
 
-  const operations: Array<OperationNode> = Object.entries(paths).flatMap(([_path, methods]) =>
+  const operations: Array<ast.OperationNode> = Object.entries(paths).flatMap(([_path, methods]) =>
     Object.entries(methods)
       .map(([, operation]) => (operation ? _parseOperation(mergedOptions, operation) : null))
-      .filter((op): op is OperationNode => op !== null),
+      .filter((op): op is ast.OperationNode => op !== null),
   )
 
-  const root = createInput({ schemas, operations })
+  const root = ast.createInput({ schemas, operations })
 
   return { root, nameMapping }
 }

package/src/resolvers.ts

@@ -1,6 +1,5 @@
 import { pascalCase } from '@internals/utils'
-import { mediaTypes } from '@kubb/ast'
-import type { MediaType, ParserOptions, PrimitiveSchemaType, SchemaType } from '@kubb/ast/types'
+import { ast } from '@kubb/core'
 import type { ParameterObject, ServerObject } from 'oas/types'
 import { isRef } from 'oas/types'
 import { matchesMimeType } from 'oas/utils'
@@ -51,7 +50,7 @@ export function resolveServerUrl(server: ServerObject, overrides?: Record<string
  * Returns `undefined` for formats not in `formatMap` (e.g. `int64`, `date-time`),
  * which are handled separately because their output depends on parser options.
  */
-export function getSchemaType(format: string): SchemaType | null {
+export function getSchemaType(format: string): ast.SchemaType | null {
   return formatMap[format as keyof typeof formatMap] ?? null
 }
 
@@ -60,7 +59,7 @@ export function getSchemaType(format: string): SchemaType | null {
  * Numeric types (`number`, `integer`, `bigint`) are returned unchanged;
  * `boolean` maps to `'boolean'`; everything else defaults to `'string'`.
  */
-export function getPrimitiveType(type: string | undefined): PrimitiveSchemaType {
+export function getPrimitiveType(type: string | undefined): ast.PrimitiveSchemaType {
   if (type === 'number' || type === 'integer' || type === 'bigint') return type
   if (type === 'boolean') return 'boolean'
 
@@ -71,8 +70,8 @@ export function getPrimitiveType(type: string | undefined): PrimitiveSchemaType
  * Narrows a raw content-type string to the `MediaType` union recognized by Kubb.
  * Returns `undefined` for content types not present in `KNOWN_MEDIA_TYPES`.
  */
-export function getMediaType(contentType: string): MediaType | null {
-  return Object.values(mediaTypes).includes(contentType as MediaType) ? (contentType as MediaType) : null
+export function getMediaType(contentType: string): ast.MediaType | null {
+  return Object.values(ast.mediaTypes).includes(contentType as ast.MediaType) ? (contentType as ast.MediaType) : null
 }
 
 export type OperationsOptions = {
@@ -444,7 +443,7 @@ export function getSchemas(document: Document, { contentType }: GetSchemasOption
  * Returns `null` when `dateType: false`, signalling the format should fall through to `string`.
  */
 export function getDateType(
-  options: ParserOptions,
+  options: ast.ParserOptions,
   format: 'date-time' | 'date' | 'time',
 ): { type: 'datetime'; offset?: boolean; local?: boolean } | { type: 'date' | 'time'; representation: 'date' | 'string' } | null {
   if (!options.dateType) {