/**
 * RPC Client Plugin for OpenSpeed
 * Provides end-to-end type safety between frontend and backend (similar to tRPC/Eden)
 */
import type { Context } from '../context.js';
export type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
export interface RouteHandler {
    (ctx: Context): any;
}
export type InferInput<T> = T extends (ctx: infer C) => any ? C extends Context & {
    body: infer B;
} ? B : never : never;
export type InferOutput<T> = T extends (...args: any[]) => infer R ? R extends Promise<infer P> ? P extends {
    body: infer B;
} ? B extends string ? any : B : any : R extends {
    body: infer B;
} ? B extends string ? any : B : any : never;
export interface RPCRoute {
    method: Method;
    path: string;
    handler: RouteHandler;
}
export interface RPCApp {
    routes: Map<string, RPCRoute>;
    get(path: string, handler: RouteHandler): this;
    post(path: string, handler: RouteHandler): this;
    put(path: string, handler: RouteHandler): this;
    patch(path: string, handler: RouteHandler): this;
    delete(path: string, handler: RouteHandler): this;
}
export interface RPCClientOptions {
    baseUrl?: string;
    headers?: Record<string, string>;
    fetch?: typeof fetch;
    onRequest?: (req: Request) => void | Promise<void>;
    onResponse?: (res: Response) => void | Promise<void>;
    onError?: (error: Error) => void | Promise<void>;
}
export interface RPCResponse<T> {
    data?: T;
    error?: {
        message: string;
        status: number;
        details?: any;
    };
    status: number;
    headers: Headers;
}
export type QueryParams = Record<string, string | number | boolean | undefined>;
export interface RequestOptions<TBody = any> {
    params?: Record<string, string>;
    query?: QueryParams;
    body?: TBody;
    headers?: Record<string, string>;
}
/**
 * Create RPC client from app type
 */
export declare function createClient<TApp extends RPCApp>(options?: RPCClientOptions): RPCClient<TApp>;
export type RPCClient<TApp extends RPCApp> = {
    [K in keyof TApp['routes']]: {
        get<T = any>(options?: RequestOptions): Promise<RPCResponse<T>>;
        post<T = any>(options?: RequestOptions): Promise<RPCResponse<T>>;
        put<T = any>(options?: RequestOptions): Promise<RPCResponse<T>>;
        patch<T = any>(options?: RequestOptions): Promise<RPCResponse<T>>;
        delete<T = any>(options?: RequestOptions): Promise<RPCResponse<T>>;
    };
};
/**
 * Helper to extract routes from app for type inference
 */
export declare function treaty<TApp extends RPCApp>(baseUrl: string, options?: Omit<RPCClientOptions, 'baseUrl'>): RPCClient<TApp>;
/**
 * Batch request helper
 */
export declare function batch<T extends Promise<any>[]>(...requests: T): Promise<{
    [K in keyof T]: Awaited<T[K]>;
}>;
/**
 * RPC middleware for server-side route collection
 */
export interface RPCPluginOptions {
    enableIntrospection?: boolean;
    prefix?: string;
}
export declare function rpc(options?: RPCPluginOptions): (ctx: Context, next: () => Promise<any>) => Promise<import("../context.js").ResponseLike | undefined>;
/**
 * Type-safe route definition helper
 */
export declare function defineRoute<TInput = any, TOutput = any>(handler: (ctx: Context & {
    body: TInput;
}) => TOutput | Promise<TOutput>): RouteHandler;
/**
 * Create typed API contract
 */
export declare function createContract<T extends Record<string, any>>(): T;
/**
 * Utility for creating webhooks/subscriptions
 */
export declare class RPCSubscription<T = any> {
    private url;
    private options;
    private listeners;
    private ws?;
    constructor(url: string, options?: RPCClientOptions);
    subscribe(callback: (data: T) => void): () => void;
    private connect;
    private disconnect;
    send(data: T): void;
}
/**
 * Example usage:
 *
 * // Server-side
 * import { Openspeed } from 'openspeed';
 * import { rpc, defineRoute } from 'openspeed/plugins/rpc';
 *
 * const app = Openspeed();
 * app.use(rpc());
 *
 * app.post('/api/user', defineRoute<{ name: string }, { id: string }>((ctx) => {
 *   const { name } = ctx.body;
 *   return ctx.json({ id: '123', name });
 * }));
 *
 * export type App = typeof app;
 *
 * // Client-side
 * import { treaty } from 'openspeed/plugins/rpc';
 * import type { App } from './server';
 *
 * const api = treaty<App>('http://localhost:3000');
 *
 * const { data, error } = await api['/api/user'].post({
 *   body: { name: 'John' } // Type-safe!
 * });
 *
 * if (data) {
 *   console.log(data.id); // Type-safe!
 * }
 */
//# sourceMappingURL=rpc.d.ts.map