import type { Schema, Infer } from '../../data/schema/types.js';
import type { DB } from '../../data/db/index.js';
import type { Handler, HttpMethod, RouteMeta, AuthRequirement, PermissionMeta, JobRetryConfig, JobTransactionMode, Checkpoint, RouteScreen } from './types.js';
import type { ResourceOperations, Resource, PaginationConfig } from '../fixture/types.js';
import type { HttpRequest, HttpResponse } from '../http/types.js';
interface BuilderState {
    databases: string[];
    requiresAuth: boolean;
    authRequirement: AuthRequirement;
    inputSchema: Schema | null;
    outputSchemas: Map<number, Schema>;
    querySchema: Schema | null;
    paramsSchema: Schema | null;
    route: RouteMeta | null;
    isJob: boolean;
    jobType: string | null;
    jobRetry: JobRetryConfig | null;
    jobTimeout: number | null;
    jobTransaction: JobTransactionMode;
    permission: PermissionMeta | null;
    pagination: PaginationConfig | null;
    wantsRequest: boolean;
    wantsResponse: boolean;
    wantsRawBody: boolean;
}
/**
 * Deps shape after `.transaction('manual')`: the databases the handler declared
 * with `.use()` move out of the top-level deps (a non-transactional handle there
 * would be a footgun) and into `checkpoint`'s callback, which binds them inside a
 * fresh tenant-scoped transaction. `checkpoint` is added in their place.
 */
type ManualDeps<TDeps, TDb> = Omit<TDeps, keyof TDb> & {
    checkpoint: Checkpoint<TDb>;
};
export declare class Builder<TDeps extends Record<string, unknown>, TDb extends Record<string, DB> = Record<never, DB>> {
    private readonly state;
    constructor(state?: Partial<BuilderState>);
    use(): Builder<TDeps & {
        db: DB;
    }, TDb & {
        db: DB;
    }>;
    use<N extends string>(name: N): Builder<TDeps & Record<N, DB>, TDb & Record<N, DB>>;
    auth<TAuth>(): Builder<TDeps & {
        auth: TAuth;
    }, TDb>;
    authOptional<TAuth>(): Builder<TDeps & {
        auth: TAuth | null;
    }, TDb>;
    public(): Builder<TDeps, TDb>;
    input<T extends Schema>(schema: T): Builder<TDeps & {
        input: Infer<T>;
    }, TDb>;
    query<T extends Schema>(schema: T): Builder<TDeps & {
        query: Infer<T>;
    }, TDb>;
    params<T extends Schema>(schema: T): Builder<TDeps & {
        params: Infer<T>;
    }, TDb>;
    output<T extends Schema>(schema: T): Builder<TDeps, TDb>;
    output<T extends Schema>(status: number, schema: T): Builder<TDeps, TDb>;
    route(method: HttpMethod, path: string, options?: {
        bodyLimit?: number;
        screen?: RouteScreen;
    }): Builder<TDeps, TDb>;
    job(type?: string): Builder<TDeps, TDb>;
    /**
     * Selects how the job's database transaction(s) are managed.
     *
     * `'auto'` (default) keeps the single framework-owned outer transaction.
     * `'manual'` opens no outer transaction; the handler instead receives a
     * `checkpoint(fn)` primitive and owns its own commit boundaries — the
     * databases declared with `.use()` move from the top-level deps into
     * `checkpoint`'s callback. The job's contract shifts from atomic to
     * at-least-once / idempotent-on-resume; the handler owns resume.
     */
    transaction(mode: 'auto'): Builder<TDeps, TDb>;
    transaction(mode: 'manual'): Builder<ManualDeps<TDeps, TDb>, TDb>;
    retry(config: JobRetryConfig): Builder<TDeps, TDb>;
    timeout(ms: number): Builder<TDeps, TDb>;
    permission(resource: string, action: string, scope?: string): Builder<TDeps, TDb>;
    paginate(config?: {
        defaultLimit?: number;
        maxLimit?: number;
    }): Builder<TDeps, TDb>;
    request(): Builder<TDeps & {
        request: HttpRequest;
    }, TDb>;
    response(): Builder<TDeps & {
        response: HttpResponse;
    }, TDb>;
    rawBody(): Builder<TDeps & {
        rawBody: Buffer;
    }, TDb>;
    fixture<TAuth>(name: string, operations: ResourceOperations<TAuth>): Resource<TAuth>;
    fit<TReturn>(fn: (deps: TDeps) => Promise<TReturn>): Handler<TDeps, TReturn>;
}
export declare function createBuilder(): Builder<Record<never, never>>;
export {};
//# sourceMappingURL=builder.d.ts.map