alepha 0.7.5 → 0.7.7

package/server.d.ts

@@ -1,1042 +1,433 @@
-import * as _alepha_core from '@alepha/core';
-import { Static as Static$1, TObject as TObject$1, TSchema as TSchema$2, Async, StreamLike, Alepha, FileLike, OPTIONS, KIND, Module } from '@alepha/core';
-export { KIND } from '@alepha/core';
-import { UserAccountToken, Permission, ServiceAccountDescriptor as ServiceAccountDescriptor$1, SecurityProvider, JwtProvider } from '@alepha/security';
-import { IncomingMessage, ServerResponse as ServerResponse$1 } from 'node:http';
-import { Readable } from 'node:stream';
-import { ReadableStream } from 'node:stream/web';
-import { Route, RouterProvider } from '@alepha/router';
-import * as _alepha_cache from '@alepha/cache';
-import { DurationLike, DateTimeProvider } from '@alepha/datetime';
-import * as _alepha_retry from '@alepha/retry';
-import { BusboyConfig } from '@fastify/busboy';
-import * as http from 'http';
-
-/** Symbol key applied to readonly types */
-declare const ReadonlyKind$1: unique symbol;
-/** Symbol key applied to optional types */
-declare const OptionalKind$1: unique symbol;
-/** Symbol key applied to types */
-declare const Hint$1: unique symbol;
-/** Symbol key applied to types */
-declare const Kind$1: unique symbol;
-
-interface TAny extends TSchema$1 {
-    [Kind$1]: 'Any';
-    static: any;
-}
-
-type TReadonly<T extends TSchema$1> = T & {
-    [ReadonlyKind$1]: 'Readonly';
-};
-
-type UnionStatic<T extends TSchema$1[], P extends unknown[]> = {
-    [K in keyof T]: T[K] extends TSchema$1 ? Static<T[K], P> : never;
-}[number];
-interface TUnion<T extends TSchema$1[] = TSchema$1[]> extends TSchema$1 {
-    [Kind$1]: 'Union';
-    static: UnionStatic<T, this['params']>;
-    anyOf: T;
-}
-
-type StringFormatOption$1 = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex' | ({} & string);
-type StringContentEncodingOption$1 = '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64' | ({} & string);
-interface StringOptions$1 extends SchemaOptions$1 {
-    /** The maximum string length */
-    maxLength?: number;
-    /** The minimum string length */
-    minLength?: number;
-    /** A regular expression pattern this string should match */
-    pattern?: string;
-    /** A format this string should match */
-    format?: StringFormatOption$1;
-    /** The content encoding for this string */
-    contentEncoding?: StringContentEncodingOption$1;
-    /** The content media type for this string */
-    contentMediaType?: string;
-}
-interface TString$1 extends TSchema$1, StringOptions$1 {
-    [Kind$1]: 'String';
-    static: string;
-    type: 'string';
-}
-
-interface TBoolean extends TSchema$1 {
-    [Kind$1]: 'Boolean';
-    static: boolean;
-    type: 'boolean';
-}
-
-interface NumberOptions extends SchemaOptions$1 {
-    exclusiveMaximum?: number;
-    exclusiveMinimum?: number;
-    maximum?: number;
-    minimum?: number;
-    multipleOf?: number;
-}
-interface TNumber extends TSchema$1, NumberOptions {
-    [Kind$1]: 'Number';
-    static: number;
-    type: 'number';
-}
-
-interface IntegerOptions extends SchemaOptions$1 {
-    exclusiveMaximum?: number;
-    exclusiveMinimum?: number;
-    maximum?: number;
-    minimum?: number;
-    multipleOf?: number;
-}
-interface TInteger extends TSchema$1, IntegerOptions {
-    [Kind$1]: 'Integer';
-    static: number;
-    type: 'integer';
-}
-
-type TOptional<T extends TSchema$1> = T & {
-    [OptionalKind$1]: 'Optional';
-};
-
-type RecordStatic<Key extends TSchema$1, Type extends TSchema$1, P extends unknown[]> = (Evaluate<{
-    [_ in Assert<Static<Key>, PropertyKey>]: Static<Type, P>;
-}>);
-interface TRecord<Key extends TSchema$1 = TSchema$1, Type extends TSchema$1 = TSchema$1> extends TSchema$1 {
-    [Kind$1]: 'Record';
-    static: RecordStatic<Key, Type, this['params']>;
-    type: 'object';
-    patternProperties: {
-        [pattern: string]: Type;
-    };
-    additionalProperties: TAdditionalProperties;
-}
-
-/** Creates a static type from a TypeBox type */
-type Static<Type extends TSchema$1, Params extends unknown[] = [], Result = (Type & {
-    params: Params;
-})['static']> = Result;
-
-type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonly<TSchema$1> ? (T[K] extends TOptional<T[K]> ? K : never) : never;
-}[keyof T];
-type ReadonlyPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TReadonly<TSchema$1> ? (T[K] extends TOptional<T[K]> ? never : K) : never;
-}[keyof T];
-type OptionalPropertyKeys<T extends TProperties> = {
-    [K in keyof T]: T[K] extends TOptional<TSchema$1> ? (T[K] extends TReadonly<T[K]> ? never : K) : never;
-}[keyof T];
-type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
-type ObjectStaticProperties<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
-type ObjectStatic<T extends TProperties, P extends unknown[]> = ObjectStaticProperties<T, {
-    [K in keyof T]: Static<T[K], P>;
-}>;
-type TPropertyKey = string | number;
-type TProperties = Record<TPropertyKey, TSchema$1>;
-type TAdditionalProperties = undefined | TSchema$1 | boolean;
-interface ObjectOptions extends SchemaOptions$1 {
-    /** Additional property constraints for this object */
-    additionalProperties?: TAdditionalProperties;
-    /** The minimum number of properties allowed on this object */
-    minProperties?: number;
-    /** The maximum number of properties allowed on this object */
-    maxProperties?: number;
-}
-interface TObject<T extends TProperties = TProperties> extends TSchema$1, ObjectOptions {
-    [Kind$1]: 'Object';
-    static: ObjectStatic<T, this['params']>;
-    additionalProperties?: TAdditionalProperties;
-    type: 'object';
-    properties: T;
-    required?: string[];
-}
-
-type Assert<T, E> = T extends E ? T : never;
-type Evaluate<T> = T extends infer O ? {
-    [K in keyof O]: O[K];
-} : never;
-type Ensure<T> = T extends infer U ? U : never;
-
-interface ArrayOptions extends SchemaOptions$1 {
-    /** The minimum number of items in this array */
-    minItems?: number;
-    /** The maximum number of items in this array */
-    maxItems?: number;
-    /** Should this schema contain unique items */
-    uniqueItems?: boolean;
-    /** A schema for which some elements should match */
-    contains?: TSchema$1;
-    /** A minimum number of contains schema matches */
-    minContains?: number;
-    /** A maximum number of contains schema matches */
-    maxContains?: number;
-}
-type ArrayStatic<T extends TSchema$1, P extends unknown[]> = Ensure<Static<T, P>[]>;
-interface TArray<T extends TSchema$1 = TSchema$1> extends TSchema$1, ArrayOptions {
-    [Kind$1]: 'Array';
-    static: ArrayStatic<T, this['params']>;
-    type: 'array';
-    items: T;
-}
-
-interface SchemaOptions$1 {
-    $schema?: string;
-    /** Id for this schema */
-    $id?: string;
-    /** Title of this schema */
-    title?: string;
-    /** Description of this schema */
-    description?: string;
-    /** Default value for this schema */
-    default?: any;
-    /** Example values matching this schema */
-    examples?: any;
-    /** Optional annotation for readOnly */
-    readOnly?: boolean;
-    /** Optional annotation for writeOnly */
-    writeOnly?: boolean;
-    [prop: string]: any;
-}
-interface TKind$1 {
-    [Kind$1]: string;
-}
-interface TSchema$1 extends TKind$1, SchemaOptions$1 {
-    [ReadonlyKind$1]?: string;
-    [OptionalKind$1]?: string;
-    [Hint$1]?: string;
-    params: unknown[];
-    static: unknown;
-}
-
+import * as _alepha_core1 from "@alepha/core";
+import * as _alepha_core3 from "@alepha/core";
+import * as _alepha_core7 from "@alepha/core";
+import * as _alepha_core9 from "@alepha/core";
+import * as _alepha_core71 from "@alepha/core";
+import * as _alepha_core10 from "@alepha/core";
+import * as _alepha_core15 from "@alepha/core";
+import * as _alepha_core23 from "@alepha/core";
+import { Alepha, Async, FileLike, KIND, KIND as KIND$1, Module, OPTIONS, Static, StreamLike, TObject, TSchema } from "@alepha/core";
+import { JwtProvider, Permission, SecurityProvider, ServiceAccountDescriptor, UserAccountToken } from "@alepha/security";
+import { BusboyConfig } from "@fastify/busboy";
+import * as _alepha_cache2 from "@alepha/cache";
+import { Readable } from "node:stream";
+import { ReadableStream } from "node:stream/web";
+import { Route, RouterProvider } from "@alepha/router";
+import { IncomingMessage, ServerResponse as ServerResponse$1 } from "node:http";
+import { DurationLike } from "@alepha/datetime";
+import * as _sinclair_typebox13 from "@sinclair/typebox";
+import * as _sinclair_typebox37 from "@sinclair/typebox";
+import * as _sinclair_typebox21 from "@sinclair/typebox";
+import * as _sinclair_typebox27 from "@sinclair/typebox";
+import * as _sinclair_typebox63 from "@sinclair/typebox";
+import * as http18 from "http";
+
+//#region src/constants/routeMethods.d.ts
 declare const routeMethods: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "CONNECT", "TRACE"];
 type RouteMethod = (typeof routeMethods)[number];
-
-declare const envSchema$4: TObject$1<{
-    SERVER_ALS_ENABLED: TBoolean;
-}>;
-declare module "alepha" {
-    interface Env extends Partial<Static$1<typeof envSchema$4>> {
-    }
-}
-/**
- * Main router for all routes on the server side.
- *
- * Remember:
- * - $route => generic route
- * - $action => action route (for API calls)
- * - $page => React route (for SSR)
- */
-declare class ServerRouterProvider extends RouterProvider<ServerRouteWithHandler> {
-    protected readonly alepha: Alepha;
-    protected readonly env: {
-        SERVER_ALS_ENABLED: boolean;
-    };
-    createRequestId(): string;
-    route<TConfig extends RequestConfigSchema = RequestConfigSchema>(route: ServerRoute<TConfig>): Promise<void>;
-    onRequest(route: ServerRoute, rawRequest: ServerRawRequest, responseType: ResponseType, withAls: boolean): Promise<ServerResponse>;
-    protected processRequest(request: ServerRequest, route: ServerRoute, responseType: ResponseType, withAls: boolean): Promise<{
-        status: number;
-        headers: Record<string, string> & {
-            "set-cookie"?: string[];
-        };
-        body: any;
-    }>;
-    protected runRouteHandler(route: ServerRoute, request: ServerRequest, responseType: ResponseType, withAls: boolean): Promise<void>;
-    protected getResponseType(schema?: RequestConfigSchema): ResponseType;
-    protected errorHandler(route: ServerRoute, request: ServerRequest, error: Error): Promise<void>;
-    validateRequest(route: {
-        schema?: RequestConfigSchema;
-    }, request: ServerRequestConfig): void;
-    serializeResponse(route: ServerRoute, reply: ServerReply, responseType: ResponseType): void;
-}
+//#endregion
+//#region src/helpers/ServerReply.d.ts
+declare class ServerReply {
+  headers: Record<string, string> & {
+    "set-cookie"?: string[];
+  };
+  status?: number;
+  body?: any;
+  redirect(url: string, status?: number): void;
+  setStatus(status: number): void;
+  setHeader(name: string, value: string): void;
+}
+//#endregion
+//#region src/interfaces/index.d.ts
 interface RequestConfigSchema {
-    body?: TSchema$2;
-    params?: TObject$1;
-    query?: TObject$1;
-    headers?: TObject$1;
-    response?: TSchema$2;
+  body?: TSchema;
+  params?: TObject;
+  query?: TObject;
+  headers?: TObject;
+  response?: TSchema;
 }
 interface ServerRequestConfig<TConfig extends RequestConfigSchema = RequestConfigSchema> {
-    body: TConfig["body"] extends TSchema$2 ? Static$1<TConfig["body"]> : any;
-    headers: TConfig["headers"] extends TObject$1 ? Static$1<TConfig["headers"]> : Record<string, string>;
-    params: TConfig["params"] extends TObject$1 ? Static$1<TConfig["params"]> : Record<string, string>;
-    query: TConfig["query"] extends TObject$1 ? Static$1<TConfig["query"]> : Record<string, string>;
+  body: TConfig["body"] extends TSchema ? 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, string>;
 }
 type ServerRequestConfigEntry<TConfig extends RequestConfigSchema = RequestConfigSchema> = Partial<ServerRequestConfig<TConfig>>;
 interface ServerRequest<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRequestConfig<TConfig> {
-    method: RouteMethod;
-    url: URL;
-    metadata: Record<string, any>;
-    reply: ServerReply;
-    raw: {
-        node?: {
-            req: IncomingMessage;
-            res: ServerResponse$1;
-        };
+  method: RouteMethod;
+  url: URL;
+  metadata: Record<string, any>;
+  reply: ServerReply;
+  raw: {
+    node?: {
+      req: IncomingMessage;
+      res: ServerResponse$1;
     };
-    user: UserAccountToken;
+  };
+  user: UserAccountToken;
 }
 interface ServerRoute<TConfig extends RequestConfigSchema = RequestConfigSchema> extends Route {
-    method?: RouteMethod;
-    handler: ServerHandler<TConfig>;
-    schema?: TConfig;
-    /**
-     * @see ServerLoggerProvider
-     */
-    silent?: boolean;
-    /**
-     * @see ServerSecurityProvider
-     */
-    secure?: ServerRouteSecure;
-}
-type ServerResponseBody<TConfig extends RequestConfigSchema = RequestConfigSchema> = TConfig["response"] extends TSchema$2 ? Static$1<TConfig["response"]> : ResponseBodyType;
-type ResponseType = "json" | "text" | "void" | "file" | "any";
+  method?: RouteMethod;
+  handler: ServerHandler<TConfig>;
+  schema?: TConfig;
+  /**
+   * @see ServerLoggerProvider
+   */
+  silent?: boolean;
+  /**
+   * @see ServerSecurityProvider
+   */
+  secure?: ServerRouteSecure;
+}
+type ServerResponseBody<TConfig extends RequestConfigSchema = RequestConfigSchema> = TConfig["response"] extends TSchema ? 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>>;
 type ServerMiddlewareHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (request: ServerRequest<TConfig>) => Async<ServerResponseBody<TConfig> | undefined>;
-interface ServerReply {
-    headers: Record<string, string> & {
-        "set-cookie"?: string[];
-    };
-    status?: number;
-    body?: any;
-    redirect(url: string): void;
-}
 interface ServerResponse {
-    body: string | Buffer | ArrayBuffer | Readable | ReadableStream;
-    headers: Record<string, string>;
-    status: number;
+  body: string | Buffer | ArrayBuffer | Readable | ReadableStream;
+  headers: Record<string, string>;
+  status: number;
 }
 interface ServerRouteWithHandler extends Route {
-    handler: (request: ServerRawRequest) => Promise<ServerResponse>;
+  handler: (request: ServerRawRequest) => Promise<ServerResponse>;
 }
 interface ServerRawRequest {
-    method: RouteMethod;
-    url: URL;
-    headers: Record<string, string>;
-    query: Record<string, string>;
-    params: Record<string, string>;
-    raw: {
-        node?: {
-            req: IncomingMessage;
-            res: ServerResponse$1;
-        };
+  method: RouteMethod;
+  url: URL;
+  headers: Record<string, string>;
+  query: Record<string, string>;
+  params: Record<string, string>;
+  raw: {
+    node?: {
+      req: IncomingMessage;
+      res: ServerResponse$1;
     };
+  };
 }
 type ServerRouteSecure = boolean | {
-    permissions?: string[];
-    roles?: string[];
-    realms?: string[];
-    organizations?: string[];
+  permissions?: string[];
+  roles?: string[];
+  realms?: string[];
+  organizations?: string[];
 };
-
+//#endregion
+//#region src/helpers/ActionDescriptorHelper.d.ts
 declare class ActionDescriptorHelper {
-    name(options: ActionDescriptorOptions, _instance: any, key: string): string;
-    path(options: ActionDescriptorOptions, _instance: any, key: string): string;
-    link(options: ActionDescriptorOptions, instance: any, key: string, prefix?: string): HttpClientLink;
-    method(options: {
-        method?: string;
-        schema?: any;
-    }): RouteMethod;
-    permission(options: ActionDescriptorOptions, instance: any, key: string): Permission;
-    group(options: ActionDescriptorOptions, instance: any): string;
-    isMultipart(options: {
-        schema?: RequestConfigSchema;
-    }): boolean;
-    bodyContentType(options: ActionDescriptorOptions): string | undefined;
-    protected short(name: string): string;
-    fetchLinks(_url: string): void;
-}
-
-declare const apiLinkSchema: TObject<{
-    name: TString$1;
-    path: TString$1;
-    method: TOptional<TString$1>;
-    group: TOptional<TString$1>;
-    requestBodyType: TOptional<TString$1>;
-    service: TOptional<TString$1>;
-}>;
-declare const apiLinksResponseSchema: TObject<{
-    prefix: TOptional<TString$1>;
-    links: TArray<TObject<{
-        name: TString$1;
-        path: TString$1;
-        method: TOptional<TString$1>;
-        group: TOptional<TString$1>;
-        requestBodyType: TOptional<TString$1>;
-        service: TOptional<TString$1>;
-    }>>;
-}>;
-type ApiLinksResponse = Static$1<typeof apiLinksResponseSchema>;
-type ApiLink = Static$1<typeof apiLinkSchema>;
-
-declare class HttpClient {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly alepha: Alepha;
-    protected readonly helper: ActionDescriptorHelper;
-    readonly cache: _alepha_cache.CacheDescriptor<HttpClientCache, any[]>;
-    protected readonly pendingRequests: HttpClientPendingRequests;
-    readonly URL_LINKS = "/api/_links";
-    links?: Array<HttpClientLink>;
-    pushLink(link: HttpClientLink): void;
-    clear(): Promise<void>;
-    fetch<T>(url: string, request?: RequestInit, options?: FetchRunOptions): Promise<FetchResponse<T>>;
-    json<T = any>(url: string, options?: RequestInit): Promise<T>;
-    protected url(host: string, link: HttpClientLink, args: ServerRequestConfigEntry): string;
-    protected body(init: RequestInit, headers: Record<string, string>, link: HttpClientLink, args?: ServerRequestConfigEntry): Promise<void>;
-    protected responseData(response: Response, options: FetchRunOptions): Promise<any>;
-    protected isMaybeFile(response: Response): boolean;
-    protected createFileLike(response: Response, defaultFileName?: string): FileLike;
-    protected pathVariables(url: string, action: HttpClientLink, args?: ServerRequestConfigEntry): string;
-    protected queryParams(url: string, action: {
-        schema?: {
-            query?: TObject$1;
-        };
-    }, args?: ServerRequestConfigEntry): string;
-    /**
-     * Transform a link into a fetch-request then call fetch().
-     */
-    fetchLink(args: FetchLinkArgs): Promise<FetchResponse>;
-    /**
-     * Create a proxy client.
-     * This allows to call actions as methods, e.g. `client.actionName()`.
-     */
-    of<T extends object>(scope?: ClientScope): HttpVirtualClient<T>;
-    protected getLinkByName(name: string, options?: ClientScope): Promise<HttpClientLink>;
-    /**
-     * Resolve a link by its name and call it.
-     * - If link is local, it will call the local handler.
-     * - If link is remote, it will make a fetch request to the remote server.
-     */
-    follow(name: string, config?: Partial<ServerRequestConfigEntry>, options?: ClientRequestOptions & ClientScope): Promise<any>;
-    protected followRemote(link: HttpClientLink, config?: Partial<ServerRequestConfigEntry>, options?: ClientRequestOptions): Promise<FetchResponse>;
-    can(name: string): boolean;
-    getLinks(force?: boolean): Promise<HttpClientLink[]>;
-}
-type HttpClientPendingRequests = Record<string, Promise<any> | undefined>;
-interface FetchFactoryAdditionalOptions {
-    host?: string | (() => string);
-}
-interface FetchRunOptions {
-    /**
-     * Key to identify the request in the pending requests.
-     */
-    key?: string;
-    /**
-     * The schema to validate the response against.
-     */
-    schema?: TSchema$2;
-    /**
-     * Built-in cache options.
-     */
-    cache?: boolean | number | DurationLike;
-}
-interface HttpClientLink extends ApiLink {
-    secured?: boolean;
-    prefix?: string;
-    host?: string;
-    service?: string;
+  name(options: ActionDescriptorOptions, instance: any, key: string): string;
+  path(options: ActionDescriptorOptions, _instance: any, key: string): string;
+  method(options: {
+    method?: string;
+    schema?: any;
+  }): RouteMethod;
+  permission(options: ActionDescriptorOptions, instance: any, key: string): Permission;
+  group(options: ActionDescriptorOptions, instance: any): string;
+  isMultipart(options: {
     schema?: RequestConfigSchema;
-    handler?: ServerHandler;
-}
-interface ClientScope {
-    group?: string;
-    service?: string;
+  }): boolean;
+  bodyContentType(options: ActionDescriptorOptions): string | undefined;
+  protected short(name: string): string;
+  fetchLinks(_url: string): void;
 }
-type HttpVirtualClient<T> = {
-    [K in keyof T as T[K] extends ActionDescriptor ? K : never]: T[K] extends ActionDescriptor<infer Schema> ? T[K] & {
-        can: () => boolean;
-        schema: Schema;
-    } : never;
-};
-interface HttpClientCache {
-    data: any;
-    etag?: string;
+//#endregion
+//#region src/services/HttpClient.d.ts
+declare class HttpClient {
+  protected readonly log: _alepha_core1.Logger;
+  protected readonly alepha: Alepha;
+  protected readonly helper: ActionDescriptorHelper;
+  readonly cache: _alepha_cache2.CacheDescriptor<HttpClientCache, any[]>;
+  protected readonly pendingRequests: HttpClientPendingRequests;
+  clear(): Promise<void>;
+  fetchAction(args: FetchActionArgs): Promise<FetchResponse>;
+  fetch<T>(url: string, request?: RequestInit,
+  // standard options
+  options?: FetchOptions): Promise<FetchResponse<T>>;
+  json<T = any>(url: string, options?: RequestInit): Promise<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 {
+  /**
+   * Key to identify the request in the pending requests.
+   */
+  key?: string;
+  /**
+   * The schema to validate the response against.
+   */
+  schema?: TSchema;
+  /**
+   * Built-in cache options.
+   */
+  cache?: boolean | number | DurationLike;
 }
 interface FetchResponse<T = any> {
-    data: T;
-    status: number;
-    statusText: string;
-    headers: Headers;
-    raw?: Response;
-}
-interface FetchLinkArgs {
-    link: HttpClientLink;
-    host?: string;
-    config?: ServerRequestConfigEntry;
-    options?: ClientRequestOptions;
+  data: T;
+  status: number;
+  statusText: string;
+  headers: Headers;
+  raw?: Response;
 }
-
-declare const KEY$2 = "ACTION";
+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;
+  schema?: {
+    params?: TObject;
+    query?: TObject;
+    body?: TSchema;
+    response?: TSchema;
+  };
+}
+//#endregion
+//#region src/descriptors/$action.d.ts
+declare const KEY$1 = "ACTION";
 interface ActionDescriptorOptions<TConfig extends RequestConfigSchema = RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema"> {
-    /**
-     * Name the route.
-     */
-    name?: string;
-    /**
-     * Namespace of the route, used for grouping.
-     *
-     * @default Class name containing the route.
-     */
-    group?: string;
-    /**
-     * If false, disabled the security check for this route.
-     *
-     * @default true when SecurityModule is enabled, false otherwise.
-     * @deprecated
-     */
-    security?: boolean;
-    /**
-     * Pathname of the route.
-     */
-    path?: string;
-    /**
-     * Inherit options from another route.
-     */
-    use?: {
-        [OPTIONS]: ActionDescriptorOptions<TConfig>;
-    };
-    /**
-     * The route method.
-     *
-     * @default "GET" or "POST" when schema body is defined.
-     */
-    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;
-    /**
-     * Short description of the route.
-     */
-    summary?: string;
-    /**
-     * Long description of the route.
-     */
-    description?: string;
-    /**
-     * Disable the route. Useful with env variables do disable one specific route.
-     */
-    disabled?: boolean;
-    /**
-     * Mark the route as private.
-     * - It won't be exposed in the API documentation.
-     * - It won't be exposed in _links.
-     */
-    internal?: boolean;
-    /**
-     * Main route handler. This is where the route logic is implemented.
-     */
-    handler?: ServerHandler<TConfig>;
+  /**
+   * Name the route.
+   */
+  name?: string;
+  /**
+   * Namespace of the route, used for grouping.
+   *
+   * @default Class name containing the route.
+   */
+  group?: string;
+  /**
+   * If false, disabled the security check for this route.
+   *
+   * @default true when SecurityModule is enabled, false otherwise.
+   * @deprecated
+   */
+  security?: boolean;
+  /**
+   * Pathname of the route.
+   */
+  path?: string;
+  /**
+   * Inherit options from another route.
+   */
+  use?: {
+    [OPTIONS]: ActionDescriptorOptions<TConfig>;
+  };
+  /**
+   * The route method.
+   *
+   * @default "GET" or "POST" when schema body is defined.
+   */
+  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;
+  /**
+   * Short description of the route.
+   */
+  summary?: string;
+  /**
+   * Long description of the route.
+   */
+  description?: string;
+  /**
+   * Disable the route. Useful with env variables do disable one specific route.
+   */
+  disabled?: boolean;
+  /**
+   * Mark the route as private.
+   * - It won't be exposed in the API documentation.
+   * - It won't be exposed in _links.
+   */
+  internal?: boolean;
+  /**
+   * Main route handler. This is where the route logic is implemented.
+   */
+  handler?: ServerHandler<TConfig>;
 }
 interface ActionDescriptor<TConfig extends RequestConfigSchema = RequestConfigSchema> {
-    [KIND]: typeof KEY$2;
-    [OPTIONS]: ActionDescriptorOptions<TConfig>;
-    /**
-     * Fetch or just call local route when available.
-     */
-    (config?: ClientRequestEntry<TConfig>, opts?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
-    /**
-     * Just fetch the route. Skip any local route.
-     */
-    fetch: (config?: ClientRequestEntry<TConfig>, opts?: ClientRequestOptions) => Promise<FetchResponse<ClientRequestResponse<TConfig>>>;
-    /**
-     * Name of the permission required to access this route.
-     */
-    permission: () => string;
+  [KIND$1]: typeof KEY$1;
+  [OPTIONS]: ActionDescriptorOptions<TConfig>;
+  /**
+   * Fetch or just call local route when available.
+   */
+  (config?: ClientRequestEntry<TConfig>, opts?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
+  /**
+   * Just fetch the route. Skip any local route.
+   */
+  fetch: (config?: ClientRequestEntry<TConfig>, opts?: ClientRequestOptions) => Promise<FetchResponse<ClientRequestResponse<TConfig>>>;
+  /**
+   * Name of the permission required to access this route.
+   */
+  permission: () => string;
 }
 declare const $action: {
-    <TConfig extends RequestConfigSchema>(options: ActionDescriptorOptions<TConfig>): ActionDescriptor<TConfig>;
-    [KIND]: string;
-};
-type ClientRequestEntry<TConfig extends RequestConfigSchema = RequestConfigSchema, T = ClientRequestEntryContainer<TConfig>> = {
-    [K in keyof T as T[K] extends undefined ? never : K]: T[K];
+  <TConfig extends RequestConfigSchema>(options: ActionDescriptorOptions<TConfig>): ActionDescriptor<TConfig>;
+  [KIND$1]: string;
 };
+type ClientRequestEntry<TConfig extends RequestConfigSchema = RequestConfigSchema, T = ClientRequestEntryContainer<TConfig>> = { [K in keyof T as T[K] extends undefined ? never : K]: T[K] };
 type ClientRequestEntryContainer<TConfig extends RequestConfigSchema = RequestConfigSchema> = {
-    body: TConfig["body"] extends TSchema$2 ? Static$1<TConfig["body"]> : undefined;
-    params: TConfig["params"] extends TSchema$2 ? Static$1<TConfig["params"]> : undefined;
-    headers?: TConfig["headers"] extends TSchema$2 ? Static$1<TConfig["headers"]> : undefined;
-    query?: TConfig["query"] extends TSchema$2 ? Partial<Static$1<TConfig["query"]>> : undefined;
+  body: TConfig["body"] extends TSchema ? Static<TConfig["body"]> : undefined;
+  params: TConfig["params"] extends TSchema ? Static<TConfig["params"]> : undefined;
+  headers?: TConfig["headers"] extends TSchema ? Static<TConfig["headers"]> : undefined;
+  query?: TConfig["query"] extends TSchema ? Partial<Static<TConfig["query"]>> : undefined;
 };
-interface ClientRequestOptions extends FetchRunOptions {
-    /**
-     * Forward user from the previous request.
-     * If "system", use system user. @see {ServerSecurityProvider.localSystemUser}
-     * If "context", use the user from the current context (e.g. request).
-     *
-     * @default "system" is provided, else "context" is used.
-     */
-    user?: UserAccountToken | "system" | "context";
-    /**
-     * Standard request fetch options.
-     */
-    request?: RequestInit;
-}
-type ClientRequestResponse<TConfig extends RequestConfigSchema> = TConfig["response"] extends TSchema$2 ? Static$1<TConfig["response"]> : any;
-
+interface ClientRequestOptions extends FetchOptions {
+  /**
+   * Forward user from the previous request.
+   * If "system", use system user. @see {ServerSecurityProvider.localSystemUser}
+   * If "context", use the user from the current context (e.g. request).
+   *
+   * @default "system" is provided, else "context" is used.
+   */
+  user?: UserAccountToken | "system" | "context";
+  /**
+   * Standard request fetch options.
+   */
+  request?: RequestInit;
+}
+type ClientRequestResponse<TConfig extends RequestConfigSchema> = TConfig["response"] extends TSchema ? Static<TConfig["response"]> : any;
+//#endregion
+//#region src/errors/HttpError.d.ts
 declare class HttpError extends Error {
-    static toJSON(error: HttpError): {
-        status: number;
-        error: string | undefined;
-        message: string;
-        cause: {
-            name: string;
-            message: string;
-        };
-    } | {
-        status: number;
-        error: string | undefined;
-        message: string;
-        cause?: undefined;
-    };
-    readonly status: number;
-    readonly error?: string;
-    readonly reason?: {
-        name: string;
-        message: string;
+  static toJSON(error: HttpError): {
+    status: number;
+    error: string | undefined;
+    message: string;
+    cause: {
+      name: string;
+      message: string;
     };
-    constructor(options: {
-        error?: string;
-        message: string;
-        status: number;
-        cause?: {
-            name: string;
-            message: string;
-        } | unknown;
-    }, cause?: unknown);
+  } | {
+    status: number;
+    error: string | undefined;
+    message: string;
+    cause?: undefined;
+  };
+  readonly status: number;
+  readonly error?: string;
+  readonly reason?: {
+    name: string;
+    message: string;
+  };
+  constructor(options: {
+    error?: string;
+    message: string;
+    status: number;
+    cause?: {
+      name: string;
+      message: string;
+    } | unknown;
+  }, cause?: unknown);
 }
 declare const errorNameByStatus: Record<number, string>;
 declare const isHttpError: (error: unknown) => error is HttpErrorLike;
 interface HttpErrorLike extends Error {
-    status: number;
-}
-
-declare const $client: <T extends object>(scope?: ClientScope) => HttpVirtualClient<T>;
-
-type ProxyDescriptorOptions = {
-    path: string;
-    target: string;
-    disabled?: boolean;
-    beforeRequest?: (request: ServerRequest, proxyRequest: RequestInit) => Async<void>;
-    afterResponse?: (request: ServerRequest, proxyResponse: Response) => Async<void>;
-    rewrite?: (url: URL) => void;
-};
-interface ProxyDescriptor {
-    [KIND]: "PROXY";
-    [OPTIONS]: ProxyDescriptorOptions;
+  status: number;
 }
-declare const $proxy: {
-    (options: ProxyDescriptorOptions): ProxyDescriptor;
-    [KIND]: string;
-};
-
-/**
- * Represents a User Account extracted from JWT.
- */
-interface UserAccountInfo {
-    /**
-     * ID of user account. Based on JWT.sub.
-     */
-    id: string;
-    /**
-     * Represents the roles assigned to a user.
-     */
-    roles?: string[];
-    /**
-     * User full name, if available.
-     */
-    name?: string;
-    /**
-     * User email, if available.
-     */
-    email?: string;
-    /**
-     * User profile picture URL, if available.
-     */
-    picture?: string;
-    /**
-     * Organization ID, if available.
-     */
-    organization?: string;
-}
-
-/** Symbol key applied to readonly types */
-declare const ReadonlyKind: unique symbol;
-/** Symbol key applied to optional types */
-declare const OptionalKind: unique symbol;
-/** Symbol key applied to types */
-declare const Hint: unique symbol;
-/** Symbol key applied to types */
-declare const Kind: unique symbol;
-
-type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex' | ({} & string);
-type StringContentEncodingOption = '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64' | ({} & string);
-interface StringOptions extends SchemaOptions {
-    /** The maximum string length */
-    maxLength?: number;
-    /** The minimum string length */
-    minLength?: number;
-    /** A regular expression pattern this string should match */
-    pattern?: string;
-    /** A format this string should match */
-    format?: StringFormatOption;
-    /** The content encoding for this string */
-    contentEncoding?: StringContentEncodingOption;
-    /** The content media type for this string */
-    contentMediaType?: string;
-}
-interface TString extends TSchema, StringOptions {
-    [Kind]: 'String';
-    static: string;
-    type: 'string';
-}
-
-interface SchemaOptions {
-    $schema?: string;
-    /** Id for this schema */
-    $id?: string;
-    /** Title of this schema */
-    title?: string;
-    /** Description of this schema */
-    description?: string;
-    /** Default value for this schema */
-    default?: any;
-    /** Example values matching this schema */
-    examples?: any;
-    /** Optional annotation for readOnly */
-    readOnly?: boolean;
-    /** Optional annotation for writeOnly */
-    writeOnly?: boolean;
-    [prop: string]: any;
-}
-interface TKind {
-    [Kind]: string;
-}
-interface TSchema extends TKind, SchemaOptions {
-    [ReadonlyKind]?: string;
-    [OptionalKind]?: string;
-    [Hint]?: string;
-    params: unknown[];
-    static: unknown;
-}
-
-declare const envSchema$3: _alepha_core.TObject<{
-    SECURITY_SECRET_KEY: TString;
-}>;
-interface ServiceAccountDescriptor {
-    token: () => Promise<string>;
-}
-declare module "alepha/core" {
-    interface Env extends Partial<Static$1<typeof envSchema$3>> {
-    }
-}
-
-declare module "@alepha/core" {
-    interface Hooks {
-        "security:user:created": {
-            realm: string;
-            user: UserAccountInfo;
-        };
-    }
-}
-
-declare const KEY$1 = "REMOTE";
-interface RemoteDescriptorOptions {
-    /**
-     * The URL of the remote service.
-     * You can use a function to generate the URL dynamically.
-     * You probably should use $inject(env) to get the URL from the environment.
-     *
-     * @example
-     * ```ts
-     * import { $remote } from "@alepha/server";
-     * import { $inject, t } from "@alepha/core";
-     *
-     * class App {
-     *   env = $inject(t.object({
-     *     REMOTE_URL: t.string({default: "http://localhost:3000"}),
-     *   }));
-     *   remote = $remote({
-     *     url: this.env.REMOTE_URL,
-     *   });
-     * }
-     * ```
-     */
-    url: string | (() => string);
-    /**
-     * The name of the remote service.
-     *
-     * @default Member of the class containing the remote service.
-     */
-    name?: string;
-    /**
-     * If true, all methods of the remote service will be exposed as actions in this context.
-     * > Note: Proxy will never use the service account, it just... proxies the request.
-     */
-    proxy?: boolean | Partial<ProxyDescriptorOptions & {
-        /**
-         * If true, the remote service won't be available internally, only through the proxy.
-         */
-        noInternal: boolean;
-    }>;
-    /**
-     * For communication between the server and the remote service with a security layer.
-     * This will be used for internal communication and will not be exposed to the client.
-     */
-    serviceAccount?: ServiceAccountDescriptor;
-}
-interface RemoteDescriptor {
-    [KIND]: typeof KEY$1;
-    [OPTIONS]: RemoteDescriptorOptions;
-}
-/**
- * $remote is a descriptor that allows you to define a remote service access.
- *
- * Use it only when you have 2 or more services that need to communicate with each other.
- *
- * All remote services can be exposed as actions, ... or not.
- *
- * You can add a service account if you want to use a security layer.
- */
-declare const $remote: {
-    (options: RemoteDescriptorOptions): RemoteDescriptor;
-    [KIND]: string;
-};
-
+//#endregion
+//#region src/descriptors/$route.d.ts
 declare const KEY = "ROUTE";
-interface RouteDescriptorOptions<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRoute<TConfig> {
-}
+interface RouteDescriptorOptions<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRoute<TConfig> {}
 type RouteDescriptor<TConfig extends RequestConfigSchema = RequestConfigSchema> = {
-    [KIND]: typeof KEY;
-    [OPTIONS]: RouteDescriptorOptions<TConfig>;
+  [KIND$1]: typeof KEY;
+  [OPTIONS]: RouteDescriptorOptions<TConfig>;
 };
 declare const $route: {
-    <TConfig extends RequestConfigSchema = RequestConfigSchema>(options: RouteDescriptorOptions<TConfig>): RouteDescriptor<TConfig>;
-    [KIND]: string;
+  <TConfig extends RequestConfigSchema = RequestConfigSchema>(options: RouteDescriptorOptions<TConfig>): RouteDescriptor<TConfig>;
+  [KIND$1]: string;
 };
-
+//#endregion
+//#region src/errors/BadRequestError.d.ts
 declare class BadRequestError extends HttpError {
-    constructor(message?: string, cause?: unknown);
+  constructor(message?: string, cause?: unknown);
 }
-
+//#endregion
+//#region src/errors/ConflictError.d.ts
 declare class ConflictError extends HttpError {
-    constructor(message?: string, cause?: unknown);
+  constructor(message?: string, cause?: unknown);
 }
-
+//#endregion
+//#region src/errors/ForbiddenError.d.ts
 declare class ForbiddenError extends HttpError {
-    constructor(message?: string, cause?: unknown);
+  constructor(message?: string, cause?: unknown);
 }
-
+//#endregion
+//#region src/errors/NotFoundError.d.ts
 declare class NotFoundError extends HttpError {
-    constructor(message?: string, cause?: unknown);
+  constructor(message?: string, cause?: unknown);
 }
-
+//#endregion
+//#region src/errors/UnauthorizedError.d.ts
 declare class UnauthorizedError extends HttpError {
-    constructor(message?: string, cause?: unknown);
+  constructor(message?: string, cause?: unknown);
 }
-
+//#endregion
+//#region src/errors/ValidationError.d.ts
 declare class ValidationError extends HttpError {
-    constructor(message?: string, cause?: unknown);
-}
-
-/**
- * Register `/health` endpoint.
- *
- * - Provides basic health information about the server.
- */
-declare class ServerHealthProvider {
-    protected readonly dateTimeProvider: DateTimeProvider;
-    protected readonly alepha: Alepha;
-    readonly health: RouteDescriptor<{
-        response: TObject<{
-            message: TString$1;
-            uptime: TNumber;
-            date: TString$1;
-            ready: TBoolean;
-        }>;
-    }>;
-}
-
-declare class ProxyDescriptorProvider {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly routerProvider: ServerRouterProvider;
-    protected readonly alepha: Alepha;
-    readonly configure: _alepha_core.HookDescriptor<"configure">;
-    createProxyHandler(options: Omit<ProxyDescriptorOptions, "path">): ServerHandler;
-    proxy(options: ProxyDescriptorOptions): Promise<void>;
-    private getRawRequestBody;
+  constructor(message?: string, cause?: unknown);
 }
-
-declare class ServerProvider {
-    constructor();
-    get hostname(): string;
-}
-
-declare const envSchema$2: _alepha_core.TObject<{
-    SERVER_API_PREFIX: TString$1;
-    SERVER_SECURITY_ENABLED: TBoolean;
-}>;
-declare module "@alepha/core" {
-    interface Env extends Partial<Static$1<typeof envSchema$2>> {
-    }
-    interface State {
-        /**
-         * Real (or fake) user account, used for internal actions.
-         * If you define this, you assume that all actions are executed by this user by default.
-         * And to force a different user, you need to pass it explicitly in the options.
-         */
-        "ServerSecurityProvider.localSystemUser"?: UserAccountToken;
-    }
-}
-declare class ServerActionDescriptorProvider {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly alepha: Alepha;
-    protected readonly env: {
-        SERVER_API_PREFIX: string;
-        SERVER_SECURITY_ENABLED: boolean;
-    };
-    protected readonly client: HttpClient;
-    protected readonly serverProvider: ServerProvider;
-    protected readonly helper: ActionDescriptorHelper;
-    protected readonly routerProvider: ServerRouterProvider;
-    protected readonly actions: ServerRouteAction[];
-    getActions(): ServerRouteAction<RequestConfigSchema>[];
-    getPrefix(): string;
-    readonly configure: _alepha_core.HookDescriptor<"configure">;
-    registerAction(value: ActionDescriptor, key: string, instance: any, prefix?: string): Promise<void>;
-    /**
-     * Check a mock function for the specified route.
-     *
-     * This is mostly used for testing purposes.
-     */
-    protected createLocalFunction(action: ActionDescriptorOptions, permission: Permission): (config?: ServerRequestConfigEntry, options?: ClientRequestOptions) => Promise<any>;
-    /**
-     * Get the user account token for a local action call.
-     * It will check the options, context, and system user.
-     */
-    protected getUserFromLocalFunctionContext(options: {
-        user?: UserAccountToken | "system" | "context";
-    }, permission: Permission, isRouteSecure: boolean): UserAccountToken | undefined;
-}
-declare const isServerAction: (value: any) => value is ServerRouteAction;
-interface ServerRemote {
-    url: string;
-    name: string;
-    proxy: boolean;
-    internal: boolean;
-    links: (args: {
-        authorization?: string;
-    }) => Promise<ApiLinksResponse>;
-    schema: (args: {
-        name: string;
-        authorization?: string;
-    }) => Promise<any>;
-    serviceAccount?: ServiceAccountDescriptor$1;
-    prefix: string;
-}
-interface ServerRouteAction<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRoute<TConfig> {
-    prefix: string;
-    method: RouteMethod;
-    name: string;
-    group: string;
-    permission: Permission;
-    options: ActionDescriptorOptions;
-}
-
-declare class RemoteDescriptorProvider {
-    static path: {
-        apiLinks: string;
-    };
-    protected readonly alepha: Alepha;
-    protected readonly client: HttpClient;
-    protected readonly proxyProvider: ProxyDescriptorProvider;
-    protected readonly remotes: Array<ServerRemote>;
-    protected readonly log: _alepha_core.Logger;
-    getRemotes(): ServerRemote[];
-    readonly configure: _alepha_core.HookDescriptor<"configure">;
-    readonly start: _alepha_core.HookDescriptor<"start">;
-    registerRemote(value: RemoteDescriptor, key: string): Promise<void>;
-    protected readonly fetchLinks: _alepha_retry.RetryDescriptor<(opts: {
-        service: string;
-        url: string;
-        authorization?: string;
-    }) => Promise<{
-        prefix?: string | undefined;
-        links: {
-            method?: string | undefined;
-            group?: string | undefined;
-            requestBodyType?: string | undefined;
-            service?: string | undefined;
-            path: string;
-            name: string;
-        }[];
-    }>>;
-}
-
-declare class ServerLinksProvider {
-    protected readonly alepha: Alepha;
-    protected readonly client: HttpClient;
-    protected readonly remoteProvider: RemoteDescriptorProvider;
-    protected readonly serverActionDescriptorProvider: ServerActionDescriptorProvider;
-    readonly links: RouteDescriptor<{
-        response: TObject<{
-            prefix: TOptional<TString$1>;
-            links: TArray<TObject<{
-                name: TString$1;
-                path: TString$1;
-                method: TOptional<TString$1>;
-                group: TOptional<TString$1>;
-                requestBodyType: TOptional<TString$1>;
-                service: TOptional<TString$1>;
-            }>>;
-        }>;
-    }>;
-    readonly schema: RouteDescriptor<{
-        params: TObject<{
-            name: TString$1;
-        }>;
-        response: TRecord<TString$1, TAny>;
-    }>;
-    getLinks(options: {
-        user?: UserAccountToken;
-        authorization?: string;
-    }): Promise<ApiLinksResponse>;
-}
-
+//#endregion
+//#region src/providers/features/ServerLoggerProvider.d.ts
 declare class ServerLoggerProvider {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly alepha: Alepha;
-    readonly onRequest: _alepha_core.HookDescriptor<"server:onRequest">;
-    readonly onError: _alepha_core.HookDescriptor<"server:onError">;
-    readonly onResponse: _alepha_core.HookDescriptor<"server:onResponse">;
-}
-
+  protected readonly log: _alepha_core3.Logger;
+  protected readonly alepha: Alepha;
+  readonly onRequest: _alepha_core3.HookDescriptor<"server:onRequest">;
+  readonly onError: _alepha_core3.HookDescriptor<"server:onError">;
+  readonly onResponse: _alepha_core3.HookDescriptor<"server:onResponse">;
+}
+//#endregion
+//#region src/providers/features/ServerMultipartProvider.d.ts
 declare class ServerMultipartProvider {
-    protected readonly helper: ActionDescriptorHelper;
-    protected readonly alepha: Alepha;
-    readonly onRequest: _alepha_core.HookDescriptor<"server:onRequest">;
-    readonly onSend: _alepha_core.HookDescriptor<"server:onResponse">;
-    handleMultipartBodyFromNode(route: ServerRoute, stream: IncomingMessage): Promise<{
-        body: Record<string, any>;
-        cleanup: () => Promise<void>;
-    }>;
-    parseMultipart(req: IncomingMessage, config?: Omit<BusboyConfig, "headers">): Promise<MultipartResult>;
+  protected readonly helper: ActionDescriptorHelper;
+  protected readonly alepha: Alepha;
+  readonly onRequest: _alepha_core7.HookDescriptor<"server:onRequest">;
+  readonly onSend: _alepha_core7.HookDescriptor<"server:onResponse">;
+  handleMultipartBodyFromNode(route: ServerRoute, stream: IncomingMessage): Promise<{
+    body: Record<string, any>;
+    cleanup: () => Promise<void>;
+  }>;
+  parseMultipart(req: IncomingMessage, config?: Omit<BusboyConfig, "headers">): Promise<MultipartResult>;
 }
 interface MultipartResult {
-    fields: Record<string, string | string[]>;
-    files: Record<string, HybridFile>;
+  fields: Record<string, string | string[]>;
+  files: Record<string, HybridFile>;
 }
 interface HybridFile extends FileLike {
-    cleanup(): Promise<void>;
-    _state: {
-        cleanup: boolean;
-        size: number;
-        tmpPath: string;
-    };
-}
-
+  cleanup(): Promise<void>;
+  _state: {
+    cleanup: boolean;
+    size: number;
+    tmpPath: string;
+  };
+}
+//#endregion
+//#region src/providers/features/ServerNotReadyProvider.d.ts
 /**
  * On every request, this provider checks if the server is ready.
  *
@@ -1045,134 +436,258 @@ interface HybridFile extends FileLike {
  * 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: _alepha_core.HookDescriptor<"server:onRequest">;
+  protected readonly alepha: Alepha;
+  readonly onRequest: _alepha_core9.HookDescriptor<"server:onRequest">;
 }
-
+//#endregion
+//#region src/providers/features/ServerSecurityProvider.d.ts
 declare class ServerSecurityProvider {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly securityProvider: SecurityProvider;
-    protected readonly jwtProvider: JwtProvider;
-    protected readonly alepha: Alepha;
-    readonly onClientRequest: _alepha_core.HookDescriptor<"client:onRequest">;
-    protected readonly onRequest: _alepha_core.HookDescriptor<"server:onRequest">;
-    protected readonly onRoute: _alepha_core.HookDescriptor<"server:onRoute">;
-}
-
+  protected readonly log: _alepha_core71.Logger;
+  protected readonly securityProvider: SecurityProvider;
+  protected readonly jwtProvider: JwtProvider;
+  protected readonly alepha: Alepha;
+  readonly onClientRequest: _alepha_core71.HookDescriptor<"client:onRequest">;
+  protected readonly onRequest: _alepha_core71.HookDescriptor<"server:onRequest">;
+  protected readonly onRoute: _alepha_core71.HookDescriptor<"server:onRoute">;
+}
+//#endregion
+//#region src/providers/features/ServerTimingProvider.d.ts
 type TimingMap = Record<string, [number, number]>;
 declare class ServerTimingProvider {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly alepha: Alepha;
-    readonly onRequest: _alepha_core.HookDescriptor<"server:onRequest">;
-    readonly onResponse: _alepha_core.HookDescriptor<"server:onResponse">;
-    protected get handlerName(): string;
-    beginTiming(name: string): void;
-    endTiming(name: string): void;
-    protected setDuration(name: string, timing: TimingMap): void;
+  protected readonly log: _alepha_core10.Logger;
+  protected readonly alepha: Alepha;
+  readonly onRequest: _alepha_core10.HookDescriptor<"server:onRequest">;
+  readonly onResponse: _alepha_core10.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/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<ServerRouteWithHandler> {
+  protected readonly alepha: Alepha;
+  route<TConfig extends RequestConfigSchema = RequestConfigSchema>(route: ServerRoute<TConfig>): Promise<void>;
+  onRequest(route: ServerRoute, rawRequest: ServerRawRequest, responseKind: ResponseKind): Promise<ServerResponse>;
+  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>;
+  protected getResponseType(schema?: RequestConfigSchema): ResponseKind;
+  protected errorHandler(route: ServerRoute, request: ServerRequest, error: Error): Promise<void>;
+  validateRequest(route: {
+    schema?: RequestConfigSchema;
+  }, request: ServerRequestConfig): void;
+  serializeResponse(route: ServerRoute, reply: ServerReply, responseKind: ResponseKind): void;
 }
-
-declare const envSchema$1: _alepha_core.TObject<{
-    SERVER_PORT: TNumber;
-    SERVER_HOST: TString$1;
+//#endregion
+//#region src/providers/platforms/ServerProvider.d.ts
+declare class ServerProvider {
+  constructor();
+  get hostname(): string;
+}
+//#endregion
+//#region src/providers/platforms/NodeHttpServerProvider.d.ts
+declare const envSchema$1: _alepha_core15.TObject<{
+  SERVER_PORT: _sinclair_typebox13.TNumber;
+  SERVER_HOST: _sinclair_typebox13.TString;
 }>;
-declare module "@alepha/core" {
-    interface Env extends Partial<Static$1<typeof envSchema$1>> {
-    }
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema$1>> {}
 }
 declare class NodeHttpServerProvider implements ServerProvider {
-    protected readonly alepha: Alepha;
-    protected readonly log: _alepha_core.Logger;
-    protected readonly env: {
-        SERVER_PORT: number;
-        SERVER_HOST: string;
-    };
-    protected readonly router: ServerRouterProvider;
-    protected readonly server: http.Server<typeof IncomingMessage, typeof ServerResponse$1>;
-    handle(req: IncomingMessage, res: ServerResponse$1): Promise<number | void>;
-    createRouterRequest(req: IncomingMessage, res: ServerResponse$1, params?: Record<string, string>): ServerRawRequest;
-    getProtocol(req: IncomingMessage): "http" | "https";
-    shouldHaveBody(method: string): boolean;
-    get hostname(): string;
-    readonly start: _alepha_core.HookDescriptor<"start">;
-    protected readonly stop: _alepha_core.HookDescriptor<"stop">;
-    protected listen(): Promise<void>;
-    protected close(): Promise<void>;
-}
-
-declare const errorSchema: TObject<{
-    error: TString$1;
-    status: TNumber;
-    message: TString$1;
-    details: TOptional<TString$1>;
-    cause: TOptional<TObject<{
-        name: TString$1;
-        message: TString$1;
-    }>>;
+  protected readonly alepha: Alepha;
+  protected readonly log: _alepha_core15.Logger;
+  protected readonly env: {
+    SERVER_PORT: number;
+    SERVER_HOST: string;
+  };
+  protected readonly router: ServerRouterProvider;
+  protected readonly server: http18.Server<typeof IncomingMessage, typeof ServerResponse$1>;
+  handle(req: IncomingMessage, res: ServerResponse$1): Promise<number | void>;
+  createRouterRequest(req: IncomingMessage, res: ServerResponse$1, params?: Record<string, string>): ServerRawRequest;
+  getProtocol(req: IncomingMessage): "http" | "https";
+  shouldHaveBody(method: string): boolean;
+  get hostname(): string;
+  readonly start: _alepha_core15.HookDescriptor<"start">;
+  protected readonly stop: _alepha_core15.HookDescriptor<"stop">;
+  protected listen(): Promise<void>;
+  protected close(): Promise<void>;
+}
+//#endregion
+//#region src/schemas/apiLinksResponseSchema.d.ts
+declare const apiLinkSchema: _sinclair_typebox37.TObject<{
+  name: _sinclair_typebox37.TString;
+  path: _sinclair_typebox37.TString;
+  method: _sinclair_typebox37.TOptional<_sinclair_typebox37.TString>;
+  group: _sinclair_typebox37.TOptional<_sinclair_typebox37.TString>;
+  requestBodyType: _sinclair_typebox37.TOptional<_sinclair_typebox37.TString>;
+  service: _sinclair_typebox37.TOptional<_sinclair_typebox37.TString>;
 }>;
-
-declare const okSchema: TObject<{
-    ok: TBoolean;
-    id: TOptional<TUnion<[TString$1, TInteger]>>;
-    count: TOptional<TNumber>;
+declare const apiLinksResponseSchema: _sinclair_typebox37.TObject<{
+  prefix: _sinclair_typebox37.TOptional<_sinclair_typebox37.TString>;
+  links: _sinclair_typebox37.TArray<_sinclair_typebox37.TObject<{
+    name: _sinclair_typebox37.TString;
+    path: _sinclair_typebox37.TString;
+    method: _sinclair_typebox37.TOptional<_sinclair_typebox37.TString>;
+    group: _sinclair_typebox37.TOptional<_sinclair_typebox37.TString>;
+    requestBodyType: _sinclair_typebox37.TOptional<_sinclair_typebox37.TString>;
+    service: _sinclair_typebox37.TOptional<_sinclair_typebox37.TString>;
+  }>>;
 }>;
-type Ok = Static$1<typeof okSchema>;
-
-declare const envSchema: _alepha_core.TObject<{
-    SERVER_LINKS_ENABLED: TBoolean;
-    SERVER_HEALTH_ENABLED: TBoolean;
+type ApiLinksResponse = Static<typeof apiLinksResponseSchema>;
+type ApiLink = Static<typeof apiLinkSchema>;
+//#endregion
+//#region src/providers/ServerActionDescriptorProvider.d.ts
+declare const envSchema: _alepha_core23.TObject<{
+  SERVER_API_PREFIX: _sinclair_typebox21.TString;
+  SERVER_SECURITY_ENABLED: _sinclair_typebox21.TBoolean;
 }>;
-declare module "@alepha/core" {
-    interface Hooks {
-        "server:onRoute": {
-            route: ServerRoute;
-        };
-        "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: HttpClientLink;
-            config: ServerRequestConfigEntry;
-            options: ClientRequestOptions;
-            headers: Record<string, string>;
-            request: RequestInit;
-        };
-        "client:beforeFetch": {
-            url: string;
-            options: FetchRunOptions;
-            request: RequestInit;
-        };
-        "client:onError": {
-            route?: HttpClientLink;
-            error: HttpError;
-        };
-    }
+declare module "alepha/core" {
+  interface Env extends Partial<Static<typeof envSchema>> {}
+  interface State {
+    /**
+     * Real (or fake) user account, used for internal actions.
+     * If you define this, you assume that all actions are executed by this user by default.
+     * And to force a different user, you need to pass it explicitly in the options.
+     */
+    "ServerSecurityProvider.localSystemUser"?: UserAccountToken;
+  }
+}
+declare class ServerActionDescriptorProvider {
+  protected readonly log: _alepha_core23.Logger;
+  protected readonly alepha: Alepha;
+  protected readonly env: {
+    SERVER_API_PREFIX: string;
+    SERVER_SECURITY_ENABLED: boolean;
+  };
+  protected readonly client: HttpClient;
+  protected readonly serverProvider: ServerProvider;
+  protected readonly helper: ActionDescriptorHelper;
+  protected readonly routerProvider: ServerRouterProvider;
+  protected readonly actions: ServerRouteAction[];
+  getActions(): ServerRouteAction<RequestConfigSchema>[];
+  getPrefix(): string;
+  readonly configure: _alepha_core23.HookDescriptor<"configure">;
+  registerAction(value: ActionDescriptor, key: string, instance: any, prefix?: string): Promise<void>;
+  /**
+   * Check a mock function for the specified route.
+   *
+   * This is mostly used for testing purposes.
+   */
+  protected createLocalHandler(action: ActionDescriptorOptions, permission: Permission): (config?: ServerRequestConfigEntry, options?: ClientRequestOptions) => Promise<any>;
+  /**
+   * Get the user account token for a local action call.
+   * It will check the options, context, and system user.
+   */
+  protected getUserFromLocalFunctionContext(options: {
+    user?: UserAccountToken | "system" | "context";
+  }, permission: Permission, isRouteSecure: boolean): UserAccountToken | undefined;
+}
+declare const isServerAction: (value: any) => value is ServerRouteAction;
+interface ServerRemote {
+  url: string;
+  name: string;
+  proxy: boolean;
+  internal: boolean;
+  links: (args: {
+    authorization?: string;
+  }) => Promise<ApiLinksResponse>;
+  schema: (args: {
+    name: string;
+    authorization?: string;
+  }) => Promise<any>;
+  serviceAccount?: ServiceAccountDescriptor;
+  prefix: string;
 }
+interface ServerRouteAction<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRoute<TConfig> {
+  prefix: string;
+  method: RouteMethod;
+  name: string;
+  group: string;
+  permission: Permission;
+  options: ActionDescriptorOptions;
+  localHandler: LocalHandler;
+}
+type LocalHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (config?: ServerRequestConfigEntry<TConfig>, options?: ClientRequestOptions) => Promise<any>;
+//#endregion
+//#region src/schemas/errorSchema.d.ts
+declare const errorSchema: _sinclair_typebox27.TObject<{
+  error: _sinclair_typebox27.TString;
+  status: _sinclair_typebox27.TNumber;
+  message: _sinclair_typebox27.TString;
+  details: _sinclair_typebox27.TOptional<_sinclair_typebox27.TString>;
+  cause: _sinclair_typebox27.TOptional<_sinclair_typebox27.TObject<{
+    name: _sinclair_typebox27.TString;
+    message: _sinclair_typebox27.TString;
+  }>>;
+}>;
+//#endregion
+//#region src/schemas/okSchema.d.ts
+declare const okSchema: _sinclair_typebox63.TObject<{
+  ok: _sinclair_typebox63.TBoolean;
+  id: _sinclair_typebox63.TOptional<_sinclair_typebox63.TUnion<[_sinclair_typebox63.TString, _sinclair_typebox63.TInteger]>>;
+  count: _sinclair_typebox63.TOptional<_sinclair_typebox63.TNumber>;
+}>;
+type Ok = Static<typeof okSchema>;
+//#endregion
+//#region src/index.d.ts
 declare module "@alepha/core" {
-    interface Env extends Partial<Static$1<typeof envSchema>> {
-    }
+  interface Hooks {
+    "server:onRoute": {
+      route: ServerRoute;
+    };
+    "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;
+    };
+  }
 }
 declare class AlephaServer implements Module {
-    protected readonly env: {
-        SERVER_LINKS_ENABLED: boolean;
-        SERVER_HEALTH_ENABLED: boolean;
-    };
-    readonly name = "alepha.server";
-    readonly $services: (alepha: Alepha) => void;
+  readonly name = "alepha.server";
+  readonly $services: (alepha: Alepha) => void;
 }
-
-export { $action, $client, $proxy, $remote, $route, type ActionDescriptor, type ActionDescriptorOptions, AlephaServer, type ApiLink, type ApiLinksResponse, BadRequestError, type ClientRequestEntry, type ClientRequestEntryContainer, type ClientRequestOptions, type ClientRequestResponse, type ClientScope, ConflictError, type FetchFactoryAdditionalOptions, type FetchLinkArgs, type FetchResponse, type FetchRunOptions, ForbiddenError, HttpClient, type HttpClientLink, type HttpClientPendingRequests, HttpError, type HttpErrorLike, type HttpVirtualClient, NodeHttpServerProvider, NotFoundError, type Ok, type ProxyDescriptor, type ProxyDescriptorOptions, ProxyDescriptorProvider, type RemoteDescriptor, type RemoteDescriptorOptions, RemoteDescriptorProvider, type RequestConfigSchema, type ResponseBodyType, type ResponseType, type RouteDescriptor, type RouteDescriptorOptions, type RouteMethod, ServerActionDescriptorProvider, type ServerHandler, ServerHealthProvider, ServerLinksProvider, ServerLoggerProvider, type ServerMiddlewareHandler, ServerMultipartProvider, ServerNotReadyProvider, ServerProvider, type ServerRawRequest, type ServerRemote, type ServerReply, type ServerRequest, type ServerRequestConfig, type ServerRequestConfigEntry, type ServerResponse, type ServerResponseBody, type ServerRoute, type ServerRouteAction, type ServerRouteSecure, type ServerRouteWithHandler, ServerRouterProvider, ServerSecurityProvider, ServerTimingProvider, UnauthorizedError, ValidationError, apiLinkSchema, apiLinksResponseSchema, errorNameByStatus, errorSchema, isHttpError, isServerAction, okSchema, routeMethods };
+//#endregion
+export { $action, $route, ActionDescriptor, ActionDescriptorHelper, ActionDescriptorOptions, AlephaServer, ApiLink, ApiLinksResponse, BadRequestError, ClientRequestEntry, ClientRequestEntryContainer, ClientRequestOptions, ClientRequestResponse, ConflictError, FetchActionArgs, FetchOptions, FetchResponse, ForbiddenError, HttpAction, HttpClient, HttpClientPendingRequests, HttpError, HttpErrorLike, KIND, LocalHandler, NodeHttpServerProvider, NotFoundError, Ok, RequestConfigSchema, ResponseBodyType, ResponseKind, RouteDescriptor, RouteDescriptorOptions, RouteMethod, ServerActionDescriptorProvider, ServerHandler, ServerLoggerProvider, ServerMiddlewareHandler, ServerMultipartProvider, ServerNotReadyProvider, ServerProvider, ServerRawRequest, ServerRemote, ServerReply, ServerRequest, ServerRequestConfig, ServerRequestConfigEntry, ServerResponse, ServerResponseBody, ServerRoute, ServerRouteAction, ServerRouteSecure, ServerRouteWithHandler, ServerRouterProvider, ServerSecurityProvider, ServerTimingProvider, UnauthorizedError, ValidationError, apiLinkSchema, apiLinksResponseSchema, errorNameByStatus, errorSchema, isHttpError, isServerAction, okSchema, routeMethods };
+//# sourceMappingURL=index.d.ts.map