@kubb/ast 5.0.0-alpha.15 → 5.0.0-alpha.17

package/dist/index.d.ts

@@ -1,18 +1,141 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { A as syncPropertySchema, C as createObjectBindingParameter, D as createResponse, E as createProperty, F as OperationNode, I as ResponseNode, N as RootNode, O as createRoot, S as createFunctionParameters, T as createParameter, V as ParameterNode, bt as nodeKinds, d as transform, f as walk, ft as FunctionParameterNode, g as resolveRef, h as refMapToObject, k as createSchema, l as collect, lt as PropertyNode, m as buildRefMap, mt as ObjectBindingParameterNode, nt as SchemaNodeByType, pt as FunctionParametersNode, tt as SchemaNode, u as composeTransformers, ut as FunctionNode, vt as httpMethods, w as createOperation, x as createFunctionParameter, xt as schemaTypes, y as definePrinter, yt as mediaTypes } from "./visitor-UlWOe-In.js";
+import { A as createRoot, B as ResponseNode, C as createFunctionParameter, Ct as httpMethods, D as createParameter, E as createOperation, Et as schemaTypes, G as ParameterNode, L as RootNode, M as InferSchema, N as InferSchemaNode, O as createProperty, P as ParserOptions, S as createDiscriminantNode, T as createObjectBindingParameter, Tt as nodeKinds, _ as resolveRef, _t as FunctionParametersNode, at as SchemaNode, b as definePrinter, d as transform, f as walk, g as refMapToObject, gt as FunctionParameterNode, h as extractRefName, j as createSchema, k as createResponse, l as collect, m as buildRefMap, mt as FunctionNode, ot as SchemaNodeByType, pt as PropertyNode, u as composeTransformers, vt as ObjectBindingParameterNode, w as createFunctionParameters, wt as mediaTypes, xt as SCALAR_PRIMITIVE_TYPES, y as PrinterFactoryOptions, z as OperationNode } from "./visitor-BFn3X90U.js";
 
-//#region src/functionPrinter.d.ts
+//#region src/guards.d.ts
+/**
+ * Narrows a `SchemaNode` to the variant that matches `type`.
+ *
+ * @example
+ * ```ts
+ * const schema = createSchema({ type: 'string' })
+ * const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | undefined
+ * ```
+ */
+declare function narrowSchema<T extends SchemaNode['type']>(node: SchemaNode | undefined, type: T): SchemaNodeByType[T] | undefined;
+/**
+ * Returns `true` when the input is a `RootNode`.
+ *
+ * @example
+ * ```ts
+ * if (isRootNode(node)) {
+ *   console.log(node.schemas.length)
+ * }
+ * ```
+ */
+declare const isRootNode: (node: unknown) => node is RootNode;
 /**
- * The four rendering modes for a `FunctionParametersNode`.
+ * Returns `true` when the input is an `OperationNode`.
  *
- * | Mode          | Output example                              | Use case                        |
- * |---------------|---------------------------------------------|---------------------------------|
- * | `declaration` | `id: string, config: Config = {}`           | Function parameter declarations |
- * | `call`        | `id, { method, url }`                       | Function call arguments         |
- * | `keys`        | `{ id, config }`                            | Key names only (destructuring)  |
- * | `values`      | `{ id: id, config: config }`                | Key → value pairs               |
+ * @example
+ * ```ts
+ * if (isOperationNode(node)) {
+ *   console.log(node.operationId)
+ * }
+ * ```
+ */
+declare const isOperationNode: (node: unknown) => node is OperationNode;
+/**
+ * Returns `true` when the input is a `SchemaNode`.
+ *
+ * @example
+ * ```ts
+ * if (isSchemaNode(node)) {
+ *   console.log(node.type)
+ * }
+ * ```
+ */
+declare const isSchemaNode: (node: unknown) => node is SchemaNode;
+/**
+ * Returns `true` when the input is a `PropertyNode`.
+ */
+declare const isPropertyNode: (node: unknown) => node is PropertyNode;
+/**
+ * Returns `true` when the input is a `ParameterNode`.
+ */
+declare const isParameterNode: (node: unknown) => node is ParameterNode;
+/**
+ * Returns `true` when the input is a `ResponseNode`.
+ */
+declare const isResponseNode: (node: unknown) => node is ResponseNode;
+/**
+ * Returns `true` when the input is a `FunctionParameterNode`.
+ */
+declare const isFunctionParameterNode: (node: unknown) => node is FunctionParameterNode;
+/**
+ * Returns `true` when the input is an `ObjectBindingParameterNode`.
+ */
+declare const isObjectBindingParameterNode: (node: unknown) => node is ObjectBindingParameterNode;
+/**
+ * Returns `true` when the input is a `FunctionParametersNode`.
  */
+declare const isFunctionParametersNode: (node: unknown) => node is FunctionParametersNode;
+//#endregion
+//#region src/printers/functionPrinter.d.ts
+/**
+ * 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.print(p)).filter(Boolean).join(', ')
+ *       return `{ ${inner} }`
+ *     },
+ *     functionParameters(node) {
+ *       return node.params.map(p => this.print(p)).filter(Boolean).join(', ')
+ *     },
+ *   },
+ * }))
+ * ```
+ */
+declare const defineFunctionPrinter: <T extends PrinterFactoryOptions>(build: (options: T["options"]) => {
+  name: T["name"];
+  options: T["options"];
+  nodes: Partial<{
+    functionParameter: (this: {
+      print: (node: FunctionNode) => T["output"] | null | undefined;
+      options: T["options"];
+    }, node: FunctionParameterNode) => T["output"] | null | undefined;
+    objectBindingParameter: (this: {
+      print: (node: FunctionNode) => T["output"] | null | undefined;
+      options: T["options"];
+    }, node: ObjectBindingParameterNode) => T["output"] | null | undefined;
+    functionParameters: (this: {
+      print: (node: FunctionNode) => T["output"] | null | undefined;
+      options: T["options"];
+    }, node: FunctionParametersNode) => T["output"] | null | undefined;
+  }>;
+  print?: ((this: {
+    print: (node: FunctionNode) => T["output"] | null | undefined;
+    options: T["options"];
+  }, node: FunctionNode) => T["printOutput"] | null | undefined) | undefined;
+}) => (options?: T["options"] | undefined) => {
+  name: T["name"];
+  options: T["options"];
+  print: (node: FunctionNode) => T["printOutput"] | null | undefined;
+};
 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.
@@ -24,12 +147,12 @@ type FunctionPrinterOptions = {
   transformType?: (type: string) => string;
 };
 /**
- * Default function-signature printer. Covers the four standard output modes
- * used throughout Kubb plugins.
+ * Default function-signature printer.
+ * Covers the four standard output modes used across Kubb plugins.
  *
  * @example
  * ```ts
- * const printer = functionSignaturePrinter({ mode: 'declaration' })
+ * const printer = functionPrinter({ mode: 'declaration' })
  *
  * const sig = createFunctionParameters({
  *   params: [
@@ -47,67 +170,130 @@ declare const functionPrinter: (options?: FunctionPrinterOptions | undefined) =>
   print: (node: FunctionNode) => string | null | undefined;
 };
 //#endregion
-//#region src/guards.d.ts
-/**
- * Narrows a `SchemaNode` to the specific variant matching `type`.
- */
-declare function narrowSchema<T extends SchemaNode['type']>(node: SchemaNode | undefined, type: T): SchemaNodeByType[T] | undefined;
-/**
- * Type guard for `RootNode`.
- */
-declare const isRootNode: (node: unknown) => node is RootNode;
-/**
- * Type guard for `OperationNode`.
- */
-declare const isOperationNode: (node: unknown) => node is OperationNode;
-/**
- * Type guard for `SchemaNode`.
- */
-declare const isSchemaNode: (node: unknown) => node is SchemaNode;
-/**
- * Type guard for `PropertyNode`.
- */
-declare const isPropertyNode: (node: unknown) => node is PropertyNode;
+//#region src/resolvers.d.ts
+declare function findDiscriminator(mapping: Record<string, string> | undefined, ref: string | undefined): string | undefined;
+declare function childName(parentName: string | undefined, propName: string): string | undefined;
+declare function enumPropName(parentName: string | undefined, propName: string, enumSuffix: string): string;
 /**
- * Type guard for `ParameterNode`.
+ * Collects import entries for all `ref` schema nodes in `node`.
  */
-declare const isParameterNode: (node: unknown) => node is ParameterNode;
+declare function collectImports<TImport>({
+  node,
+  nameMapping,
+  resolve
+}: {
+  node: SchemaNode;
+  nameMapping: Map<string, string>;
+  resolve: (schemaName: string) => TImport | undefined;
+}): Array<TImport>;
+//#endregion
+//#region src/transformers.d.ts
 /**
- * Type guard for `ResponseNode`.
+ * Replaces a discriminator property's schema with a string enum of allowed values.
+ *
+ * If `node` is not an object schema, or if the property does not exist, the input
+ * node is returned as-is.
+ *
+ * @example
+ * ```ts
+ * const schema = createSchema({
+ *   type: 'object',
+ *   properties: [createProperty({ name: 'type', required: true, schema: createSchema({ type: 'string' }) })],
+ * })
+ * const result = setDiscriminatorEnum({ node: schema, propertyName: 'type', values: ['dog', 'cat'] })
+ * ```
  */
-declare const isResponseNode: (node: unknown) => node is ResponseNode;
+declare function setDiscriminatorEnum({
+  node,
+  propertyName,
+  values,
+  enumName
+}: {
+  node: SchemaNode;
+  propertyName: string;
+  values: Array<string>;
+  enumName?: string;
+}): SchemaNode;
 /**
- * Type guard for `FunctionParameterNode`.
+ * Merges adjacent anonymous object members into a single anonymous object member.
+ *
+ * @example
+ * ```ts
+ * const merged = mergeAdjacentObjects([
+ *   createSchema({ type: 'object', properties: [createProperty({ name: 'a', schema: createSchema({ type: 'string' }) })] }),
+ *   createSchema({ type: 'object', properties: [createProperty({ name: 'b', schema: createSchema({ type: 'number' }) })] }),
+ * ])
+ * ```
  */
-declare const isFunctionParameterNode: (node: unknown) => node is FunctionParameterNode;
+declare function mergeAdjacentObjects(members: Array<SchemaNode>): Array<SchemaNode>;
 /**
- * Type guard for `ObjectBindingParameterNode`.
+ * Removes enum members that are covered by broader scalar primitives in the same union.
+ *
+ * @example
+ * ```ts
+ * const simplified = simplifyUnion([
+ *   createSchema({ type: 'enum', primitive: 'string', enumValues: ['active'] }),
+ *   createSchema({ type: 'string' }),
+ * ])
+ * // keeps only string member
+ * ```
  */
-declare const isObjectBindingParameterNode: (node: unknown) => node is ObjectBindingParameterNode;
+declare function simplifyUnion(members: Array<SchemaNode>): Array<SchemaNode>;
+declare function setEnumName(propNode: SchemaNode, parentName: string | undefined, propName: string, enumSuffix: string): SchemaNode;
 /**
- * Type guard for `FunctionParametersNode`.
+ * Walks a schema tree and resolves `ref`/`enum` names through callbacks.
  */
-declare const isFunctionParametersNode: (node: unknown) => node is FunctionParametersNode;
+declare function resolveNames({
+  node,
+  nameMapping,
+  resolveName,
+  resolveEnumName
+}: {
+  node: SchemaNode;
+  nameMapping: Map<string, string>;
+  resolveName: (ref: string) => string | undefined;
+  resolveEnumName?: (name: string) => string | undefined;
+}): SchemaNode;
 //#endregion
 //#region src/utils.d.ts
 /**
- * Returns `true` when a schema node will be represented as a plain string in generated code.
+ * Returns `true` when a schema is emitted as a plain TypeScript `string`.
  *
  * - `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
+ * ```
  */
-declare function isPlainStringType(node: SchemaNode): boolean;
+declare function isStringType(node: SchemaNode): boolean;
 /**
- * Transforms the `name` field of each parameter node according to the given casing strategy.
+ * Applies casing rules to parameter names and returns a new parameter array.
  *
- * The original `params` array is never mutated — a new array of cloned nodes is returned.
- * When no `casing` is provided the original array is returned as-is.
+ * The input array is not mutated.
+ * If `casing` is not set, the original array is returned unchanged.
  *
  * Use this before passing parameters to schema builders so that property keys
- * in the generated output match the desired casing while the original
- * `OperationNode.parameters` array remains untouched for other consumers.
+ * in generated output match the desired casing while preserving
+ * `OperationNode.parameters` for other consumers.
+ *
+ * @example
+ * ```ts
+ * const params = [createParameter({ name: 'pet_id', in: 'query', schema: createSchema({ type: 'string' }) })]
+ * const cased = caseParams(params, 'camelcase')
+ * // cased[0].name === 'petId'
+ * ```
+ */
+declare function caseParams(params: Array<ParameterNode>, casing: 'camelcase' | undefined): Array<ParameterNode>;
+/**
+ * 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.
  */
-declare function applyParamsCasing(params: Array<ParameterNode>, casing: 'camelcase' | undefined): Array<ParameterNode>;
+declare function syncOptionality(required: boolean, schema: SchemaNode): SchemaNode;
 //#endregion
-export { applyParamsCasing, buildRefMap, collect, composeTransformers, createFunctionParameter, createFunctionParameters, createObjectBindingParameter, createOperation, createParameter, createProperty, createResponse, createRoot, createSchema, definePrinter, functionPrinter, httpMethods, isFunctionParameterNode, isFunctionParametersNode, isObjectBindingParameterNode, isOperationNode, isParameterNode, isPlainStringType, isPropertyNode, isResponseNode, isRootNode, isSchemaNode, mediaTypes, narrowSchema, nodeKinds, refMapToObject, resolveRef, schemaTypes, syncPropertySchema, transform, walk };
+export { type InferSchema, type InferSchemaNode, type ParserOptions, SCALAR_PRIMITIVE_TYPES, buildRefMap, caseParams, childName, collect, collectImports, composeTransformers, createDiscriminantNode, createFunctionParameter, createFunctionParameters, createObjectBindingParameter, createOperation, createParameter, createProperty, createResponse, createRoot, createSchema, defineFunctionPrinter, definePrinter, enumPropName, extractRefName, findDiscriminator, functionPrinter, httpMethods, isFunctionParameterNode, isFunctionParametersNode, isObjectBindingParameterNode, isOperationNode, isParameterNode, isPropertyNode, isResponseNode, isRootNode, isSchemaNode, isStringType, mediaTypes, mergeAdjacentObjects, narrowSchema, nodeKinds, refMapToObject, resolveNames, resolveRef, schemaTypes, setDiscriminatorEnum, setEnumName, simplifyUnion, syncOptionality, transform, walk };
 //# sourceMappingURL=index.d.ts.map