import type { VextClientContract, VextClientRouteMethod } from "./types.js";
type VextHeadersInit = ConstructorParameters<typeof Headers>[0];
type RoutesByMethod<TContract extends VextClientContract, TMethod extends VextClientRouteMethod> = Extract<TContract["routes"][number], {
    method: TMethod;
}>;
type PathFor<TContract extends VextClientContract, TMethod extends VextClientRouteMethod> = RoutesByMethod<TContract, TMethod>["path"] & string;
type RouteTypeFor<TContract extends VextClientContract, TRouteTypes, TMethod extends VextClientRouteMethod, TPath extends string> = Extract<RoutesByMethod<TContract, TMethod>, {
    path: TPath;
}> extends {
    routeId: infer TRouteId;
} ? TRouteId extends keyof TRouteTypes ? TRouteTypes[TRouteId] extends VextApiRouteType ? TRouteTypes[TRouteId] : VextApiRouteType : VextApiRouteType : VextApiRouteType;
export interface VextApiClientOptions {
    baseUrl?: string;
    fetch?: typeof fetch;
    headers?: VextHeadersInit;
}
export interface VextApiRequestOptions {
    params?: Record<string, string | number | boolean>;
    query?: Record<string, string | number | boolean | null | undefined | Array<string | number>>;
    body?: unknown;
    headers?: VextHeadersInit;
    signal?: AbortSignal;
}
/** Type-only route projection emitted by the generated API client. */
export interface VextApiRouteType {
    params: unknown;
    query: unknown;
    headers: unknown;
    /** Cookie validation is contract metadata; browser fetch owns cookie transport. */
    cookies: unknown;
    body: unknown;
    response: unknown;
}
export type VextApiRequestOptionsFor<TRoute extends VextApiRouteType> = Omit<VextApiRequestOptions, "params" | "query" | "headers" | "body"> & {
    params?: TRoute["params"];
    query?: TRoute["query"];
    headers?: TRoute["headers"];
    body?: TRoute["body"];
};
export declare class VextApiError extends Error {
    readonly name = "VextApiError";
    readonly status: number;
    readonly code: unknown;
    readonly details: unknown;
    readonly response: Response;
    readonly rawBody: unknown;
    constructor(args: {
        status: number;
        message: string;
        response: Response;
        rawBody: unknown;
        code?: unknown;
        details?: unknown;
    });
}
export declare function isVextApiError(error: unknown): error is VextApiError;
export interface VextApiClient<TContract extends VextClientContract, TRouteTypes = Record<never, VextApiRouteType>> {
    readonly contract: TContract;
    request<TMethod extends VextClientRouteMethod, TPath extends PathFor<TContract, TMethod>>(method: TMethod, path: TPath, options?: VextApiRequestOptionsFor<RouteTypeFor<TContract, TRouteTypes, TMethod, TPath>>): Promise<RouteTypeFor<TContract, TRouteTypes, TMethod, TPath>["response"]>;
    GET<TPath extends PathFor<TContract, "GET">>(path: TPath, options?: VextApiRequestOptionsFor<RouteTypeFor<TContract, TRouteTypes, "GET", TPath>>): Promise<RouteTypeFor<TContract, TRouteTypes, "GET", TPath>["response"]>;
    POST<TPath extends PathFor<TContract, "POST">>(path: TPath, options?: VextApiRequestOptionsFor<RouteTypeFor<TContract, TRouteTypes, "POST", TPath>>): Promise<RouteTypeFor<TContract, TRouteTypes, "POST", TPath>["response"]>;
    PUT<TPath extends PathFor<TContract, "PUT">>(path: TPath, options?: VextApiRequestOptionsFor<RouteTypeFor<TContract, TRouteTypes, "PUT", TPath>>): Promise<RouteTypeFor<TContract, TRouteTypes, "PUT", TPath>["response"]>;
    PATCH<TPath extends PathFor<TContract, "PATCH">>(path: TPath, options?: VextApiRequestOptionsFor<RouteTypeFor<TContract, TRouteTypes, "PATCH", TPath>>): Promise<RouteTypeFor<TContract, TRouteTypes, "PATCH", TPath>["response"]>;
    DELETE<TPath extends PathFor<TContract, "DELETE">>(path: TPath, options?: VextApiRequestOptionsFor<RouteTypeFor<TContract, TRouteTypes, "DELETE", TPath>>): Promise<RouteTypeFor<TContract, TRouteTypes, "DELETE", TPath>["response"]>;
    HEAD<TPath extends PathFor<TContract, "HEAD">>(path: TPath, options?: VextApiRequestOptionsFor<RouteTypeFor<TContract, TRouteTypes, "HEAD", TPath>>): Promise<RouteTypeFor<TContract, TRouteTypes, "HEAD", TPath>["response"]>;
    OPTIONS<TPath extends PathFor<TContract, "OPTIONS">>(path: TPath, options?: VextApiRequestOptionsFor<RouteTypeFor<TContract, TRouteTypes, "OPTIONS", TPath>>): Promise<RouteTypeFor<TContract, TRouteTypes, "OPTIONS", TPath>["response"]>;
}
export declare function createVextApiClient<const TContract extends VextClientContract, TRouteTypes = Record<never, VextApiRouteType>>(contract: TContract, options?: VextApiClientOptions): VextApiClient<TContract, TRouteTypes>;
export {};