import { FarmCacheInvalidationTarget } from './cache.mjs';

type MultipartField = string | number | boolean | bigint | Blob | Date | null | undefined;
type MultipartValues = Record<string, MultipartField | readonly MultipartField[]>;
/**
 * A real FormData value that retains the submitted value shape for generated
 * API-client inference.
 */
type TypedFormData<TValues> = FormData & {
    readonly __farmMultipartInput: TValues;
};
type MultipartSchema<TSchema> = TSchema & {
    readonly __farmMultipartSchema: true;
};
type FarmStreamResponse<TItem> = Response & {
    readonly __farmStreamItem: TItem;
};
interface FarmAPIStream<TItem> extends AsyncIterable<TItem> {
    readonly response: Response;
    cancel(reason?: unknown): Promise<void>;
}
type SchemaLike = {
    parse(data: unknown): unknown;
};
/**
 * Mark a body schema as multipart. The handler still receives the schema's
 * parsed object; generated clients require `toFormData(...)` for the request.
 */
declare function multipart<TSchema extends SchemaLike>(schema: TSchema): MultipartSchema<TSchema>;
declare function isMultipartSchema(value: unknown): value is MultipartSchema<SchemaLike>;
/**
 * Encode a typed object as multipart FormData without converting File or Blob
 * values to JSON or base64.
 */
declare function toFormData<TValues extends MultipartValues>(values: TValues): TypedFormData<TValues>;
/**
 * Stream JSON values as newline-delimited JSON. Each source value becomes one
 * independently decodable item instead of buffering the whole response.
 */
declare function jsonStream<TItem>(source: AsyncIterable<TItem> | Iterable<TItem>, init?: ResponseInit): FarmStreamResponse<TItem>;
declare function isJSONStreamResponse(response: {
    headers?: Pick<Headers, "get"> | null;
}): boolean;
/**
 * Decode a Farm JSON stream lazily. The response body is read only as the
 * consumer advances the async iterator, preserving fetch backpressure.
 */
declare function readJSONStream<TItem>(response: Response): FarmAPIStream<TItem>;
declare function isFarmAPIStream(value: unknown): value is FarmAPIStream<unknown>;

/** Server-only schema contract shared by declarative routes and the API runtime. */
interface RouteSchema {
    readonly _input?: unknown;
    readonly _output?: unknown;
    parse?: (value: unknown) => unknown;
    parseAsync?: (value: unknown) => Promise<unknown>;
    readonly "~standard"?: {
        readonly types?: {
            input: unknown;
            output: unknown;
        };
        validate(value: unknown): unknown;
    };
}
type RouteSchemaInput<T> = T extends {
    _input: infer I;
} ? I : T extends {
    "~standard": {
        types?: {
            input: infer I;
        };
    };
} ? I : unknown;
type RouteSchemaOutput<T> = T extends {
    _output: infer O;
} ? O : T extends {
    "~standard": {
        types?: {
            output: infer O;
        };
    };
} ? O : T extends {
    parse: (...args: any[]) => infer O;
} ? Awaited<O> : unknown;

type AnySchema = RouteSchema;
type MaybePromise<T> = T | Promise<T>;
type Simplify<T> = {
    [TKey in keyof T]: T[TKey];
} & {};
type UnionToIntersection$1<T> = (T extends unknown ? (value: T) => void : never) extends (value: infer TIntersection) => void ? TIntersection : never;
type InferOutput<T> = RouteSchemaOutput<T>;
type InferInput<T> = T extends {
    _input: infer I;
} ? I : T extends {
    "~standard": unknown;
} ? RouteSchemaInput<T> : T extends {
    parse: (data: infer I) => unknown;
} ? I : unknown;
type InferBodyInput<T> = T extends MultipartSchema<AnySchema> ? TypedFormData<InferInput<T>> : InferInput<T>;
type InferHeadersOutput<T> = [T] extends [never] ? Record<string, string> : T extends AnySchema ? InferOutput<T> : Record<string, string>;
type EndpointErrorSchema = AnySchema & {
    parse: (data: unknown) => unknown;
};
type EndpointErrorDefinitionBase<TStatus extends number> = {
    status: TStatus;
    /** Public message safe to expose to API callers. */
    message?: string;
};
type EndpointErrorDefinition<TSchema extends EndpointErrorSchema = EndpointErrorSchema, TStatus extends number = number> = EndpointErrorDefinitionBase<TStatus> & ({
    /** Schema for the public error payload exposed to API callers. */
    data: TSchema;
    schema?: never;
} | {
    data?: never;
    /** @deprecated Use `data` for consistency with server functions. */
    schema: TSchema;
});
type EndpointErrorDefinitions = Record<string, EndpointErrorDefinition<EndpointErrorSchema, number>>;
type InferEndpointErrorSchema<TDefinition> = TDefinition extends {
    data: infer TSchema extends AnySchema;
} ? TSchema : TDefinition extends {
    schema: infer TSchema extends AnySchema;
} ? TSchema : never;
type EndpointErrorContracts<TErrors extends EndpointErrorDefinitions> = {
    [TCode in keyof TErrors]: {
        data: InferOutput<InferEndpointErrorSchema<TErrors[TCode]>>;
        status: TErrors[TCode]["status"];
    };
};
type EndpointErrorHandler<TErrors extends EndpointErrorDefinitions> = <TCode extends keyof TErrors & string>(code: TCode, data: InferInput<InferEndpointErrorSchema<TErrors[TCode]>>) => never;
/** @deprecated Use `EndpointErrorHandler`. */
type EndpointFail<TErrors extends EndpointErrorDefinitions> = EndpointErrorHandler<TErrors>;
declare class EndpointFailure<TCode extends string = string, TData = unknown> extends Error {
    readonly code: TCode;
    readonly data: TData;
    readonly status: number;
    constructor(code: TCode, data: TData, options: {
        status: number;
        message: string;
    });
}
declare function isEndpointFailure(value: unknown): value is EndpointFailure<string, unknown>;
type EndpointParamValue = string | string[];
type EndpointParams = Record<string, EndpointParamValue>;
type EndpointMiddlewareContext<TContext extends object = {}, TBody = unknown, TQuery = unknown, THeaders = Record<string, string>> = {
    body: TBody;
    query: TQuery;
    headers: THeaders;
    request: Request;
    /** Context accumulated from middleware that ran earlier in the chain. */
    context: Readonly<TContext>;
    params: EndpointParams;
};
type EndpointMiddlewareResult<TProvidedContext extends object = object> = TProvidedContext | true | false | Response;
/** A plain async function. No wrapper or `next()` callback is required. */
type EndpointMiddleware<TProvidedContext extends object = object, TContext extends object = {}, TBody = unknown, TQuery = unknown, THeaders = Record<string, string>> = (ctx: EndpointMiddlewareContext<TContext, TBody, TQuery, THeaders>) => MaybePromise<EndpointMiddlewareResult<TProvidedContext>>;
type AnyEndpointMiddleware = (ctx: EndpointMiddlewareContext<any, any, any, any>) => unknown;
type EndpointInvalidationTarget = FarmCacheInvalidationTarget;
type EndpointInvalidationContext<TContext extends object = {}, TBody = unknown, TQuery = unknown, THeaders = Record<string, string>> = EndpointMiddlewareContext<TContext, TBody, TQuery, THeaders> & {
    /** The raw value returned by the endpoint handler. */
    result: unknown;
};
type EndpointInvalidations<TContext extends object = {}, TBody = unknown, TQuery = unknown, THeaders = Record<string, string>> = readonly EndpointInvalidationTarget[] | ((context: EndpointInvalidationContext<TContext, TBody, TQuery, THeaders>) => readonly EndpointInvalidationTarget[] | Promise<readonly EndpointInvalidationTarget[]>);
type ValidateEndpointMiddlewares<TMiddlewares extends readonly AnyEndpointMiddleware[]> = {
    readonly [TIndex in keyof TMiddlewares]: TMiddlewares[TIndex] extends AnyEndpointMiddleware ? [Awaited<ReturnType<TMiddlewares[TIndex]>>] extends [EndpointMiddlewareResult<object>] ? TMiddlewares[TIndex] : never : never;
};
type ContextFromMiddlewareResult<TResult> = Exclude<TResult, Response | boolean> extends infer TContext ? [TContext] extends [never] ? {} : TContext extends object ? TContext : {} : {};
type ContextFromMiddleware<TMiddleware> = TMiddleware extends (...args: any[]) => infer TResult ? ContextFromMiddlewareResult<Awaited<TResult>> : {};
type InferEndpointMiddlewareContext<TMiddlewares extends readonly ((...args: any[]) => any)[], TContext extends object = {}> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest] ? TMiddleware extends (...args: any[]) => any ? TRest extends readonly ((...args: any[]) => any)[] ? InferEndpointMiddlewareContext<TRest, Simplify<TContext & ContextFromMiddleware<TMiddleware>>> : Simplify<TContext> : Simplify<TContext> : number extends TMiddlewares["length"] ? Simplify<TContext & UnionToIntersection$1<ContextFromMiddleware<TMiddlewares[number]>>> : Simplify<TContext>;
type EndpointOptions<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TMiddlewares extends readonly AnyEndpointMiddleware[] = readonly [], TErrors extends EndpointErrorDefinitions = {}> = {
    method?: "GET" | "HEAD" | "QUERY" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS";
    body?: TBody;
    query?: TQuery;
    headers?: THeaders;
    middleware?: TMiddlewares;
    /**
     * Cache keys, tags, and route paths made stale after a successful handler result.
     * The resolver receives validated input and middleware context.
     */
    invalidates?: EndpointInvalidations<InferEndpointMiddlewareContext<TMiddlewares>, InferOutput<TBody>, InferOutput<TQuery>, InferHeadersOutput<THeaders>>;
    errors?: TErrors;
    /** @deprecated Use plain functions in `middleware` for Farm endpoint middleware. */
    use?: any[];
};
type EndpointHandler<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any, TContext extends object = {}, TErrors extends EndpointErrorDefinitions = {}> = (ctx: {
    body: InferOutput<TBody>;
    query: InferOutput<TQuery>;
    headers: InferHeadersOutput<THeaders>;
    request: Request;
    context: Readonly<TContext>;
    params: EndpointParams;
    error: EndpointErrorHandler<TErrors>;
    /** @deprecated Use `error`. */
    fail: EndpointFail<TErrors>;
}) => Promise<TResponse> | TResponse;
type TypedEndpoint<TBody = never, TQuery = never, TResponse = any, THeaders = Record<string, string>, TErrors = never, TBodyInput = TBody, TQueryInput = TQuery> = {
    __types: {
        body: TBody;
        inputBody: TBodyInput;
        query: TQuery;
        inputQuery: TQueryInput;
        headers: THeaders;
        response: TResponse;
        errors: TErrors;
    };
    __path?: string;
    __method?: string;
} & ((options?: {
    body?: TBodyInput;
    query?: TQueryInput;
}) => Promise<TResponse>);
type CreatedEndpoint<TBody extends AnySchema, TQuery extends AnySchema, THeaders extends AnySchema, TResponse, TErrors extends EndpointErrorDefinitions = {}> = TypedEndpoint<InferOutput<TBody>, InferOutput<TQuery>, Awaited<TResponse>, InferHeadersOutput<THeaders>, EndpointErrorContracts<TErrors>, InferBodyInput<TBody>, InferInput<TQuery>>;
type AnyEndpointOptions = EndpointOptions<AnySchema, AnySchema, AnySchema, readonly AnyEndpointMiddleware[], EndpointErrorDefinitions>;
type EndpointBodyFromOptions<TOptions> = TOptions extends {
    body: infer TBody extends AnySchema;
} ? TBody : never;
type EndpointQueryFromOptions<TOptions> = TOptions extends {
    query: infer TQuery extends AnySchema;
} ? TQuery : never;
type EndpointHeadersFromOptions<TOptions> = TOptions extends {
    headers: infer THeaders extends AnySchema;
} ? THeaders : never;
type EndpointMiddlewaresFromOptions<TOptions> = TOptions extends {
    middleware: infer TMiddlewares extends readonly AnyEndpointMiddleware[];
} ? TMiddlewares : readonly [];
type EndpointErrorsFromOptions<TOptions> = TOptions extends {
    errors: infer TErrors extends EndpointErrorDefinitions;
} ? TErrors : {};
type MethodlessEndpointOptions = Omit<AnyEndpointOptions, "method">;
type EndpointHandlerFromOptions<TOptions, TResponse> = EndpointHandler<EndpointBodyFromOptions<TOptions>, EndpointQueryFromOptions<TOptions>, EndpointHeadersFromOptions<TOptions>, TResponse, InferEndpointMiddlewareContext<EndpointMiddlewaresFromOptions<TOptions>>, EndpointErrorsFromOptions<TOptions>>;
type ValidatedEndpointHandlerFromOptions<TOptions, TResponse> = EndpointHandlerFromOptions<TOptions, TResponse> & (EndpointMiddlewaresFromOptions<TOptions> extends ValidateEndpointMiddlewares<EndpointMiddlewaresFromOptions<TOptions>> ? unknown : never);
type CreatedEndpointFromOptions<TOptions, TResponse> = CreatedEndpoint<EndpointBodyFromOptions<TOptions>, EndpointQueryFromOptions<TOptions>, EndpointHeadersFromOptions<TOptions>, TResponse, EndpointErrorsFromOptions<TOptions>>;
/**
 * Create a Farm.js API endpoint
 *
 * Supports two patterns:
 * 1. File-based routing (path auto-inferred from file location):
 *    `export const POST = createEndpoint({ method: 'POST', body: schema }, handler)`
 *    `createEndpoint({ method: 'GET', query: z.object({...}) }, handler)`
 *
 * 2. Explicit path (for routes.ts at project root):
 *    `createEndpoint('/api/hello', { method: 'GET', query: z.object({...}) }, handler)`
 */
declare function createEndpoint<const TOptions extends AnyEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
declare function createEndpoint<const TOptions extends AnyEndpointOptions, TResponse = any>(path: string, options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
declare function createEndpoint<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: EndpointOptions<TBody, TQuery, THeaders, readonly []>, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
declare function createEndpoint<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(path: string, options: EndpointOptions<TBody, TQuery, THeaders, readonly []>, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
/**
 * Convenience method for GET requests
 */
declare function GET<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
declare function GET<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
declare function GET<TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<never, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<never, TQuery, THeaders, TResponse>): CreatedEndpoint<never, TQuery, THeaders, TResponse>;
/**
 * Convenience method for HEAD requests
 */
declare function HEAD<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
declare function HEAD<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
declare function HEAD<TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<never, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<never, TQuery, THeaders, TResponse>): CreatedEndpoint<never, TQuery, THeaders, TResponse>;
/**
 * Convenience method for safe, idempotent QUERY requests with a request body
 */
declare function QUERY<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
declare function QUERY<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
declare function QUERY<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<TBody, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
/**
 * Convenience method for POST requests
 */
declare function POST<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
declare function POST<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
declare function POST<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<TBody, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
/**
 * Convenience method for PUT requests
 */
declare function PUT<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
declare function PUT<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
declare function PUT<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<TBody, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
/**
 * Convenience method for DELETE requests
 */
declare function DELETE<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
declare function DELETE<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
declare function DELETE<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<TBody, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
/**
 * Convenience method for PATCH requests
 */
declare function PATCH<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
declare function PATCH<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
declare function PATCH<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<TBody, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;
/**
 * Convenience method for OPTIONS requests
 */
declare function OPTIONS<T = any>(handler: EndpointHandler<never, never, never, T>): CreatedEndpoint<never, never, never, T>;
declare function OPTIONS<const TOptions extends MethodlessEndpointOptions, TResponse = any>(options: TOptions, handler: ValidatedEndpointHandlerFromOptions<TOptions, TResponse>): CreatedEndpointFromOptions<TOptions, TResponse>;
declare function OPTIONS<TBody extends AnySchema = never, TQuery extends AnySchema = never, THeaders extends AnySchema = never, TResponse = any>(options: Omit<EndpointOptions<TBody, TQuery, THeaders, readonly []>, "method">, handler: EndpointHandler<TBody, TQuery, THeaders, TResponse>): CreatedEndpoint<TBody, TQuery, THeaders, TResponse>;

type RouteMethod = "GET" | "HEAD" | "QUERY" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
type RoutePathParams<Path extends string> = Path extends `${infer Head}/${infer Tail}` ? RoutePathParams<Head> & RoutePathParams<Tail> : Path extends `[[...${infer Name}]]` ? {
    [K in Name]?: string[];
} : Path extends `[...${infer Name}]` ? {
    [K in Name]: string[];
} : Path extends `[${infer Name}]` ? {
    [K in Name]: string;
} : {};
interface RouteInputSchemas {
    body?: RouteSchema;
    query?: RouteSchema;
    params?: RouteSchema;
    headers?: RouteSchema;
}
type Input<I, K extends PropertyKey> = K extends keyof I ? RouteSchemaInput<I[K]> : never;
type Output<I, K extends PropertyKey, Fallback = unknown> = K extends keyof I ? RouteSchemaOutput<I[K]> : Fallback;
/** JSON responses have wire types, not server-side instances such as Date. */
type RouteJSON<T> = T extends Response ? unknown : T extends {
    toJSON(): infer J;
} ? RouteJSON<J> : T extends bigint | symbol | ((...args: any[]) => any) ? never : T extends readonly (infer V)[] ? RouteJSON<V>[] : T extends object ? {
    [K in keyof T]: RouteJSON<T[K]>;
} : T;
type RouteDefinition<P extends string = string, M extends RouteMethod = RouteMethod, E = any> = {
    readonly path: P;
    readonly method: M;
    readonly endpoint: E;
};
type RouteEndpoint<P extends string, I extends RouteInputSchemas, R> = TypedEndpoint<Output<I, "body">, Input<I, "query">, RouteJSON<R>, Input<I, "headers">, never, Input<I, "body">> & {
    __types: {
        params: RoutePathParams<P>;
        inputHeaders: Input<I, "headers">;
    };
};
type TrimStart<P extends string> = P extends `/${infer Rest}` ? TrimStart<Rest> : P;
type Join<P extends string, C extends string> = C extends "" ? P : `${P}/${TrimStart<C>}`;
type ParamsCheck<P extends string, I extends RouteInputSchemas> = I extends {
    params: infer S;
} ? Exclude<keyof RoutePathParams<P>, keyof RouteSchemaOutput<S>> extends never ? Exclude<keyof RouteSchemaOutput<S>, keyof RoutePathParams<P>> extends never ? unknown : {
    __error_unknown_route_params: never;
} : {
    __error_missing_route_params: never;
} : unknown;
type RouteMiddlewareResults = readonly (EndpointMiddlewareResult | Promise<EndpointMiddlewareResult>)[];
type RouteMiddlewares<Results extends readonly unknown[]> = {
    readonly [K in keyof Results]: (context: Parameters<AnyEndpointMiddleware>[0]) => Results[K];
};
type RouteOptions<P extends string, I extends RouteInputSchemas, O extends RouteSchema | undefined, R, MiddlewareResults extends RouteMiddlewareResults = RouteMiddlewareResults> = {
    input?: I & ParamsCheck<P, I>;
    /** Validate plain JSON handler results. Raw Response/stream results are never buffered. */
    output?: O;
    middleware?: RouteMiddlewares<MiddlewareResults>;
    handler(request: Request, context: {
        input: {
            body: Output<I, "body">;
            query: Output<I, "query", Record<string, string | string[]>>;
            headers: Output<I, "headers", Record<string, string>>;
            params: Output<I, "params", RoutePathParams<P>>;
        };
        params: Output<I, "params", RoutePathParams<P>>;
        context: Readonly<InferEndpointMiddlewareContext<RouteMiddlewares<MiddlewareResults>>>;
    }): R | Promise<R>;
};
type RouteBuilder<P extends string, M extends RouteMethod> = <const C extends string, const MiddlewareResults extends RouteMiddlewareResults, const I extends RouteInputSchemas = {}, O extends RouteSchema | undefined = undefined, R = unknown>(path: C, options: RouteOptions<Join<P, C>, I, O, R, MiddlewareResults>) => RouteDefinition<Join<P, C>, M, RouteEndpoint<Join<P, C>, I, Extract<Awaited<R>, Response> extends never ? O extends RouteSchema ? RouteSchemaOutput<O> : Awaited<R> : unknown>>;
type RouteFactory<P extends string = ""> = {
    [M in Lowercase<RouteMethod>]: RouteBuilder<P, Uppercase<M> & RouteMethod>;
} & {
    /** Return a new builder; never mutate the parent scope. */
    scope<const C extends string>(path: C): RouteFactory<Join<P, C>>;
};
type PluginRoutes = readonly RouteDefinition[];
type PluginRoutesFactory<R extends PluginRoutes = PluginRoutes> = (context: {
    route: RouteFactory;
}) => R;
declare function createRouteFactory(): RouteFactory;
type UnionToIntersection<U> = (U extends unknown ? (v: U) => void : never) extends (v: infer I) => void ? I : never;
type RouteTree<P extends string, M extends string, E> = P extends `${infer Head}/${infer Tail}` ? {
    [K in Head]: RouteTree<Tail, M, E>;
} : P extends "" ? {
    [K in Lowercase<M>]: E;
} : {
    [K in P]: {
        [Method in Lowercase<M>]: E;
    };
};
type HasMethodSegment<P extends string> = P extends `${infer H}/${infer T}` ? H extends Lowercase<RouteMethod> ? true : HasMethodSegment<T> : P extends Lowercase<RouteMethod> ? true : false;
type DefinitionTree<D> = D extends RouteDefinition<infer P, infer M, infer E> ? string extends P ? {} : (P extends `/api/integrations${string}` ? true : HasMethodSegment<P>) extends true ? {
    [K in P extends `/api/${infer C}` ? `/${C}` : "/"]: {
        [Method in Lowercase<M>]: E;
    };
} : RouteTree<P extends `/api/${infer C}` ? C : "", M, E> : {};
type PluginAPIRouter<C> = C extends {
    plugins: readonly (infer P)[];
} ? UnionToIntersection<P extends {
    routes?: PluginRoutesFactory<infer R>;
} ? DefinitionTree<R[number]> : {}> : {};
declare function resolvePluginRoutes(plugins?: readonly {
    name: string;
    routes?: PluginRoutesFactory;
}[]): PluginRoutes;

export { type PluginAPIRouter as $, type AnyEndpointMiddleware as A, isMultipartSchema as B, toFormData as C, DELETE as D, EndpointFailure as E, type FarmStreamResponse as F, GET as G, HEAD as H, type InferEndpointMiddlewareContext as I, jsonStream as J, isJSONStreamResponse as K, readJSONStream as L, type MultipartField as M, isFarmAPIStream as N, OPTIONS as O, type PluginRoutesFactory as P, QUERY as Q, type RouteMethod as R, type RoutePathParams as S, type TypedEndpoint as T, type RouteInputSchemas as U, type RouteJSON as V, type RouteDefinition as W, type RouteOptions as X, type RouteFactory as Y, type PluginRoutes as Z, createRouteFactory as _, type EndpointErrorSchema as a, resolvePluginRoutes as a0, type EndpointErrorDefinition as b, type EndpointErrorDefinitions as c, type EndpointErrorContracts as d, type EndpointErrorHandler as e, type EndpointFail as f, type EndpointParamValue as g, type EndpointParams as h, isEndpointFailure as i, type EndpointMiddlewareContext as j, type EndpointMiddlewareResult as k, type EndpointMiddleware as l, type EndpointInvalidationTarget as m, type EndpointInvalidationContext as n, type EndpointInvalidations as o, type EndpointOptions as p, type EndpointHandler as q, createEndpoint as r, POST as s, PUT as t, PATCH as u, type MultipartValues as v, type TypedFormData as w, type MultipartSchema as x, type FarmAPIStream as y, multipart as z };