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

package/dist/operationParams-BZ07xDm0.d.ts

@@ -0,0 +1,204 @@
+import { n as __name } from "./chunk-CNktS9qV.js";
+import { A as FunctionParametersNode, N as TypeExpression, P as TypeLiteralNode, f as OperationNode, k as FunctionParameterNode, w as ParameterNode } from "./index-BzjwdK2M.js";
+
+//#region src/utils/operationParams.d.ts
+declare function caseParams(params: Array<ParameterNode>, casing: 'camelcase' | undefined): Array<ParameterNode>;
+/**
+ * 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;
+  };
+  /**
+   * Transforms every resolved type name before it lands in a parameter node, 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, it falls back to the schema primitive (a plain type-name string). When the
+ * parameter belongs to a named group, it emits an {@link IndexedAccessTypeNode} like
+ * `GroupParams['petId']`, otherwise the resolved individual name.
+ */
+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;
+//#endregion
+export { buildTypeLiteral as a, resolveParamType as c, buildGroupParam as i, OperationParamsResolver as n, caseParams as o, ParamGroupType as r, createOperationParams as s, BuildGroupArgs as t };
+//# sourceMappingURL=operationParams-BZ07xDm0.d.ts.map