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

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { t as __name } from "./chunk--u3MIqq1.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-COwfCgLK.js";
+import { A as syncOptionality, C as createParameter, Ct as httpMethods, D as createRoot, E as createResponse, Et as schemaTypes, N as ParserOptions, O as createSchema, R as OperationNode, S as createOperation, T as createProperty, Tt as mediaTypes, W as ParameterNode, _ as createPrinterFactory, _t as ParameterGroupNode, at as SchemaNodeByType, b as createFunctionParameter, d as transform, f as walk, g as PrinterFactoryOptions, gt as FunctionParametersNode, ht as FunctionParameterNode, it as SchemaNode, k as createTypeNode, l as collect, m as extractRefName, u as composeTransformers, v as definePrinter, w as createParameterGroup, wt as isScalarPrimitive, x as createFunctionParameters, xt as ScalarPrimitive } from "./visitor-DsdLcLjR.js";
 
 //#region src/guards.d.ts
 /**
@@ -12,17 +12,6 @@ import { A as createRoot, B as ResponseNode, C as createFunctionParameter, Ct as
  * ```
  */
 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;
 /**
  * Returns `true` when the input is an `OperationNode`.
  *
@@ -45,132 +34,6 @@ declare const isOperationNode: (node: unknown) => node is OperationNode;
  * ```
  */
 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.transform(p)).filter(Boolean).join(', ')
- *       return `{ ${inner} }`
- *     },
- *     functionParameters(node) {
- *       return node.params.map(p => this.transform(p)).filter(Boolean).join(', ')
- *     },
- *   },
- * }))
- * ```
- */
-declare const defineFunctionPrinter: <T extends PrinterFactoryOptions>(build: (options: T["options"]) => {
-  name: T["name"];
-  options: T["options"];
-  nodes: Partial<{
-    functionParameter: (this: {
-      transform: (node: FunctionNode) => T["output"] | null | undefined;
-      options: T["options"];
-    }, node: FunctionParameterNode) => T["output"] | null | undefined;
-    objectBindingParameter: (this: {
-      transform: (node: FunctionNode) => T["output"] | null | undefined;
-      options: T["options"];
-    }, node: ObjectBindingParameterNode) => T["output"] | null | undefined;
-    functionParameters: (this: {
-      transform: (node: FunctionNode) => T["output"] | null | undefined;
-      options: T["options"];
-    }, node: FunctionParametersNode) => T["output"] | null | undefined;
-  }>;
-  print?: ((this: {
-    transform: (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"];
-  transform: (node: FunctionNode) => T["output"] | null | undefined;
-  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.
-   */
-  transformName?: (name: string) => string;
-  /**
-   * Optional transformation applied to every type string before printing.
-   */
-  transformType?: (type: string) => string;
-};
-/**
- * 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 = {}"
- * ```
- */
-declare const functionPrinter: (options?: FunctionPrinterOptions | undefined) => {
-  name: "functionParameters";
-  options: FunctionPrinterOptions;
-  transform: (node: FunctionNode) => string | null | undefined;
-  print: (node: FunctionNode) => string | null | undefined;
-};
 //#endregion
 //#region src/resolvers.d.ts
 declare function findDiscriminator(mapping: Record<string, string> | undefined, ref: string | undefined): string | null;
@@ -242,32 +105,18 @@ declare function mergeAdjacentObjects(members: Array<SchemaNode>): Array<SchemaN
  */
 declare function simplifyUnion(members: Array<SchemaNode>): Array<SchemaNode>;
 declare function setEnumName(propNode: SchemaNode, parentName: string | null | undefined, propName: string, enumSuffix: string): SchemaNode;
-/**
- * Walks a schema tree and resolves `ref`/`enum` names through callbacks.
- */
-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 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
  * ```
  */
 declare function isStringType(node: SchemaNode): boolean;
@@ -290,12 +139,162 @@ declare function isStringType(node: SchemaNode): boolean;
  */
 declare function caseParams(params: Array<ParameterNode>, casing: 'camelcase' | undefined): Array<ParameterNode>;
 /**
- * Syncs property/parameter schema optionality flags from `required` and `schema.nullable`.
+ * Creates a single-property object schema used as a discriminator literal.
+ *
+ * @example
+ * ```ts
+ * createDiscriminantNode({ propertyName: 'type', value: 'dog' })
+ * // -> { type: 'object', properties: [{ name: 'type', required: true, schema: enum('dog') }] }
+ * ```
+ */
+declare function createDiscriminantNode({
+  propertyName,
+  value
+}: {
+  propertyName: string;
+  value: string;
+}): SchemaNode;
+/**
+ * Resolver interface for {@link createOperationParams}.
+ *
+ * `ResolverTs` from `@kubb/plugin-ts` satisfies this interface and can be passed directly.
+ */
+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}.
+ */
+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;
+};
+/**
+ * Converts an {@link OperationNode} into a {@link FunctionParametersNode}.
  *
- * - `optional` is set for non-required, non-nullable schemas.
- * - `nullish` is set for non-required, nullable schemas.
+ * 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: '{}' })],
+ * })
+ * ```
  */
-declare function syncOptionality(required: boolean, schema: SchemaNode): SchemaNode;
+declare function createOperationParams(node: OperationNode, options: CreateOperationParamsOptions): FunctionParametersNode;
 //#endregion
-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 };
+export { type OperationParamsResolver, type ParserOptions, type PrinterFactoryOptions, type ScalarPrimitive, caseParams, childName, collect, collectImports, composeTransformers, createDiscriminantNode, createFunctionParameter, createFunctionParameters, createOperation, createOperationParams, createParameter, createParameterGroup, createPrinterFactory, createProperty, createResponse, createRoot, createSchema, createTypeNode, definePrinter, enumPropName, extractRefName, findDiscriminator, httpMethods, isOperationNode, isScalarPrimitive, isSchemaNode, isStringType, mediaTypes, mergeAdjacentObjects, narrowSchema, schemaTypes, setDiscriminatorEnum, setEnumName, simplifyUnion, syncOptionality, transform, walk };
 //# sourceMappingURL=index.d.ts.map