import './assert_dev_env.js';
import type { z } from 'zod';
import type { AppSurface, AppSurfaceRoute } from '../http/surface.js';
import type { RouteErrorSchemas } from '../http/error_schemas.js';
/**
 * Resolve an absolute path relative to the caller's module.
 *
 * @param import_meta_url - the caller's `import.meta.url`
 */
export declare const resolve_fixture_path: (filename: string, import_meta_url: string) => string;
/**
 * Compare live surface against a committed snapshot JSON file.
 *
 * Failure message instructs the developer to run `gro gen` to update the
 * snapshot — every fuz_app consumer wires the snapshot through a `*.gen.ts`
 * file so regeneration goes through the same pipeline as the rest of the
 * generated artifacts.
 *
 * @param surface - the live surface to check
 * @param snapshot_path - absolute path to the committed JSON snapshot
 * @throws AssertionError if the live surface does not deep-equal the snapshot,
 *   or `Error` if the snapshot file is unreadable / malformed JSON.
 */
export declare const assert_surface_matches_snapshot: (surface: AppSurface, snapshot_path: string) => void;
/**
 * Verify surface generation is deterministic (build twice, compare).
 */
export declare const assert_surface_deterministic: (build_surface: () => AppSurface) => void;
/**
 * Bidirectional check: no unexpected public routes, no missing expected ones.
 *
 * @param surface - the app surface to check
 * @param expected_public - format: `['GET /health', 'POST /api/account/login']`
 * @throws AssertionError if the live surface has public routes not in
 *   `expected_public`, or if any entry in `expected_public` is missing from
 *   the live surface.
 */
export declare const assert_only_expected_public_routes: (surface: AppSurface, expected_public: Array<string>) => void;
/**
 * Look up the merged error schema for a route+status from a pre-built schema lookup.
 *
 * @param lookup - map from `"METHOD /path"` to merged error schemas
 * @param route - the surface route to look up
 * @param status - HTTP status code
 * @returns the Zod schema for that route+status, or `undefined` when no error
 *   schema is declared for the status code
 */
export declare const get_route_error_schema: (lookup: Map<string, RouteErrorSchemas>, route: AppSurfaceRoute, status: number) => z.ZodType | undefined;
/**
 * Assert that an error schema exists for a route+status and validate the body against it.
 *
 * Protected routes should always have auto-derived error schemas (401 for authenticated,
 * 403 for role-restricted). A missing schema indicates a gap in error schema derivation.
 *
 * @param lookup - map from `"METHOD /path"` to merged error schemas
 * @param route - the surface route to validate against
 * @param status - expected HTTP status code
 * @param body - the parsed response body to validate
 * @throws AssertionError if no schema is declared for the route+status pair.
 * @throws ZodError if the body does not satisfy the declared schema.
 */
export declare const assert_error_schema_valid: (lookup: Map<string, RouteErrorSchemas>, route: AppSurfaceRoute, status: number, body: unknown) => void;
/**
 * Verify every route under a path prefix has the exact expected middleware stack.
 *
 * @param surface - the app surface to check
 * @param path_prefix - prefix to filter routes (e.g. `'/api/'`)
 * @param expected_middleware - the exact middleware names in order
 * @throws AssertionError if no routes match `path_prefix`, or if any matching
 *   route's `applicable_middleware` does not deep-equal `expected_middleware`.
 */
export declare const assert_full_middleware_stack: (surface: AppSurface, path_prefix: string, expected_middleware: Array<string>) => void;
//# sourceMappingURL=assertions.d.ts.map