@visulima/api-platform/dist/index-server.d.mts

Visulima API platform is a set of tools to build and consume web APIs

import { IncomingMessage, ServerResponse } from 'node:http';
import * as _visulima_connect from '@visulima/connect';
import { NodeRouter, Route, Nextable, FunctionLike, ValueOrPromise, NextHandler } from '@visulima/connect';
export { EdgeRequestHandler, EdgeRouter, ExpressRequestHandler, FindResult, FunctionLike, HandlerOptions, HttpMethod, NextHandler, Nextable, NodeRequestHandler, NodeRouter, Route, RouteShortcutMethod, Router, ValueOrPromise, createEdgeRouter, expressWrapper, sendJson, withZod } from '@visulima/connect';
import { AnyZodObject, ZodObject } from 'zod';
import { CorsOptions, CorsOptionsDelegate } from 'cors';
import { NextApiResponse } from 'next/types';
import { RateLimiterAbstract, RateLimiterRes } from 'rate-limiter-flexible';
export { d as dateIn, a as dateOut, i as zod } from './index-browser-Cy6Ywaan.mjs';
export { s as swaggerHandler } from './swagger-handler-CsN63rqo.mjs';
export { BadGateway, BadRequest, BandwidthLimitExceeded, Conflict, ExpectationFailed, FailedDependency, Forbidden, GatewayTimeout, Gone, HTTPVersionNotSupported, ImATeapot, InsufficientStorage, InternalServerError, LengthRequired, Locked, LoopDetected, MethodNotAllowed, MisdirectedRequest, NetworkAuthenticationRequire, NotAcceptable, NotExtended, NotFound, NotImplemented, PayloadTooLarge, PaymentRequired, PreconditionFailed, PreconditionRequired, ProxyAuthenticationRequired, RangeNotSatisfiable, RequestHeaderFieldsTooLarge, RequestTimeout, ServiceUnavailable, TooManyRequests, URITooLong, Unauthorized, UnavailableForLegalReasons, UnprocessableEntity, UnsupportedMediaType, UpgradeRequired, VariantAlsoNegotiates, default as createHttpError } from 'http-errors';
import '@visulima/crud';
import 'openapi-types';

type ErrorHandler = <Request extends IncomingMessage, Response extends ServerResponse>(
    error: any,
    request: Request,
    response: Response,
) => Promise<any> | any;

type ErrorHandlers = {
    handler: ErrorHandler;
    regex: RegExp;
}[];

type Serializer = (data: any) => Buffer | Uint8Array | string;

type Serializers = {
    regex: RegExp;
    serializer: Serializer;
}[];

declare const serialize: <Request extends IncomingMessage, Response extends ServerResponse>(serializers: Serializers, request: Request, response: Response, data: unknown, options: {
    defaultContentType: string;
}) => Buffer | Uint8Array | string;

declare const xmlTransformer: Serializer;

declare const yamlTransformer: Serializer;

declare const createNodeRouter: <Request extends IncomingMessage, Response extends ServerResponse, Schema extends AnyZodObject = ZodObject<{
    body?: AnyZodObject;
    headers?: AnyZodObject;
    query?: AnyZodObject;
}>>(options?: {
    errorHandlers?: ErrorHandlers;
    middlewares?: {
        "http-header-normalizer"?: {
            canonical?: boolean;
            normalizeHeaderKey?: (key: string, canonical: boolean) => string;
        };
        serializers?: {
            defaultContentType?: string;
            serializers?: Serializers;
        };
    };
    showTrace?: boolean;
}) => NodeRouter<Request, Response, Schema>;

declare const onError: <Request extends IncomingMessage, Response extends ServerResponse>(errorHandlers: ErrorHandlers, showTrace: boolean) => (error: unknown, request: Request, response: Response) => Promise<void>;
declare const onNoMatch: <Request extends IncomingMessage, Response extends ServerResponse>(request: Request, response: Response, routes: Route<Nextable<FunctionLike>>[]) => ValueOrPromise<void>;

declare const corsMiddleware: <Request extends IncomingMessage, Response extends ServerResponse>(options?: CorsOptions | CorsOptionsDelegate) => _visulima_connect.Nextable<_visulima_connect.NodeRequestHandler<Request, Response>>;

declare const httpHeaderNormalizerMiddleware: (options_?: {
    canonical?: boolean;
    normalizeHeaderKey?: (key: string, canonical: boolean) => string;
}) => ((request: IncomingMessage, response: ServerResponse, next: NextHandler) => ValueOrPromise<void>);

type HeaderValue = ReadonlyArray<string> | number | string;
declare const rateLimiterMiddleware: (rateLimiter: RateLimiterAbstract, headers?: (limiterResponse: RateLimiterRes) => Record<string, HeaderValue>) => <Request extends IncomingMessage, Response extends ServerResponse>(request: Request, response: NextApiResponse | Response, next: NextHandler) => Promise<void>;

declare const serializersMiddleware: (serializers?: Serializers, defaultContentType?: string) => <Request extends IncomingMessage, Response extends ServerResponse>(request: Request, response: NextApiResponse | Response, next: NextHandler) => Promise<ValueOrPromise<void>>;

export { type Serializer, type Serializers, corsMiddleware, createNodeRouter, httpHeaderNormalizerMiddleware, onError, onNoMatch, rateLimiterMiddleware, serialize, serializersMiddleware, xmlTransformer, yamlTransformer };