/**
 * Next.js Route Helpers
 *
 * Utility functions for working with Next.js API routes.
 * These helpers reduce boilerplate for common operations like
 * extracting query parameters and parsing request bodies.
 *
 * @example Query params with Zod validation
 * ```typescript
 * import { extractQueryParams } from '@plyaz/core/frameworks/nextjs';
 * import { z } from 'zod';
 *
 * const querySchema = z.object({
 *   page: z.coerce.number().default(1),
 *   limit: z.coerce.number().default(10),
 *   search: z.string().optional(),
 * });
 *
 * export async function GET(request: NextRequest) {
 *   const { page, limit, search } = extractQueryParams(request, querySchema);
 *   // Use typed params...
 * }
 * ```
 *
 * @example Body parsing with validation
 * ```typescript
 * import { extractJsonBody } from '@plyaz/core/frameworks/nextjs';
 * import { z } from 'zod';
 *
 * const createUserSchema = z.object({
 *   name: z.string(),
 *   email: z.string().email(),
 * });
 *
 * export async function POST(request: NextRequest) {
 *   const body = await extractJsonBody(request, createUserSchema);
 *   // body is typed as { name: string; email: string }
 * }
 * ```
 */
import type { NextRequest } from 'next/server';
interface ZodLikeSchema<T> {
    parse: (data: unknown) => T;
    safeParse: (data: unknown) => {
        success: true;
        data: T;
    } | {
        success: false;
        error: {
            message: string;
        };
    };
}
/**
 * Extract and parse query parameters from a Next.js request.
 *
 * @param request - Next.js request object
 * @param schema - Zod schema for validation (optional)
 * @returns Parsed and validated query parameters
 * @throws If validation fails
 *
 * @example Without validation
 * ```typescript
 * const params = extractQueryParams(request);
 * // params: Record<string, string>
 * ```
 *
 * @example With Zod validation
 * ```typescript
 * const schema = z.object({
 *   page: z.coerce.number().default(1),
 *   limit: z.coerce.number().max(100).default(20),
 * });
 *
 * const { page, limit } = extractQueryParams(request, schema);
 * // page: number, limit: number
 * ```
 */
export declare function extractQueryParams<T>(request: NextRequest, schema: ZodLikeSchema<T>): T;
export declare function extractQueryParams(request: NextRequest): Record<string, string>;
/**
 * Extract and parse JSON body from a Next.js request.
 *
 * @param request - Next.js request object
 * @param schema - Zod schema for validation (optional)
 * @returns Parsed and validated body
 * @throws If body parsing or validation fails
 *
 * @example Without validation
 * ```typescript
 * const body = await extractJsonBody(request);
 * // body: unknown
 * ```
 *
 * @example With Zod validation
 * ```typescript
 * const schema = z.object({
 *   name: z.string(),
 *   email: z.string().email(),
 *   role: z.enum(['admin', 'user']).default('user'),
 * });
 *
 * const body = await extractJsonBody(request, schema);
 * // body: { name: string; email: string; role: 'admin' | 'user' }
 * ```
 */
export declare function extractJsonBody<T>(request: NextRequest, schema: ZodLikeSchema<T>): Promise<T>;
export declare function extractJsonBody(request: NextRequest): Promise<unknown>;
/**
 * Safely extract and parse JSON body from a Next.js request.
 * Returns null if parsing fails instead of throwing.
 *
 * @param request - Next.js request object
 * @param schema - Zod schema for validation (optional)
 * @returns Parsed body or null if parsing failed
 *
 * @example
 * ```typescript
 * const body = await safeExtractJsonBody(request, schema);
 * if (!body) {
 *   return Response.json({ error: 'Invalid request body' }, { status: 400 });
 * }
 * ```
 */
export declare function safeExtractJsonBody<T>(request: NextRequest, schema: ZodLikeSchema<T>): Promise<T | null>;
export declare function safeExtractJsonBody(request: NextRequest): Promise<unknown | null>;
/**
 * Extract route parameters from Next.js context.
 * Handles the async params pattern in Next.js App Router.
 *
 * @param context - Next.js route context with async params
 * @returns Resolved params object
 *
 * @example
 * ```typescript
 * // app/api/users/[id]/route.ts
 * export async function GET(request: NextRequest, context: { params: Promise<{ id: string }> }) {
 *   const { id } = await extractRouteParams(context);
 *   // id: string
 * }
 * ```
 */
export declare function extractRouteParams<T extends Record<string, string> = Record<string, string>>(context: {
    params: Promise<T>;
} | {
    params: T;
} | undefined): Promise<T>;
/**
 * Extract headers from a Next.js request as a plain object.
 *
 * @param request - Next.js request object
 * @returns Headers as a plain object
 *
 * @example
 * ```typescript
 * const headers = extractHeaders(request);
 * const auth = headers['authorization'];
 * const contentType = headers['content-type'];
 * ```
 */
export declare function extractHeaders(request: NextRequest): Record<string, string | undefined>;
/**
 * Extract a specific header value from a Next.js request.
 *
 * @param request - Next.js request object
 * @param name - Header name (case-insensitive)
 * @returns Header value or undefined
 *
 * @example
 * ```typescript
 * const auth = extractHeader(request, 'authorization');
 * if (!auth?.startsWith('Bearer ')) {
 *   return Response.json({ error: 'Unauthorized' }, { status: 401 });
 * }
 * ```
 */
export declare function extractHeader(request: NextRequest, name: string): string | undefined;
export declare function extractBearerToken(request: NextRequest): string | null;
export {};
//# sourceMappingURL=helpers.d.ts.map