@kubb/ast 5.0.0-beta.58 → 5.0.0-beta.59

package/dist/{ast-ClnJg9BN.d.ts → index-BzjwdK2M.d.ts}

@@ -128,7 +128,11 @@ declare function defineNode<TNode extends BaseNode, TInput = Omit<TNode, 'kind'>
 type JSDocNode = {
   /**
    * JSDoc comment lines. `undefined` entries are filtered out during rendering.
-   * @example ['@description A pet resource', '@deprecated']
+   *
+   * @example
+   * ```ts
+   * ['@description A pet resource', '@deprecated']
+   * ```
    */
   comments?: Array<string | undefined>;
 };
@@ -145,9 +149,6 @@ type JSDocNode = {
  * ```
  */
 type ConstNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'Const';
   /**
    * Name of the constant declaration.
@@ -155,12 +156,13 @@ type ConstNode = BaseNode & {
   name: string;
   /**
    * Whether the declaration should be exported.
-   * @default false
    */
   export?: boolean | null;
   /**
-   * Optional explicit type annotation.
-   * @example 'Pet'
+   * Explicit type annotation.
+   *
+   * @example Type reference
+   * `'Pet'`
    */
   type?: string | null;
   /**
@@ -169,12 +171,11 @@ type ConstNode = BaseNode & {
   JSDoc?: JSDocNode | null;
   /**
    * Whether to append `as const` to the declaration.
-   * @default false
    */
   asConst?: boolean | null;
   /**
    * Child nodes representing the value of the constant (children of the `Const` component).
-   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
    */
   nodes?: Array<CodeNode>;
 };
@@ -191,9 +192,6 @@ type ConstNode = BaseNode & {
  * ```
  */
 type TypeNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'Type';
   /**
    * Name of the type alias.
@@ -201,7 +199,6 @@ type TypeNode = BaseNode & {
   name: string;
   /**
    * Whether the declaration should be exported.
-   * @default false
    */
   export?: boolean | null;
   /**
@@ -210,7 +207,7 @@ type TypeNode = BaseNode & {
   JSDoc?: JSDocNode | null;
   /**
    * Child nodes representing the type body (children of the `Type` component).
-   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
    */
   nodes?: Array<CodeNode>;
 };
@@ -227,9 +224,6 @@ type TypeNode = BaseNode & {
  * ```
  */
 type FunctionNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'Function';
   /**
    * Name of the function.
@@ -237,7 +231,6 @@ type FunctionNode = BaseNode & {
   name: string;
   /**
    * Whether the function is a default export.
-   * @default false
    */
   default?: boolean | null;
   /**
@@ -246,22 +239,24 @@ type FunctionNode = BaseNode & {
   params?: string | null;
   /**
    * Whether the function should be exported.
-   * @default false
    */
   export?: boolean | null;
   /**
    * Whether the function is async. When `true`, the return type is wrapped in `Promise<>`.
-   * @default false
    */
   async?: boolean | null;
   /**
    * TypeScript generic type parameters.
-   * @example ['T', 'U extends string']
+   *
+   * @example Constrained generics
+   * `['T', 'U extends string']`
    */
   generics?: string | Array<string> | null;
   /**
    * Return type annotation.
-   * @example 'Pet'
+   *
+   * @example Type reference
+   * `'Pet'`
    */
   returnType?: string | null;
   /**
@@ -270,7 +265,7 @@ type FunctionNode = BaseNode & {
   JSDoc?: JSDocNode | null;
   /**
    * Child nodes representing the function body (children of the `Function` component).
-   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
    */
   nodes?: Array<CodeNode>;
 };
@@ -287,9 +282,6 @@ type FunctionNode = BaseNode & {
  * ```
  */
 type ArrowFunctionNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'ArrowFunction';
   /**
    * Name of the arrow function (used as the `const` variable name).
@@ -297,7 +289,6 @@ type ArrowFunctionNode = BaseNode & {
   name: string;
   /**
    * Whether the function is a default export.
-   * @default false
    */
   default?: boolean | null;
   /**
@@ -306,22 +297,24 @@ type ArrowFunctionNode = BaseNode & {
   params?: string | null;
   /**
    * Whether the arrow function should be exported.
-   * @default false
    */
   export?: boolean | null;
   /**
    * Whether the arrow function is async. When `true`, the return type is wrapped in `Promise<>`.
-   * @default false
    */
   async?: boolean | null;
   /**
    * TypeScript generic type parameters.
-   * @example ['T', 'U extends string']
+   *
+   * @example Constrained generics
+   * `['T', 'U extends string']`
    */
   generics?: string | Array<string> | null;
   /**
    * Return type annotation.
-   * @example 'Pet'
+   *
+   * @example Type reference
+   * `'Pet'`
    */
   returnType?: string | null;
   /**
@@ -330,12 +323,11 @@ type ArrowFunctionNode = BaseNode & {
   JSDoc?: JSDocNode | null;
   /**
    * Render the arrow function body as a single-line expression.
-   * @default false
    */
   singleLine?: boolean | null;
   /**
    * Child nodes representing the function body (children of the `Function.Arrow` component).
-   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
    */
   nodes?: Array<CodeNode>;
 };
@@ -352,9 +344,6 @@ type ArrowFunctionNode = BaseNode & {
  * ```
  */
 type TextNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'Text';
   /**
    * The raw string content.
@@ -364,9 +353,8 @@ type TextNode = BaseNode & {
 /**
  * AST node representing a line break in the source output.
  *
- * Corresponds to `<br/>` in JSX components. When printed, produces an empty
- * string that, joined with `\n` by `printNodes` creates a blank line
- * between surrounding code nodes.
+ * Corresponds to `<br/>` in JSX components. When printed it produces an empty string,
+ * so joining nodes with `\n` in `printNodes` leaves a blank line between the surrounding code.
  *
  * @example
  * ```ts
@@ -376,16 +364,13 @@ type TextNode = BaseNode & {
  * ```
  */
 type BreakNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'Break';
 };
 /**
  * AST node representing a raw JSX fragment in the source output.
  *
- * Mirrors the `Jsx` component from `@kubb/renderer-jsx`. Use this to embed raw
- * JSX/TSX markup (including fragments `<>…</>`) directly in generated code.
+ * Mirrors the `Jsx` component from `@kubb/renderer-jsx`. Embeds raw JSX/TSX markup
+ * (including fragments `<>…</>`) directly in generated code.
  *
  * @example
  * ```ts
@@ -394,9 +379,6 @@ type BreakNode = BaseNode & {
  * ```
  */
 type JsxNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'Jsx';
   /**
    * The raw JSX string content.
@@ -672,9 +654,6 @@ type InferSchemaNode<TSchema extends object, TDateType extends ParserOptions['da
  * ```
  */
 type PropertyNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'Property';
   /**
    * Property key.
@@ -963,8 +942,9 @@ type UnionSchemaNode = CompositeSchemaNodeBase & {
    */
   discriminatorPropertyName?: string;
   /**
-   * Logical strategy applied to union members: 'one' means exactly one member must be valid (from `oneOf`),
-   * 'any' means any number of members can be valid (from `anyOf`).
+   * How many union members must be valid.
+   * - `'one'`: exactly one member, from `oneOf`
+   * - `'any'`: any number of members, from `anyOf`
    */
   strategy?: 'one' | 'any';
 };
@@ -1344,8 +1324,8 @@ declare function createSchema(props: CreateSchemaInput): SchemaNode;
 /**
  * AST node representing one content-type entry of a request body or response.
  *
- * One entry per content type declared in the spec (e.g. `application/json`,
- * `multipart/form-data`), each carrying its own body schema.
+ * There is one entry per content type declared in the spec (e.g. `application/json`,
+ * `multipart/form-data`), and each entry holds its own body schema.
  *
  * @example
  * ```ts
@@ -1424,27 +1404,31 @@ type ImportNode = BaseNode & {
   kind: 'Import';
   /**
    * Import name(s) to be used.
-   * @example ['useState']
-   * @example 'React'
+   *
+   * @example Named imports
+   * `['useState']`
+   *
+   * @example Default import
+   * `'React'`
    */
   name: ImportName;
   /**
    * Path for the import.
-   * @example '@kubb/core'
+   *
+   * @example
+   * `'@kubb/core'`
    */
   path: string;
   /**
-   * Add type-only import prefix.
+   * Add a type-only import prefix.
    * - `true` generates `import type { Type } from './path'`
    * - `false` generates `import { Type } from './path'`
-   * @default false
    */
   isTypeOnly?: boolean | null;
   /**
-   * Import entire module as namespace.
+   * Import the entire module as a namespace.
    * - `true` generates `import * as Name from './path'`
-   * - `false` generates standard import
-   * @default false
+   * - `false` generates a standard import
    */
   isNameSpace?: boolean | null;
   /**
@@ -1479,27 +1463,31 @@ type ExportNode = BaseNode & {
   kind: 'Export';
   /**
    * Export name(s) to be used. When omitted, generates a wildcard export.
-   * @example ['useState']
-   * @example 'React'
+   *
+   * @example Named exports
+   * `['useState']`
+   *
+   * @example Single export
+   * `'React'`
    */
   name?: string | Array<string> | null;
   /**
    * Path for the export.
-   * @example '@kubb/core'
+   *
+   * @example
+   * `'@kubb/core'`
    */
   path: string;
   /**
-   * Add type-only export prefix.
+   * Add a type-only export prefix.
    * - `true` generates `export type { Type } from './path'`
    * - `false` generates `export { Type } from './path'`
-   * @default false
    */
   isTypeOnly?: boolean | null;
   /**
    * Export as an aliased namespace.
    * - `true` generates `export * as aliasName from './path'`
    * - `false` generates a standard export
-   * @default false
    */
   asAlias?: boolean | null;
 };
@@ -1524,22 +1512,19 @@ type SourceNode = BaseNode & {
   name?: string | null;
   /**
    * Mark this source as a type-only export.
-   * @default false
    */
   isTypeOnly?: boolean | null;
   /**
-   * Include `export` keyword in the generated source.
-   * @default false
+   * Include the `export` keyword in the generated source.
    */
   isExportable?: boolean | null;
   /**
    * Include this source in barrel/index file generation.
-   * @default false
    */
   isIndexable?: boolean | null;
   /**
-   * Structured child nodes representing the content of this source fragment, in DOM order.
-   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
+   * Child nodes that make up this source fragment, in DOM order.
+   * Use a {@link TextNode} for raw string content.
    */
   nodes?: Array<CodeNode>;
 };
@@ -1566,8 +1551,8 @@ type SourceNode = BaseNode & {
 type FileNode<TMeta extends object = object> = BaseNode & {
   kind: 'File';
   /**
-   * Unique identifier derived from a SHA256 hash of the file path. Computed
-   * by `createFile`; callers do not need to provide it.
+   * Unique identifier derived from a SHA256 hash of the file path. `createFile`
+   * computes it, so callers do not need to provide it.
    */
   id: string;
   /**
@@ -1602,7 +1587,7 @@ type FileNode<TMeta extends object = object> = BaseNode & {
    */
   exports: Array<ExportNode>;
   /**
-   * Optional metadata attached to this file (used by plugins for barrel generation etc.).
+   * Optional metadata attached to this file, read by plugins during barrel generation.
    */
   meta?: TMeta;
   /**
@@ -1683,9 +1668,6 @@ type TypeExpression = string | TypeLiteralNode | IndexedAccessTypeNode;
  * ```
  */
 type TypeLiteralNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'TypeLiteral';
   /**
    * Members of the object type, rendered in order.
@@ -1716,9 +1698,6 @@ type TypeLiteralNode = BaseNode & {
  * ```
  */
 type IndexedAccessTypeNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'IndexedAccessType';
   /**
    * Name of the type being indexed, e.g. `'GetPetPathParams'`.
@@ -1740,9 +1719,6 @@ type IndexedAccessTypeNode = BaseNode & {
  * ```
  */
 type ObjectBindingPatternNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'ObjectBindingPattern';
   /**
    * Bound elements, rendered in order.
@@ -1780,9 +1756,6 @@ type ObjectBindingPatternNode = BaseNode & {
  * `{ id, name? }: { id: string; name?: string } = {}`
  */
 type FunctionParameterNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'FunctionParameter';
   /**
    * Parameter name, or an {@link ObjectBindingPatternNode} for a destructured group.
@@ -1816,9 +1789,6 @@ type FunctionParameterNode = BaseNode & {
  * - `call`        → `(id, { method, url })` function call arguments
  */
 type FunctionParametersNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'FunctionParameters';
   /**
    * Ordered parameter nodes.
@@ -1964,9 +1934,6 @@ type ParameterLocation = 'path' | 'query' | 'header' | 'cookie';
  * ```
  */
 type ParameterNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'Parameter';
   /**
    * Parameter name.
@@ -2023,12 +1990,9 @@ declare const createParameter: (input: UserParameterNode) => ParameterNode;
  * ```
  */
 type RequestBodyNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'RequestBody';
   /**
-   * Human-readable request body description.
+   * Request body description carried over from the spec.
    */
   description?: string;
   /**
@@ -2037,11 +2001,11 @@ type RequestBodyNode = BaseNode & {
    */
   required?: boolean;
   /**
-   * All available content type entries for this request body.
+   * Content type entries for this request body.
    *
    * When the adapter `contentType` option is set, this array contains exactly one entry for
    * that content type. Otherwise it contains one entry per content type declared in the spec,
-   * so that plugins can generate code for every variant (e.g. separate hooks for
+   * so plugins can generate code for every variant (for example, separate hooks for
    * `application/json` and `multipart/form-data`).
    */
   content?: Array<ContentNode>;
@@ -2187,7 +2151,7 @@ type OperationNodeBase = BaseNode & {
    */
   deprecated?: boolean;
   /**
-   * Parameters that could be used, we have QueryParams, PathParams, HeaderParams and CookieParams
+   * Query, path, header, and cookie parameters for the operation.
    */
   parameters: Array<ParameterNode>;
   /**
@@ -2310,11 +2274,11 @@ type InputMeta = {
   baseURL?: string | null;
   /**
    * Names of schemas that participate in a circular reference chain.
-   * Computed once during the adapter pre-scan, use this instead of calling
-   * `findCircularSchemas` per generator call.
+   * Computed once during the adapter pre-scan, so a generator never has to
+   * call `findCircularSchemas` itself.
    *
    * Convert to a `Set` once at the start of a generator, not per-schema,
-   * to keep lookup O(1) without repeated allocations.
+   * so lookups stay O(1) without repeated allocations.
    *
    * @example Wrap a circular schema in z.lazy()
    * ```ts
@@ -2325,11 +2289,11 @@ type InputMeta = {
   circularNames: ReadonlyArray<string>;
   /**
    * Names of schemas whose type is `enum`.
-   * Computed once during the adapter pre-scan, use this instead of filtering
-   * schemas per generator call.
+   * Computed once during the adapter pre-scan, so a generator never has to
+   * filter the schema list itself.
    *
    * Convert to a `Set` once at the start of a generator when you need repeated
-   * membership checks, rather than calling `.includes()` per schema.
+   * membership checks, so each check stays O(1) instead of an array scan.
    *
    * @example Check if a referenced schema is an enum
    * `const enums = new Set(meta.enumNames)`
@@ -2465,267 +2429,5 @@ declare function createOutput(overrides?: Partial<Omit<OutputNode, 'kind'>>): Ou
  */
 type Node = InputNode | OutputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode | RequestBodyNode | ContentNode | FunctionParamNode | FileNode | ImportNode | ExportNode | SourceNode | ConstNode | TypeNode | FunctionNode | ArrowFunctionNode;
 //#endregion
-//#region src/utils/ast.d.ts
-/**
- * Merges a ref node with its resolved schema, giving usage-site fields precedence.
- *
- * Usage-site fields (`description`, `readOnly`, `nullable`, `deprecated`) on the ref node
- * override the same fields in the resolved `node.schema`. Non-ref nodes are returned unchanged.
- *
- * @example
- * ```ts
- * // Ref with description override
- * const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A cute pet' })
- * const merged = syncSchemaRef(ref)  // merges with resolved Pet schema
- * ```
- */
-declare function syncSchemaRef(node: SchemaNode): SchemaNode;
-/**
- * Type guard that returns `true` when a schema emits as a plain `string` type.
- *
- * Covers `string`, `uuid`, `email`, `url`, and `datetime` types. For `date` and `time`
- * types, returns `true` only when `representation` is `'string'` rather than `'date'`.
- */
-declare function isStringType(node: SchemaNode): boolean;
-declare function caseParams(params: Array<ParameterNode>, casing: 'camelcase' | undefined): Array<ParameterNode>;
-/**
- * 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;
-/**
- * Named type for a group of parameters (query or header) emitted as a single typed parameter.
- */
-type ParamGroupType = {
-  /**
-   * Type expression for the group, a plain group-name reference.
-   */
-  type: TypeExpression;
-  /**
-   * 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.
- */
-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>;
-  /**
-   * 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;
-};
-/**
- * Resolves the {@link TypeExpression} for an individual parameter.
- *
- * Without a resolver, falls back to the schema primitive (a plain type-name string).
- * When the parameter belongs to a named group, emits an {@link IndexedAccessTypeNode}
- * (`GroupParams['petId']`); otherwise the resolved individual name as a plain string.
- */
-declare function resolveParamType({
-  node,
-  param,
-  resolver
-}: {
-  node: OperationNode;
-  param: ParameterNode;
-  resolver: OperationParamsResolver | undefined;
-}): TypeExpression;
-/**
- * Converts an `OperationNode` into function parameters for code generation.
- *
- * Centralizes parameter grouping logic for all plugins. `paramsType` chooses between one
- * destructured object parameter (`object`) and separate top-level parameters (`inline`), while
- * `pathParamsType` controls how path params render in inline mode. Provide a `resolver` for type
- * name resolution and `extraParams` for plugin-specific trailing parameters such as an `options` object.
- */
-declare function createOperationParams(node: OperationNode, options: CreateOperationParamsOptions): FunctionParametersNode;
-/**
- * Shared arguments for building a query or header parameter group.
- */
-type BuildGroupArgs = {
-  name: string;
-  node: OperationNode;
-  params: Array<ParameterNode>;
-  groupType: ParamGroupType | null;
-  resolver: OperationParamsResolver | undefined;
-  wrapType: (type: string) => string;
-};
-/**
- * Builds a single {@link FunctionParameterNode} for a query or header group.
- * Returns an empty array when there are no params to emit.
- *
- * A pre-resolved `groupType` emits `name: GroupType`. Otherwise it builds an inline
- * {@link TypeLiteralNode} from the individual params.
- */
-declare function buildGroupParam(args: BuildGroupArgs): Array<FunctionParameterNode>;
-/**
- * Builds a {@link TypeLiteralNode} 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 }`).
- */
-declare function buildTypeLiteral({
-  node,
-  params,
-  resolver
-}: {
-  node: OperationNode;
-  params: Array<ParameterNode>;
-  resolver: OperationParamsResolver | undefined;
-}): TypeLiteralNode;
-declare function collectUsedSchemaNames(operations: ReadonlyArray<OperationNode>, schemas: ReadonlyArray<SchemaNode>): Set<string>;
-/**
- * Identifies all schemas that participate in circular dependency chains, including direct self-loops.
- *
- * Returns a Set of schema names with circular dependencies. Use this to wrap recursive schema positions
- * in deferred constructs (lazy getter, `z.lazy(() => …)`) to prevent infinite recursion when generated code runs.
- * Refs are followed by name only, keeping the algorithm linear in the schema graph size.
- *
- * @note Call this once on the full schema graph, then use `containsCircularRef()` to check individual schemas.
- */
-declare function findCircularSchemas(schemas: ReadonlyArray<SchemaNode>): Set<string>;
-/**
- * Type guard returning `true` when a schema or anything nested within it contains a ref to a circular schema.
- *
- * Use `excludeName` to ignore refs to specific schemas (useful when self-references are handled separately).
- * Commonly used with `findCircularSchemas()` to detect where lazy wrappers are needed in code generation.
- *
- * @note Returns `true` for the first matching circular ref found. Use for fast dependency checks.
- */
-declare function containsCircularRef(node: SchemaNode | undefined, {
-  circularSchemas,
-  excludeName
-}: {
-  circularSchemas: ReadonlySet<string>;
-  excludeName?: string;
-}): boolean;
-//#endregion
-export { functionParametersDef as $, createBreak as $t, responseDef as A, StringSchemaNode as At, FunctionParamNode as B, ParserOptions as Bt, HttpMethod as C, ObjectSchemaNode as Ct, operationDef as D, SchemaNode as Dt, createOperation as E, ScalarSchemaType as Et, ParameterLocation as F, schemaDef as Ft, TypeExpression as G, JSDocNode as Gt, FunctionParametersNode as H, CodeNode as Ht, ParameterNode as I, PropertyNode as It, createFunctionParameters as J, TypeNode as Jt, TypeLiteralNode as K, JsxNode as Kt, createParameter as L, createProperty as Lt, RequestBodyNode as M, UnionSchemaNode as Mt, createRequestBody as N, UrlSchemaNode as Nt, ResponseNode as O, SchemaNodeByType as Ot, requestBodyDef as P, createSchema as Pt, functionParameterDef as Q, createArrowFunction as Qt, parameterDef as R, propertyDef as Rt, inputDef as S, NumberSchemaNode as St, OperationNode as T, RefSchemaNode as Tt, IndexedAccessTypeNode as U, ConstNode as Ut, FunctionParameterNode as V, ArrowFunctionNode as Vt, ObjectBindingPatternNode as W, FunctionNode as Wt, createObjectBindingPattern as X, breakDef as Xt, createIndexedAccessType as Y, arrowFunctionDef as Yt, createTypeLiteral as Z, constDef as Zt, createOutput as _, ArraySchemaNode as _t, buildTypeLiteral as a, functionDef as an, ImportNode as at, InputNode as b, EnumSchemaNode as bt, containsCircularRef as c, typeDef as cn, createImport as ct, findCircularSchemas as d, defineNode as dn, fileDef as dt, createConst as en, indexedAccessTypeDef as et, isStringType as f, syncOptionality as fn, importDef as ft, OutputNode as g, createContent as gt, Node as h, contentDef as ht, buildGroupParam as i, createType as in, FileNode as it, StatusCode as j, TimeSchemaNode as jt, createResponse as k, SchemaType as kt, createDiscriminantNode as l, DistributiveOmit as ln, createSource as lt, syncSchemaRef as m, ContentNode as mt, OperationParamsResolver as n, createJsx as nn, typeLiteralDef as nt, caseParams as o, jsxDef as on, SourceNode as ot, resolveParamType as p, NodeKind as pn, sourceDef as pt, createFunctionParameter as q, TextNode as qt, ParamGroupType as r, createText as rn, ExportNode as rt, collectUsedSchemaNames as s, textDef as sn, createExport as st, BuildGroupArgs as t, createFunction as tn, objectBindingPatternDef as tt, createOperationParams as u, NodeDef as un, exportDef as ut, outputDef as v, DateSchemaNode as vt, HttpOperationNode as w, PrimitiveSchemaType as wt, createInput as x, IntersectionSchemaNode as xt, InputMeta as y, DatetimeSchemaNode as yt, FunctionParamKind as z, InferSchemaNode as zt };
-//# sourceMappingURL=ast-ClnJg9BN.d.ts.map
+export { fileDef as $, textDef as $t, FunctionParametersNode as A, InferSchemaNode as At, functionParameterDef as B, TypeNode as Bt, ParameterLocation as C, UrlSchemaNode as Ct, FunctionParamKind as D, UserPropertyNode as Dt, parameterDef as E, PropertyNode as Et, createFunctionParameter as F, ConstNode as Ft, ExportNode as G, createBreak as Gt, indexedAccessTypeDef as H, breakDef as Ht, createFunctionParameters as I, FunctionNode as It, SourceNode as J, createJsx as Jt, FileNode as K, createConst as Kt, createIndexedAccessType as L, JSDocNode as Lt, ObjectBindingPatternNode as M, ArrowFunctionNode as Mt, TypeExpression as N, BreakNode as Nt, FunctionParamNode as O, createProperty as Ot, TypeLiteralNode as P, CodeNode as Pt, exportDef as Q, jsxDef as Qt, createObjectBindingPattern as R, JsxNode as Rt, requestBodyDef as S, UnionSchemaNode as St, createParameter as T, schemaDef as Tt, objectBindingPatternDef as U, constDef as Ut, functionParametersDef as V, arrowFunctionDef as Vt, typeLiteralDef as W, createArrowFunction as Wt, createImport as X, createType as Xt, createExport as Y, createText as Yt, createSource as Z, functionDef as Zt, responseDef as _, SchemaNode as _t, InputMeta as a, BaseNode as an, createContent as at, UserRequestBody as b, StringSchemaNode as bt, inputDef as c, DatetimeSchemaNode as ct, HttpOperationNode as d, NumberSchemaNode as dt, typeDef as en, importDef as et, OperationNode as f, ObjectSchemaNode as ft, createResponse as g, ScalarSchemaType as gt, ResponseNode as h, ScalarSchemaNode as ht, outputDef as i, syncOptionality as in, contentDef as it, IndexedAccessTypeNode as j, ParserOptions as jt, FunctionParameterNode as k, propertyDef as kt, GenericOperationNode as l, EnumSchemaNode as lt, operationDef as m, RefSchemaNode as mt, OutputNode as n, NodeDef as nn, ContentNode as nt, InputNode as o, NodeKind as on, ArraySchemaNode as ot, createOperation as p, PrimitiveSchemaType as pt, ImportNode as q, createFunction as qt, createOutput as r, defineNode as rn, UserContent as rt, createInput as s, DateSchemaNode as st, Node as t, DistributiveOmit as tn, sourceDef as tt, HttpMethod as u, IntersectionSchemaNode as ut, StatusCode as v, SchemaNodeByType as vt, ParameterNode as w, createSchema as wt, createRequestBody as x, TimeSchemaNode as xt, RequestBodyNode as y, SchemaType as yt, createTypeLiteral as z, TextNode as zt };
+//# sourceMappingURL=index-BzjwdK2M.d.ts.map