alepha 0.6.7 → 0.6.9

package/server.d.ts

@@ -1 +1,879 @@
-export * from '@alepha/server';
+import * as _alepha_core from '@alepha/core';
+import { Static as Static$1, TObject as TObject$1, TSchema as TSchema$1, Async, StreamLike, Alepha, OPTIONS, KIND, FileLike } from '@alepha/core';
+export { KIND } from '@alepha/core';
+import { UserAccountToken, Permission, 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 } from '@alepha/datetime';
+import { BusboyConfig } from '@fastify/busboy';
+import * as http from 'http';
+
+/** 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 TReadonly<T extends TSchema> = T & {
+    [ReadonlyKind]: 'Readonly';
+};
+
+type UnionStatic<T extends TSchema[], P extends unknown[]> = {
+    [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
+}[number];
+interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
+    [Kind]: 'Union';
+    static: UnionStatic<T, this['params']>;
+    anyOf: T;
+}
+
+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 TBoolean extends TSchema {
+    [Kind]: 'Boolean';
+    static: boolean;
+    type: 'boolean';
+}
+
+interface NumberOptions extends SchemaOptions {
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    maximum?: number;
+    minimum?: number;
+    multipleOf?: number;
+}
+interface TNumber extends TSchema, NumberOptions {
+    [Kind]: 'Number';
+    static: number;
+    type: 'number';
+}
+
+interface IntegerOptions extends SchemaOptions {
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    maximum?: number;
+    minimum?: number;
+    multipleOf?: number;
+}
+interface TInteger extends TSchema, IntegerOptions {
+    [Kind]: 'Integer';
+    static: number;
+    type: 'integer';
+}
+
+type TOptional<T extends TSchema> = T & {
+    [OptionalKind]: 'Optional';
+};
+
+/** Creates a static type from a TypeBox type */
+type Static<Type extends TSchema, Params extends unknown[] = [], Result = (Type & {
+    params: Params;
+})['static']> = Result;
+
+type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TReadonly<TSchema> ? (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> ? (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> ? (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>;
+type TAdditionalProperties = undefined | TSchema | boolean;
+interface ObjectOptions extends SchemaOptions {
+    /** 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, ObjectOptions {
+    [Kind]: 'Object';
+    static: ObjectStatic<T, this['params']>;
+    additionalProperties?: TAdditionalProperties;
+    type: 'object';
+    properties: T;
+    required?: string[];
+}
+
+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 {
+    /** 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;
+    /** A minimum number of contains schema matches */
+    minContains?: number;
+    /** A maximum number of contains schema matches */
+    maxContains?: number;
+}
+type ArrayStatic<T extends TSchema, P extends unknown[]> = Ensure<Static<T, P>[]>;
+interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
+    [Kind]: 'Array';
+    static: ArrayStatic<T, this['params']>;
+    type: 'array';
+    items: T;
+}
+
+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 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>> {
+    }
+}
+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>;
+    handle(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 tryRequestProcessing(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;
+}
+interface RequestConfigSchema {
+    body?: TSchema$1;
+    params?: TObject$1;
+    query?: TObject$1;
+    headers?: TObject$1;
+    response?: TSchema$1;
+}
+interface ServerRequestConfig<TConfig extends RequestConfigSchema = RequestConfigSchema> {
+    body: TConfig["body"] extends TSchema$1 ? 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>;
+}
+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;
+        };
+    };
+    user: UserAccountToken;
+}
+interface ServerRoute<TConfig extends RequestConfigSchema = RequestConfigSchema> extends Route {
+    method?: RouteMethod;
+    silent?: boolean;
+    handler: ServerHandler<TConfig>;
+    schema?: TConfig;
+}
+type ServerResponseBody<TConfig extends RequestConfigSchema = RequestConfigSchema> = TConfig["response"] extends TSchema$1 ? Static$1<TConfig["response"]> : ResponseBodyType;
+type ResponseType = "json" | "text" | "void" | "file" | "any";
+type ResponseBodyType = string | Buffer | StreamLike | undefined | null | void;
+type ServerHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (request: ServerRequest<TConfig>) => Async<ServerResponseBody<TConfig>>;
+interface ServerReply {
+    headers: Record<string, string> & {
+        "set-cookie"?: string[];
+    };
+    status?: number;
+    body?: any;
+    redirect(url: string): void;
+}
+interface ServerResponse {
+    body: string | ArrayBuffer | Readable | ReadableStream;
+    headers: Record<string, string>;
+    status: number;
+}
+interface ServerRouteWithHandler extends Route {
+    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;
+        };
+    };
+}
+
+/**
+ * Route descriptor options.
+ */
+interface RouteDescriptorOptions<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.
+     */
+    security?: boolean;
+    /**
+     * Pathname of the route.
+     */
+    path?: string;
+    /**
+     * Inherit options from another route.
+     */
+    use?: {
+        [OPTIONS]: RouteDescriptorOptions<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 will not be exposed in the API documentation.
+     */
+    internal?: boolean;
+    /**
+     * Main route handler. This is where the route logic is implemented.
+     */
+    handler?: ServerHandler<TConfig>;
+}
+interface RouteDescriptor<TConfig extends RequestConfigSchema = RequestConfigSchema> {
+    [KIND]: "ROUTE";
+    [OPTIONS]: RouteDescriptorOptions<TConfig>;
+    /**
+     * Fetch or just call local route when available.
+     */
+    (config?: ClientRequestEntry<TConfig>, opts?: ClientRequestOptions): ClientRequestResponse<TConfig>;
+    /**
+     * Just fetch the route. Skip any local route.
+     */
+    fetch: (config?: ClientRequestEntry<TConfig>, opts?: ClientRequestOptions) => ClientRequestResponse<TConfig>;
+    /**
+     * Name of the permission required to access this route.
+     */
+    permission: () => string;
+}
+/**
+ * Declare a new route.
+ *
+ * ```ts
+ * class A {
+ *   hello = $route({
+ *     url: "/hello",
+ *     handler: () => "Hello, World!",
+ *   });
+ * }
+ * ```
+ *
+ * @param options The route options.
+ * @returns The route.
+ */
+declare const $route: {
+    <TConfig extends RequestConfigSchema>(options: RouteDescriptorOptions<TConfig>): RouteDescriptor<TConfig>;
+    [KIND]: string;
+};
+declare const $action: {
+    <TConfig extends RequestConfigSchema>(options: RouteDescriptorOptions<TConfig>): RouteDescriptor<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];
+};
+type ClientRequestEntryContainer<TConfig extends RequestConfigSchema = RequestConfigSchema> = {
+    body: TConfig["body"] extends TSchema$1 ? Static$1<TConfig["body"]> : undefined;
+    params: TConfig["params"] extends TSchema$1 ? Static$1<TConfig["params"]> : undefined;
+    headers?: TConfig["headers"] extends TSchema$1 ? Static$1<TConfig["headers"]> : undefined;
+    query?: TConfig["query"] extends TSchema$1 ? Partial<Static$1<TConfig["query"]>> : undefined;
+};
+interface ClientRequestOptions {
+    /**
+     * Built-in cache options.
+     * Number as seconds or boolean to enable cache.
+     */
+    cache?: number | boolean;
+    /**
+     * Forward user from the previous request.
+     *
+     * In testing environments, you can pass a partial user token.
+     */
+    user?: Partial<UserAccountToken>;
+    /**
+     * Standard request fetch options.
+     */
+    request?: RequestInit;
+}
+type ClientRequestResponse<TConfig extends RequestConfigSchema> = Promise<TConfig["response"] extends TSchema$1 ? Static$1<TConfig["response"]> : Response>;
+
+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;
+    };
+    constructor(options: {
+        error?: string;
+        message: string;
+        status: number;
+        cause?: {
+            name: string;
+            message: string;
+        } | unknown;
+    }, cause?: unknown);
+}
+declare const errorNameByStatus: Record<number, string>;
+
+declare class RouteDescriptorHelper {
+    name(options: RouteDescriptorOptions, instance: any, key: string): string;
+    path(options: RouteDescriptorOptions, instance: any, key: string, prefix?: string): string;
+    link(options: RouteDescriptorOptions, instance: any, key: string, prefix?: string): HttpClientLink;
+    method(options: {
+        method?: string;
+        schema?: any;
+    }): RouteMethod;
+    permission(options: RouteDescriptorOptions, instance: any, key: string, prefix?: string): Permission;
+    group(options: RouteDescriptorOptions, instance: any): string;
+    isMultipart(options: {
+        schema?: RequestConfigSchema;
+    }): boolean;
+    bodyContentType(options: RouteDescriptorOptions): string | undefined;
+    protected short(name: string): string;
+}
+
+declare class HttpClient {
+    protected readonly alepha: Alepha;
+    protected readonly env: {
+        SERVER_API_URL: string;
+        CLIENT_API_PREFIX: string;
+    };
+    protected readonly helper: RouteDescriptorHelper;
+    readonly URL_LINKS = "/_links";
+    readonly cache: _alepha_cache.CacheDescriptor<any, any[]>;
+    links?: Array<HttpClientLink>;
+    protected readonly pendingRequests: HttpClientPendingRequests;
+    json<T = any>(url: string, options?: RequestInit): Promise<T>;
+    clear(): Promise<void>;
+    createFetchFunction(link: HttpClientLink, options?: FetchFactoryAdditionalOptions): (config?: Partial<ClientRequestEntry>, request?: ClientRequestOptions) => Promise<any>;
+    request(args: {
+        config?: ServerRequestConfigEntry;
+        link: HttpClientLink;
+        request?: ClientRequestOptions;
+        host?: string;
+    }): Promise<any>;
+    protected url(host: string, link: HttpClientLink, args: ServerRequestConfigEntry): string;
+    protected body(init: RequestInit, headers: Record<string, string>, link: HttpClientLink, args?: ServerRequestConfigEntry): Promise<void>;
+    fetch<T>(url: string, request: RequestInit, options?: FetchRunOptions): Promise<T>;
+    /**
+     * Parse the response.
+     *
+     * @param response
+     * @param options
+     * @protected
+     */
+    protected response(response: Response, options: FetchRunOptions): Promise<Response | any>;
+    protected getFileLike(response: Response, defaultFileName?: string): FileLike;
+    protected pathVariables(url: string, action: HttpClientLink, args?: ServerRequestConfigEntry): string;
+    protected queryParams(url: string, action: HttpClientLink, args?: ServerRequestConfigEntry): string;
+    of<T extends object>(options?: {
+        group?: string;
+        host?: string | (() => string);
+    }): HttpVirtualClient<T>;
+    follow(name: string, config?: any, options?: {
+        request?: ClientRequestOptions;
+        group?: string;
+        host?: string | (() => string);
+    }): Promise<any>;
+    can(name: string): boolean;
+    getLinks(opts?: {
+        force?: boolean;
+        host?: string;
+    }): Promise<HttpClientLink[]>;
+}
+type HttpClientPendingRequests = Record<string, Promise<any> | undefined>;
+interface FetchFactoryAdditionalOptions {
+    host?: string | (() => string);
+}
+interface FetchRunOptions {
+    schema?: TSchema$1;
+    raw?: boolean;
+    cache?: boolean | DurationLike;
+}
+interface HttpClientLink {
+    method: RouteMethod;
+    path: string;
+    name: string;
+    group?: string;
+    contentType?: string;
+    protected?: boolean;
+    schema?: RequestConfigSchema;
+    handler?: ServerHandler;
+}
+type HttpVirtualClient<T> = {
+    [K in keyof T as T[K] extends RouteDescriptor ? K : never]: T[K] & {
+        can: () => boolean;
+    };
+};
+
+declare const REMOTE_DESCRIPTOR_KEY = "REMOTE";
+interface RemoteDescriptorOptions {
+    /**
+     * The URL of the remote service.
+     */
+    url: string | (() => string);
+    /**
+     * One or many instance of classes to be registered as remote services.
+     * Services must contain some $action() descriptors.
+     */
+    services: object | Array<object>;
+    /**
+     * The name of the remote service.
+     *
+     * @default Member of the class containing the remote service.
+     */
+    name?: string;
+}
+interface RemoteDescriptor {
+    [KIND]: typeof REMOTE_DESCRIPTOR_KEY;
+    [OPTIONS]: RemoteDescriptorOptions;
+}
+declare const $remote: {
+    (options: RemoteDescriptorOptions): RemoteDescriptor;
+    [KIND]: string;
+};
+
+declare class ServerProvider {
+    get hostname(): string;
+}
+
+declare const envSchema$3: _alepha_core.TObject<{
+    SERVER_API_PREFIX: TString;
+    SERVER_SECURITY_ENABLED: TBoolean;
+}>;
+declare module "alepha/core" {
+    interface Env extends Partial<Static$1<typeof envSchema$3>> {
+    }
+}
+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: RouteDescriptorHelper;
+    protected readonly routerProvider: ServerRouterProvider;
+    protected readonly remotes: Array<ServerRemote>;
+    protected readonly actions: ServerRouteAction[];
+    getActions(): ServerRouteAction<RequestConfigSchema>[];
+    readonly configure: _alepha_core.HookDescriptor<"configure">;
+    registerRemote(value: RemoteDescriptor, key: string): void;
+    registerAction(value: RouteDescriptor, key: string, instance: any, prefix?: string): Promise<void>;
+    /**
+     * When your action has no handler, it's considered as an 'API'.
+     * Instead of creating an http route, create a bridge to a local or remote function.
+     *
+     * ```ts
+     * class Api {
+     *   hello = $action(); // <- route 'Api'
+     * }
+     *
+     * class Controller {
+     *   api = $inject(Api);
+     *   hello = $action({ // <-- route
+     *     use: this.api.hello,
+     *     handler: () => new Response("Hello world"),
+     *   })
+     * }
+     *
+     * const api = alepha.get(Api);
+     *
+     * api.hello(); // <-- call the local controller function if available
+     *
+     * // or with $remote
+     * class Remotes {
+     *   api = $remote({ url: "http://localhost:8080", services: [Api] });
+     * }
+     *
+     * // or with future auto-discovery
+     * ```
+     */
+    registerActionApi(routeDescriptor: RouteDescriptor, instance: any, key: string): void;
+    /**
+     * Check a mock function for the specified route.
+     *
+     * This is mostly used for testing purposes.
+     *
+     * @param value
+     * @param permission
+     * @protected
+     */
+    protected createLocalFunction(value: RouteDescriptor, permission: Permission): (config?: ServerRequestConfigEntry, options?: ClientRequestOptions) => Promise<any>;
+    /**
+     * Security adapted for local function.
+     */
+    protected getUserFromLocalFunctionContext(options: {
+        user?: Partial<UserAccountToken>;
+    }, permission: Permission, security: boolean): UserAccountToken | undefined;
+    /**
+     * TODO: remove it, this is a hack for testing purposes
+     */
+    protected createSystemUser(): UserAccountToken;
+}
+declare const isServerAction: (value: any) => value is ServerRouteAction;
+interface ServerRemote {
+    url: string;
+    services: object[];
+    name: string;
+}
+interface ServerRouteAction<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRoute<TConfig> {
+    method: RouteMethod;
+    name: string;
+    group: string;
+    permission: Permission;
+    options: RouteDescriptorOptions;
+}
+
+declare const envSchema$2: _alepha_core.TObject<{
+    SERVER_API_URL: TString;
+}>;
+declare module "@alepha/core" {
+    interface Env extends Partial<Static$1<typeof envSchema$2>> {
+    }
+}
+declare class BrowserActionDescriptorProvider {
+    protected readonly log: _alepha_core.Logger;
+    protected readonly alepha: Alepha;
+    protected readonly client: HttpClient;
+    protected readonly env: {
+        SERVER_API_URL: string;
+    };
+    protected readonly helper: RouteDescriptorHelper;
+    readonly configure: _alepha_core.HookDescriptor<"configure">;
+    configureActions(): void;
+    registerAction(value: RouteDescriptor, instance: any, key: string): void;
+}
+
+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">;
+}
+
+declare class ServerLinksProvider {
+    protected readonly alepha: Alepha;
+    protected readonly client: HttpClient;
+    readonly links: RouteDescriptor<{
+        response: TArray<TObject<{
+            name: TString;
+            method: TOptional<TString>;
+            path: TOptional<TString>;
+            group: TOptional<TString>;
+            protected: TOptional<TBoolean>;
+            contentType: TOptional<TString>;
+        }>>;
+    }>;
+}
+
+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">;
+}
+
+declare class ServerMultipartProvider {
+    protected readonly helper: RouteDescriptorHelper;
+    protected readonly alepha: Alepha;
+    readonly onRequest: _alepha_core.HookDescriptor<"server:onRequest">;
+    readonly onSend: _alepha_core.HookDescriptor<"server:onSend">;
+    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>;
+}
+interface HybridFile extends FileLike {
+    cleanup(): Promise<void>;
+    _state: {
+        cleanup: boolean;
+        size: number;
+        tmpPath: string;
+    };
+}
+/**
+ * Create a file-like object from various sources.
+ */
+declare const file: (source: string | Buffer | ArrayBuffer | StreamLike, options?: {
+    type?: string;
+    name?: string;
+}) => FileLike;
+declare const bufferToStream: (buffer: Buffer) => Readable;
+declare const streamToBuffer: (stream: Readable) => Promise<Buffer>;
+declare const bufferToArrayBuffer: (buffer: Buffer) => ArrayBuffer;
+declare const getContentType: (filename: string) => string;
+
+declare const envSchema$1: _alepha_core.TObject<{
+    SERVER_PORT: TNumber;
+    SERVER_HOST: TString;
+}>;
+declare module "@alepha/core" {
+    interface Env extends Partial<Static$1<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;
+    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;
+    status: TNumber;
+    message: TString;
+    details: TOptional<TString>;
+    cause: TOptional<TObject<{
+        name: TString;
+        message: TString;
+    }>>;
+}>;
+
+declare const okSchema: TObject<{
+    ok: TBoolean;
+    id: TOptional<TUnion<[TString, TInteger]>>;
+    count: TOptional<TNumber>;
+}>;
+type Ok = Static$1<typeof okSchema>;
+
+declare class BadRequestError extends HttpError {
+    constructor(message?: string, cause?: unknown);
+}
+
+declare class ConflictError extends HttpError {
+    constructor(message?: string, cause?: unknown);
+}
+
+declare class ForbiddenError extends HttpError {
+    constructor(message?: string, cause?: unknown);
+}
+
+declare class NotFoundError extends HttpError {
+    constructor(message?: string, cause?: unknown);
+}
+
+declare class UnauthorizedError extends HttpError {
+    constructor(message?: string, cause?: unknown);
+}
+
+declare class ValidationError extends HttpError {
+    constructor(message?: string, cause?: unknown);
+}
+
+declare const envSchema: _alepha_core.TObject<{
+    SERVER_LINKS_ENABLED: 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$1<typeof envSchema>> {
+    }
+}
+declare class ServerModule {
+    protected readonly env: {
+        SERVER_LINKS_ENABLED: boolean;
+    };
+    protected readonly alepha: Alepha;
+    constructor();
+}
+
+export { $action, $remote, $route, BadRequestError, BrowserActionDescriptorProvider, type ClientRequestEntry, type ClientRequestEntryContainer, type ClientRequestOptions, type ClientRequestResponse, ConflictError, type FetchFactoryAdditionalOptions, type FetchRunOptions, ForbiddenError, HttpClient, type HttpClientLink, type HttpClientPendingRequests, HttpError, type HttpVirtualClient, NodeHttpServerProvider, NotFoundError, type Ok, REMOTE_DESCRIPTOR_KEY, type RemoteDescriptor, type RemoteDescriptorOptions, type RequestConfigSchema, type ResponseBodyType, type ResponseType, type RouteDescriptor, type RouteDescriptorOptions, type RouteMethod, ServerActionDescriptorProvider, type ServerHandler, ServerLinksProvider, ServerLoggerProvider, ServerModule, ServerMultipartProvider, ServerProvider, type ServerRawRequest, type ServerRemote, type ServerReply, type ServerRequest, type ServerRequestConfig, type ServerRequestConfigEntry, type ServerResponse, type ServerResponseBody, type ServerRoute, type ServerRouteAction, type ServerRouteWithHandler, ServerRouterProvider, ServerSecurityProvider, UnauthorizedError, ValidationError, bufferToArrayBuffer, bufferToStream, errorNameByStatus, errorSchema, file, getContentType, isServerAction, okSchema, routeMethods, streamToBuffer };