alepha 0.13.0 → 0.13.2

package/dist/server/index.d.cts

@@ -1,810 +0,0 @@
-import * as alepha17 from "alepha";
-import { Alepha, AlephaError, Async, Descriptor, FileLike, KIND, Static, StreamLike, TArray, TFile, TObject, TRecord, TSchema, TStream, TString, TVoid } from "alepha";
-import { IncomingMessage, Server, ServerResponse as ServerResponse$1 } from "node:http";
-import * as alepha_logger6 from "alepha/logger";
-import { Readable } from "node:stream";
-import { ReadableStream } from "node:stream/web";
-import { Route, RouterProvider } from "alepha/router";
-import { DateTimeProvider, DurationLike } from "alepha/datetime";
-import * as alepha_cache0 from "alepha/cache";
-
-//#region src/server/constants/routeMethods.d.ts
-declare const routeMethods: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "CONNECT", "TRACE"];
-type RouteMethod = (typeof routeMethods)[number];
-//#endregion
-//#region src/server/helpers/ServerReply.d.ts
-/**
- * Helper for building server replies.
- */
-declare class ServerReply {
-  headers: Record<string, string> & {
-    "set-cookie"?: string[];
-  };
-  status?: number;
-  body?: any;
-  /**
-   * Redirect to a given URL with optional status code (default 302).
-   */
-  redirect(url: string, status?: number): void;
-  /**
-   * Set the response status code.
-   */
-  setStatus(status: number): this;
-  /**
-   * Set a response header.
-   */
-  setHeader(name: string, value: string): this;
-  /**
-   * Set the response body.
-   */
-  setBody(body: any): this;
-}
-//#endregion
-//#region src/server/services/UserAgentParser.d.ts
-interface UserAgentInfo {
-  os: "Windows" | "Android" | "Ubuntu" | "MacOS" | "iOS" | "Linux" | "FreeBSD" | "OpenBSD" | "ChromeOS" | "BlackBerry" | "Symbian" | "Windows Phone";
-  browser: "Chrome" | "Firefox" | "Safari" | "Edge" | "Opera" | "Internet Explorer" | "Brave" | "Vivaldi" | "Samsung Browser" | "UC Browser" | "Yandex";
-  device: "MOBILE" | "DESKTOP" | "TABLET";
-}
-/**
- * Simple User-Agent parser to detect OS, browser, and device type.
- * This parser is not exhaustive and may not cover all edge cases.
- *
- * Use result for non
- */
-declare class UserAgentParser {
-  parse(userAgent?: string): UserAgentInfo;
-}
-//#endregion
-//#region src/server/interfaces/ServerRequest.d.ts
-type TRequestBody = TObject | TString | TArray | TRecord | TStream;
-type TResponseBody = TObject | TString | TRecord | TFile | TArray | TStream | TVoid;
-interface RequestConfigSchema {
-  body?: TRequestBody;
-  params?: TObject;
-  query?: TObject;
-  headers?: TObject;
-  response?: TResponseBody;
-}
-interface ServerRequestConfig<TConfig extends RequestConfigSchema = RequestConfigSchema> {
-  body: TConfig["body"] extends TRequestBody ? Static<TConfig["body"]> : any;
-  headers: TConfig["headers"] extends TObject ? Static<TConfig["headers"]> : Record<string, string>;
-  params: TConfig["params"] extends TObject ? Static<TConfig["params"]> : Record<string, string>;
-  query: TConfig["query"] extends TObject ? Static<TConfig["query"]> : Record<string, any>;
-}
-type ServerRequestConfigEntry<TConfig extends RequestConfigSchema = RequestConfigSchema> = Partial<ServerRequestConfig<TConfig>>;
-interface ServerRequest<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRequestConfig<TConfig> {
-  /**
-   * HTTP method used for this request.
-   */
-  method: RouteMethod;
-  /**
-   * Full request URL.
-   */
-  url: URL;
-  /**
-   * Unique request ID assigned to this request.
-   */
-  requestId: string;
-  /**
-   * Client IP address.
-   * Will parse `X-Forwarded-For` header if present.
-   */
-  ip?: string;
-  /**
-   * Value of the `Host` header sent by the client.
-   */
-  host?: string;
-  /**
-   * Browser user agent information.
-   * Information are not guaranteed to be accurate. Use with caution.
-   *
-   * @see {@link UserAgentParser}
-   */
-  userAgent: UserAgentInfo;
-  /**
-   * Arbitrary metadata attached to the request. Can be used by middlewares to store information.
-   */
-  metadata: Record<string, any>;
-  /**
-   * Reply object to be used to send response.
-   */
-  reply: ServerReply;
-  /**
-   * The raw underlying request object (Web Request).
-   */
-  raw: ServerRawRequest;
-}
-interface ServerRoute<TConfig extends RequestConfigSchema = RequestConfigSchema> extends Route {
-  /**
-   * Handler function for this route.
-   */
-  handler: ServerHandler<TConfig>;
-  /**
-   * HTTP method for this route.
-   */
-  method?: RouteMethod;
-  /**
-   * Request/response schema for this route.
-   *
-   * Request schema contains:
-   * - body, for POST/PUT/PATCH requests
-   * - params, for URL parameters (e.g. /user/:id)
-   * - query, for URL query parameters (e.g. /user?id=123)
-   * - headers, for HTTP headers
-   *
-   * Response schema contains:
-   * - response
-   *
-   * Response schema is used to validate and serialize the response sent by the handler.
-   */
-  schema?: TConfig;
-  /**
-   * @see ServerLoggerProvider
-   */
-  silent?: boolean;
-}
-type ServerResponseBody<TConfig extends RequestConfigSchema = RequestConfigSchema> = TConfig["response"] extends TResponseBody ? Static<TConfig["response"]> : ResponseBodyType;
-type ResponseKind = "json" | "text" | "void" | "file" | "any";
-type ResponseBodyType = string | Buffer | StreamLike | undefined | null | void;
-type ServerHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (request: ServerRequest<TConfig>) => Async<ServerResponseBody<TConfig>>;
-interface ServerResponse {
-  body: string | Buffer | ArrayBuffer | Readable | ReadableStream;
-  headers: Record<string, string>;
-  status: number;
-}
-type ServerRouteRequestHandler = (request: ServerRequestData) => Promise<ServerResponse>;
-interface ServerRouteMatcher extends Route {
-  handler: ServerRouteRequestHandler;
-}
-interface ServerRequestData {
-  method: RouteMethod;
-  url: URL;
-  headers: Record<string, string>;
-  query: Record<string, string>;
-  params: Record<string, string>;
-  raw: ServerRawRequest;
-}
-interface ServerRawRequest {
-  node?: NodeRequestEvent;
-  web?: WebRequestEvent;
-}
-interface NodeRequestEvent {
-  req: IncomingMessage;
-  res: ServerResponse$1;
-}
-interface WebRequestEvent {
-  req: Request;
-  res?: Response;
-}
-//#endregion
-//#region src/server/services/ServerRequestParser.d.ts
-declare class ServerRequestParser {
-  protected readonly alepha: Alepha;
-  protected readonly userAgentParser: UserAgentParser;
-  createServerRequest(rawRequest: ServerRequestData): ServerRequest;
-  getRequestId(request: ServerRequestData): string | undefined;
-  getRequestUserAgent(request: ServerRequestData): UserAgentInfo;
-  getRequestIp(request: ServerRequestData): string | undefined;
-}
-//#endregion
-//#region src/server/providers/ServerTimingProvider.d.ts
-type TimingMap = Record<string, [number, number]>;
-declare class ServerTimingProvider {
-  protected readonly log: alepha_logger6.Logger;
-  protected readonly alepha: Alepha;
-  options: {
-    prefix: string;
-    disabled: boolean;
-  };
-  readonly onRequest: alepha17.HookDescriptor<"server:onRequest">;
-  readonly onResponse: alepha17.HookDescriptor<"server:onResponse">;
-  protected get handlerName(): string;
-  beginTiming(name: string): void;
-  endTiming(name: string): void;
-  protected setDuration(name: string, timing: TimingMap): void;
-}
-//#endregion
-//#region src/server/providers/ServerRouterProvider.d.ts
-/**
- * Main router for all routes on the server side.
- *
- * - $route => generic route
- * - $action => action route (for API calls)
- * - $page => React route (for SSR)
- */
-declare class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
-  protected readonly log: alepha_logger6.Logger;
-  protected readonly alepha: Alepha;
-  protected readonly routes: ServerRoute[];
-  protected readonly serverTimingProvider: ServerTimingProvider;
-  protected readonly serverRequestParser: ServerRequestParser;
-  /**
-   * Get all registered routes, optionally filtered by a pattern.
-   *
-   * Pattern accept simple wildcard '*' at the end.
-   * Example: '/api/*' will match all routes starting with '/api/' but '/api/' will match only that exact route.
-   */
-  getRoutes(pattern?: string): ServerRoute[];
-  createRoute<TConfig extends RequestConfigSchema = RequestConfigSchema>(route: ServerRoute<TConfig>): void;
-  protected getContextId(headers: Record<string, string>): string;
-  protected processRequest(request: ServerRequest, route: ServerRoute, responseKind: ResponseKind): Promise<{
-    status: number;
-    headers: Record<string, string> & {
-      "set-cookie"?: string[];
-    };
-    body: any;
-  }>;
-  protected runRouteHandler(route: ServerRoute, request: ServerRequest, responseKind: ResponseKind): Promise<void>;
-  serializeResponse(route: ServerRoute, reply: ServerReply, responseKind: ResponseKind): void;
-  protected getResponseType(schema?: RequestConfigSchema): ResponseKind;
-  protected errorHandler(route: ServerRoute, request: ServerRequest, error: Error): Promise<void>;
-  validateRequest(route: {
-    schema?: RequestConfigSchema;
-  }, request: ServerRequestConfig): void;
-}
-//#endregion
-//#region src/server/providers/ServerProvider.d.ts
-/**
- * Base server provider to handle incoming requests and route them.
- *
- * This is the default implementation for serverless environments.
- *
- * ServerProvider supports both Node.js HTTP requests and Web (Fetch API) requests.
- */
-declare class ServerProvider {
-  protected readonly log: alepha_logger6.Logger;
-  protected readonly alepha: Alepha;
-  protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly router: ServerRouterProvider;
-  protected readonly internalServerErrorMessage = "Internal Server Error";
-  get hostname(): string;
-  /**
-   * When a Node.js HTTP request is received from outside. (Vercel, AWS Lambda, etc.)
-   */
-  protected readonly onNodeRequest: alepha17.HookDescriptor<"node:request">;
-  /**
-   * When a Web (Fetch API) request is received from outside. (Netlify, Cloudflare Workers, etc.)
-   */
-  protected readonly onWebRequest: alepha17.HookDescriptor<"web:request">;
-  /**
-   * Handle Node.js HTTP request event.
-   *
-   * Technically, we just convert Node.js request to Web Standard Request.
-   */
-  handleNodeRequest(nodeRequestEvent: NodeRequestEvent): Promise<void>;
-  /**
-   * Handle Web (Fetch API) request event.
-   */
-  handleWebRequest(ev: WebRequestEvent): Promise<void>;
-  /**
-   * Helper for Vite development mode to let Vite handle (or not) 404.
-   */
-  protected isViteNotFound(url?: string, route?: Route, params?: Record<string, string>): boolean;
-}
-//#endregion
-//#region src/server/services/HttpClient.d.ts
-declare class HttpClient {
-  protected readonly log: alepha_logger6.Logger;
-  protected readonly alepha: Alepha;
-  readonly cache: alepha_cache0.CacheDescriptorFn<HttpClientCache, any[]>;
-  protected readonly pendingRequests: HttpClientPendingRequests;
-  fetchAction(args: FetchActionArgs): Promise<FetchResponse>;
-  fetch<T extends TSchema>(url: string, request?: RequestInitWithOptions<T>): Promise<FetchResponse<Static<T>>>;
-  protected url(host: string, action: HttpAction, args: ServerRequestConfigEntry): string;
-  protected body(init: RequestInit, headers: Record<string, string>, action: HttpAction, args?: ServerRequestConfigEntry): Promise<void>;
-  protected responseData(response: Response, options: FetchOptions): Promise<any>;
-  protected isMaybeFile(response: Response): boolean;
-  protected createFileLike(response: Response, defaultFileName?: string): FileLike;
-  pathVariables(url: string, action: {
-    schema?: {
-      params?: TObject;
-    };
-  }, args?: ServerRequestConfigEntry): string;
-  queryParams(url: string, action: {
-    schema?: {
-      query?: TObject;
-    };
-  }, args?: ServerRequestConfigEntry): string;
-}
-interface FetchOptions<T extends TSchema = TSchema> {
-  /**
-   * Key to identify the request in the pending requests.
-   */
-  key?: string;
-  /**
-   * The schema to validate the response against.
-   */
-  schema?: {
-    response?: T;
-  };
-  /**
-   * Built-in cache options.
-   */
-  localCache?: boolean | number | DurationLike;
-}
-type RequestInitWithOptions<T extends TSchema = TSchema> = RequestInit & FetchOptions<T>;
-interface FetchResponse<T = any> {
-  data: T;
-  status: number;
-  statusText: string;
-  headers: Headers;
-  raw?: Response;
-}
-type HttpClientPendingRequests = Record<string, Promise<any> | undefined>;
-interface HttpClientCache {
-  data: any;
-  etag?: string;
-}
-interface FetchActionArgs {
-  action: HttpAction;
-  host?: string;
-  config?: ServerRequestConfigEntry;
-  options?: ClientRequestOptions;
-}
-interface HttpAction {
-  method?: string;
-  prefix?: string;
-  path: string;
-  requestBodyType?: string;
-  schema?: {
-    params?: TObject;
-    query?: TObject;
-    body?: TRequestBody;
-    response?: TResponseBody;
-  };
-}
-//#endregion
-//#region src/server/descriptors/$action.d.ts
-/**
- * Creates a server action descriptor for defining type-safe HTTP endpoints.
- *
- * Server actions are the core building blocks for REST APIs in Alepha, providing declarative
- * HTTP endpoints with full type safety, automatic validation, and OpenAPI documentation.
- *
- * **Key Features**
- * - Full TypeScript inference for request/response types
- * - Automatic schema validation using TypeBox
- * - Convention-based URL generation with customizable paths
- * - Direct invocation (`run()`) or HTTP requests (`fetch()`)
- * - Built-in authentication and authorization support
- * - Automatic content-type handling (JSON, form-data, plain text)
- *
- * **URL Generation**
- * Actions are prefixed with `/api` by default (configurable via `SERVER_API_PREFIX`).
- * HTTP method defaults to GET, or POST if body schema is provided.
- *
- * **Common Use Cases**
- * - CRUD operations with type safety
- * - File upload and download endpoints
- * - Microservice communication
- *
- * @example
- * ```ts
- * class UserController {
- *   getUsers = $action({
- *     path: "/users",
- *     schema: {
- *       query: t.object({
- *         page: t.optional(t.number({ default: 1 })),
- *         limit: t.optional(t.number({ default: 10 }))
- *       }),
- *       response: t.object({
- *         users: t.array(t.object({
- *           id: t.text(),
- *           name: t.text(),
- *           email: t.text()
- *         })),
- *         total: t.number()
- *       })
- *     },
- *     handler: async ({ query }) => {
- *       const users = await this.userService.findUsers(query);
- *       return { users: users.items, total: users.total };
- *     }
- *   });
- *
- *   createUser = $action({
- *     method: "POST",
- *     path: "/users",
- *     schema: {
- *       body: t.object({
- *         name: t.text(),
- *         email: t.text({ format: "email" })
- *       }),
- *       response: t.object({ id: t.text(), name: t.text() })
- *     },
- *     handler: async ({ body }) => {
- *       return await this.userService.create(body);
- *     }
- *   });
- * }
- * ```
- */
-declare const $action: {
-  <TConfig extends RequestConfigSchema>(options: ActionDescriptorOptions<TConfig>): ActionDescriptorFn<TConfig>;
-  [KIND]: typeof ActionDescriptor;
-};
-interface ActionDescriptorOptions<TConfig extends RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema" | "mapParams"> {
-  /**
-   * Name of the action.
-   *
-   * - It will be used to generate the route path if `path` is not provided.
-   * - It will be used to generate the permission name if `security` is enabled.
-   */
-  name?: string;
-  /**
-   * Group actions together.
-   *
-   * - If not provided, the service name containing the route will be used.
-   * - It will be used as Tag for documentation purposes.
-   * - It will be used for permission name generation if `security` is enabled.
-   *
-   * @example
-   * ```ts
-   * // group = "MyController"
-   * class MyController {
-   * 	hello = $action({ handler: () => "Hello World" });
-   * }
-   *
-   * // group = "users"
-   * class MyOtherController {
-   *   group = "users";
-   *   a1 = $action({ handler: () => "Action 1", group: this.group });
-   *   a2 = $action({ handler: () => "Action 2", group: this.group });
-   * }
-   * ```
-   */
-  group?: string;
-  /**
-   * Pathname of the route. If not provided, property key is used.
-   */
-  path?: string;
-  /**
-   * The route method.
-   *
-   * - If not provided, it will be set to "GET" by default.
-   * - If not provider and a body is provided, it will be set to "POST".
-   *
-   * Wildcard methods are not supported for now. (e.g. "ALL", "ANY", etc.)
-   */
-  method?: RouteMethod;
-  /**
-   * The config schema of the route.
-   * - body: The request body schema.
-   * - params: Path variables schema.
-   * - query: The request query-params schema.
-   * - response: The response schema.
-   */
-  schema?: TConfig;
-  /**
-   * A short description of the action. Used for documentation purposes.
-   */
-  description?: string;
-  /**
-   * Disable the route. Useful with env variables do disable one specific route.
-   * Route won't be available in the API but can still be called locally!
-   */
-  disabled?: boolean;
-  /**
-   * Main route handler. This is where the route logic is implemented.
-   */
-  handler: ServerActionHandler<TConfig>;
-}
-declare class ActionDescriptor<TConfig extends RequestConfigSchema> extends Descriptor<ActionDescriptorOptions<TConfig>> {
-  protected readonly log: alepha_logger6.Logger;
-  protected readonly env: {
-    SERVER_API_PREFIX: string;
-  };
-  protected readonly httpClient: HttpClient;
-  protected readonly serverProvider: ServerProvider;
-  protected readonly serverRouterProvider: ServerRouterProvider;
-  protected onInit(): void;
-  get prefix(): string;
-  get route(): ServerRoute;
-  /**
-   * Returns the name of the action.
-   */
-  get name(): string;
-  /**
-   * Returns the group of the action. (e.g. "orders", "admin", etc.)
-   */
-  get group(): string;
-  /**
-   * Returns the HTTP method of the action.
-   */
-  get method(): RouteMethod;
-  /**
-   * Returns the path of the action.
-   *
-   * Path is prefixed by `/api` by default.
-   */
-  get path(): string;
-  get schema(): TConfig | undefined;
-  getBodyContentType(): string | undefined;
-  /**
-   * Call the action handler directly.
-   * There is no HTTP layer involved.
-   */
-  run(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
-  /**
-   * Works like `run`, but always fetches (http request) the route.
-   */
-  fetch(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<FetchResponse<ClientRequestResponse<TConfig>>>;
-}
-interface ActionDescriptorFn<TConfig extends RequestConfigSchema> extends ActionDescriptor<TConfig> {
-  (config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
-}
-type ClientRequestEntry<TConfig extends RequestConfigSchema, T = ClientRequestEntryContainer<TConfig>> = { [K in keyof T as T[K] extends undefined ? never : K]: T[K] };
-type ClientRequestEntryContainer<TConfig extends RequestConfigSchema> = {
-  body: TConfig["body"] extends TObject ? Static<TConfig["body"]> : undefined;
-  params: TConfig["params"] extends TObject ? Static<TConfig["params"]> : undefined;
-  headers?: TConfig["headers"] extends TObject ? Static<TConfig["headers"]> : undefined;
-  query?: TConfig["query"] extends TObject ? Partial<Static<TConfig["query"]>> : undefined;
-};
-interface ClientRequestOptions extends FetchOptions {
-  /**
-   * Standard request fetch options.
-   */
-  request?: RequestInit;
-}
-type ClientRequestResponse<TConfig extends RequestConfigSchema> = TConfig["response"] extends TSchema ? Static<TConfig["response"]> : any;
-/**
- * Specific handler for server actions.
- */
-type ServerActionHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (request: ServerActionRequest<TConfig>) => Async<ServerResponseBody<TConfig>>;
-/**
- * Server Action Request Interface
- *
- * Can be extended with module augmentation to add custom properties (like `user` in Server Security).
- *
- * This is NOT Server Request, but a specific type for actions.
- */
-interface ServerActionRequest<TConfig extends RequestConfigSchema> extends ServerRequest<TConfig> {}
-//#endregion
-//#region src/server/schemas/errorSchema.d.ts
-declare const errorSchema: alepha17.TObject<{
-  error: alepha17.TString;
-  status: alepha17.TInteger;
-  message: alepha17.TString;
-  details: alepha17.TOptional<alepha17.TString>;
-  requestId: alepha17.TOptional<alepha17.TString>;
-  cause: alepha17.TOptional<alepha17.TObject<{
-    name: alepha17.TString;
-    message: alepha17.TString;
-  }>>;
-}>;
-type ErrorSchema = Static<typeof errorSchema>;
-//#endregion
-//#region src/server/errors/HttpError.d.ts
-declare const isHttpError: (error: unknown, status?: number) => error is HttpErrorLike;
-declare class HttpError extends AlephaError {
-  name: string;
-  static is: (error: unknown, status?: number) => error is HttpErrorLike;
-  static toJSON(error: HttpError): ErrorSchema;
-  readonly error: string;
-  readonly status: number;
-  readonly requestId?: string;
-  readonly details?: string;
-  readonly reason?: {
-    name: string;
-    message: string;
-  };
-  constructor(options: Partial<ErrorSchema>, cause?: unknown);
-}
-declare const errorNameByStatus: Record<number, string>;
-interface HttpErrorLike extends Error {
-  status: number;
-}
-//#endregion
-//#region src/server/descriptors/$route.d.ts
-/**
- * Create a basic endpoint.
- *
- * It's a low level descriptor. You probably want to use `$action` instead.
- *
- * @see {@link $action}
- * @see {@link $page}
- */
-declare const $route: {
-  <TConfig extends RequestConfigSchema>(options: RouteDescriptorOptions<TConfig>): RouteDescriptor<TConfig>;
-  [KIND]: typeof RouteDescriptor;
-};
-interface RouteDescriptorOptions<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRoute<TConfig> {}
-declare class RouteDescriptor<TConfig extends RequestConfigSchema> extends Descriptor<RouteDescriptorOptions<TConfig>> {
-  protected readonly serverRouterProvider: ServerRouterProvider;
-  protected onInit(): void;
-}
-//#endregion
-//#region src/server/errors/BadRequestError.d.ts
-declare class BadRequestError extends HttpError {
-  constructor(message?: string, cause?: unknown);
-}
-//#endregion
-//#region src/server/errors/ConflictError.d.ts
-declare class ConflictError extends HttpError {
-  constructor(message?: string, cause?: unknown);
-}
-//#endregion
-//#region src/server/errors/ForbiddenError.d.ts
-declare class ForbiddenError extends HttpError {
-  constructor(message?: string, cause?: unknown);
-}
-//#endregion
-//#region src/server/errors/NotFoundError.d.ts
-declare class NotFoundError extends HttpError {
-  constructor(message?: string, cause?: unknown);
-}
-//#endregion
-//#region src/server/errors/UnauthorizedError.d.ts
-declare class UnauthorizedError extends HttpError {
-  readonly name = "UnauthorizedError";
-  constructor(message?: string, cause?: unknown);
-}
-//#endregion
-//#region src/server/errors/ValidationError.d.ts
-declare class ValidationError extends HttpError {
-  constructor(message?: string, cause?: unknown);
-}
-//#endregion
-//#region src/server/helpers/isMultipart.d.ts
-/**
- * Checks if the route has multipart/form-data request body.
- */
-declare const isMultipart: (options: {
-  schema?: RequestConfigSchema;
-  requestBodyType?: string;
-}) => boolean;
-//#endregion
-//#region src/server/schemas/okSchema.d.ts
-declare const okSchema: alepha17.TObject<{
-  ok: alepha17.TBoolean;
-  id: alepha17.TOptional<alepha17.TUnion<[alepha17.TString, alepha17.TInteger]>>;
-  count: alepha17.TOptional<alepha17.TNumber>;
-}>;
-type Ok = Static<typeof okSchema>;
-//#endregion
-//#region src/server/providers/BunHttpServerProvider.d.ts
-declare const envSchema$1: alepha17.TObject<{
-  SERVER_PORT: alepha17.TInteger;
-  SERVER_HOST: alepha17.TString;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$1>> {}
-}
-declare const Bun: any;
-declare class BunHttpServerProvider extends ServerProvider {
-  protected readonly alepha: Alepha;
-  protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly log: alepha_logger6.Logger;
-  protected readonly env: {
-    SERVER_PORT: number;
-    SERVER_HOST: string;
-  };
-  protected readonly router: ServerRouterProvider;
-  protected bunServer?: ReturnType<typeof Bun.serve>;
-  get hostname(): string;
-  readonly start: alepha17.HookDescriptor<"start">;
-  protected readonly stop: alepha17.HookDescriptor<"stop">;
-  protected listen(): Promise<void>;
-  protected close(): Promise<void>;
-}
-//#endregion
-//#region src/server/providers/NodeHttpServerProvider.d.ts
-declare const envSchema: alepha17.TObject<{
-  SERVER_PORT: alepha17.TInteger;
-  SERVER_HOST: alepha17.TString;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema>> {}
-}
-declare class NodeHttpServerProvider extends ServerProvider {
-  protected readonly alepha: Alepha;
-  protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly log: alepha_logger6.Logger;
-  protected readonly env: {
-    SERVER_PORT: number;
-    SERVER_HOST: string;
-  };
-  protected readonly router: ServerRouterProvider;
-  get hostname(): string;
-  readonly server: Server<typeof IncomingMessage, typeof ServerResponse$1>;
-  readonly start: alepha17.HookDescriptor<"start">;
-  protected createHttpServer(func: (req: IncomingMessage, res: ServerResponse$1) => void): Server;
-  protected readonly stop: alepha17.HookDescriptor<"stop">;
-  protected listen(): Promise<void>;
-  protected close(): Promise<void>;
-}
-//#endregion
-//#region src/server/providers/ServerLoggerProvider.d.ts
-declare class ServerLoggerProvider {
-  protected readonly log: alepha_logger6.Logger;
-  protected readonly alepha: Alepha;
-  readonly onRequest: alepha17.HookDescriptor<"server:onRequest">;
-  readonly onError: alepha17.HookDescriptor<"server:onError">;
-  readonly onResponse: alepha17.HookDescriptor<"server:onResponse">;
-}
-//#endregion
-//#region src/server/providers/ServerNotReadyProvider.d.ts
-/**
- * On every request, this provider checks if the server is ready.
- *
- * If the server is not ready, it responds with a 503 status code and a message indicating that the server is not ready yet.
- *
- * The response also includes a `Retry-After` header indicating that the client should retry after 5 seconds.
- */
-declare class ServerNotReadyProvider {
-  protected readonly alepha: Alepha;
-  readonly onRequest: alepha17.HookDescriptor<"server:onRequest">;
-}
-//#endregion
-//#region src/server/index.d.ts
-declare module "alepha" {
-  interface State {
-    "alepha.node.server"?: Server;
-  }
-  interface Hooks {
-    "action:onRequest": {
-      action: ActionDescriptor<RequestConfigSchema>;
-      request: ServerRequest;
-      options: ClientRequestOptions;
-    };
-    "action:onResponse": {
-      action: ActionDescriptor<RequestConfigSchema>;
-      request: ServerRequest;
-      options: ClientRequestOptions;
-      response: any;
-    };
-    "server:onRequest": {
-      route: ServerRoute;
-      request: ServerRequest;
-    };
-    "server:onError": {
-      route: ServerRoute;
-      request: ServerRequest;
-      error: Error;
-    };
-    "server:onSend": {
-      route: ServerRoute;
-      request: ServerRequest;
-    };
-    "server:onResponse": {
-      route: ServerRoute;
-      request: ServerRequest;
-      response: ServerResponse;
-    };
-    "client:onRequest": {
-      route: HttpAction;
-      config: ServerRequestConfigEntry;
-      options: ClientRequestOptions;
-      headers: Record<string, string>;
-      request: RequestInit;
-    };
-    "client:beforeFetch": {
-      url: string;
-      options: FetchOptions;
-      request: RequestInit;
-    };
-    "client:onError": {
-      route?: HttpAction;
-      error: HttpError;
-    };
-    "node:request": NodeRequestEvent;
-    "web:request": WebRequestEvent;
-  }
-}
-/**
- * Provides high-performance HTTP server capabilities with declarative routing and action descriptors.
- *
- * The server module enables building REST APIs and web applications using `$route` and `$action` descriptors
- * on class properties. It provides automatic request/response handling, schema validation, middleware support,
- * and seamless integration with other Alepha modules for a complete backend solution.
- *
- * @see {@link $route}
- * @see {@link $action}
- * @module alepha.server
- */
-declare const AlephaServer: alepha17.Service<alepha17.Module>;
-//#endregion
-export { $action, $route, ActionDescriptor, ActionDescriptorFn, ActionDescriptorOptions, AlephaServer, BadRequestError, BunHttpServerProvider, ClientRequestEntry, ClientRequestEntryContainer, ClientRequestOptions, ClientRequestResponse, ConflictError, ErrorSchema, FetchActionArgs, FetchOptions, FetchResponse, ForbiddenError, HttpAction, HttpClient, HttpClientPendingRequests, HttpError, HttpErrorLike, NodeHttpServerProvider, NodeRequestEvent, NotFoundError, Ok, RequestConfigSchema, RequestInitWithOptions, ResponseBodyType, ResponseKind, RouteDescriptor, RouteDescriptorOptions, RouteMethod, ServerActionHandler, ServerActionRequest, ServerHandler, ServerLoggerProvider, ServerNotReadyProvider, ServerProvider, ServerRawRequest, ServerReply, ServerRequest, ServerRequestConfig, ServerRequestConfigEntry, ServerRequestData, ServerResponse, ServerResponseBody, ServerRoute, ServerRouteMatcher, ServerRouteRequestHandler, ServerRouterProvider, ServerTimingProvider, TRequestBody, TResponseBody, UnauthorizedError, ValidationError, WebRequestEvent, errorNameByStatus, errorSchema, isHttpError, isMultipart, okSchema, routeMethods };
-//# sourceMappingURL=index.d.cts.map