@veloxts/router 0.6.84 → 0.6.85

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @veloxts/router
 
+## 0.6.85
+
+### Patch Changes
+
+- implement missing features from original requirements
+- Updated dependencies
+  - @veloxts/core@0.6.85
+  - @veloxts/validation@0.6.85
+
 ## 0.6.84
 
 ### Patch Changes

package/dist/expose.d.ts

@@ -7,7 +7,7 @@
  * @module serve
  */
 import { type VeloxApp } from '@veloxts/core';
-import { type AnyRouter } from './trpc/index.js';
+import { type AnyRouter, type InferRouterFromCollections } from './trpc/index.js';
 import type { ProcedureCollection } from './types.js';
 /**
  * Options for serving procedures
@@ -38,38 +38,41 @@ export interface ServeOptions {
  * This is the recommended way to register your API.
  * Define your procedures once, serve them everywhere.
  *
+ * **IMPORTANT**: Use `as const` on the procedures array to preserve
+ * literal types for full type inference on the returned router.
+ *
  * @param app - VeloxTS application instance
- * @param procedures - Array of procedure collections to serve
+ * @param procedures - Array of procedure collections to serve (use `as const`)
  * @param options - Optional configuration for API and RPC prefixes
- * @returns The tRPC router for type exports
+ * @returns The typed tRPC router for type exports
  *
  * @example
  * ```typescript
  * // Both REST (/api) and tRPC (/trpc) with zero config
- * const router = await serve(app, [healthProcedures, userProcedures]);
- * export type AppRouter = typeof router;
+ * const router = await serve(app, [healthProcedures, userProcedures] as const);
+ * export type AppRouter = typeof router; // Fully typed!
  * ```
  *
  * @example
  * ```typescript
  * // REST only (external API)
- * await serve(app, [healthProcedures, userProcedures], { rpc: false });
+ * await serve(app, [healthProcedures, userProcedures] as const, { rpc: false });
  * ```
  *
  * @example
  * ```typescript
  * // tRPC only (internal app)
- * const router = await serve(app, [healthProcedures, userProcedures], { api: false });
+ * const router = await serve(app, [healthProcedures, userProcedures] as const, { api: false });
  * export type AppRouter = typeof router;
  * ```
  *
  * @example
  * ```typescript
  * // Custom prefixes
- * const router = await serve(app, [healthProcedures, userProcedures], {
+ * const router = await serve(app, [healthProcedures, userProcedures] as const, {
  *   api: '/v1',
  *   rpc: '/rpc',
  * });
  * ```
  */
-export declare function serve(app: VeloxApp, procedures: ProcedureCollection[], options?: ServeOptions): Promise<AnyRouter>;
+export declare function serve<const T extends readonly ProcedureCollection[]>(app: VeloxApp, procedures: T, options?: ServeOptions): Promise<AnyRouter & InferRouterFromCollections<T>>;

package/dist/expose.js

@@ -8,7 +8,7 @@
  */
 import { fail } from '@veloxts/core';
 import { rest } from './rest/index.js';
-import { appRouter, registerTRPCPlugin, trpc } from './trpc/index.js';
+import { appRouter, registerTRPCPlugin, trpc, } from './trpc/index.js';
 // ============================================================================
 // Main Function
 // ============================================================================
@@ -18,35 +18,38 @@ import { appRouter, registerTRPCPlugin, trpc } from './trpc/index.js';
  * This is the recommended way to register your API.
  * Define your procedures once, serve them everywhere.
  *
+ * **IMPORTANT**: Use `as const` on the procedures array to preserve
+ * literal types for full type inference on the returned router.
+ *
  * @param app - VeloxTS application instance
- * @param procedures - Array of procedure collections to serve
+ * @param procedures - Array of procedure collections to serve (use `as const`)
  * @param options - Optional configuration for API and RPC prefixes
- * @returns The tRPC router for type exports
+ * @returns The typed tRPC router for type exports
  *
  * @example
  * ```typescript
  * // Both REST (/api) and tRPC (/trpc) with zero config
- * const router = await serve(app, [healthProcedures, userProcedures]);
- * export type AppRouter = typeof router;
+ * const router = await serve(app, [healthProcedures, userProcedures] as const);
+ * export type AppRouter = typeof router; // Fully typed!
  * ```
  *
  * @example
  * ```typescript
  * // REST only (external API)
- * await serve(app, [healthProcedures, userProcedures], { rpc: false });
+ * await serve(app, [healthProcedures, userProcedures] as const, { rpc: false });
  * ```
  *
  * @example
  * ```typescript
  * // tRPC only (internal app)
- * const router = await serve(app, [healthProcedures, userProcedures], { api: false });
+ * const router = await serve(app, [healthProcedures, userProcedures] as const, { api: false });
  * export type AppRouter = typeof router;
  * ```
  *
  * @example
  * ```typescript
  * // Custom prefixes
- * const router = await serve(app, [healthProcedures, userProcedures], {
+ * const router = await serve(app, [healthProcedures, userProcedures] as const, {
  *   api: '/v1',
  *   rpc: '/rpc',
  * });
@@ -73,7 +76,8 @@ export async function serve(app, procedures, options = {}) {
     }
     // Register REST routes if enabled
     if (apiPrefix !== false) {
-        app.routes(rest(procedures, { prefix: apiPrefix }));
+        // Need to spread to convert readonly tuple to mutable array for rest()
+        app.routes(rest([...procedures], { prefix: apiPrefix }));
     }
     return router;
 }

package/dist/index.d.ts

@@ -39,7 +39,7 @@
  */
 /** Router package version */
 export declare const ROUTER_VERSION: string;
-export type { CompiledProcedure, ContextExtensions, ContextFactory, ExtendedContext, GuardLike, HttpMethod, InferProcedureContext, InferProcedureInput, InferProcedureOutput, InferProcedureTypes, MiddlewareArgs, MiddlewareFunction, MiddlewareNext, MiddlewareResult, ParentResourceConfig, ProcedureCollection, ProcedureHandler, ProcedureHandlerArgs, ProcedureRecord, ProcedureType, RestRouteOverride, } from './types.js';
+export type { CompiledProcedure, ContextExtensions, ContextFactory, ExtendedContext, GuardLike, HttpMethod, InferProcedureContext, InferProcedureInput, InferProcedureOutput, InferProcedureTypes, MiddlewareArgs, MiddlewareFunction, MiddlewareNext, MiddlewareResult, ParentResourceChain, ParentResourceConfig, ProcedureCollection, ProcedureHandler, ProcedureHandlerArgs, ProcedureRecord, ProcedureType, RestRouteOverride, } from './types.js';
 export { PROCEDURE_METHOD_MAP, } from './types.js';
 export type { GuardErrorResponse, RouterErrorCode } from './errors.js';
 export { GuardError, isGuardError } from './errors.js';
@@ -51,10 +51,14 @@ export type { RouterResult } from './router-utils.js';
 export { createRouter, toRouter } from './router-utils.js';
 export type { NamingWarning, NamingWarningType, WarningConfig, WarningOption } from './warnings.js';
 export { analyzeNamingConvention, isDevelopment, normalizeWarningOption } from './warnings.js';
-export type { ExtractRoutesType, RestAdapterOptions, RestMapping, RestRoute, RouteMap, } from './rest/index.js';
-export { buildNestedRestPath, buildRestPath, extractRoutes, followsNamingConvention, generateRestRoutes, getRouteSummary, inferResourceName, parseNamingConvention, registerRestRoutes, rest, } from './rest/index.js';
-export type { AnyRouter, InferAppRouter, TRPCInstance, TRPCPluginOptions, } from './trpc/index.js';
+export type { ExtractRoutesType, GenerateRestRoutesOptions, RestAdapterOptions, RestMapping, RestRoute, RouteMap, } from './rest/index.js';
+export { buildMultiLevelNestedPath, buildNestedRestPath, buildRestPath, calculateNestingDepth, extractRoutes, followsNamingConvention, generateRestRoutes, getRouteSummary, inferResourceName, parseNamingConvention, registerRestRoutes, rest, } from './rest/index.js';
+export type { AnyRouter, 
+/** @deprecated Use `TRPCRouter` instead */
+AsTRPCRouter, CollectionsToRouterRecord, ExtractNamespace, ExtractProcedures, InferAppRouter, InferRouterFromCollections, MapProcedureRecordToTRPC, MapProcedureToTRPC, TRPCInstance, TRPCPluginOptions, TRPCRouter, } from './trpc/index.js';
 export { appRouter, buildTRPCRouter, createTRPCContextFactory, registerTRPCPlugin, trpc, veloxErrorToTRPCError, } from './trpc/index.js';
+export type { RpcOptions, RpcResult } from './rpc.js';
+export { registerRpc, rpc } from './rpc.js';
 export type { DiscoveryOptions, DiscoveryResult, DiscoveryWarning } from './discovery/index.js';
 export { DiscoveryError, DiscoveryErrorCode, directoryNotFound, discoverProcedures, discoverProceduresVerbose, fileLoadError, invalidExport, invalidFileType, isDiscoveryError, noProceduresFound, permissionDenied, } from './discovery/index.js';
 export type { ServeOptions } from './expose.js';

package/dist/index.js

@@ -58,10 +58,11 @@ defineProcedures, executeProcedure, isCompiledProcedure, isProcedureCollection,
 export { createProcedure, typedProcedure } from './procedure/factory.js';
 export { createRouter, toRouter } from './router-utils.js';
 export { analyzeNamingConvention, isDevelopment, normalizeWarningOption } from './warnings.js';
-export { buildNestedRestPath, buildRestPath, extractRoutes, followsNamingConvention, generateRestRoutes, getRouteSummary, inferResourceName, parseNamingConvention, registerRestRoutes, rest, } from './rest/index.js';
+export { buildMultiLevelNestedPath, buildNestedRestPath, buildRestPath, calculateNestingDepth, extractRoutes, followsNamingConvention, generateRestRoutes, getRouteSummary, inferResourceName, parseNamingConvention, registerRestRoutes, rest, } from './rest/index.js';
 export { 
 // tRPC utilities
 appRouter, buildTRPCRouter, createTRPCContextFactory, registerTRPCPlugin, trpc, veloxErrorToTRPCError, } from './trpc/index.js';
+export { registerRpc, rpc } from './rpc.js';
 export { DiscoveryError, DiscoveryErrorCode, directoryNotFound, discoverProcedures, discoverProceduresVerbose, fileLoadError, invalidExport, invalidFileType, isDiscoveryError, noProceduresFound, permissionDenied, } from './discovery/index.js';
 export { serve } from './expose.js';
 // ============================================================================

package/dist/middleware/chain.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Shared middleware chain execution utility
+ *
+ * Provides a single implementation for executing middleware chains,
+ * used by both the procedure builder and tRPC adapter.
+ *
+ * @module middleware/chain
+ */
+import type { BaseContext } from '@veloxts/core';
+import type { MiddlewareFunction } from '../types.js';
+/**
+ * Result wrapper for middleware chain execution
+ */
+export interface MiddlewareResult<TOutput> {
+    output: TOutput;
+}
+/**
+ * Execute a middleware chain with the given handler
+ *
+ * Builds the chain from end to start and executes it, allowing each
+ * middleware to extend the context before calling the next middleware.
+ *
+ * @param middlewares - Array of middleware functions to execute
+ * @param input - The input to pass to each middleware
+ * @param ctx - The context object (will be mutated by middleware)
+ * @param handler - The final handler to execute after all middleware
+ * @returns The output from the handler
+ *
+ * @example
+ * ```typescript
+ * const result = await executeMiddlewareChain(
+ *   procedure.middlewares,
+ *   input,
+ *   ctx,
+ *   async () => handler({ input, ctx })
+ * );
+ * ```
+ */
+export declare function executeMiddlewareChain<TInput, TOutput, TContext extends BaseContext>(middlewares: ReadonlyArray<MiddlewareFunction<TInput, TContext, TContext, TOutput>>, input: TInput, ctx: TContext, handler: () => Promise<TOutput>): Promise<TOutput>;
+/**
+ * Create a precompiled middleware executor for a fixed middleware chain
+ *
+ * This is an optimization that builds the chain structure once during
+ * procedure compilation, creating a reusable function that can execute
+ * the chain without rebuilding closures on every request.
+ *
+ * @param middlewares - Array of middleware functions
+ * @param handler - The procedure handler (can return sync or async)
+ * @returns A function that executes the full chain
+ */
+export declare function createMiddlewareExecutor<TInput, TOutput, TContext extends BaseContext>(middlewares: ReadonlyArray<MiddlewareFunction<TInput, TContext, TContext, TOutput>>, handler: (params: {
+    input: TInput;
+    ctx: TContext;
+}) => TOutput | Promise<TOutput>): (input: TInput, ctx: TContext) => Promise<TOutput>;

package/dist/middleware/chain.js

@@ -0,0 +1,80 @@
+/**
+ * Shared middleware chain execution utility
+ *
+ * Provides a single implementation for executing middleware chains,
+ * used by both the procedure builder and tRPC adapter.
+ *
+ * @module middleware/chain
+ */
+/**
+ * Execute a middleware chain with the given handler
+ *
+ * Builds the chain from end to start and executes it, allowing each
+ * middleware to extend the context before calling the next middleware.
+ *
+ * @param middlewares - Array of middleware functions to execute
+ * @param input - The input to pass to each middleware
+ * @param ctx - The context object (will be mutated by middleware)
+ * @param handler - The final handler to execute after all middleware
+ * @returns The output from the handler
+ *
+ * @example
+ * ```typescript
+ * const result = await executeMiddlewareChain(
+ *   procedure.middlewares,
+ *   input,
+ *   ctx,
+ *   async () => handler({ input, ctx })
+ * );
+ * ```
+ */
+export async function executeMiddlewareChain(middlewares, input, ctx, handler) {
+    // Build the chain from the end (handler) back to the start
+    let next = async () => {
+        const output = await handler();
+        return { output };
+    };
+    // Wrap each middleware from last to first
+    for (let i = middlewares.length - 1; i >= 0; i--) {
+        const middleware = middlewares[i];
+        const currentNext = next;
+        next = async () => {
+            return middleware({
+                input,
+                ctx,
+                next: async (opts) => {
+                    // Allow middleware to extend context
+                    if (opts?.ctx) {
+                        Object.assign(ctx, opts.ctx);
+                    }
+                    return currentNext();
+                },
+            });
+        };
+    }
+    const result = await next();
+    return result.output;
+}
+/**
+ * Create a precompiled middleware executor for a fixed middleware chain
+ *
+ * This is an optimization that builds the chain structure once during
+ * procedure compilation, creating a reusable function that can execute
+ * the chain without rebuilding closures on every request.
+ *
+ * @param middlewares - Array of middleware functions
+ * @param handler - The procedure handler (can return sync or async)
+ * @returns A function that executes the full chain
+ */
+export function createMiddlewareExecutor(middlewares, handler) {
+    // If no middlewares, just return a direct handler call
+    if (middlewares.length === 0) {
+        return async (input, ctx) => {
+            return handler({ input, ctx });
+        };
+    }
+    // Return an executor that uses the shared chain execution
+    return async (input, ctx) => {
+        return executeMiddlewareChain(middlewares, input, ctx, async () => handler({ input, ctx }));
+    };
+}

package/dist/middleware/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Middleware utilities
+ *
+ * @module middleware
+ */
+export type { MiddlewareResult } from './chain.js';
+export { createMiddlewareExecutor, executeMiddlewareChain } from './chain.js';

package/dist/middleware/index.js

@@ -0,0 +1,6 @@
+/**
+ * Middleware utilities
+ *
+ * @module middleware
+ */
+export { createMiddlewareExecutor, executeMiddlewareChain } from './chain.js';

package/dist/procedure/builder.js

@@ -9,6 +9,7 @@
  */
 import { ConfigurationError, logWarning } from '@veloxts/core';
 import { GuardError } from '../errors.js';
+import { createMiddlewareExecutor, executeMiddlewareChain } from '../middleware/chain.js';
 import { analyzeNamingConvention, isDevelopment, normalizeWarningOption, } from '../warnings.js';
 // ============================================================================
 // Utility Functions
@@ -115,6 +116,7 @@ export function procedure() {
         guards: [],
         restOverride: undefined,
         parentResource: undefined,
+        parentResources: undefined,
     });
 }
 // ============================================================================
@@ -209,18 +211,31 @@ function createBuilder(state) {
             });
         },
         /**
-         * Declares a parent resource for nested routes
+         * Declares a parent resource for nested routes (single level)
          */
-        parent(namespace, paramName) {
+        parent(resource, param) {
             const parentConfig = {
-                namespace,
-                paramName: paramName ?? deriveParentParamName(namespace),
+                resource,
+                param: param ?? deriveParentParamName(resource),
             };
             return createBuilder({
                 ...state,
                 parentResource: parentConfig,
             });
         },
+        /**
+         * Declares multiple parent resources for deeply nested routes
+         */
+        parents(config) {
+            const parentConfigs = config.map((item) => ({
+                resource: item.resource,
+                param: item.param ?? deriveParentParamName(item.resource),
+            }));
+            return createBuilder({
+                ...state,
+                parentResources: parentConfigs,
+            });
+        },
         /**
          * Finalizes as a query procedure
          */
@@ -261,6 +276,7 @@ function compileProcedure(type, handler, state) {
         guards: state.guards,
         restOverride: state.restOverride,
         parentResource: state.parentResource,
+        parentResources: state.parentResources,
         // Store pre-compiled executor for performance
         _precompiledExecutor: precompiledExecutor,
     };
@@ -275,36 +291,7 @@ function compileProcedure(type, handler, state) {
  * @internal
  */
 function createPrecompiledMiddlewareExecutor(middlewares, handler) {
-    // Pre-build the chain executor once
-    return async (input, ctx) => {
-        // Create mutable context copy for middleware extensions
-        const mutableCtx = ctx;
-        // Build the handler wrapper
-        const executeHandler = async () => {
-            const output = await handler({ input, ctx: mutableCtx });
-            return { output };
-        };
-        // Build chain from end to start (only done once per request, not per middleware)
-        let next = executeHandler;
-        for (let i = middlewares.length - 1; i >= 0; i--) {
-            const middleware = middlewares[i];
-            const currentNext = next;
-            next = async () => {
-                return middleware({
-                    input,
-                    ctx: mutableCtx,
-                    next: async (opts) => {
-                        if (opts?.ctx) {
-                            Object.assign(mutableCtx, opts.ctx);
-                        }
-                        return currentNext();
-                    },
-                });
-            };
-        }
-        const result = await next();
-        return result.output;
-    };
+    return createMiddlewareExecutor(middlewares, handler);
 }
 /**
  * Defines a collection of procedures under a namespace
@@ -502,31 +489,7 @@ export async function executeProcedure(procedure, rawInput, ctx) {
  * @internal
  */
 async function executeMiddlewareChainFallback(middlewares, input, ctx, handler) {
-    // Build the chain from the end (handler) back to the start
-    let next = async () => {
-        const output = await handler();
-        return { output };
-    };
-    // Wrap each middleware from last to first
-    for (let i = middlewares.length - 1; i >= 0; i--) {
-        const middleware = middlewares[i];
-        const currentNext = next;
-        next = async () => {
-            return middleware({
-                input,
-                ctx,
-                next: async (opts) => {
-                    // Allow middleware to extend context
-                    if (opts?.ctx) {
-                        Object.assign(ctx, opts.ctx);
-                    }
-                    return currentNext();
-                },
-            });
-        };
-    }
-    const result = await next();
-    return result.output;
+    return executeMiddlewareChain(middlewares, input, ctx, handler);
 }
 // ============================================================================
 // Type Utilities

package/dist/procedure/types.d.ts

@@ -249,16 +249,16 @@ export interface ProcedureBuilder<TInput = unknown, TOutput = unknown, TContext
      */
     rest(config: RestRouteOverride): ProcedureBuilder<TInput, TOutput, TContext>;
     /**
-     * Declares a parent resource for nested routes
+     * Declares a parent resource for nested routes (single level)
      *
      * When a procedure has a parent resource, the REST path will be nested
-     * under the parent: `/${parentNamespace}/:${parentParam}/${childNamespace}/:id`
+     * under the parent: `/${parentResource}/:${parentParam}/${childResource}/:id`
      *
      * The input schema should include the parent parameter (e.g., `postId`) for
      * proper type safety and runtime validation.
      *
-     * @param namespace - Parent resource namespace (e.g., 'posts', 'users')
-     * @param paramName - Optional custom parameter name (default: `${singularNamespace}Id`)
+     * @param resource - Parent resource name (e.g., 'posts', 'users')
+     * @param param - Optional custom parameter name (default: `${singularResource}Id`)
      * @returns Same builder (no type changes)
      *
      * @example
@@ -276,7 +276,38 @@ export interface ProcedureBuilder<TInput = unknown, TOutput = unknown, TContext
      *   .query(async ({ input }) => { ... });
      * ```
      */
-    parent(namespace: string, paramName?: string): ProcedureBuilder<TInput, TOutput, TContext>;
+    parent(resource: string, param?: string): ProcedureBuilder<TInput, TOutput, TContext>;
+    /**
+     * Declares multiple parent resources for deeply nested routes
+     *
+     * When a procedure has multiple parent resources, the REST path will be
+     * deeply nested: `/${parent1}/:${param1}/${parent2}/:${param2}/.../${child}/:id`
+     *
+     * The input schema should include ALL parent parameters for proper type safety.
+     *
+     * @param config - Array of parent resource configurations from outermost to innermost
+     * @returns Same builder (no type changes)
+     *
+     * @example
+     * ```typescript
+     * // Generates: GET /organizations/:orgId/projects/:projectId/tasks/:id
+     * const getTask = procedure()
+     *   .parents([
+     *     { resource: 'organizations', param: 'orgId' },
+     *     { resource: 'projects', param: 'projectId' },
+     *   ])
+     *   .input(z.object({
+     *     orgId: z.string(),
+     *     projectId: z.string(),
+     *     id: z.string()
+     *   }))
+     *   .query(async ({ input }) => { ... });
+     * ```
+     */
+    parents(config: Array<{
+        resource: string;
+        param?: string;
+    }>): ProcedureBuilder<TInput, TOutput, TContext>;
     /**
      * Finalizes the procedure as a query (read-only operation)
      *
@@ -333,8 +364,10 @@ export interface BuilderRuntimeState {
     guards: GuardLike<unknown>[];
     /** REST route override */
     restOverride?: RestRouteOverride;
-    /** Parent resource configuration for nested routes */
+    /** Parent resource configuration for nested routes (single level) */
     parentResource?: ParentResourceConfig;
+    /** Multi-level parent resource configuration for deeply nested routes */
+    parentResources?: ParentResourceConfig[];
 }
 /**
  * Type for the procedures object passed to defineProcedures

package/dist/rest/adapter.d.ts

@@ -41,6 +41,35 @@ export interface RestAdapterOptions {
     prefix?: string;
     /** Custom error handler */
     onError?: (error: unknown, request: FastifyRequest, reply: FastifyReply) => void;
+    /**
+     * Generate flat shortcut routes alongside nested routes.
+     *
+     * When enabled, nested routes like `/organizations/:orgId/projects/:projectId/tasks/:id`
+     * will also generate a flat shortcut route like `/tasks/:id`.
+     *
+     * Note: Shortcuts only work for single-resource operations (GET, PUT, PATCH, DELETE with :id).
+     * Collection operations (list, create) require parent context and are NOT generated as shortcuts.
+     *
+     * @example
+     * ```typescript
+     * rest([tasks], { shortcuts: true })
+     * // Generates:
+     * // GET /organizations/:orgId/projects/:projectId/tasks/:id (nested)
+     * // GET /tasks/:id (shortcut)
+     * ```
+     *
+     * @default false
+     */
+    shortcuts?: boolean;
+    /**
+     * Enable warnings about deep nesting (3+ levels).
+     *
+     * When true (default), the router warns when nesting exceeds 3 levels.
+     * Set to false to silence these warnings.
+     *
+     * @default true
+     */
+    nestingWarnings?: boolean;
 }
 /**
  * Internal options used during route registration
@@ -53,6 +82,13 @@ interface InternalRegistrationOptions extends RestAdapterOptions {
      */
     _prefixHandledByFastify?: boolean;
 }
+/** Options for generating REST routes */
+export interface GenerateRestRoutesOptions {
+    /** Generate flat shortcut routes alongside nested routes */
+    shortcuts?: boolean;
+    /** Enable nesting depth warnings (default: true) */
+    nestingWarnings?: boolean;
+}
 /**
  * Generate REST routes from a procedure collection
  *
@@ -62,9 +98,10 @@ interface InternalRegistrationOptions extends RestAdapterOptions {
  * 3. Skipping if neither applies (tRPC-only procedure)
  *
  * @param collection - Procedure collection to generate routes from
+ * @param options - Optional route generation options
  * @returns Array of REST route definitions
  */
-export declare function generateRestRoutes(collection: ProcedureCollection): RestRoute[];
+export declare function generateRestRoutes(collection: ProcedureCollection, options?: GenerateRestRoutesOptions): RestRoute[];
 /**
  * Register REST routes from procedure collections onto a Fastify instance
  *