/**
 * Transform: v1 route files → v2 Hono chained style
 *
 * v1 pattern:
 *   import { createRouter } from '@agentuity/runtime';
 *   const router = createRouter();
 *   router.get('/foo', handler);
 *   router.post('/bar', handler);
 *   export default router;
 *
 * v2 pattern:
 *   import { Hono } from 'hono';
 *   import type { Env } from '@agentuity/runtime';
 *
 *   const router = new Hono<Env>()
 *     .get('/foo', handler)
 *     .post('/bar', handler);
 *
 *   export default router;
 *
 * WHY CHAINING MATTERS — Hono RPC type inference:
 *   Hono accumulates route types via TypeScript's return-type inference on
 *   each chained call.  If you break the chain (e.g. `router.get(...)` on a
 *   separate statement after the variable declaration), the Schema type
 *   parameter never accumulates new routes and `typeof router` carries no
 *   route information.  The chained style is the ONLY way to get the full
 *   AppRouter type used by `hc<AppRouter>()` on the frontend.
 *
 *   Individual route files export a typed router; the barrel (src/api/index.ts)
 *   composes them with `.route()` and re-exports `AppRouter = typeof router`.
 *   Frontend code imports that type:
 *
 *     import { hc } from 'hono/client';
 *     import type { AppRouter } from '../api';          // or wherever
 *     const client = hc<AppRouter>(window.location.origin + '/api');
 *     const res = await client.hello.$post({ json: { name: 'World' } });
 *
 * COMPLEXITY GUARD: if the file:
 *   • Has more than one createRouter() call
 *   • Uses variable re-assignment of the router variable
 * …we refuse and return a complexityError.
 */
export interface RouteTransformResult {
    source: string | null;
    complexityError?: string;
    changes: string[];
}
export declare function transformRouteFile(source: string): RouteTransformResult;
//# sourceMappingURL=routes.d.ts.map