alepha 0.7.4 → 0.7.6

package/server.d.ts

@@ -1,795 +1,476 @@
-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_core5 from "@alepha/core";
+import * as _alepha_core57 from "@alepha/core";
+import * as _alepha_core61 from "@alepha/core";
+import * as _alepha_core109 from "@alepha/core";
+import * as _alepha_core43 from "@alepha/core";
+import * as _alepha_core47 from "@alepha/core";
+import * as _alepha_core49 from "@alepha/core";
+import * as _alepha_core50 from "@alepha/core";
+import * as _alepha_core54 from "@alepha/core";
+import * as _alepha_core103 from "@alepha/core";
+import * as _alepha_core3 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 { DateTimeProvider, DurationLike } from "@alepha/datetime";
+import * as _alepha_cache6 from "@alepha/cache";
+import * as _alepha_retry112 from "@alepha/retry";
+import { Readable } from "node:stream";
+import { ReadableStream } from "node:stream/web";
+import { Route, RouterProvider } from "@alepha/router";
+import { BusboyConfig } from "@fastify/busboy";
+import { IncomingMessage, ServerResponse as ServerResponse$1 } from "node:http";
+import * as _sinclair_typebox65 from "@sinclair/typebox";
+import * as _sinclair_typebox15 from "@sinclair/typebox";
+import * as _sinclair_typebox59 from "@sinclair/typebox";
+import * as _sinclair_typebox21 from "@sinclair/typebox";
+import * as _sinclair_typebox101 from "@sinclair/typebox";
+import * as _sinclair_typebox91 from "@sinclair/typebox";
+import * as _sinclair_typebox7 from "@sinclair/typebox";
+import * as _sinclair_typebox1 from "@sinclair/typebox";
+import * as http106 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/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;
+  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>;
+  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;
+}
+//#endregion
+//#region src/schemas/apiLinksResponseSchema.d.ts
+declare const apiLinkSchema: _sinclair_typebox65.TObject<{
+  name: _sinclair_typebox65.TString;
+  path: _sinclair_typebox65.TString;
+  method: _sinclair_typebox65.TOptional<_sinclair_typebox65.TString>;
+  group: _sinclair_typebox65.TOptional<_sinclair_typebox65.TString>;
+  requestBodyType: _sinclair_typebox65.TOptional<_sinclair_typebox65.TString>;
+  service: _sinclair_typebox65.TOptional<_sinclair_typebox65.TString>;
 }>;
-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>;
-    }>>;
+declare const apiLinksResponseSchema: _sinclair_typebox65.TObject<{
+  prefix: _sinclair_typebox65.TOptional<_sinclair_typebox65.TString>;
+  links: _sinclair_typebox65.TArray<_sinclair_typebox65.TObject<{
+    name: _sinclair_typebox65.TString;
+    path: _sinclair_typebox65.TString;
+    method: _sinclair_typebox65.TOptional<_sinclair_typebox65.TString>;
+    group: _sinclair_typebox65.TOptional<_sinclair_typebox65.TString>;
+    requestBodyType: _sinclair_typebox65.TOptional<_sinclair_typebox65.TString>;
+    service: _sinclair_typebox65.TOptional<_sinclair_typebox65.TString>;
+  }>>;
 }>;
-type ApiLinksResponse = Static$1<typeof apiLinksResponseSchema>;
-type ApiLink = Static$1<typeof apiLinkSchema>;
-
+type ApiLinksResponse = Static<typeof apiLinksResponseSchema>;
+type ApiLink = Static<typeof apiLinkSchema>;
+//#endregion
+//#region src/services/HttpClient.d.ts
 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[]>;
+  protected readonly log: _alepha_core5.Logger;
+  protected readonly alepha: Alepha;
+  protected readonly helper: ActionDescriptorHelper;
+  readonly cache: _alepha_cache6.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;
+    };
+  }, 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);
+  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;
+  /**
+   * 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 HttpClientLink extends ApiLink {
-    secured?: boolean;
-    prefix?: string;
-    host?: string;
-    service?: string;
-    schema?: RequestConfigSchema;
-    handler?: ServerHandler;
+  secured?: boolean;
+  prefix?: string;
+  host?: string;
+  service?: string;
+  schema?: RequestConfigSchema;
+  handler?: ServerHandler;
 }
 interface ClientScope {
-    group?: string;
-    service?: string;
+  group?: string;
+  service?: string;
 }
-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;
-};
+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;
+  data: any;
+  etag?: string;
 }
 interface FetchResponse<T = any> {
-    data: T;
-    status: number;
-    statusText: string;
-    headers: Headers;
-    raw?: Response;
+  data: T;
+  status: number;
+  statusText: string;
+  headers: Headers;
+  raw?: Response;
 }
 interface FetchLinkArgs {
-    link: HttpClientLink;
-    host?: string;
-    config?: ServerRequestConfigEntry;
-    options?: ClientRequestOptions;
+  link: HttpClientLink;
+  host?: string;
+  config?: ServerRequestConfigEntry;
+  options?: ClientRequestOptions;
 }
-
+//#endregion
+//#region src/descriptors/$action.d.ts
 declare const KEY$2 = "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$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;
 }
 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;
-
+  /**
+   * 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;
+  status: number;
 }
-
+//#endregion
+//#region src/descriptors/$client.d.ts
 declare const $client: <T extends object>(scope?: ClientScope) => HttpVirtualClient<T>;
-
+//#endregion
+//#region src/descriptors/$proxy.d.ts
 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;
+  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;
+  [KIND$1]: "PROXY";
+  [OPTIONS]: ProxyDescriptorOptions;
 }
 declare const $proxy: {
-    (options: ProxyDescriptorOptions): ProxyDescriptor;
-    [KIND]: string;
+  (options: ProxyDescriptorOptions): ProxyDescriptor;
+  [KIND$1]: 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;
-        };
-    }
-}
-
+//#endregion
+//#region src/descriptors/$remote.d.ts
 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;
+  /**
+   * 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;
+  [KIND$1]: typeof KEY$1;
+  [OPTIONS]: RemoteDescriptorOptions;
 }
 /**
  * $remote is a descriptor that allows you to define a remote service access.
@@ -801,242 +482,285 @@ interface RemoteDescriptor {
  * You can add a service account if you want to use a security layer.
  */
 declare const $remote: {
-    (options: RemoteDescriptorOptions): RemoteDescriptor;
-    [KIND]: string;
+  (options: RemoteDescriptorOptions): RemoteDescriptor;
+  [KIND$1]: 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);
+  constructor(message?: string, cause?: unknown);
 }
-
+//#endregion
+//#region src/providers/features/ServerHealthProvider.d.ts
 /**
  * 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;
-        }>;
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly alepha: Alepha;
+  readonly health: RouteDescriptor<{
+    response: _sinclair_typebox15.TObject<{
+      message: _sinclair_typebox15.TString;
+      uptime: _sinclair_typebox15.TNumber;
+      date: _sinclair_typebox15.TString;
+      ready: _sinclair_typebox15.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;
+//#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;
+  createRequestId(): string;
+  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;
 }
-
+//#endregion
+//#region src/providers/ProxyDescriptorProvider.d.ts
+declare class ProxyDescriptorProvider {
+  protected readonly log: _alepha_core57.Logger;
+  protected readonly routerProvider: ServerRouterProvider;
+  protected readonly alepha: Alepha;
+  readonly configure: _alepha_core57.HookDescriptor<"configure">;
+  createProxyHandler(options: Omit<ProxyDescriptorOptions, "path">): ServerHandler;
+  proxy(options: ProxyDescriptorOptions): Promise<void>;
+  private getRawRequestBody;
+}
+//#endregion
+//#region src/providers/platforms/ServerProvider.d.ts
 declare class ServerProvider {
-    constructor();
-    get hostname(): string;
-}
-
-declare const envSchema$2: _alepha_core.TObject<{
-    SERVER_API_PREFIX: TString$1;
-    SERVER_SECURITY_ENABLED: TBoolean;
+  constructor();
+  get hostname(): string;
+}
+//#endregion
+//#region src/providers/ServerActionDescriptorProvider.d.ts
+declare const envSchema$2: _alepha_core61.TObject<{
+  SERVER_API_PREFIX: _sinclair_typebox59.TString;
+  SERVER_SECURITY_ENABLED: _sinclair_typebox59.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>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema$2>> {}
+  interface State {
     /**
-     * Get the user account token for a local action call.
-     * It will check the options, context, and system user.
+     * 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.
      */
-    protected getUserFromLocalFunctionContext(options: {
-        user?: UserAccountToken | "system" | "context";
-    }, permission: Permission, isRouteSecure: boolean): UserAccountToken | undefined;
+    "ServerSecurityProvider.localSystemUser"?: UserAccountToken;
+  }
+}
+declare class ServerActionDescriptorProvider {
+  protected readonly log: _alepha_core61.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_core61.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;
+  url: string;
+  name: string;
+  proxy: boolean;
+  internal: boolean;
+  links: (args: {
+    authorization?: string;
+  }) => Promise<ApiLinksResponse>;
+  schema: (args: {
     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;
+    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;
-}
-
+  prefix: string;
+  method: RouteMethod;
+  name: string;
+  group: string;
+  permission: Permission;
+  options: ActionDescriptorOptions;
+}
+//#endregion
+//#region src/providers/RemoteDescriptorProvider.d.ts
 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;
-        }[];
-    }>>;
-}
-
+  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_core109.Logger;
+  getRemotes(): ServerRemote[];
+  readonly configure: _alepha_core109.HookDescriptor<"configure">;
+  readonly start: _alepha_core109.HookDescriptor<"start">;
+  registerRemote(value: RemoteDescriptor, key: string): Promise<void>;
+  protected readonly fetchLinks: _alepha_retry112.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;
+      name: string;
+      path: string;
+    }[];
+  }>>;
+}
+//#endregion
+//#region src/providers/features/ServerLinksProvider.d.ts
 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>;
-            }>>;
-        }>;
+  protected readonly alepha: Alepha;
+  protected readonly client: HttpClient;
+  protected readonly remoteProvider: RemoteDescriptorProvider;
+  protected readonly serverActionDescriptorProvider: ServerActionDescriptorProvider;
+  readonly links: RouteDescriptor<{
+    response: _sinclair_typebox21.TObject<{
+      prefix: _sinclair_typebox21.TOptional<_sinclair_typebox21.TString>;
+      links: _sinclair_typebox21.TArray<_sinclair_typebox21.TObject<{
+        name: _sinclair_typebox21.TString;
+        path: _sinclair_typebox21.TString;
+        method: _sinclair_typebox21.TOptional<_sinclair_typebox21.TString>;
+        group: _sinclair_typebox21.TOptional<_sinclair_typebox21.TString>;
+        requestBodyType: _sinclair_typebox21.TOptional<_sinclair_typebox21.TString>;
+        service: _sinclair_typebox21.TOptional<_sinclair_typebox21.TString>;
+      }>>;
     }>;
-    readonly schema: RouteDescriptor<{
-        params: TObject<{
-            name: TString$1;
-        }>;
-        response: TRecord<TString$1, TAny>;
+  }>;
+  readonly schema: RouteDescriptor<{
+    params: _sinclair_typebox21.TObject<{
+      name: _sinclair_typebox21.TString;
     }>;
-    getLinks(options: {
-        user?: UserAccountToken;
-        authorization?: string;
-    }): Promise<ApiLinksResponse>;
-}
-
+    response: _sinclair_typebox21.TRecord<_sinclair_typebox21.TString, _sinclair_typebox21.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_core43.Logger;
+  protected readonly alepha: Alepha;
+  readonly onRequest: _alepha_core43.HookDescriptor<"server:onRequest">;
+  readonly onError: _alepha_core43.HookDescriptor<"server:onError">;
+  readonly onResponse: _alepha_core43.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_core47.HookDescriptor<"server:onRequest">;
+  readonly onSend: _alepha_core47.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 +769,139 @@ 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_core49.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_core50.Logger;
+  protected readonly securityProvider: SecurityProvider;
+  protected readonly jwtProvider: JwtProvider;
+  protected readonly alepha: Alepha;
+  readonly onClientRequest: _alepha_core50.HookDescriptor<"client:onRequest">;
+  protected readonly onRequest: _alepha_core50.HookDescriptor<"server:onRequest">;
+  protected readonly onRoute: _alepha_core50.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;
-}
-
-declare const envSchema$1: _alepha_core.TObject<{
-    SERVER_PORT: TNumber;
-    SERVER_HOST: TString$1;
+  protected readonly log: _alepha_core54.Logger;
+  protected readonly alepha: Alepha;
+  readonly onRequest: _alepha_core54.HookDescriptor<"server:onRequest">;
+  readonly onResponse: _alepha_core54.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/platforms/NodeHttpServerProvider.d.ts
+declare const envSchema$1: _alepha_core103.TObject<{
+  SERVER_PORT: _sinclair_typebox101.TNumber;
+  SERVER_HOST: _sinclair_typebox101.TString;
 }>;
-declare module "@alepha/core" {
-    interface Env extends Partial<Static$1<typeof envSchema$1>> {
-    }
+declare module "alepha/core" {
+  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_core103.Logger;
+  protected readonly env: {
+    SERVER_PORT: number;
+    SERVER_HOST: string;
+  };
+  protected readonly router: ServerRouterProvider;
+  protected readonly server: http106.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_core103.HookDescriptor<"start">;
+  protected readonly stop: _alepha_core103.HookDescriptor<"stop">;
+  protected listen(): Promise<void>;
+  protected close(): Promise<void>;
+}
+//#endregion
+//#region src/schemas/errorSchema.d.ts
+declare const errorSchema: _sinclair_typebox91.TObject<{
+  error: _sinclair_typebox91.TString;
+  status: _sinclair_typebox91.TNumber;
+  message: _sinclair_typebox91.TString;
+  details: _sinclair_typebox91.TOptional<_sinclair_typebox91.TString>;
+  cause: _sinclair_typebox91.TOptional<_sinclair_typebox91.TObject<{
+    name: _sinclair_typebox91.TString;
+    message: _sinclair_typebox91.TString;
+  }>>;
 }>;
-
-declare const okSchema: TObject<{
-    ok: TBoolean;
-    id: TOptional<TUnion<[TString$1, TInteger]>>;
-    count: TOptional<TNumber>;
-}>;
-type Ok = Static$1<typeof okSchema>;
-
-declare const envSchema: _alepha_core.TObject<{
-    SERVER_LINKS_ENABLED: TBoolean;
-    SERVER_HEALTH_ENABLED: TBoolean;
+//#endregion
+//#region src/schemas/okSchema.d.ts
+declare const okSchema: _sinclair_typebox7.TObject<{
+  ok: _sinclair_typebox7.TBoolean;
+  id: _sinclair_typebox7.TOptional<_sinclair_typebox7.TUnion<[_sinclair_typebox7.TString, _sinclair_typebox7.TInteger]>>;
+  count: _sinclair_typebox7.TOptional<_sinclair_typebox7.TNumber>;
 }>;
+type Ok = Static<typeof okSchema>;
+//#endregion
+//#region src/index.d.ts
 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;
-        };
-    }
+  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 const envSchema: _alepha_core3.TObject<{
+  SERVER_LINKS_ENABLED: _sinclair_typebox1.TBoolean;
+  SERVER_HEALTH_ENABLED: _sinclair_typebox1.TBoolean;
+}>;
 declare module "@alepha/core" {
-    interface Env extends Partial<Static$1<typeof envSchema>> {
-    }
+  interface Env extends Partial<Static<typeof envSchema>> {}
 }
 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;
-}
-
-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 };
+  protected readonly env: {
+    SERVER_LINKS_ENABLED: boolean;
+    SERVER_HEALTH_ENABLED: boolean;
+  };
+  readonly name = "alepha.server";
+  readonly $services: (alepha: Alepha) => void;
+}
+//#endregion
+export { $action, $client, $proxy, $remote, $route, ActionDescriptor, ActionDescriptorOptions, AlephaServer, ApiLink, ApiLinksResponse, BadRequestError, ClientRequestEntry, ClientRequestEntryContainer, ClientRequestOptions, ClientRequestResponse, ClientScope, ConflictError, FetchFactoryAdditionalOptions, FetchLinkArgs, FetchResponse, FetchRunOptions, ForbiddenError, HttpClient, HttpClientLink, HttpClientPendingRequests, HttpError, HttpErrorLike, HttpVirtualClient, KIND, NodeHttpServerProvider, NotFoundError, Ok, ProxyDescriptor, ProxyDescriptorOptions, ProxyDescriptorProvider, RemoteDescriptor, RemoteDescriptorOptions, RemoteDescriptorProvider, RequestConfigSchema, ResponseBodyType, ResponseKind, RouteDescriptor, RouteDescriptorOptions, RouteMethod, ServerActionDescriptorProvider, ServerHandler, ServerHealthProvider, ServerLinksProvider, 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