@alepha/react 0.13.1 → 0.13.3

package/dist/auth/index.d.ts

@@ -1,256 +1,57 @@
-import * as alepha18 from "alepha";
-import { Alepha, AlephaError, Async, Descriptor, FileLike, InstantiableClass, LogLevel, LoggerInterface, Static, StreamLike, TArray, TFile, TObject, TRecord, TSchema, TStream, TString, TVoid } from "alepha";
-import dayjsDuration from "dayjs/plugin/duration.js";
-import DayjsApi, { Dayjs, ManipulateType, PluginFunc } from "dayjs";
+import * as alepha4 from "alepha";
+import { Alepha, AlephaError, Async, FileLike, InstantiableClass, LogLevel, LoggerInterface, Primitive, Static, StreamLike, TArray, TFile, TObject, TRecord, TSchema, TStream, TString, TVoid } from "alepha";
 import { IncomingMessage, Server, ServerResponse } from "node:http";
 import { Readable } from "node:stream";
 import { ReadableStream } from "node:stream/web";
+import dayjsDuration from "dayjs/plugin/duration.js";
+import DayjsApi, { Dayjs, ManipulateType, PluginFunc } from "dayjs";
 
 //#region ../alepha/src/security/schemas/userAccountInfoSchema.d.ts
-declare const userAccountInfoSchema: alepha18.TObject<{
-  id: alepha18.TString;
-  name: alepha18.TOptional<alepha18.TString>;
-  email: alepha18.TOptional<alepha18.TString>;
-  username: alepha18.TOptional<alepha18.TString>;
-  picture: alepha18.TOptional<alepha18.TString>;
-  sessionId: alepha18.TOptional<alepha18.TString>;
-  organizations: alepha18.TOptional<alepha18.TArray<alepha18.TString>>;
-  roles: alepha18.TOptional<alepha18.TArray<alepha18.TString>>;
+declare const userAccountInfoSchema: alepha4.TObject<{
+  id: alepha4.TString;
+  name: alepha4.TOptional<alepha4.TString>;
+  email: alepha4.TOptional<alepha4.TString>;
+  username: alepha4.TOptional<alepha4.TString>;
+  picture: alepha4.TOptional<alepha4.TString>;
+  sessionId: alepha4.TOptional<alepha4.TString>;
+  organizations: alepha4.TOptional<alepha4.TArray<alepha4.TString>>;
+  roles: alepha4.TOptional<alepha4.TArray<alepha4.TString>>;
 }>;
 type UserAccount = Static<typeof userAccountInfoSchema>;
 //#endregion
-//#region ../alepha/src/logger/schemas/logEntrySchema.d.ts
-declare const logEntrySchema: alepha18.TObject<{
-  level: alepha18.TUnsafe<"SILENT" | "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
-  message: alepha18.TString;
-  service: alepha18.TString;
-  module: alepha18.TString;
-  context: alepha18.TOptional<alepha18.TString>;
-  app: alepha18.TOptional<alepha18.TString>;
-  data: alepha18.TOptional<alepha18.TAny>;
-  timestamp: alepha18.TNumber;
-}>;
-type LogEntry = Static<typeof logEntrySchema>;
-//#endregion
-//#region ../alepha/src/datetime/providers/DateTimeProvider.d.ts
-type DateTime = DayjsApi.Dayjs;
-type Duration = dayjsDuration.Duration;
-type DurationLike = number | dayjsDuration.Duration | [number, ManipulateType];
-declare class DateTimeProvider {
-  static PLUGINS: Array<PluginFunc<any>>;
-  protected alepha: Alepha;
-  protected ref: DateTime | null;
-  protected readonly timeouts: Timeout[];
-  protected readonly intervals: Interval[];
-  constructor();
-  protected readonly onStart: alepha18.HookDescriptor<"start">;
-  protected readonly onStop: alepha18.HookDescriptor<"stop">;
-  setLocale(locale: string): void;
-  isDateTime(value: unknown): value is DateTime;
-  /**
-   * Create a new UTC DateTime instance.
-   */
-  utc(date: string | number | Date | Dayjs | null | undefined): DateTime;
-  /**
-   * Create a new DateTime instance.
-   */
-  of(date: string | number | Date | Dayjs | null | undefined): DateTime;
-  /**
-   * Get the current date as a string.
-   */
-  toISOString(date?: Date | string | DateTime): string;
-  /**
-   * Get the current date.
-   */
-  now(): DateTime;
-  /**
-   * Get the current date as a string.
-   *
-   * This is much faster than `DateTimeProvider.now().toISOString()` as it avoids creating a DateTime instance.
-   */
-  nowISOString(): string;
-  /**
-   * Get the current date as milliseconds since epoch.
-   *
-   * This is much faster than `DateTimeProvider.now().valueOf()` as it avoids creating a DateTime instance.
-   */
-  nowMillis(): number;
-  /**
-   * Get the current date as a string.
-   *
-   * @protected
-   */
-  protected getCurrentDate(): DateTime;
-  /**
-   * Create a new Duration instance.
-   */
-  duration: (duration: DurationLike, unit?: ManipulateType) => Duration;
-  isDurationLike(value: unknown): value is DurationLike;
-  /**
-   * Return a promise that resolves after the next tick.
-   * It uses `setTimeout` with 0 ms delay.
-   */
-  tick(): Promise<void>;
-  /**
-   * Wait for a certain duration.
-   *
-   * You can clear the timeout by using the `AbortSignal` API.
-   * Aborted signal will resolve the promise immediately, it does not reject it.
-   */
-  wait(duration: DurationLike, options?: {
-    signal?: AbortSignal;
-    now?: number;
-  }): Promise<void>;
-  createInterval(run: () => unknown, duration: DurationLike, start?: boolean): Interval;
-  /**
-   * Run a callback after a certain duration.
-   */
-  createTimeout(callback: () => void, duration: DurationLike, now?: number): Timeout;
-  clearTimeout(timeout: Timeout): void;
-  clearInterval(interval: Interval): void;
-  /**
-   * Run a function with a deadline.
-   */
-  deadline<T>(fn: (signal: AbortSignal) => Promise<T>, duration: DurationLike): Promise<T>;
-  /**
-   * Add time to the current date.
-   */
-  travel(duration: DurationLike, unit?: ManipulateType): Promise<void>;
-  /**
-   * Stop the time.
-   */
-  pause(): DateTime;
-  /**
-   * Reset the reference date.
-   */
-  reset(): void;
-}
-interface Interval {
-  timer?: any;
-  duration: number;
-  run: () => unknown;
-}
-interface Timeout {
-  now: number;
-  timer?: any;
-  duration: number;
-  callback: () => void;
-  clear: () => void;
-}
-//#endregion
-//#region ../alepha/src/logger/providers/LogDestinationProvider.d.ts
-declare abstract class LogDestinationProvider {
-  abstract write(message: string, entry: LogEntry): void;
-}
-//#endregion
-//#region ../alepha/src/logger/providers/LogFormatterProvider.d.ts
-declare abstract class LogFormatterProvider {
-  abstract format(entry: LogEntry): string;
-}
-//#endregion
-//#region ../alepha/src/logger/services/Logger.d.ts
-declare class Logger implements LoggerInterface {
-  protected readonly alepha: Alepha;
-  protected readonly formatter: LogFormatterProvider;
-  protected readonly destination: LogDestinationProvider;
-  protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly levels: Record<string, number>;
-  protected readonly service: string;
-  protected readonly module: string;
-  protected readonly app?: string;
-  protected appLogLevel: string;
-  protected logLevel: LogLevel;
-  constructor(service: string, module: string);
-  get context(): string | undefined;
-  get level(): string;
-  parseLevel(level: string, app: string): LogLevel;
-  private matchesPattern;
-  asLogLevel(something: string): LogLevel;
-  error(message: string, data?: unknown): void;
-  warn(message: string, data?: unknown): void;
-  info(message: string, data?: unknown): void;
-  debug(message: string, data?: unknown): void;
-  trace(message: string, data?: unknown): void;
-  protected log(level: LogLevel, message: string, data?: unknown): void;
-  protected emit(entry: LogEntry, message?: string): void;
-}
-//#endregion
-//#region ../alepha/src/logger/index.d.ts
-declare const envSchema$3: alepha18.TObject<{
-  /**
-   * Default log level for the application.
-   *
-   * Default by environment:
-   * - dev = info
-   * - prod = info
-   * - test = error
-   *
-   * Levels are: "trace" | "debug" | "info" | "warn" | "error" | "silent"
-   *
-   * Level can be set for a specific module:
-   *
-   * @example
-   * LOG_LEVEL=my.module.name:debug,info # Set debug level for my.module.name and info for all other modules
-   * LOG_LEVEL=alepha:trace, info # Set trace level for all alepha modules and info for all other modules
-   */
-  LOG_LEVEL: alepha18.TOptional<alepha18.TString>;
-  /**
-   * Built-in log formats.
-   * - "json" - JSON format, useful for structured logging and log aggregation. {@link JsonFormatterProvider}
-   * - "pretty" - Simple text format, human-readable, with colors. {@link SimpleFormatterProvider}
-   * - "raw" - Raw format, no formatting, just the message.  {@link RawFormatterProvider}
-   */
-  LOG_FORMAT: alepha18.TOptional<alepha18.TUnsafe<"json" | "pretty" | "raw">>;
+//#region ../alepha/src/server/schemas/errorSchema.d.ts
+declare const errorSchema: alepha4.TObject<{
+  error: alepha4.TString;
+  status: alepha4.TInteger;
+  message: alepha4.TString;
+  details: alepha4.TOptional<alepha4.TString>;
+  requestId: alepha4.TOptional<alepha4.TString>;
+  cause: alepha4.TOptional<alepha4.TObject<{
+    name: alepha4.TString;
+    message: alepha4.TString;
+  }>>;
 }>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$3>> {}
-  interface State {
-    /**
-     * Current log level for the application or specific modules.
-     */
-    "alepha.logger.level"?: string;
-  }
-  interface Hooks {
-    log: {
-      message?: string;
-      entry: LogEntry;
-    };
-  }
-}
+type ErrorSchema = Static<typeof errorSchema>;
 //#endregion
-//#region ../alepha/src/security/interfaces/UserAccountToken.d.ts
-/**
- * Add contextual metadata to a user account info.
- * E.g. UserAccountToken is a UserAccountInfo during a request.
- */
-interface UserAccountToken extends UserAccount {
-  /**
-   * Access token for the user.
-   */
-  token?: string;
-  /**
-   * Realm name of the user.
-   */
-  realm?: string;
-  /**
-   * Is user dedicated to his own resources for this scope ?
-   * Mostly, Admin is false and Customer is true.
-   */
-  ownership?: string | boolean;
+//#region ../alepha/src/server/errors/HttpError.d.ts
+declare class HttpError extends AlephaError {
+  name: string;
+  static is: (error: unknown, status?: number) => error is HttpErrorLike;
+  static toJSON(error: HttpError): ErrorSchema;
+  readonly error: string;
+  readonly status: number;
+  readonly requestId?: string;
+  readonly details?: string;
+  readonly reason?: {
+    name: string;
+    message: string;
+  };
+  constructor(options: Partial<ErrorSchema>, cause?: unknown);
 }
-//#endregion
-//#region ../alepha/src/security/providers/SecurityProvider.d.ts
-declare const envSchema$2: alepha18.TObject<{
-  APP_SECRET: alepha18.TString;
-}>;
-declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$2>> {}
+interface HttpErrorLike extends Error {
+  status: number;
 }
 //#endregion
-//#region ../alepha/src/server/constants/routeMethods.d.ts
-declare const routeMethods: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "CONNECT", "TRACE"];
-type RouteMethod = (typeof routeMethods)[number];
-//#endregion
 //#region ../alepha/src/router/providers/RouterProvider.d.ts
 declare abstract class RouterProvider<T extends Route = Route> {
   protected routePathRegex: RegExp;
@@ -295,6 +96,10 @@ interface Tree<T extends Route> {
   };
 }
 //#endregion
+//#region ../alepha/src/server/constants/routeMethods.d.ts
+declare const routeMethods: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "CONNECT", "TRACE"];
+type RouteMethod = (typeof routeMethods)[number];
+//#endregion
 //#region ../alepha/src/server/helpers/ServerReply.d.ts
 /**
  * Helper for building server replies.
@@ -461,6 +266,205 @@ interface WebRequestEvent {
   res?: Response;
 }
 //#endregion
+//#region ../alepha/src/logger/schemas/logEntrySchema.d.ts
+declare const logEntrySchema: alepha4.TObject<{
+  level: alepha4.TUnsafe<"SILENT" | "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
+  message: alepha4.TString;
+  service: alepha4.TString;
+  module: alepha4.TString;
+  context: alepha4.TOptional<alepha4.TString>;
+  app: alepha4.TOptional<alepha4.TString>;
+  data: alepha4.TOptional<alepha4.TAny>;
+  timestamp: alepha4.TNumber;
+}>;
+type LogEntry = Static<typeof logEntrySchema>;
+//#endregion
+//#region ../alepha/src/datetime/providers/DateTimeProvider.d.ts
+type DateTime = DayjsApi.Dayjs;
+type Duration = dayjsDuration.Duration;
+type DurationLike = number | dayjsDuration.Duration | [number, ManipulateType];
+declare class DateTimeProvider {
+  static PLUGINS: Array<PluginFunc<any>>;
+  protected alepha: Alepha;
+  protected ref: DateTime | null;
+  protected readonly timeouts: Timeout[];
+  protected readonly intervals: Interval[];
+  constructor();
+  protected readonly onStart: alepha4.HookPrimitive<"start">;
+  protected readonly onStop: alepha4.HookPrimitive<"stop">;
+  setLocale(locale: string): void;
+  isDateTime(value: unknown): value is DateTime;
+  /**
+   * Create a new UTC DateTime instance.
+   */
+  utc(date: string | number | Date | Dayjs | null | undefined): DateTime;
+  /**
+   * Create a new DateTime instance.
+   */
+  of(date: string | number | Date | Dayjs | null | undefined): DateTime;
+  /**
+   * Get the current date as a string.
+   */
+  toISOString(date?: Date | string | DateTime): string;
+  /**
+   * Get the current date.
+   */
+  now(): DateTime;
+  /**
+   * Get the current date as a string.
+   *
+   * This is much faster than `DateTimeProvider.now().toISOString()` as it avoids creating a DateTime instance.
+   */
+  nowISOString(): string;
+  /**
+   * Get the current date as milliseconds since epoch.
+   *
+   * This is much faster than `DateTimeProvider.now().valueOf()` as it avoids creating a DateTime instance.
+   */
+  nowMillis(): number;
+  /**
+   * Get the current date as a string.
+   *
+   * @protected
+   */
+  protected getCurrentDate(): DateTime;
+  /**
+   * Create a new Duration instance.
+   */
+  duration: (duration: DurationLike, unit?: ManipulateType) => Duration;
+  isDurationLike(value: unknown): value is DurationLike;
+  /**
+   * Return a promise that resolves after the next tick.
+   * It uses `setTimeout` with 0 ms delay.
+   */
+  tick(): Promise<void>;
+  /**
+   * Wait for a certain duration.
+   *
+   * You can clear the timeout by using the `AbortSignal` API.
+   * Aborted signal will resolve the promise immediately, it does not reject it.
+   */
+  wait(duration: DurationLike, options?: {
+    signal?: AbortSignal;
+    now?: number;
+  }): Promise<void>;
+  createInterval(run: () => unknown, duration: DurationLike, start?: boolean): Interval;
+  /**
+   * Run a callback after a certain duration.
+   */
+  createTimeout(callback: () => void, duration: DurationLike, now?: number): Timeout;
+  clearTimeout(timeout: Timeout): void;
+  clearInterval(interval: Interval): void;
+  /**
+   * Run a function with a deadline.
+   */
+  deadline<T>(fn: (signal: AbortSignal) => Promise<T>, duration: DurationLike): Promise<T>;
+  /**
+   * Add time to the current date.
+   */
+  travel(duration: DurationLike, unit?: ManipulateType): Promise<void>;
+  /**
+   * Stop the time.
+   */
+  pause(): DateTime;
+  /**
+   * Reset the reference date.
+   */
+  reset(): void;
+}
+interface Interval {
+  timer?: any;
+  duration: number;
+  run: () => unknown;
+}
+interface Timeout {
+  now: number;
+  timer?: any;
+  duration: number;
+  callback: () => void;
+  clear: () => void;
+}
+//#endregion
+//#region ../alepha/src/logger/providers/LogDestinationProvider.d.ts
+declare abstract class LogDestinationProvider {
+  abstract write(message: string, entry: LogEntry): void;
+}
+//#endregion
+//#region ../alepha/src/logger/providers/LogFormatterProvider.d.ts
+declare abstract class LogFormatterProvider {
+  abstract format(entry: LogEntry): string;
+}
+//#endregion
+//#region ../alepha/src/logger/services/Logger.d.ts
+declare class Logger implements LoggerInterface {
+  protected readonly alepha: Alepha;
+  protected readonly formatter: LogFormatterProvider;
+  protected readonly destination: LogDestinationProvider;
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly levels: Record<string, number>;
+  protected readonly service: string;
+  protected readonly module: string;
+  protected readonly app?: string;
+  protected appLogLevel: string;
+  protected logLevel: LogLevel;
+  constructor(service: string, module: string);
+  get context(): string | undefined;
+  get level(): string;
+  parseLevel(level: string, app: string): LogLevel;
+  private matchesPattern;
+  asLogLevel(something: string): LogLevel;
+  error(message: string, data?: unknown): void;
+  warn(message: string, data?: unknown): void;
+  info(message: string, data?: unknown): void;
+  debug(message: string, data?: unknown): void;
+  trace(message: string, data?: unknown): void;
+  protected log(level: LogLevel, message: string, data?: unknown): void;
+  protected emit(entry: LogEntry, message?: string): void;
+}
+//#endregion
+//#region ../alepha/src/logger/index.d.ts
+declare const envSchema$3: alepha4.TObject<{
+  /**
+   * Default log level for the application.
+   *
+   * Default by environment:
+   * - dev = info
+   * - prod = info
+   * - test = error
+   *
+   * Levels are: "trace" | "debug" | "info" | "warn" | "error" | "silent"
+   *
+   * Level can be set for a specific module:
+   *
+   * @example
+   * LOG_LEVEL=my.module.name:debug,info # Set debug level for my.module.name and info for all other modules
+   * LOG_LEVEL=alepha:trace, info # Set trace level for all alepha modules and info for all other modules
+   */
+  LOG_LEVEL: alepha4.TOptional<alepha4.TString>;
+  /**
+   * Built-in log formats.
+   * - "json" - JSON format, useful for structured logging and log aggregation. {@link JsonFormatterProvider}
+   * - "pretty" - Simple text format, human-readable, with colors. {@link SimpleFormatterProvider}
+   * - "raw" - Raw format, no formatting, just the message.  {@link RawFormatterProvider}
+   */
+  LOG_FORMAT: alepha4.TOptional<alepha4.TUnsafe<"json" | "pretty" | "raw">>;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema$3>> {}
+  interface State {
+    /**
+     * Current log level for the application or specific modules.
+     */
+    "alepha.logger.level"?: string;
+  }
+  interface Hooks {
+    log: {
+      message?: string;
+      entry: LogEntry;
+    };
+  }
+}
+//#endregion
 //#region ../alepha/src/server/services/ServerRequestParser.d.ts
 declare class ServerRequestParser {
   protected readonly alepha: Alepha;
@@ -480,8 +484,8 @@ declare class ServerTimingProvider {
     prefix: string;
     disabled: boolean;
   };
-  readonly onRequest: alepha18.HookDescriptor<"server:onRequest">;
-  readonly onResponse: alepha18.HookDescriptor<"server:onResponse">;
+  readonly onRequest: alepha4.HookPrimitive<"server:onRequest">;
+  readonly onResponse: alepha4.HookPrimitive<"server:onResponse">;
   protected get handlerName(): string;
   beginTiming(name: string): void;
   endTiming(name: string): void;
@@ -545,11 +549,11 @@ declare class ServerProvider {
   /**
    * When a Node.js HTTP request is received from outside. (Vercel, AWS Lambda, etc.)
    */
-  protected readonly onNodeRequest: alepha18.HookDescriptor<"node:request">;
+  protected readonly onNodeRequest: alepha4.HookPrimitive<"node:request">;
   /**
    * When a Web (Fetch API) request is received from outside. (Netlify, Cloudflare Workers, etc.)
    */
-  protected readonly onWebRequest: alepha18.HookDescriptor<"web:request">;
+  protected readonly onWebRequest: alepha4.HookPrimitive<"web:request">;
   /**
    * Handle Node.js HTTP request event.
    *
@@ -609,8 +613,8 @@ declare abstract class CacheProvider {
   abstract clear(): Promise<void>;
 }
 //#endregion
-//#region ../alepha/src/cache/descriptors/$cache.d.ts
-interface CacheDescriptorOptions<TReturn = any, TParameter extends any[] = any[]> {
+//#region ../alepha/src/cache/primitives/$cache.d.ts
+interface CachePrimitiveOptions<TReturn = any, TParameter extends any[] = any[]> {
   /**
    * The cache name. This is useful for invalidating multiple caches at once.
    *
@@ -645,7 +649,7 @@ interface CacheDescriptorOptions<TReturn = any, TParameter extends any[] = any[]
    */
   disabled?: boolean;
 }
-declare class CacheDescriptor<TReturn = any, TParameter extends any[] = any[]> extends Descriptor<CacheDescriptorOptions<TReturn, TParameter>> {
+declare class CachePrimitive<TReturn = any, TParameter extends any[] = any[]> extends Primitive<CachePrimitiveOptions<TReturn, TParameter>> {
   protected readonly env: {
     CACHE_ENABLED: boolean;
     CACHE_DEFAULT_TTL: number;
@@ -669,9 +673,9 @@ declare class CacheDescriptor<TReturn = any, TParameter extends any[] = any[]> e
   protected deserialize<TReturn>(uint8Array: Uint8Array): Promise<TReturn>;
   protected $provider(): CacheProvider;
 }
-interface CacheDescriptorFn<TReturn = any, TParameter extends any[] = any[]> extends CacheDescriptor<TReturn, TParameter> {
+interface CachePrimitiveFn<TReturn = any, TParameter extends any[] = any[]> extends CachePrimitive<TReturn, TParameter> {
   /**
-   * Run the cache descriptor with the provided arguments.
+   * Run the cache primitive with the provided arguments.
    */
   (...args: TParameter): Promise<TReturn>;
 }
@@ -680,7 +684,7 @@ interface CacheDescriptorFn<TReturn = any, TParameter extends any[] = any[]> ext
 declare class HttpClient {
   protected readonly log: Logger;
   protected readonly alepha: Alepha;
-  readonly cache: CacheDescriptorFn<HttpClientCache, any[]>;
+  readonly cache: CachePrimitiveFn<HttpClientCache, any[]>;
   protected readonly pendingRequests: HttpClientPendingRequests;
   fetchAction(args: FetchActionArgs): Promise<FetchResponse>;
   fetch<T extends TSchema>(url: string, request?: RequestInitWithOptions<T>): Promise<FetchResponse<Static<T>>>;
@@ -748,8 +752,8 @@ interface HttpAction {
   };
 }
 //#endregion
-//#region ../alepha/src/server/descriptors/$action.d.ts
-interface ActionDescriptorOptions<TConfig extends RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema" | "mapParams"> {
+//#region ../alepha/src/server/primitives/$action.d.ts
+interface ActionPrimitiveOptions<TConfig extends RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema" | "mapParams"> {
   /**
    * Name of the action.
    *
@@ -815,7 +819,7 @@ interface ActionDescriptorOptions<TConfig extends RequestConfigSchema> extends O
    */
   handler: ServerActionHandler<TConfig>;
 }
-declare class ActionDescriptor<TConfig extends RequestConfigSchema> extends Descriptor<ActionDescriptorOptions<TConfig>> {
+declare class ActionPrimitive<TConfig extends RequestConfigSchema> extends Primitive<ActionPrimitiveOptions<TConfig>> {
   protected readonly log: Logger;
   protected readonly env: {
     SERVER_API_PREFIX: string;
@@ -883,55 +887,22 @@ type ServerActionHandler<TConfig extends RequestConfigSchema = RequestConfigSche
  */
 interface ServerActionRequest<TConfig extends RequestConfigSchema> extends ServerRequest<TConfig> {}
 //#endregion
-//#region ../alepha/src/server/schemas/errorSchema.d.ts
-declare const errorSchema: alepha18.TObject<{
-  error: alepha18.TString;
-  status: alepha18.TInteger;
-  message: alepha18.TString;
-  details: alepha18.TOptional<alepha18.TString>;
-  requestId: alepha18.TOptional<alepha18.TString>;
-  cause: alepha18.TOptional<alepha18.TObject<{
-    name: alepha18.TString;
-    message: alepha18.TString;
-  }>>;
-}>;
-type ErrorSchema = Static<typeof errorSchema>;
-//#endregion
-//#region ../alepha/src/server/errors/HttpError.d.ts
-declare class HttpError extends AlephaError {
-  name: string;
-  static is: (error: unknown, status?: number) => error is HttpErrorLike;
-  static toJSON(error: HttpError): ErrorSchema;
-  readonly error: string;
-  readonly status: number;
-  readonly requestId?: string;
-  readonly details?: string;
-  readonly reason?: {
-    name: string;
-    message: string;
-  };
-  constructor(options: Partial<ErrorSchema>, cause?: unknown);
-}
-interface HttpErrorLike extends Error {
-  status: number;
-}
-//#endregion
 //#region ../alepha/src/server/providers/BunHttpServerProvider.d.ts
-declare const envSchema$1: alepha18.TObject<{
-  SERVER_PORT: alepha18.TInteger;
-  SERVER_HOST: alepha18.TString;
+declare const envSchema$2: alepha4.TObject<{
+  SERVER_PORT: alepha4.TInteger;
+  SERVER_HOST: alepha4.TString;
 }>;
 declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema$1>> {}
+  interface Env extends Partial<Static<typeof envSchema$2>> {}
 }
 //#endregion
 //#region ../alepha/src/server/providers/NodeHttpServerProvider.d.ts
-declare const envSchema: alepha18.TObject<{
-  SERVER_PORT: alepha18.TInteger;
-  SERVER_HOST: alepha18.TString;
+declare const envSchema$1: alepha4.TObject<{
+  SERVER_PORT: alepha4.TInteger;
+  SERVER_HOST: alepha4.TString;
 }>;
 declare module "alepha" {
-  interface Env extends Partial<Static<typeof envSchema>> {}
+  interface Env extends Partial<Static<typeof envSchema$1>> {}
 }
 //#endregion
 //#region ../alepha/src/server/index.d.ts
@@ -941,12 +912,12 @@ declare module "alepha" {
   }
   interface Hooks {
     "action:onRequest": {
-      action: ActionDescriptor<RequestConfigSchema>;
+      action: ActionPrimitive<RequestConfigSchema>;
       request: ServerRequest;
       options: ClientRequestOptions;
     };
     "action:onResponse": {
-      action: ActionDescriptor<RequestConfigSchema>;
+      action: ActionPrimitive<RequestConfigSchema>;
       request: ServerRequest;
       options: ClientRequestOptions;
       response: any;
@@ -990,6 +961,35 @@ declare module "alepha" {
   }
 }
 //#endregion
+//#region ../alepha/src/security/interfaces/UserAccountToken.d.ts
+/**
+ * Add contextual metadata to a user account info.
+ * E.g. UserAccountToken is a UserAccountInfo during a request.
+ */
+interface UserAccountToken extends UserAccount {
+  /**
+   * Access token for the user.
+   */
+  token?: string;
+  /**
+   * Realm name of the user.
+   */
+  realm?: string;
+  /**
+   * Is user dedicated to his own resources for this scope ?
+   * Mostly, Admin is false and Customer is true.
+   */
+  ownership?: string | boolean;
+}
+//#endregion
+//#region ../alepha/src/security/providers/SecurityProvider.d.ts
+declare const envSchema: alepha4.TObject<{
+  APP_SECRET: alepha4.TString;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema>> {}
+}
+//#endregion
 //#region ../alepha/src/security/index.d.ts
 declare module "alepha" {
   interface Hooks {
@@ -1002,7 +1002,7 @@ declare module "alepha" {
 /**
  * Provides comprehensive authentication and authorization capabilities with JWT tokens, role-based access control, and user management.
  *
- * The security module enables building secure applications using descriptors like `$realm`, `$role`, and `$permission`
+ * The security module enables building secure applications using primitives like `$realm`, `$role`, and `$permission`
  * on class properties. It offers JWT-based authentication, fine-grained permissions, service accounts, and seamless
  * integration with various authentication providers and user management systems.
  *
@@ -1077,22 +1077,91 @@ declare module "alepha/server" {
  */
 //#endregion
 //#region ../alepha/src/server-links/schemas/apiLinksResponseSchema.d.ts
-declare const apiLinksResponseSchema: alepha18.TObject<{
-  prefix: alepha18.TOptional<alepha18.TString>;
-  links: alepha18.TArray<alepha18.TObject<{
-    name: alepha18.TString;
-    group: alepha18.TOptional<alepha18.TString>;
-    path: alepha18.TString;
-    method: alepha18.TOptional<alepha18.TString>;
-    requestBodyType: alepha18.TOptional<alepha18.TString>;
-    service: alepha18.TOptional<alepha18.TString>;
+declare const apiLinkSchema: alepha4.TObject<{
+  name: alepha4.TString;
+  group: alepha4.TOptional<alepha4.TString>;
+  path: alepha4.TString;
+  method: alepha4.TOptional<alepha4.TString>;
+  requestBodyType: alepha4.TOptional<alepha4.TString>;
+  service: alepha4.TOptional<alepha4.TString>;
+}>;
+declare const apiLinksResponseSchema: alepha4.TObject<{
+  prefix: alepha4.TOptional<alepha4.TString>;
+  links: alepha4.TArray<alepha4.TObject<{
+    name: alepha4.TString;
+    group: alepha4.TOptional<alepha4.TString>;
+    path: alepha4.TString;
+    method: alepha4.TOptional<alepha4.TString>;
+    requestBodyType: alepha4.TOptional<alepha4.TString>;
+    service: alepha4.TOptional<alepha4.TString>;
   }>>;
 }>;
 type ApiLinksResponse = Static<typeof apiLinksResponseSchema>;
+type ApiLink = Static<typeof apiLinkSchema>;
 //#endregion
 //#region ../alepha/src/server-links/providers/LinkProvider.d.ts
-type HttpVirtualClient<T> = { [K in keyof T as T[K] extends ActionDescriptor<RequestConfigSchema> ? K : never]: T[K] extends ActionDescriptor<infer Schema> ? VirtualAction<Schema> : never };
-interface VirtualAction<T extends RequestConfigSchema> extends Pick<ActionDescriptor<T>, "name" | "run" | "fetch"> {
+/**
+ * Browser, SSR friendly, service to handle links.
+ */
+declare class LinkProvider {
+  static path: {
+    apiLinks: string;
+    apiSchema: string;
+  };
+  protected readonly log: Logger;
+  protected readonly alepha: Alepha;
+  protected readonly httpClient: HttpClient;
+  protected serverLinks: Array<HttpClientLink>;
+  /**
+   * Get applicative links registered on the server.
+   * This does not include lazy-loaded remote links.
+   */
+  getServerLinks(): HttpClientLink[];
+  /**
+   * Register a new link for the application.
+   */
+  registerLink(link: HttpClientLink): void;
+  get links(): HttpClientLink[];
+  /**
+   * Force browser to refresh links from the server.
+   */
+  fetchLinks(): Promise<HttpClientLink[]>;
+  /**
+   * Create a virtual client that can be used to call actions.
+   *
+   * Use js Proxy under the hood.
+   */
+  client<T extends object>(scope?: ClientScope): HttpVirtualClient<T>;
+  /**
+   * Check if a link with the given name exists.
+   * @param name
+   */
+  can(name: string): boolean;
+  /**
+   * 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 createVirtualAction<T extends RequestConfigSchema>(name: string, scope?: ClientScope): VirtualAction<T>;
+  protected followRemote(link: HttpClientLink, config?: Partial<ServerRequestConfigEntry>, options?: ClientRequestOptions): Promise<FetchResponse>;
+  protected getLinkByName(name: string, options?: ClientScope): Promise<HttpClientLink>;
+}
+interface HttpClientLink extends ApiLink {
+  secured?: boolean | ServerRouteSecure;
+  prefix?: string;
+  host?: string;
+  service?: string;
+  schema?: RequestConfigSchema;
+  handler?: (request: ServerRequest, options: ClientRequestOptions) => Async<ServerResponseBody>;
+}
+interface ClientScope {
+  group?: string;
+  service?: string;
+  hostname?: string;
+}
+type HttpVirtualClient<T> = { [K in keyof T as T[K] extends ActionPrimitive<RequestConfigSchema> ? K : never]: T[K] extends ActionPrimitive<infer Schema> ? VirtualAction<Schema> : never };
+interface VirtualAction<T extends RequestConfigSchema> extends Pick<ActionPrimitive<T>, "name" | "run" | "fetch"> {
   (config?: ClientRequestEntry<T>, opts?: ClientRequestOptions): Promise<ClientRequestResponse<T>>;
   can: () => boolean;
 }
@@ -1112,7 +1181,7 @@ declare module "alepha" {
 /**
  * Provides server-side link management and remote capabilities for client-server interactions.
  *
- * The server-links module enables declarative link definitions using `$remote` and `$client` descriptors,
+ * The server-links module enables declarative link definitions using `$remote` and `$client` primitives,
  * facilitating seamless API endpoint management and client-server communication. It integrates with server
  * security features to ensure safe and controlled access to resources.
  *
@@ -1143,7 +1212,21 @@ declare const useAuth: <T extends object = any>() => {
   can: <Api extends object = any>(name: keyof HttpVirtualClient<Api>) => boolean;
 };
 //#endregion
-//#region ../alepha/src/server-cookies/descriptors/$cookie.d.ts
+//#region ../alepha/src/server-auth/schemas/tokensSchema.d.ts
+declare const tokensSchema: alepha4.TObject<{
+  provider: alepha4.TString;
+  access_token: alepha4.TString;
+  issued_at: alepha4.TNumber;
+  expires_in: alepha4.TOptional<alepha4.TNumber>;
+  refresh_token: alepha4.TOptional<alepha4.TString>;
+  refresh_token_expires_in: alepha4.TOptional<alepha4.TNumber>;
+  refresh_expires_in: alepha4.TOptional<alepha4.TNumber>;
+  id_token: alepha4.TOptional<alepha4.TString>;
+  scope: alepha4.TOptional<alepha4.TString>;
+}>;
+type Tokens = Static<typeof tokensSchema>;
+//#endregion
+//#region ../alepha/src/server-cookies/primitives/$cookie.d.ts
 interface Cookies {
   req: Record<string, string>;
   res: Record<string, Cookie | null>;
@@ -1165,9 +1248,9 @@ declare module "alepha/server" {
   }
 }
 /**
- * Provides HTTP cookie management capabilities for server requests and responses with type-safe cookie descriptors.
+ * Provides HTTP cookie management capabilities for server requests and responses with type-safe cookie primitives.
  *
- * The server-cookies module enables declarative cookie handling using the `$cookie` descriptor on class properties.
+ * The server-cookies module enables declarative cookie handling using the `$cookie` primitive on class properties.
  * It offers automatic cookie parsing, secure cookie configuration, and seamless integration with server routes
  * for managing user sessions, preferences, and authentication tokens.
  *
@@ -1175,20 +1258,6 @@ declare module "alepha/server" {
  * @module alepha.server.cookies
  */
 //#endregion
-//#region ../alepha/src/server-auth/schemas/tokensSchema.d.ts
-declare const tokensSchema: alepha18.TObject<{
-  provider: alepha18.TString;
-  access_token: alepha18.TString;
-  issued_at: alepha18.TNumber;
-  expires_in: alepha18.TOptional<alepha18.TNumber>;
-  refresh_token: alepha18.TOptional<alepha18.TString>;
-  refresh_token_expires_in: alepha18.TOptional<alepha18.TNumber>;
-  refresh_expires_in: alepha18.TOptional<alepha18.TNumber>;
-  id_token: alepha18.TOptional<alepha18.TString>;
-  scope: alepha18.TOptional<alepha18.TString>;
-}>;
-type Tokens = Static<typeof tokensSchema>;
-//#endregion
 //#region ../alepha/src/server-auth/index.d.ts
 declare module "alepha" {
   interface State {
@@ -1222,8 +1291,9 @@ declare class ReactAuth {
   protected readonly log: Logger;
   protected readonly alepha: Alepha;
   protected readonly httpClient: HttpClient;
-  protected readonly onBeginTransition: alepha18.HookDescriptor<"react:transition:begin">;
-  protected readonly onFetchRequest: alepha18.HookDescriptor<"client:onRequest">;
+  protected readonly linkProvider: LinkProvider;
+  protected readonly onBeginTransition: alepha4.HookPrimitive<"react:transition:begin">;
+  protected readonly onFetchRequest: alepha4.HookPrimitive<"client:onRequest">;
   /**
    * Get the current authenticated user.
    *
@@ -1240,6 +1310,7 @@ declare class ReactAuth {
     roles?: string[] | undefined;
     id: string;
   } | undefined>;
+  can(action: string): boolean;
   login(provider: string, options: {
     hostname?: string;
     username?: string;
@@ -1253,7 +1324,7 @@ declare class ReactAuth {
 //#region src/auth/providers/ReactAuthProvider.d.ts
 declare class ReactAuthProvider {
   protected readonly alepha: Alepha;
-  readonly onRender: alepha18.HookDescriptor<"react:server:render:begin">;
+  readonly onRender: alepha4.HookPrimitive<"react:server:render:begin">;
 }
 //#endregion
 //#region src/auth/index.d.ts
@@ -1268,7 +1339,7 @@ declare module "@alepha/react" {
  * @see {@link ReactAuthProvider}
  * @module alepha.react.auth
  */
-declare const AlephaReactAuth: alepha18.Service<alepha18.Module>;
+declare const AlephaReactAuth: alepha4.Service<alepha4.Module>;
 //#endregion
 export { AlephaReactAuth, ReactAuth, ReactAuthProvider, useAuth };
 //# sourceMappingURL=index.d.ts.map