@alepha/ui 0.11.12 → 0.12.1

package/dist/core/index.d.ts

@@ -0,0 +1,2743 @@
+import * as alepha79 from "alepha";
+import { Alepha, AlephaError, Async, Descriptor, FileLike, InstantiableClass, LogLevel, LoggerInterface, Page, PageMetadata, Static, StreamLike, TArray, TFile, TObject, TProperties, TRecord, TSchema, TStream, TString, TVoid, TypeBoxError } from "alepha";
+import { AnchorProps, AppShellFooterProps, AppShellHeaderProps, AppShellMainProps, AppShellNavbarProps, AppShellProps, AutocompleteProps, BurgerProps, ButtonProps, ColorInputProps, ColorSchemeScriptProps, FileInputProps, Flex, FlexProps, MantineBreakpoint, MantineProviderProps, MantineSize, MenuProps, MenuTargetProps, ModalProps, MultiSelectProps, NumberInputProps, PasswordInputProps, SegmentedControlProps, SelectProps, SliderProps, SwitchProps, TableProps, TableTrProps, TagsInputProps, Text, TextInputProps, TextareaProps, ThemeIconProps, TooltipProps } from "@mantine/core";
+import { ModalsProviderProps } from "@mantine/modals";
+import * as _mantine_notifications0 from "@mantine/notifications";
+import { NotificationData, NotificationsProps } from "@mantine/notifications";
+import { NavigationProgressProps } from "@mantine/nprogress";
+import * as react_jsx_runtime4 from "react/jsx-runtime";
+import { ComponentType, FC, InputHTMLAttributes, ReactElement, ReactNode } from "react";
+import { DateInputProps, DateTimePickerProps, TimeInputProps } from "@mantine/dates";
+import "dayjs/plugin/relativeTime.js";
+import dayjsDuration from "dayjs/plugin/duration.js";
+import "dayjs/plugin/utc.js";
+import "dayjs/plugin/timezone.js";
+import "dayjs/plugin/localizedFormat.js";
+import "dayjs/locale/ar.js";
+import "dayjs/locale/fr.js";
+import DayjsApi, { Dayjs, ManipulateType, PluginFunc } from "dayjs";
+import { IncomingMessage, Server, ServerResponse } from "node:http";
+import { Readable } from "node:stream";
+import { ReadableStream } from "node:stream/web";
+
+//#region ../alepha/src/logger/schemas/logEntrySchema.d.ts
+declare const logEntrySchema: alepha79.TObject<{
+  level: alepha79.TUnsafe<"SILENT" | "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR">;
+  message: alepha79.TString;
+  service: alepha79.TString;
+  module: alepha79.TString;
+  context: alepha79.TOptional<alepha79.TString>;
+  app: alepha79.TOptional<alepha79.TString>;
+  data: alepha79.TOptional<alepha79.TAny>;
+  timestamp: alepha79.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: alepha79.HookDescriptor<"start">;
+  protected readonly onStop: alepha79.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$1>(fn: (signal: AbortSignal) => Promise<T$1>, duration: DurationLike): Promise<T$1>;
+  /**
+   * 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$6: alepha79.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: alepha79.TOptional<alepha79.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: alepha79.TOptional<alepha79.TUnsafe<"json" | "pretty" | "raw">>;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema$6>> {}
+  interface State {
+    /**
+     * Current log level for the application or specific modules.
+     */
+    "alepha.logger.level"?: string;
+  }
+  interface Hooks {
+    log: {
+      message?: string;
+      entry: LogEntry;
+    };
+  }
+}
+//#endregion
+//#region ../react/src/form/services/FormModel.d.ts
+/**
+ * FormModel is a dynamic form handler that generates form inputs based on a provided TypeBox schema.
+ * It manages form state, handles input changes, and processes form submissions with validation.
+ *
+ * It means to be injected and used within React components to provide a structured way to create and manage forms.
+ *
+ * @see {@link useForm}
+ */
+declare class FormModel<T$1 extends TObject> {
+  readonly id: string;
+  readonly options: FormCtrlOptions<T$1>;
+  protected readonly log: Logger;
+  protected readonly alepha: Alepha;
+  protected readonly values: Record<string, any>;
+  protected submitInProgress: boolean;
+  input: SchemaToInput<T$1>;
+  get submitting(): boolean;
+  constructor(id: string, options: FormCtrlOptions<T$1>);
+  get element(): HTMLFormElement;
+  get currentValues(): Record<string, any>;
+  get props(): {
+    id: string;
+    noValidate: boolean;
+    onSubmit: (ev?: FormEventLike) => void;
+    onReset: (event: FormEventLike) => Promise<void>;
+  };
+  readonly reset: (event: FormEventLike) => Promise<void>;
+  readonly submit: () => Promise<void>;
+  /**
+   * Restructures flat keys like "address.city" into nested objects like { address: { city: ... } }
+   * Values are already typed from onChange, so no conversion is needed.
+   */
+  protected restructureValues(store: Record<string, any>): Record<string, any>;
+  /**
+   * Helper to restructure a flat key like "address.city" into nested object structure.
+   * The value is already typed, so we just assign it to the nested path.
+   */
+  protected restructureNestedValue(values: Record<string, any>, key: string, value: any): void;
+  protected createProxyFromSchema<T$1 extends TObject>(options: FormCtrlOptions<T$1>, schema: TSchema, context: {
+    parent: string;
+    store: Record<string, any>;
+  }): SchemaToInput<T$1>;
+  protected createInputFromSchema<T$1 extends TObject>(name: keyof Static<T$1> & string, options: FormCtrlOptions<T$1>, schema: TObject, required: boolean, context: {
+    parent: string;
+    store: Record<string, any>;
+  }): InputField;
+  /**
+   * Convert an input value to the correct type based on the schema.
+   * Handles raw DOM values (strings, booleans from checkboxes, Files, etc.)
+   */
+  protected getValueFromInput(input: any, schema: TSchema): any;
+  protected valueToInputEntry(value: any): string | number | boolean;
+}
+type SchemaToInput<T$1 extends TObject> = { [K in keyof T$1["properties"]]: T$1["properties"][K] extends TObject ? SchemaToInput<T$1["properties"][K]> : InputField };
+interface FormEventLike {
+  preventDefault?: () => void;
+  stopPropagation?: () => void;
+}
+interface InputField {
+  path: string;
+  required: boolean;
+  props: InputHTMLAttributesLike;
+  schema: TSchema;
+  set: (value: any) => void;
+  form: FormModel<any>;
+}
+type InputHTMLAttributesLike = Pick<InputHTMLAttributes<unknown>, "id" | "name" | "type" | "value" | "defaultValue" | "required" | "maxLength" | "minLength" | "aria-label" | "autoComplete"> & {
+  value?: any;
+  defaultValue?: any;
+  onChange?: (event: any) => void;
+};
+type FormCtrlOptions<T$1 extends TObject> = {
+  /**
+   * The schema defining the structure and validation rules for the form.
+   * This should be a TypeBox schema object.
+   */
+  schema: T$1;
+  /**
+   * Callback function to handle form submission.
+   * This function will receive the parsed and validated form values.
+   */
+  handler: (values: Static<T$1>, args: {
+    form: HTMLFormElement;
+  }) => unknown;
+  /**
+   * Optional initial values for the form fields.
+   * This can be used to pre-populate the form with existing data.
+   */
+  initialValues?: Partial<Static<T$1>>;
+  /**
+   * Optional function to create custom field attributes.
+   * This can be used to add custom validation, styles, or other attributes.
+   */
+  onCreateField?: (name: keyof Static<T$1> & string, schema: TSchema) => InputHTMLAttributes<unknown>;
+  /**
+   * If defined, this will generate a unique ID for each field, prefixed with this string.
+   *
+   * > "username" with id="form-123" will become "form-123-username".
+   *
+   * If omitted, IDs will not be generated.
+   */
+  id?: string;
+  onError?: (error: Error, args: {
+    form: HTMLFormElement;
+  }) => void;
+  onChange?: (key: string, value: any, store: Record<string, any>) => void;
+  onReset?: () => void;
+};
+//#endregion
+//#region ../react/src/form/index.d.ts
+declare module "alepha" {
+  interface Hooks {
+    "form:change": {
+      id: string;
+      path: string;
+      value: any;
+    };
+    "form:reset": {
+      id: string;
+      values: Record<string, any>;
+    };
+    "form:submit:begin": {
+      id: string;
+    };
+    "form:submit:success": {
+      id: string;
+      values: Record<string, any>;
+    };
+    "form:submit:error": {
+      id: string;
+      error: Error;
+    };
+    "form:submit:end": {
+      id: string;
+    };
+  }
+}
+/**
+ * React hooks for managing forms in Alepha applications.
+ *
+ * This module provides a set of hooks to simplify form handling, validation, and submission in React applications built with Alepha.
+ *
+ * It includes:
+ * - `useForm`: A hook for managing form state, validation, and submission.
+ *
+ * @see {@link useForm}
+ * @module alepha.react.form
+ */
+//#endregion
+//#region src/core/utils/parseInput.d.ts
+interface GenericControlProps {
+  input: InputField;
+  title?: string;
+  description?: string;
+  icon?: ReactElement | ((props: {
+    size: number;
+  }) => ReactNode);
+}
+//#endregion
+//#region src/core/components/form/ControlNumber.d.ts
+interface ControlNumberProps extends GenericControlProps {
+  numberInputProps?: Partial<NumberInputProps>;
+  sliderProps?: Partial<SliderProps>;
+}
+//#endregion
+//#region src/core/components/form/ControlSelect.d.ts
+type SelectValueLabel = string | {
+  value: string;
+  label: string;
+  icon?: string;
+};
+interface ControlSelectProps extends GenericControlProps {
+  select?: boolean | SelectProps;
+  multi?: boolean | MultiSelectProps;
+  tags?: boolean | TagsInputProps;
+  autocomplete?: boolean | AutocompleteProps;
+  segmented?: boolean | Partial<SegmentedControlProps>;
+  loader?: () => Promise<SelectValueLabel[]>;
+}
+/**
+ * ControlSelect component for handling Select, MultiSelect, and TagsInput.
+ *
+ * Features:
+ * - Basic Select with enum support
+ * - MultiSelect for array of enums
+ * - TagsInput for array of strings (no enum)
+ * - Future: Lazy loading
+ * - Future: Searchable/filterable options
+ * - Future: Custom option rendering
+ *
+ * Automatically detects enum values and array types from schema.
+ */
+declare const ControlSelect: (props: ControlSelectProps) => react_jsx_runtime4.JSX.Element | null;
+//#endregion
+//#region src/core/components/form/Control.d.ts
+interface ControlProps extends GenericControlProps {
+  text?: TextInputProps;
+  area?: boolean | TextareaProps;
+  select?: boolean | Partial<ControlSelectProps>;
+  password?: boolean | PasswordInputProps;
+  switch?: boolean | SwitchProps;
+  number?: boolean | Partial<ControlNumberProps>;
+  file?: boolean | FileInputProps;
+  color?: boolean | ColorInputProps;
+  date?: boolean | DateInputProps;
+  datetime?: boolean | DateTimePickerProps;
+  time?: boolean | TimeInputProps;
+  query?: any;
+  custom?: ComponentType<CustomControlProps>;
+}
+/**
+ * Generic form control that renders the appropriate input based on the schema and props.
+ *
+ * Supports:
+ * - TextInput (with format detection: email, url, tel)
+ * - Textarea
+ * - NumberInput (for number/integer types)
+ * - FileInput
+ * - ColorInput (for color format)
+ * - Select (for enum types)
+ * - Autocomplete
+ * - PasswordInput
+ * - Switch (for boolean types)
+ * - SegmentedControl (for enum types)
+ * - DateInput (for date format)
+ * - DateTimePicker (for date-time format)
+ * - TimeInput (for time format)
+ * - QueryBuilder (for building type-safe queries with autocomplete)
+ * - Custom component
+ *
+ * Automatically handles labels, descriptions, error messages, required state, and default icons.
+ */
+declare const Control: (_props: ControlProps) => react_jsx_runtime4.JSX.Element | null;
+type CustomControlProps = {
+  defaultValue: any;
+  onChange: (value: any) => void;
+};
+//#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$1 extends Route = Route> {
+  protected routePathRegex: RegExp;
+  protected tree: Tree<T$1>;
+  protected cache: Map<string, RouteMatch<T$1>>;
+  match(path: string): RouteMatch<T$1>;
+  protected test(path: string): void;
+  protected push(route: T$1): void;
+  protected createRouteMatch(path: string): RouteMatch<T$1>;
+  protected mapParams(match: RouteMatch<T$1>): RouteMatch<T$1>;
+  protected createParts(path: string): string[];
+}
+interface RouteMatch<T$1 extends Route> {
+  route?: T$1;
+  params?: Record<string, string>;
+}
+interface Route {
+  path: string;
+  /**
+   * Rename a param in the route.
+   * This is automatically filled when you have scenarios like:
+   * `/customers/:id` and `/customers/:userId/payments`
+   *
+   * In this case, `:id` will be renamed to `:userId` in the second route.
+   */
+  mapParams?: Record<string, string>;
+}
+interface Tree<T$1 extends Route> {
+  route?: T$1;
+  children: {
+    [key: string]: Tree<T$1>;
+  };
+  param?: {
+    route?: T$1;
+    name: string;
+    children: {
+      [key: string]: Tree<T$1>;
+    };
+  };
+  wildcard?: {
+    route: T$1;
+  };
+}
+//#endregion
+//#region ../alepha/src/server/helpers/ServerReply.d.ts
+/**
+ * Helper for building server replies.
+ */
+declare class ServerReply {
+  headers: Record<string, string> & {
+    "set-cookie"?: string[];
+  };
+  status?: number;
+  body?: any;
+  /**
+   * Redirect to a given URL with optional status code (default 302).
+   */
+  redirect(url: string, status?: number): void;
+  /**
+   * Set the response status code.
+   */
+  setStatus(status: number): this;
+  /**
+   * Set a response header.
+   */
+  setHeader(name: string, value: string): this;
+  /**
+   * Set the response body.
+   */
+  setBody(body: any): this;
+}
+//#endregion
+//#region ../alepha/src/server/services/UserAgentParser.d.ts
+interface UserAgentInfo {
+  os: "Windows" | "Android" | "Ubuntu" | "MacOS" | "iOS" | "Linux" | "FreeBSD" | "OpenBSD" | "ChromeOS" | "BlackBerry" | "Symbian" | "Windows Phone";
+  browser: "Chrome" | "Firefox" | "Safari" | "Edge" | "Opera" | "Internet Explorer" | "Brave" | "Vivaldi" | "Samsung Browser" | "UC Browser" | "Yandex";
+  device: "MOBILE" | "DESKTOP" | "TABLET";
+}
+/**
+ * Simple User-Agent parser to detect OS, browser, and device type.
+ * This parser is not exhaustive and may not cover all edge cases.
+ *
+ * Use result for non
+ */
+declare class UserAgentParser {
+  parse(userAgent?: string): UserAgentInfo;
+}
+//#endregion
+//#region ../alepha/src/server/interfaces/ServerRequest.d.ts
+type TRequestBody = TObject | TString | TArray | TRecord | TStream;
+type TResponseBody = TObject | TString | TRecord | TFile | TArray | TStream | TVoid;
+interface RequestConfigSchema {
+  body?: TRequestBody;
+  params?: TObject;
+  query?: TObject;
+  headers?: TObject;
+  response?: TResponseBody;
+}
+interface ServerRequestConfig<TConfig extends RequestConfigSchema = RequestConfigSchema> {
+  body: TConfig["body"] extends TRequestBody ? Static<TConfig["body"]> : any;
+  headers: TConfig["headers"] extends TObject ? Static<TConfig["headers"]> : Record<string, string>;
+  params: TConfig["params"] extends TObject ? Static<TConfig["params"]> : Record<string, string>;
+  query: TConfig["query"] extends TObject ? Static<TConfig["query"]> : Record<string, any>;
+}
+type ServerRequestConfigEntry<TConfig extends RequestConfigSchema = RequestConfigSchema> = Partial<ServerRequestConfig<TConfig>>;
+interface ServerRequest<TConfig extends RequestConfigSchema = RequestConfigSchema> extends ServerRequestConfig<TConfig> {
+  /**
+   * HTTP method used for this request.
+   */
+  method: RouteMethod;
+  /**
+   * Full request URL.
+   */
+  url: URL;
+  /**
+   * Unique request ID assigned to this request.
+   */
+  requestId: string;
+  /**
+   * Client IP address.
+   * Will parse `X-Forwarded-For` header if present.
+   */
+  ip?: string;
+  /**
+   * Value of the `Host` header sent by the client.
+   */
+  host?: string;
+  /**
+   * Browser user agent information.
+   * Information are not guaranteed to be accurate. Use with caution.
+   *
+   * @see {@link UserAgentParser}
+   */
+  userAgent: UserAgentInfo;
+  /**
+   * Arbitrary metadata attached to the request. Can be used by middlewares to store information.
+   */
+  metadata: Record<string, any>;
+  /**
+   * Reply object to be used to send response.
+   */
+  reply: ServerReply;
+  /**
+   * The raw underlying request object (Web Request).
+   */
+  raw: ServerRawRequest;
+}
+interface ServerRoute<TConfig extends RequestConfigSchema = RequestConfigSchema> extends Route {
+  /**
+   * Handler function for this route.
+   */
+  handler: ServerHandler<TConfig>;
+  /**
+   * HTTP method for this route.
+   */
+  method?: RouteMethod;
+  /**
+   * Request/response schema for this route.
+   *
+   * Request schema contains:
+   * - body, for POST/PUT/PATCH requests
+   * - params, for URL parameters (e.g. /user/:id)
+   * - query, for URL query parameters (e.g. /user?id=123)
+   * - headers, for HTTP headers
+   *
+   * Response schema contains:
+   * - response
+   *
+   * Response schema is used to validate and serialize the response sent by the handler.
+   */
+  schema?: TConfig;
+  /**
+   * @see ServerLoggerProvider
+   */
+  silent?: boolean;
+}
+type ServerResponseBody<TConfig extends RequestConfigSchema = RequestConfigSchema> = TConfig["response"] extends TResponseBody ? Static<TConfig["response"]> : ResponseBodyType;
+type ResponseKind = "json" | "text" | "void" | "file" | "any";
+type ResponseBodyType = string | Buffer | StreamLike | undefined | null | void;
+type ServerHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (request: ServerRequest<TConfig>) => Async<ServerResponseBody<TConfig>>;
+interface ServerResponse$1 {
+  body: string | Buffer | ArrayBuffer | Readable | ReadableStream;
+  headers: Record<string, string>;
+  status: number;
+}
+type ServerRouteRequestHandler = (request: ServerRequestData) => Promise<ServerResponse$1>;
+interface ServerRouteMatcher extends Route {
+  handler: ServerRouteRequestHandler;
+}
+interface ServerRequestData {
+  method: RouteMethod;
+  url: URL;
+  headers: Record<string, string>;
+  query: Record<string, string>;
+  params: Record<string, string>;
+  raw: ServerRawRequest;
+}
+interface ServerRawRequest {
+  node?: NodeRequestEvent;
+  web?: WebRequestEvent;
+}
+interface NodeRequestEvent {
+  req: IncomingMessage;
+  res: ServerResponse;
+}
+interface WebRequestEvent {
+  req: Request;
+  res?: Response;
+}
+//#endregion
+//#region ../alepha/src/server/services/ServerRequestParser.d.ts
+declare class ServerRequestParser {
+  protected readonly alepha: Alepha;
+  protected readonly userAgentParser: UserAgentParser;
+  createServerRequest(rawRequest: ServerRequestData): ServerRequest;
+  getRequestId(request: ServerRequestData): string | undefined;
+  getRequestUserAgent(request: ServerRequestData): UserAgentInfo;
+  getRequestIp(request: ServerRequestData): string | undefined;
+}
+//#endregion
+//#region ../alepha/src/server/providers/ServerTimingProvider.d.ts
+type TimingMap = Record<string, [number, number]>;
+declare class ServerTimingProvider {
+  protected readonly log: Logger;
+  protected readonly alepha: Alepha;
+  options: {
+    prefix: string;
+    disabled: boolean;
+  };
+  readonly onRequest: alepha79.HookDescriptor<"server:onRequest">;
+  readonly onResponse: alepha79.HookDescriptor<"server:onResponse">;
+  protected get handlerName(): string;
+  beginTiming(name: string): void;
+  endTiming(name: string): void;
+  protected setDuration(name: string, timing: TimingMap): void;
+}
+//#endregion
+//#region ../alepha/src/server/providers/ServerRouterProvider.d.ts
+/**
+ * Main router for all routes on the server side.
+ *
+ * - $route => generic route
+ * - $action => action route (for API calls)
+ * - $page => React route (for SSR)
+ */
+declare class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
+  protected readonly log: Logger;
+  protected readonly alepha: Alepha;
+  protected readonly routes: ServerRoute[];
+  protected readonly serverTimingProvider: ServerTimingProvider;
+  protected readonly serverRequestParser: ServerRequestParser;
+  /**
+   * Get all registered routes, optionally filtered by a pattern.
+   *
+   * Pattern accept simple wildcard '*' at the end.
+   * Example: '/api/*' will match all routes starting with '/api/' but '/api/' will match only that exact route.
+   */
+  getRoutes(pattern?: string): ServerRoute[];
+  createRoute<TConfig extends RequestConfigSchema = RequestConfigSchema>(route: ServerRoute<TConfig>): void;
+  protected getContextId(headers: Record<string, string>): string;
+  protected processRequest(request: ServerRequest, route: ServerRoute, responseKind: ResponseKind): Promise<{
+    status: number;
+    headers: Record<string, string> & {
+      "set-cookie"?: string[];
+    };
+    body: any;
+  }>;
+  protected runRouteHandler(route: ServerRoute, request: ServerRequest, responseKind: ResponseKind): Promise<void>;
+  serializeResponse(route: ServerRoute, reply: ServerReply, responseKind: ResponseKind): void;
+  protected getResponseType(schema?: RequestConfigSchema): ResponseKind;
+  protected errorHandler(route: ServerRoute, request: ServerRequest, error: Error): Promise<void>;
+  validateRequest(route: {
+    schema?: RequestConfigSchema;
+  }, request: ServerRequestConfig): void;
+}
+//#endregion
+//#region ../alepha/src/server/providers/ServerProvider.d.ts
+/**
+ * Base server provider to handle incoming requests and route them.
+ *
+ * This is the default implementation for serverless environments.
+ *
+ * ServerProvider supports both Node.js HTTP requests and Web (Fetch API) requests.
+ */
+declare class ServerProvider {
+  protected readonly log: Logger;
+  protected readonly alepha: Alepha;
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly router: ServerRouterProvider;
+  protected readonly internalServerErrorMessage = "Internal Server Error";
+  get hostname(): string;
+  /**
+   * When a Node.js HTTP request is received from outside. (Vercel, AWS Lambda, etc.)
+   */
+  protected readonly onNodeRequest: alepha79.HookDescriptor<"node:request">;
+  /**
+   * When a Web (Fetch API) request is received from outside. (Netlify, Cloudflare Workers, etc.)
+   */
+  protected readonly onWebRequest: alepha79.HookDescriptor<"web:request">;
+  /**
+   * Handle Node.js HTTP request event.
+   *
+   * Technically, we just convert Node.js request to Web Standard Request.
+   */
+  handleNodeRequest(nodeRequestEvent: NodeRequestEvent): Promise<void>;
+  /**
+   * Handle Web (Fetch API) request event.
+   */
+  handleWebRequest(ev: WebRequestEvent): Promise<void>;
+  /**
+   * Helper for Vite development mode to let Vite handle (or not) 404.
+   */
+  protected isViteNotFound(url?: string, route?: Route, params?: Record<string, string>): boolean;
+}
+//#endregion
+//#region ../alepha/src/cache/providers/CacheProvider.d.ts
+/**
+ * Cache provider interface.
+ *
+ * All methods are asynchronous and return promises.
+ * Values are stored as Uint8Array.
+ */
+declare abstract class CacheProvider {
+  /**
+   * Get the value of a key.
+   *
+   * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
+   * @param key The key of the value to get.
+   *
+   * @return The value of the key, or undefined if the key does not exist.
+   */
+  abstract get(name: string, key: string): Promise<Uint8Array | undefined>;
+  /**
+   * Set the string value of a key.
+   *
+   * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
+   * @param key The key of the value to set.
+   * @param value The value to set.
+   * @param ttl The time-to-live of the key, in milliseconds.
+   *
+   * @return The value of the key.
+   */
+  abstract set(name: string, key: string, value: Uint8Array, ttl?: number): Promise<Uint8Array>;
+  /**
+   * Remove the specified keys.
+   *
+   * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
+   * @param keys The keys to delete.
+   */
+  abstract del(name: string, ...keys: string[]): Promise<void>;
+  abstract has(name: string, key: string): Promise<boolean>;
+  abstract keys(name: string, filter?: string): Promise<string[]>;
+  /**
+   * Remove all keys from all cache names.
+   */
+  abstract clear(): Promise<void>;
+}
+//#endregion
+//#region ../alepha/src/cache/descriptors/$cache.d.ts
+interface CacheDescriptorOptions<TReturn = any, TParameter extends any[] = any[]> {
+  /**
+   * The cache name. This is useful for invalidating multiple caches at once.
+   *
+   * Store key as `cache:$name:$key`.
+   *
+   * @default Name of the key of the class.
+   */
+  name?: string;
+  /**
+   * Function which returns cached data.
+   */
+  handler?: (...args: TParameter) => TReturn;
+  /**
+   * The key generator for the cache.
+   * If not provided, the arguments will be json.stringify().
+   */
+  key?: (...args: TParameter) => string;
+  /**
+   * The store provider for the cache.
+   * If not provided, the default store provider will be used.
+   */
+  provider?: InstantiableClass<CacheProvider> | "memory";
+  /**
+   * The time-to-live for the cache in seconds.
+   * Set 0 to skip expiration.
+   *
+   * @default 300 (5 minutes).
+   */
+  ttl?: DurationLike;
+  /**
+   * If the cache is disabled.
+   */
+  disabled?: boolean;
+}
+declare class CacheDescriptor<TReturn = any, TParameter extends any[] = any[]> extends Descriptor<CacheDescriptorOptions<TReturn, TParameter>> {
+  protected readonly env: {
+    CACHE_ENABLED: boolean;
+    CACHE_DEFAULT_TTL: number;
+  };
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly provider: CacheProvider;
+  protected encoder: TextEncoder;
+  protected decoder: TextDecoder;
+  protected codes: {
+    BINARY: number;
+    JSON: number;
+    STRING: number;
+  };
+  get container(): string;
+  run(...args: TParameter): Promise<TReturn>;
+  key(...args: TParameter): string;
+  invalidate(...keys: string[]): Promise<void>;
+  set(key: string, value: TReturn, ttl?: DurationLike): Promise<void>;
+  get(key: string): Promise<TReturn | undefined>;
+  protected serialize<TReturn>(value: TReturn): Uint8Array;
+  protected deserialize<TReturn>(uint8Array: Uint8Array): Promise<TReturn>;
+  protected $provider(): CacheProvider;
+}
+interface CacheDescriptorFn<TReturn = any, TParameter extends any[] = any[]> extends CacheDescriptor<TReturn, TParameter> {
+  /**
+   * Run the cache descriptor with the provided arguments.
+   */
+  (...args: TParameter): Promise<TReturn>;
+}
+//#endregion
+//#region ../alepha/src/server/services/HttpClient.d.ts
+declare class HttpClient {
+  protected readonly log: Logger;
+  protected readonly alepha: Alepha;
+  readonly cache: CacheDescriptorFn<HttpClientCache, any[]>;
+  protected readonly pendingRequests: HttpClientPendingRequests;
+  fetchAction(args: FetchActionArgs): Promise<FetchResponse>;
+  fetch<T$1 extends TSchema>(url: string, request?: RequestInitWithOptions<T$1>): Promise<FetchResponse<Static<T$1>>>;
+  protected url(host: string, action: HttpAction, args: ServerRequestConfigEntry): string;
+  protected body(init: RequestInit, headers: Record<string, string>, action: HttpAction, args?: ServerRequestConfigEntry): Promise<void>;
+  protected responseData(response: Response, options: FetchOptions): Promise<any>;
+  protected isMaybeFile(response: Response): boolean;
+  protected createFileLike(response: Response, defaultFileName?: string): FileLike;
+  pathVariables(url: string, action: {
+    schema?: {
+      params?: TObject;
+    };
+  }, args?: ServerRequestConfigEntry): string;
+  queryParams(url: string, action: {
+    schema?: {
+      query?: TObject;
+    };
+  }, args?: ServerRequestConfigEntry): string;
+}
+interface FetchOptions<T$1 extends TSchema = TSchema> {
+  /**
+   * Key to identify the request in the pending requests.
+   */
+  key?: string;
+  /**
+   * The schema to validate the response against.
+   */
+  schema?: {
+    response?: T$1;
+  };
+  /**
+   * Built-in cache options.
+   */
+  localCache?: boolean | number | DurationLike;
+}
+type RequestInitWithOptions<T$1 extends TSchema = TSchema> = RequestInit & FetchOptions<T$1>;
+interface FetchResponse<T$1 = any> {
+  data: T$1;
+  status: number;
+  statusText: string;
+  headers: Headers;
+  raw?: Response;
+}
+type HttpClientPendingRequests = Record<string, Promise<any> | undefined>;
+interface HttpClientCache {
+  data: any;
+  etag?: string;
+}
+interface FetchActionArgs {
+  action: HttpAction;
+  host?: string;
+  config?: ServerRequestConfigEntry;
+  options?: ClientRequestOptions;
+}
+interface HttpAction {
+  method?: string;
+  prefix?: string;
+  path: string;
+  requestBodyType?: string;
+  schema?: {
+    params?: TObject;
+    query?: TObject;
+    body?: TRequestBody;
+    response?: TResponseBody;
+  };
+}
+//#endregion
+//#region ../alepha/src/server/descriptors/$action.d.ts
+interface ActionDescriptorOptions<TConfig extends RequestConfigSchema> extends Omit<ServerRoute, "handler" | "path" | "schema" | "mapParams"> {
+  /**
+   * Name of the action.
+   *
+   * - It will be used to generate the route path if `path` is not provided.
+   * - It will be used to generate the permission name if `security` is enabled.
+   */
+  name?: string;
+  /**
+   * Group actions together.
+   *
+   * - If not provided, the service name containing the route will be used.
+   * - It will be used as Tag for documentation purposes.
+   * - It will be used for permission name generation if `security` is enabled.
+   *
+   * @example
+   * ```ts
+   * // group = "MyController"
+   * class MyController {
+   * 	hello = $action({ handler: () => "Hello World" });
+   * }
+   *
+   * // group = "users"
+   * class MyOtherController {
+   *   group = "users";
+   *   a1 = $action({ handler: () => "Action 1", group: this.group });
+   *   a2 = $action({ handler: () => "Action 2", group: this.group });
+   * }
+   * ```
+   */
+  group?: string;
+  /**
+   * Pathname of the route. If not provided, property key is used.
+   */
+  path?: string;
+  /**
+   * The route method.
+   *
+   * - If not provided, it will be set to "GET" by default.
+   * - If not provider and a body is provided, it will be set to "POST".
+   *
+   * Wildcard methods are not supported for now. (e.g. "ALL", "ANY", etc.)
+   */
+  method?: RouteMethod;
+  /**
+   * The config schema of the route.
+   * - body: The request body schema.
+   * - params: Path variables schema.
+   * - query: The request query-params schema.
+   * - response: The response schema.
+   */
+  schema?: TConfig;
+  /**
+   * A short description of the action. Used for documentation purposes.
+   */
+  description?: string;
+  /**
+   * Disable the route. Useful with env variables do disable one specific route.
+   * Route won't be available in the API but can still be called locally!
+   */
+  disabled?: boolean;
+  /**
+   * Main route handler. This is where the route logic is implemented.
+   */
+  handler: ServerActionHandler<TConfig>;
+}
+declare class ActionDescriptor<TConfig extends RequestConfigSchema> extends Descriptor<ActionDescriptorOptions<TConfig>> {
+  protected readonly log: Logger;
+  protected readonly env: {
+    SERVER_API_PREFIX: string;
+  };
+  protected readonly httpClient: HttpClient;
+  protected readonly serverProvider: ServerProvider;
+  protected readonly serverRouterProvider: ServerRouterProvider;
+  protected onInit(): void;
+  get prefix(): string;
+  get route(): ServerRoute;
+  /**
+   * Returns the name of the action.
+   */
+  get name(): string;
+  /**
+   * Returns the group of the action. (e.g. "orders", "admin", etc.)
+   */
+  get group(): string;
+  /**
+   * Returns the HTTP method of the action.
+   */
+  get method(): RouteMethod;
+  /**
+   * Returns the path of the action.
+   *
+   * Path is prefixed by `/api` by default.
+   */
+  get path(): string;
+  get schema(): TConfig | undefined;
+  getBodyContentType(): string | undefined;
+  /**
+   * Call the action handler directly.
+   * There is no HTTP layer involved.
+   */
+  run(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<ClientRequestResponse<TConfig>>;
+  /**
+   * Works like `run`, but always fetches (http request) the route.
+   */
+  fetch(config?: ClientRequestEntry<TConfig>, options?: ClientRequestOptions): Promise<FetchResponse<ClientRequestResponse<TConfig>>>;
+}
+type ClientRequestEntry<TConfig extends RequestConfigSchema, T$1 = ClientRequestEntryContainer<TConfig>> = { [K in keyof T$1 as T$1[K] extends undefined ? never : K]: T$1[K] };
+type ClientRequestEntryContainer<TConfig extends RequestConfigSchema> = {
+  body: TConfig["body"] extends TObject ? Static<TConfig["body"]> : undefined;
+  params: TConfig["params"] extends TObject ? Static<TConfig["params"]> : undefined;
+  headers?: TConfig["headers"] extends TObject ? Static<TConfig["headers"]> : undefined;
+  query?: TConfig["query"] extends TObject ? Partial<Static<TConfig["query"]>> : undefined;
+};
+interface ClientRequestOptions extends FetchOptions {
+  /**
+   * Standard request fetch options.
+   */
+  request?: RequestInit;
+}
+type ClientRequestResponse<TConfig extends RequestConfigSchema> = TConfig["response"] extends TSchema ? Static<TConfig["response"]> : any;
+/**
+ * Specific handler for server actions.
+ */
+type ServerActionHandler<TConfig extends RequestConfigSchema = RequestConfigSchema> = (request: ServerActionRequest<TConfig>) => Async<ServerResponseBody<TConfig>>;
+/**
+ * Server Action Request Interface
+ *
+ * Can be extended with module augmentation to add custom properties (like `user` in Server Security).
+ *
+ * This is NOT Server Request, but a specific type for actions.
+ */
+interface ServerActionRequest<TConfig extends RequestConfigSchema> extends ServerRequest<TConfig> {}
+//#endregion
+//#region ../alepha/src/server/schemas/errorSchema.d.ts
+declare const errorSchema: alepha79.TObject<{
+  error: alepha79.TString;
+  status: alepha79.TInteger;
+  message: alepha79.TString;
+  details: alepha79.TOptional<alepha79.TString>;
+  requestId: alepha79.TOptional<alepha79.TString>;
+  cause: alepha79.TOptional<alepha79.TObject<{
+    name: alepha79.TString;
+    message: alepha79.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$5: alepha79.TObject<{
+  SERVER_PORT: alepha79.TInteger;
+  SERVER_HOST: alepha79.TString;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema$5>> {}
+}
+//#endregion
+//#region ../alepha/src/server/providers/NodeHttpServerProvider.d.ts
+declare const envSchema$4: alepha79.TObject<{
+  SERVER_PORT: alepha79.TInteger;
+  SERVER_HOST: alepha79.TString;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema$4>> {}
+}
+//#endregion
+//#region ../alepha/src/server/index.d.ts
+declare module "alepha" {
+  interface State {
+    "alepha.node.server"?: Server;
+  }
+  interface Hooks {
+    "action:onRequest": {
+      action: ActionDescriptor<RequestConfigSchema>;
+      request: ServerRequest;
+      options: ClientRequestOptions;
+    };
+    "action:onResponse": {
+      action: ActionDescriptor<RequestConfigSchema>;
+      request: ServerRequest;
+      options: ClientRequestOptions;
+      response: any;
+    };
+    "server:onRequest": {
+      route: ServerRoute;
+      request: ServerRequest;
+    };
+    "server:onError": {
+      route: ServerRoute;
+      request: ServerRequest;
+      error: Error;
+    };
+    "server:onSend": {
+      route: ServerRoute;
+      request: ServerRequest;
+    };
+    "server:onResponse": {
+      route: ServerRoute;
+      request: ServerRequest;
+      response: ServerResponse$1;
+    };
+    "client:onRequest": {
+      route: HttpAction;
+      config: ServerRequestConfigEntry;
+      options: ClientRequestOptions;
+      headers: Record<string, string>;
+      request: RequestInit;
+    };
+    "client:beforeFetch": {
+      url: string;
+      options: FetchOptions;
+      request: RequestInit;
+    };
+    "client:onError": {
+      route?: HttpAction;
+      error: HttpError;
+    };
+    "node:request": NodeRequestEvent;
+    "web:request": WebRequestEvent;
+  }
+}
+//#endregion
+//#region ../alepha/src/server-cache/providers/ServerCacheProvider.d.ts
+declare module "alepha/server" {
+  interface ServerRoute {
+    /**
+     * Enable caching for this route.
+     * - If true: enables both store and etag
+     * - If object: fine-grained control over store, etag, and cache-control headers
+     *
+     * @default false
+     */
+    cache?: ServerRouteCache;
+  }
+  interface ActionDescriptor<TConfig extends RequestConfigSchema> {
+    invalidate: () => Promise<void>;
+  }
+}
+type ServerRouteCache =
+/**
+ * If true, enables caching with:
+ * - store: true
+ * - etag: true
+ */
+boolean
+/**
+ * Object configuration for fine-grained cache control.
+ *
+ * If empty, no caching will be applied.
+ */ | {
+  /**
+   * If true, enables storing cached responses. (in-memory, Redis, @see alepha/cache for other providers)
+   * If a DurationLike is provided, it will be used as the TTL for the cache.
+   * If CacheDescriptorOptions is provided, it will be used to configure the cache storage.
+   *
+   * @default false
+   */
+  store?: true | DurationLike | CacheDescriptorOptions;
+  /**
+   * If true, enables ETag support for the cached responses.
+   */
+  etag?: true;
+  /**
+   * - If true, sets Cache-Control to "public, max-age=300" (5 minutes).
+   * - If string, sets Cache-Control to the provided value directly.
+   * - If object, configures Cache-Control directives.
+   */
+  control?: true
+  /**
+   * If string, sets Cache-Control to the provided value directly.
+   */ | string
+  /**
+   * If object, configures Cache-Control directives.
+   */ | {
+    /**
+     * Indicates that the response may be cached by any cache.
+     */
+    public?: boolean;
+    /**
+     * Indicates that the response is intended for a single user and must not be stored by a shared cache.
+     */
+    private?: boolean;
+    /**
+     * Forces caches to submit the request to the origin server for validation before releasing a cached copy.
+     */
+    noCache?: boolean;
+    /**
+     * Instructs caches not to store the response.
+     */
+    noStore?: boolean;
+    /**
+     * Maximum amount of time a resource is considered fresh.
+     * Can be specified as a number (seconds) or as a DurationLike object.
+     *
+     * @example 300 // 5 minutes in seconds
+     * @example { minutes: 5 } // 5 minutes
+     * @example { hours: 1 } // 1 hour
+     */
+    maxAge?: number | DurationLike;
+    /**
+     * Overrides max-age for shared caches (e.g., CDNs).
+     * Can be specified as a number (seconds) or as a DurationLike object.
+     */
+    sMaxAge?: number | DurationLike;
+    /**
+     * Indicates that once a resource becomes stale, caches must not use it without successful validation.
+     */
+    mustRevalidate?: boolean;
+    /**
+     * Similar to must-revalidate, but only for shared caches.
+     */
+    proxyRevalidate?: boolean;
+    /**
+     * Indicates that the response can be stored but must be revalidated before each use.
+     */
+    immutable?: boolean;
+  };
+};
+//#endregion
+//#region ../react/src/core/components/ClientOnly.d.ts
+interface ClientOnlyProps {
+  fallback?: ReactNode;
+  disabled?: boolean;
+}
+//#endregion
+//#region ../react/src/core/errors/Redirection.d.ts
+/**
+ * Used for Redirection during the page loading.
+ *
+ * Depends on the context, it can be thrown or just returned.
+ */
+declare class Redirection extends Error {
+  readonly redirect: string;
+  constructor(redirect: string);
+}
+//#endregion
+//#region ../react/src/core/providers/ReactPageProvider.d.ts
+declare const envSchema$3: alepha79.TObject<{
+  REACT_STRICT_MODE: alepha79.TBoolean;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema$3>> {}
+}
+interface PageRouteEntry extends Omit<PageDescriptorOptions, "children" | "parent"> {
+  children?: PageRouteEntry[];
+}
+interface PageRoute extends PageRouteEntry {
+  type: "page";
+  name: string;
+  parent?: PageRoute;
+  match: string;
+}
+interface Layer {
+  config?: {
+    query?: Record<string, any>;
+    params?: Record<string, any>;
+    context?: Record<string, any>;
+  };
+  name: string;
+  props?: Record<string, any>;
+  error?: Error;
+  part?: string;
+  element: ReactNode;
+  index: number;
+  path: string;
+  route?: PageRoute;
+  cache?: boolean;
+}
+type PreviousLayerData = Omit<Layer, "element" | "index" | "path">;
+interface ReactRouterState {
+  /**
+   * Stack of layers for the current page.
+   */
+  layers: Array<Layer>;
+  /**
+   * URL of the current page.
+   */
+  url: URL;
+  /**
+   * Error handler for the current page.
+   */
+  onError: ErrorHandler;
+  /**
+   * Params extracted from the URL for the current page.
+   */
+  params: Record<string, any>;
+  /**
+   * Query parameters extracted from the URL for the current page.
+   */
+  query: Record<string, string>;
+  /**
+   * Optional meta information associated with the current page.
+   */
+  meta: Record<string, any>;
+}
+interface TransitionOptions {
+  previous?: PreviousLayerData[];
+}
+//#endregion
+//#region ../react/src/core/services/ReactPageService.d.ts
+declare class ReactPageService {
+  fetch(pathname: string, options?: PageDescriptorRenderOptions): Promise<{
+    html: string;
+    response: Response;
+  }>;
+  render(name: string, options?: PageDescriptorRenderOptions): Promise<PageDescriptorRenderResult>;
+}
+//#endregion
+//#region ../react/src/core/descriptors/$page.d.ts
+interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
+  /**
+   * Identifier name for the page. Must be unique.
+   *
+   * @default Descriptor key
+   */
+  name?: string;
+  /**
+   * Add a pathname to the page.
+   *
+   * Pathname can contain parameters, like `/post/:slug`.
+   *
+   * @default ""
+   */
+  path?: string;
+  /**
+   * Add an input schema to define:
+   * - `params`: parameters from the pathname.
+   * - `query`: query parameters from the URL.
+   */
+  schema?: TConfig;
+  /**
+   * Load data before rendering the page.
+   *
+   * This function receives
+   * - the request context and
+   * - the parent props (if page has a parent)
+   *
+   * In SSR, the returned data will be serialized and sent to the client, then reused during the client-side hydration.
+   *
+   * Resolve can be stopped by throwing an error, which will be handled by the `errorHandler` function.
+   * It's common to throw a `NotFoundError` to display a 404 page.
+   *
+   * RedirectError can be thrown to redirect the user to another page.
+   */
+  resolve?: (context: PageResolve<TConfig, TPropsParent>) => Async<TProps>;
+  /**
+   * The component to render when the page is loaded.
+   *
+   * If `lazy` is defined, this will be ignored.
+   * Prefer using `lazy` to improve the initial loading time.
+   */
+  component?: FC<TProps & TPropsParent>;
+  /**
+   * Lazy load the component when the page is loaded.
+   *
+   * It's recommended to use this for components to improve the initial loading time
+   * and enable code-splitting.
+   */
+  lazy?: () => Promise<{
+    default: FC<TProps & TPropsParent>;
+  }>;
+  /**
+   * Attach child pages to create nested routes.
+   * This will make the page a parent route.
+   */
+  children?: Array<PageDescriptor> | (() => Array<PageDescriptor>);
+  /**
+   * Define a parent page for nested routing.
+   */
+  parent?: PageDescriptor<PageConfigSchema, TPropsParent, any>;
+  can?: () => boolean;
+  /**
+   * Catch any error from the `resolve` function or during `rendering`.
+   *
+   * Expected to return one of the following:
+   * - a ReactNode to render an error page
+   * - a Redirection to redirect the user
+   * - undefined to let the error propagate
+   *
+   * If not defined, the error will be thrown and handled by the server or client error handler.
+   * If a leaf $page does not define an error handler, the error can be caught by parent pages.
+   *
+   * @example Catch a 404 from API and render a custom not found component:
+   * ```ts
+   * resolve: async ({ params, query }) => {
+   *    api.fetch("/api/resource", { params, query });
+   * },
+   * errorHandler: (error, context) => {
+   *   if (HttpError.is(error, 404)) {
+   *     return <ResourceNotFound />;
+   *   }
+   * }
+   * ```
+   *
+   * @example Catch an 401 error and redirect the user to the login page:
+   * ```ts
+   * resolve: async ({ params, query }) => {
+   *   // but the user is not authenticated
+   *   api.fetch("/api/resource", { params, query });
+   * },
+   * errorHandler: (error, context) => {
+   *   if (HttpError.is(error, 401)) {
+   *     // throwing a Redirection is also valid!
+   *     return new Redirection("/login");
+   *   }
+   * }
+   * ```
+   */
+  errorHandler?: ErrorHandler;
+  /**
+   * If true, the page will be considered as a static page, immutable and cacheable.
+   * Replace boolean by an object to define static entries. (e.g. list of params/query)
+   *
+   * Browser-side: it only works with `alepha/vite`, which can pre-render the page at build time.
+   *
+   * Server-side: It will act as timeless cached page. You can use `cache` to configure the cache behavior.
+   */
+  static?: boolean | {
+    entries?: Array<Partial<PageRequestConfig<TConfig>>>;
+  };
+  cache?: ServerRouteCache;
+  /**
+   * If true, force the page to be rendered only on the client-side (browser).
+   * It uses the `<ClientOnly/>` component to render the page.
+   */
+  client?: boolean | ClientOnlyProps;
+  /**
+   * Called before the server response is sent to the client. (server only)
+   */
+  onServerResponse?: (request: ServerRequest) => unknown;
+  /**
+   * Called when user leaves the page. (browser only)
+   */
+  onLeave?: () => void;
+  /**
+   * @experimental
+   *
+   * Add a css animation when the page is loaded or unloaded.
+   * It uses CSS animations, so you need to define the keyframes in your CSS.
+   *
+   * @example Simple animation name
+   * ```ts
+   * animation: "fadeIn"
+   * ```
+   *
+   * CSS example:
+   * ```css
+   * @keyframes fadeIn {
+   *  from { opacity: 0; }
+   *  to { opacity: 1; }
+   * }
+   * ```
+   *
+   * @example Detailed animation
+   * ```ts
+   * animation: {
+   *   enter: { name: "fadeIn", duration: 300 },
+   *   exit: { name: "fadeOut", duration: 200, timing: "ease-in-out" },
+   * }
+   * ```
+   *
+   * @example Only exit animation
+   * ```ts
+   * animation: {
+   *   exit: "fadeOut"
+   * }
+   * ```
+   *
+   * @example With custom timing function
+   * ```ts
+   * animation: {
+   *   enter: { name: "fadeIn", duration: 300, timing: "cubic-bezier(0.4, 0, 0.2, 1)" },
+   *   exit: { name: "fadeOut", duration: 200, timing: "ease-in-out" },
+   * }
+   * ```
+   */
+  animation?: PageAnimation;
+}
+type ErrorHandler = (error: Error, state: ReactRouterState) => ReactNode | Redirection | undefined;
+declare class PageDescriptor<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> extends Descriptor<PageDescriptorOptions<TConfig, TProps, TPropsParent>> {
+  protected readonly reactPageService: ReactPageService;
+  protected onInit(): void;
+  get name(): string;
+  /**
+   * For testing or build purposes.
+   *
+   * This will render the page (HTML layout included or not) and return the HTML + context.
+   * Only valid for server-side rendering, it will throw an error if called on the client-side.
+   */
+  render(options?: PageDescriptorRenderOptions): Promise<PageDescriptorRenderResult>;
+  fetch(options?: PageDescriptorRenderOptions): Promise<{
+    html: string;
+    response: Response;
+  }>;
+  match(url: string): boolean;
+  pathname(config: any): string;
+}
+interface PageConfigSchema {
+  query?: TSchema;
+  params?: TSchema;
+}
+type TPropsDefault = any;
+type TPropsParentDefault = {};
+interface PageDescriptorRenderOptions {
+  params?: Record<string, string>;
+  query?: Record<string, string>;
+  /**
+   * If true, the HTML layout will be included in the response.
+   * If false, only the page content will be returned.
+   *
+   * @default true
+   */
+  html?: boolean;
+  hydration?: boolean;
+}
+interface PageDescriptorRenderResult {
+  html: string;
+  state: ReactRouterState;
+  redirect?: string;
+}
+interface PageRequestConfig<TConfig extends PageConfigSchema = PageConfigSchema> {
+  params: TConfig["params"] extends TSchema ? Static<TConfig["params"]> : Record<string, string>;
+  query: TConfig["query"] extends TSchema ? Static<TConfig["query"]> : Record<string, string>;
+}
+type PageResolve<TConfig extends PageConfigSchema = PageConfigSchema, TPropsParent extends object = TPropsParentDefault> = PageRequestConfig<TConfig> & TPropsParent & Omit<ReactRouterState, "layers" | "onError">;
+type PageAnimation = PageAnimationObject | ((state: ReactRouterState) => PageAnimationObject | undefined);
+type PageAnimationObject = CssAnimationName | {
+  enter?: CssAnimation | CssAnimationName;
+  exit?: CssAnimation | CssAnimationName;
+};
+type CssAnimationName = string;
+type CssAnimation = {
+  name: string;
+  duration?: number;
+  timing?: string;
+};
+//#endregion
+//#region ../alepha/src/security/schemas/userAccountInfoSchema.d.ts
+declare const userAccountInfoSchema: alepha79.TObject<{
+  id: alepha79.TString;
+  name: alepha79.TOptional<alepha79.TString>;
+  email: alepha79.TOptional<alepha79.TString>;
+  username: alepha79.TOptional<alepha79.TString>;
+  picture: alepha79.TOptional<alepha79.TString>;
+  sessionId: alepha79.TOptional<alepha79.TString>;
+  organizations: alepha79.TOptional<alepha79.TArray<alepha79.TString>>;
+  roles: alepha79.TOptional<alepha79.TArray<alepha79.TString>>;
+}>;
+type UserAccount = Static<typeof userAccountInfoSchema>;
+//#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$2: alepha79.TObject<{
+  APP_SECRET: alepha79.TString;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema$2>> {}
+}
+//#endregion
+//#region ../alepha/src/security/index.d.ts
+declare module "alepha" {
+  interface Hooks {
+    "security:user:created": {
+      realm: string;
+      user: UserAccount;
+    };
+  }
+}
+/**
+ * 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`
+ * on class properties. It offers JWT-based authentication, fine-grained permissions, service accounts, and seamless
+ * integration with various authentication providers and user management systems.
+ *
+ * @see {@link $realm}
+ * @see {@link $role}
+ * @see {@link $permission}
+ * @module alepha.security
+ */
+//#endregion
+//#region ../alepha/src/server-security/providers/ServerBasicAuthProvider.d.ts
+interface BasicAuthOptions {
+  username: string;
+  password: string;
+}
+//#endregion
+//#region ../alepha/src/server-security/providers/ServerSecurityProvider.d.ts
+type ServerRouteSecure = {
+  realm?: string;
+  basic?: BasicAuthOptions;
+};
+//#endregion
+//#region ../alepha/src/server-security/index.d.ts
+declare module "alepha" {
+  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.
+     * > To force a different user, you need to pass it explicitly in the options.
+     */
+    "alepha.server.security.system.user"?: UserAccountToken;
+    /**
+     * The authenticated user account attached to the server request state.
+     *
+     * @internal
+     */
+    "alepha.server.request.user"?: UserAccount;
+  }
+}
+declare module "alepha/server" {
+  interface ServerRequest<TConfig> {
+    user?: UserAccountToken;
+  }
+  interface ServerActionRequest<TConfig> {
+    user: UserAccountToken;
+  }
+  interface ServerRoute {
+    /**
+     * If true, the route will be protected by the security provider.
+     * All actions are secure by default, but you can disable it for specific actions.
+     */
+    secure?: boolean | ServerRouteSecure;
+  }
+  interface ClientRequestOptions extends FetchOptions {
+    /**
+     * Forward user from the previous request.
+     * If "system", use system user. @see {ServerSecurityProvider.localSystemUser}
+     * If "context", use the user from the current context (e.g. request).
+     *
+     * @default "system" if provided, else "context" if available.
+     */
+    user?: UserAccountToken | "system" | "context";
+  }
+}
+/**
+ * Plugin for Alepha Server that provides security features. Based on the Alepha Security module.
+ *
+ * By default, all $action will be guarded by a permission check.
+ *
+ * @see {@link ServerSecurityProvider}
+ * @module alepha.server.security
+ */
+//#endregion
+//#region ../alepha/src/server-links/schemas/apiLinksResponseSchema.d.ts
+declare const apiLinksResponseSchema: alepha79.TObject<{
+  prefix: alepha79.TOptional<alepha79.TString>;
+  links: alepha79.TArray<alepha79.TObject<{
+    name: alepha79.TString;
+    group: alepha79.TOptional<alepha79.TString>;
+    path: alepha79.TString;
+    method: alepha79.TOptional<alepha79.TString>;
+    requestBodyType: alepha79.TOptional<alepha79.TString>;
+    service: alepha79.TOptional<alepha79.TString>;
+  }>>;
+}>;
+type ApiLinksResponse = Static<typeof apiLinksResponseSchema>;
+//#endregion
+//#region ../alepha/src/server-links/index.d.ts
+declare module "alepha" {
+  interface State {
+    /**
+     * API links attached to the server request state.
+     *
+     * @see {@link ApiLinksResponse}
+     * @internal
+     */
+    "alepha.server.request.apiLinks"?: ApiLinksResponse;
+  }
+}
+/**
+ * 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,
+ * facilitating seamless API endpoint management and client-server communication. It integrates with server
+ * security features to ensure safe and controlled access to resources.
+ *
+ * @see {@link $remote}
+ * @see {@link $client}
+ * @module alepha.server.links
+ */
+//#endregion
+//#region ../react/src/core/providers/ReactBrowserProvider.d.ts
+declare const envSchema$1: alepha79.TObject<{
+  REACT_ROOT_ID: alepha79.TString;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema$1>> {}
+}
+/**
+ * React browser renderer configuration atom
+ */
+declare const reactBrowserOptions: alepha79.Atom<alepha79.TObject<{
+  scrollRestoration: alepha79.TUnsafe<"top" | "manual">;
+}>, "alepha.react.browser.options">;
+type ReactBrowserRendererOptions = Static<typeof reactBrowserOptions.schema>;
+declare module "alepha" {
+  interface State {
+    [reactBrowserOptions.key]: ReactBrowserRendererOptions;
+  }
+}
+interface RouterGoOptions {
+  replace?: boolean;
+  match?: TransitionOptions;
+  params?: Record<string, string>;
+  query?: Record<string, string>;
+  meta?: Record<string, any>;
+  /**
+   * Recreate the whole page, ignoring the current state.
+   */
+  force?: boolean;
+}
+type ReactHydrationState = {
+  layers?: Array<PreviousLayerData>;
+} & {
+  [key: string]: any;
+};
+//#endregion
+//#region ../react/src/core/hooks/useAction.d.ts
+interface UseActionReturn<Args extends any[], Result> {
+  /**
+   * Execute the action with the provided arguments.
+   *
+   * @example
+   * ```tsx
+   * const action = useAction({ handler: async (data) => { ... } }, []);
+   * action.run(data);
+   * ```
+   */
+  run: (...args: Args) => Promise<Result | undefined>;
+  /**
+   * Loading state - true when action is executing.
+   */
+  loading: boolean;
+  /**
+   * Error state - contains error if action failed, undefined otherwise.
+   */
+  error?: Error;
+  /**
+   * Cancel any pending debounced action or abort the current in-flight request.
+   *
+   * @example
+   * ```tsx
+   * const action = useAction({ ... }, []);
+   *
+   * <button onClick={action.cancel} disabled={!action.loading}>
+   *   Cancel
+   * </button>
+   * ```
+   */
+  cancel: () => void;
+}
+//#endregion
+//#region ../react/src/core/hooks/useActive.d.ts
+interface UseActiveOptions {
+  href: string;
+  startWith?: boolean;
+}
+//#endregion
+//#region ../react/src/core/providers/ReactServerProvider.d.ts
+declare const envSchema: alepha79.TObject<{
+  REACT_SSR_ENABLED: alepha79.TOptional<alepha79.TBoolean>;
+  REACT_ROOT_ID: alepha79.TString;
+  REACT_SERVER_TEMPLATE: alepha79.TOptional<alepha79.TString>;
+}>;
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema>> {}
+  interface State {
+    "alepha.react.server.ssr"?: boolean;
+  }
+}
+/**
+ * React server provider configuration atom
+ */
+declare const reactServerOptions: alepha79.Atom<alepha79.TObject<{
+  publicDir: alepha79.TString;
+  staticServer: alepha79.TObject<{
+    disabled: alepha79.TBoolean;
+    path: alepha79.TString;
+  }>;
+}>, "alepha.react.server.options">;
+type ReactServerProviderOptions = Static<typeof reactServerOptions.schema>;
+declare module "alepha" {
+  interface State {
+    [reactServerOptions.key]: ReactServerProviderOptions;
+  }
+}
+//#endregion
+//#region ../react/src/core/index.d.ts
+declare module "alepha" {
+  interface State {
+    "alepha.react.router.state"?: ReactRouterState;
+  }
+  interface Hooks {
+    /**
+     * Fires when the React application is starting to be rendered on the server.
+     */
+    "react:server:render:begin": {
+      request?: ServerRequest;
+      state: ReactRouterState;
+    };
+    /**
+     * Fires when the React application has been rendered on the server.
+     */
+    "react:server:render:end": {
+      request?: ServerRequest;
+      state: ReactRouterState;
+      html: string;
+    };
+    /**
+     * Fires when the React application is being rendered on the browser.
+     */
+    "react:browser:render": {
+      root: HTMLElement;
+      element: ReactNode;
+      state: ReactRouterState;
+      hydration?: ReactHydrationState;
+    };
+    /**
+     * Fires when a user action is starting.
+     * Action can be a form submission, a route transition, or a custom action.
+     */
+    "react:action:begin": {
+      type: string;
+      id?: string;
+    };
+    /**
+     * Fires when a user action has succeeded.
+     * Action can be a form submission, a route transition, or a custom action.
+     */
+    "react:action:success": {
+      type: string;
+      id?: string;
+    };
+    /**
+     * Fires when a user action has failed.
+     * Action can be a form submission, a route transition, or a custom action.
+     */
+    "react:action:error": {
+      type: string;
+      id?: string;
+      error: Error;
+    };
+    /**
+     * Fires when a user action has completed, regardless of success or failure.
+     * Action can be a form submission, a route transition, or a custom action.
+     */
+    "react:action:end": {
+      type: string;
+      id?: string;
+    };
+    /**
+     * Fires when a route transition is starting.
+     */
+    "react:transition:begin": {
+      previous: ReactRouterState;
+      state: ReactRouterState;
+      animation?: PageAnimation;
+    };
+    /**
+     * Fires when a route transition has succeeded.
+     */
+    "react:transition:success": {
+      state: ReactRouterState;
+    };
+    /**
+     * Fires when a route transition has failed.
+     */
+    "react:transition:error": {
+      state: ReactRouterState;
+      error: Error;
+    };
+    /**
+     * Fires when a route transition has completed, regardless of success or failure.
+     */
+    "react:transition:end": {
+      state: ReactRouterState;
+    };
+  }
+}
+/**
+ * Provides full-stack React development with declarative routing, server-side rendering, and client-side hydration.
+ *
+ * The React module enables building modern React applications using the `$page` descriptor on class properties.
+ * It delivers seamless server-side rendering, automatic code splitting, and client-side navigation with full
+ * type safety and schema validation for route parameters and data.
+ *
+ * @see {@link $page}
+ * @module alepha.react
+ */
+//#endregion
+//#region src/core/components/buttons/ActionButton.d.ts
+interface ActionMenuItem {
+  /**
+   * Menu item type
+   */
+  type?: "item" | "divider" | "label";
+  /**
+   * Label text for the menu item
+   */
+  label?: string | ReactNode;
+  /**
+   * Icon element to display before the label
+   */
+  icon?: ReactNode;
+  /**
+   * Click handler for menu items
+   */
+  onClick?: () => void;
+  /**
+   * Href for navigation menu items
+   */
+  href?: string;
+  /**
+   * Color for the menu item (e.g., "red" for danger actions)
+   */
+  color?: string;
+  /**
+   * Nested submenu items
+   */
+  children?: ActionMenuItem[];
+  /**
+   * Whether the menu item is active
+   */
+  active?: boolean;
+}
+interface ActionMenuConfig {
+  /**
+   * Array of menu items to display
+   */
+  items: ActionMenuItem[];
+  /**
+   * Menu position relative to the button
+   */
+  position?: "bottom" | "bottom-start" | "bottom-end" | "top" | "top-start" | "top-end" | "left" | "right";
+  /**
+   * Menu width
+   */
+  width?: number | string;
+  /**
+   * Menu shadow
+   */
+  shadow?: "xs" | "sm" | "md" | "lg" | "xl";
+  on?: "hover" | "click";
+  targetProps?: MenuTargetProps;
+  menuProps?: MenuProps;
+}
+interface ActionCommonProps extends ButtonProps {
+  children?: ReactNode;
+  textVisibleFrom?: "xs" | "sm" | "md" | "lg" | "xl";
+  /**
+   * Tooltip to display on hover. Can be a string for simple tooltips
+   * or a TooltipProps object for advanced configuration.
+   */
+  tooltip?: string | TooltipProps;
+  /**
+   * Menu configuration. When provided, the action will display a dropdown menu.
+   */
+  menu?: ActionMenuConfig;
+  /**
+   * If set, a confirmation dialog will be shown before performing the action.
+   * If `true`, a default title and message will be used.
+   * If a string, it will be used as the message with a default title.
+   * If an object, it can contain `title` and `message` properties to customize the dialog.
+   */
+  confirm?: boolean | string | {
+    title?: string;
+    message: string;
+  };
+  /**
+   * Icon to display on the left side of the button.
+   * If no children are provided, the button will be styled as an icon-only button.
+   */
+  icon?: ReactNode | ComponentType;
+  /**
+   * Additional props to pass to the ThemeIcon wrapping the icon.
+   */
+  themeIconProps?: ThemeIconProps;
+}
+type ActionProps = ActionCommonProps & (ActionNavigationButtonProps | ActionClickButtonProps | ActionSubmitButtonProps | ActionHookButtonProps | {});
+declare const ActionButton: (_props: ActionProps) => react_jsx_runtime4.JSX.Element;
+interface ActionSubmitButtonProps extends ButtonProps {
+  form: FormModel<any>;
+  type?: "submit" | "reset";
+}
+interface ActionHookButtonProps extends ButtonProps {
+  action: UseActionReturn<any[], any>;
+}
+interface ActionClickButtonProps extends ButtonProps {
+  onClick: (e: any) => any;
+}
+interface ActionNavigationButtonProps extends ButtonProps {
+  href: string;
+  active?: Partial<UseActiveOptions> | false;
+  routerGoOptions?: RouterGoOptions;
+  classNameActive?: string;
+  variantActive?: ButtonProps["variant"];
+  target?: string;
+  anchorProps?: AnchorProps;
+}
+//#endregion
+//#region src/core/components/buttons/BurgerButton.d.ts
+interface BurgerButtonProps extends BurgerProps {}
+declare const BurgerButton: (props: BurgerButtonProps) => react_jsx_runtime4.JSX.Element;
+//#endregion
+//#region src/core/components/buttons/ClipboardButton.d.ts
+interface ClipboardButtonProps extends Omit<ActionCommonProps, "onClick" | "icon"> {
+  /**
+   * The value to copy to the clipboard
+   */
+  value: string;
+  /**
+   * Timeout in ms to show the "Copied" state (default: 2000)
+   */
+  timeout?: number;
+  /**
+   * Label to show in tooltip when not copied (default: "Copy")
+   */
+  copyLabel?: string;
+  /**
+   * Label to show in tooltip when copied (default: "Copied")
+   */
+  copiedLabel?: string;
+}
+declare const ClipboardButton: (props: ClipboardButtonProps) => react_jsx_runtime4.JSX.Element;
+//#endregion
+//#region src/core/components/buttons/DarkModeButton.d.ts
+interface DarkModeButtonProps {
+  mode?: "minimal" | "segmented";
+  size?: MantineBreakpoint;
+  variant?: "filled" | "light" | "outline" | "default" | "subtle" | "transparent";
+  fullWidth?: boolean;
+  segmentedProps?: Partial<SegmentedControlProps>;
+  actionProps?: Partial<ActionProps>;
+}
+declare const DarkModeButton: (props: DarkModeButtonProps) => react_jsx_runtime4.JSX.Element;
+//#endregion
+//#region src/core/components/buttons/LanguageButton.d.ts
+interface LanguageButtonProps {
+  languages?: string[];
+  actionProps?: ActionProps;
+}
+declare const LanguageButton: (props: LanguageButtonProps) => react_jsx_runtime4.JSX.Element;
+//#endregion
+//#region src/core/components/buttons/OmnibarButton.d.ts
+interface OmnibarButtonProps {
+  actionProps?: ActionProps;
+  collapsed?: boolean;
+}
+declare const OmnibarButton: (props: OmnibarButtonProps) => react_jsx_runtime4.JSX.Element;
+//#endregion
+//#region src/core/components/data/JsonViewer.d.ts
+interface JsonViewerProps {
+  data: any;
+  defaultExpanded?: boolean;
+  maxDepth?: number;
+  copyable?: boolean;
+  size?: MantineSize;
+}
+declare const JsonViewer: ({
+  data,
+  defaultExpanded,
+  maxDepth,
+  copyable,
+  size
+}: JsonViewerProps) => react_jsx_runtime4.JSX.Element;
+//#endregion
+//#region src/core/services/DialogService.d.ts
+interface BaseDialogOptions extends Partial<ModalProps> {
+  title?: ReactNode;
+  message?: ReactNode;
+  content?: any;
+}
+interface AlertDialogOptions extends BaseDialogOptions {
+  okLabel?: string;
+}
+interface ConfirmDialogOptions extends BaseDialogOptions {
+  confirmLabel?: string;
+  cancelLabel?: string;
+  confirmColor?: string;
+}
+interface PromptDialogOptions extends BaseDialogOptions {
+  placeholder?: string;
+  defaultValue?: string;
+  label?: string;
+  required?: boolean;
+  submitLabel?: string;
+  cancelLabel?: string;
+}
+interface AlertDialogProps {
+  options?: AlertDialogOptions;
+  onClose: () => void;
+}
+interface ConfirmDialogProps {
+  options?: ConfirmDialogOptions;
+  onConfirm: (confirmed: boolean) => void;
+}
+interface PromptDialogProps {
+  options?: PromptDialogOptions;
+  onSubmit: (value: string | null) => void;
+}
+interface DialogServiceOptions {
+  default?: Partial<BaseDialogOptions>;
+}
+declare class DialogService {
+  readonly options: DialogServiceOptions;
+  /**
+   * Show an alert dialog with a message
+   */
+  alert(options?: AlertDialogOptions): Promise<void>;
+  /**
+   * Show a confirmation dialog that returns a promise
+   */
+  confirm(options?: ConfirmDialogOptions): Promise<boolean>;
+  /**
+   * Show a prompt dialog to get user input
+   */
+  prompt(options?: PromptDialogOptions): Promise<string | null>;
+  /**
+   * Open a custom dialog with provided content
+   */
+  open(options?: BaseDialogOptions): string;
+  /**
+   * Close the currently open dialog or a specific dialog by ID
+   */
+  close(modalId?: string): void;
+  /**
+   * Show a JSON editor/viewer dialog
+   */
+  json(data?: any, options?: BaseDialogOptions): void;
+  /**
+   * Show a form dialog for structured input
+   */
+  form(options?: BaseDialogOptions): Promise<any>;
+  /**
+   * Show a loading/progress dialog with optional progress percentage
+   */
+  loading(options?: BaseDialogOptions & {
+    progress?: number;
+  }): void;
+  /**
+   * Show an image viewer/gallery dialog
+   */
+  image(src: string | string[], options?: BaseDialogOptions): void;
+}
+//#endregion
+//#region src/core/components/dialogs/AlertDialog.d.ts
+declare const AlertDialog: ({
+  options,
+  onClose
+}: AlertDialogProps) => react_jsx_runtime4.JSX.Element;
+//#endregion
+//#region src/core/components/dialogs/ConfirmDialog.d.ts
+declare const ConfirmDialog: ({
+  options,
+  onConfirm
+}: ConfirmDialogProps) => react_jsx_runtime4.JSX.Element;
+//#endregion
+//#region src/core/components/dialogs/PromptDialog.d.ts
+declare const PromptDialog: ({
+  options,
+  onSubmit
+}: PromptDialogProps) => react_jsx_runtime4.JSX.Element;
+//#endregion
+//#region src/core/components/form/ControlDate.d.ts
+interface ControlDateProps extends GenericControlProps {
+  date?: boolean | DateInputProps;
+  datetime?: boolean | DateTimePickerProps;
+  time?: boolean | TimeInputProps;
+}
+/**
+ * ControlDate component for handling date, datetime, and time inputs.
+ *
+ * Features:
+ * - DateInput for date format
+ * - DateTimePicker for date-time format
+ * - TimeInput for time format
+ *
+ * Automatically detects date formats from schema and renders appropriate picker.
+ */
+declare const ControlDate: (props: ControlDateProps) => react_jsx_runtime4.JSX.Element | null;
+//#endregion
+//#region src/core/components/form/ControlQueryBuilder.d.ts
+interface ControlQueryBuilderProps extends Omit<TextInputProps, "value" | "onChange"> {
+  schema?: TObject;
+  value?: string;
+  onChange?: (value: string) => void;
+  placeholder?: string;
+}
+/**
+ * Query builder with text input and help popover.
+ * Generates query strings for parseQueryString syntax.
+ */
+declare const ControlQueryBuilder: ({
+  schema,
+  value,
+  onChange,
+  placeholder,
+  ...textInputProps
+}: ControlQueryBuilderProps) => react_jsx_runtime4.JSX.Element;
+//#endregion
+//#region src/core/components/form/TypeForm.d.ts
+interface TypeFormProps<T$1 extends TObject> {
+  form: FormModel<T$1>;
+  columns?: number | {
+    base?: number;
+    xs?: number;
+    sm?: number;
+    md?: number;
+    lg?: number;
+    xl?: number;
+  };
+  schema?: TObject;
+  children?: (input: FormModel<T$1>["input"]) => ReactNode;
+  controlProps?: Partial<Omit<ControlProps, "input">>;
+  skipFormElement?: boolean;
+  skipSubmitButton?: boolean;
+  submitButtonProps?: Partial<Omit<ActionSubmitButtonProps, "form">>;
+  resetButtonProps?: Partial<Omit<ActionSubmitButtonProps, "form">>;
+}
+/**
+ * TypeForm component that automatically renders all form inputs based on schema.
+ * Uses the Control component to render individual fields and Mantine Grid for responsive layout.
+ *
+ * @example
+ * ```tsx
+ * import { t } from "alepha";
+ * import { useForm } from "@alepha/react/form";
+ * import { TypeForm } from "@alepha/ui";
+ *
+ * const form = useForm({
+ *   schema: t.object({
+ *     username: t.text(),
+ *     email: t.text(),
+ *     age: t.integer(),
+ *     subscribe: t.boolean(),
+ *   }),
+ *   handler: (values) => {
+ *     console.log(values);
+ *   },
+ * });
+ *
+ * return <TypeForm form={form} columns={2} />;
+ * ```
+ */
+declare const TypeForm: <T$1 extends TObject>(props: TypeFormProps<T$1>) => react_jsx_runtime4.JSX.Element | null;
+//#endregion
+//#region src/core/components/layout/AppBar.d.ts
+type AppBarItem = AppBarElement | AppBarBurger | AppBarDark | AppBarSearch | AppBarLang | AppBarSpacer | AppBarDivider;
+interface AppBarElement {
+  position: "left" | "center" | "right";
+  element: ReactNode;
+}
+interface AppBarBurger {
+  position: "left" | "center" | "right";
+  type: "burger";
+}
+interface AppBarDark {
+  position: "left" | "center" | "right";
+  type: "dark";
+  props?: DarkModeButtonProps;
+}
+interface AppBarSearch {
+  position: "left" | "center" | "right";
+  type: "search";
+  props?: OmnibarButtonProps;
+}
+interface AppBarLang {
+  position: "left" | "center" | "right";
+  type: "lang";
+  props?: LanguageButtonProps;
+}
+interface AppBarSpacer {
+  position: "left" | "center" | "right";
+  type: "spacer";
+}
+interface AppBarDivider {
+  position: "left" | "center" | "right";
+  type: "divider";
+}
+interface AppBarProps {
+  flexProps?: FlexProps;
+  items?: AppBarItem[];
+}
+declare const AppBar: (props: AppBarProps) => react_jsx_runtime4.JSX.Element;
+//#endregion
+//#region src/core/components/layout/Sidebar.d.ts
+interface SidebarProps {
+  menu?: SidebarNode[];
+  top?: SidebarNode[];
+  bottom?: SidebarNode[];
+  onItemClick?: (item: SidebarMenuItem) => void;
+  onSearchClick?: () => void;
+  theme?: SidebarTheme;
+  flexProps?: Partial<FlexProps>;
+  collapsed?: boolean;
+  gap?: MantineBreakpoint;
+  hide?: {
+    paths?: string[];
+  };
+}
+declare const Sidebar: (props: SidebarProps) => react_jsx_runtime4.JSX.Element;
+interface SidebarItemProps {
+  item: SidebarMenuItem;
+  level: number;
+  onItemClick?: (item: SidebarMenuItem) => void;
+  theme: SidebarTheme;
+}
+interface SidebarItemProps {
+  item: SidebarMenuItem;
+  level: number;
+  onItemClick?: (item: SidebarMenuItem) => void;
+  theme: SidebarTheme;
+}
+type SidebarNode = SidebarMenuItem | SidebarSpacer | SidebarDivider | SidebarSearch | SidebarElement | SidebarSection;
+interface SidebarAbstractItem {
+  position?: "top" | "bottom";
+}
+interface SidebarElement extends SidebarAbstractItem {
+  element: ReactNode;
+}
+interface SidebarSpacer extends SidebarAbstractItem {
+  type: "spacer";
+}
+interface SidebarDivider extends SidebarAbstractItem {
+  type: "divider";
+}
+interface SidebarSearch extends SidebarAbstractItem {
+  type: "search";
+}
+interface SidebarSection extends SidebarAbstractItem {
+  type: "section";
+  label: string;
+  icon?: ReactNode | ComponentType;
+}
+interface SidebarMenuItem extends SidebarAbstractItem {
+  label: string | ReactNode;
+  description?: string;
+  icon?: ReactNode | ComponentType;
+  href?: string;
+  target?: "_blank" | "_self" | "_parent" | "_top";
+  activeStartsWith?: boolean;
+  onClick?: () => void;
+  children?: SidebarMenuItem[];
+  rightSection?: ReactNode;
+  theme?: SidebarButtonTheme;
+  actionProps?: ActionProps;
+}
+interface SidebarButtonTheme {
+  radius?: MantineBreakpoint;
+  size?: MantineBreakpoint;
+}
+interface SidebarTheme {
+  button?: SidebarButtonTheme;
+  search?: SidebarButtonTheme;
+}
+//#endregion
+//#region src/core/components/layout/AdminShell.d.ts
+interface AdminShellProps {
+  appShellProps?: Partial<AppShellProps>;
+  appShellMainProps?: Partial<AppShellMainProps>;
+  appShellHeaderProps?: Partial<AppShellHeaderProps>;
+  appShellNavbarProps?: Partial<AppShellNavbarProps>;
+  appShellFooterProps?: Partial<AppShellFooterProps>;
+  sidebarProps?: Partial<SidebarProps>;
+  appBarProps?: Partial<AppBarProps>;
+  header?: ReactNode;
+  footer?: ReactNode;
+  children?: ReactNode;
+  noSidebarWhen?: {
+    /**
+     * Paths where the sidebar should be hidden.
+     */
+    paths?: string[];
+  };
+}
+declare module "alepha" {
+  interface State {
+    /**
+     * Whether the sidebar is opened or closed.
+     */
+    "alepha.ui.sidebar.opened"?: boolean;
+    /**
+     * Whether the sidebar is collapsed (narrow) or expanded (wide).
+     */
+    "alepha.ui.sidebar.collapsed"?: boolean;
+  }
+}
+declare const AdminShell: (props: AdminShellProps) => react_jsx_runtime4.JSX.Element;
+//#endregion
+//#region src/core/components/layout/Omnibar.d.ts
+interface OmnibarProps {
+  shortcut?: string | string[];
+  searchPlaceholder?: string;
+  nothingFound?: ReactNode;
+}
+declare const Omnibar: (props: OmnibarProps) => react_jsx_runtime4.JSX.Element;
+//#endregion
+//#region src/core/components/layout/AlephaMantineProvider.d.ts
+interface AlephaMantineProviderProps {
+  children?: ReactNode;
+  mantine?: MantineProviderProps;
+  colorSchemeScript?: ColorSchemeScriptProps;
+  navigationProgress?: NavigationProgressProps;
+  notifications?: NotificationsProps;
+  modals?: ModalsProviderProps;
+  omnibar?: OmnibarProps;
+}
+declare const AlephaMantineProvider: (props: AlephaMantineProviderProps) => react_jsx_runtime4.JSX.Element;
+//#endregion
+//#region src/core/components/table/DataTable.d.ts
+interface DataTableColumnContext<Filters extends TObject> {
+  index: number;
+  form: FormModel<Filters>;
+  alepha: Alepha;
+}
+interface DataTableColumn<T$1 extends object, Filters extends TObject> {
+  label: string;
+  value: (item: T$1, ctx: DataTableColumnContext<Filters>) => ReactNode;
+  fit?: boolean;
+}
+type MaybePage<T$1> = Omit<Page<T$1>, "page"> & {
+  page?: Partial<PageMetadata>;
+};
+interface DataTableSubmitContext<T$1 extends object> {
+  items: T$1[];
+}
+interface DataTableProps<T$1 extends object, Filters extends TObject> {
+  /**
+   * The items to display in the table. Can be a static page of items or a function that returns a promise resolving to a page of items.
+   */
+  items: MaybePage<T$1> | ((filters: Static<Filters> & {
+    page: number;
+    size: number;
+    sort?: string;
+  }, ctx: DataTableSubmitContext<T$1>) => Async<MaybePage<T$1>>);
+  /**
+   * The columns to display in the table. Each column is defined by a key and a DataTableColumn object.
+   */
+  columns: {
+    [key: string]: DataTableColumn<T$1, Filters>;
+  };
+  defaultSize?: number;
+  typeFormProps?: Partial<Omit<TypeFormProps<Filters>, "form">>;
+  onFilterChange?: (key: string, value: unknown, form: FormModel<Filters>) => void;
+  /**
+   * Optional filters to apply to the data.
+   */
+  filters?: TObject;
+  panel?: (item: T$1) => ReactNode;
+  canPanel?: (item: T$1) => boolean;
+  submitOnInit?: boolean;
+  submitEvery?: DurationLike;
+  withLineNumbers?: boolean;
+  withCheckbox?: boolean;
+  checkboxActions?: any[];
+  actions?: any[];
+  /**
+   * Enable infinity scroll mode. When true, pagination controls are hidden and new items are loaded automatically when scrolling to the bottom.
+   */
+  infinityScroll?: boolean;
+  /**
+   * Props to pass to the Mantine Table component.
+   */
+  tableProps?: TableProps;
+  /**
+   * Function to generate props for each table row based on the item.
+   */
+  tableTrProps?: (item: T$1) => TableTrProps;
+}
+declare const DataTable: <T$1 extends object, Filters extends TObject>(props: DataTableProps<T$1, Filters>) => react_jsx_runtime4.JSX.Element;
+//#endregion
+//#region src/core/constants/ui.d.ts
+declare const ui: {
+  colors: {
+    transparent: string;
+    background: string;
+    surface: string;
+    elevated: string;
+    border: string;
+  };
+  sizes: {
+    icon: {
+      xs: number;
+      sm: number;
+      md: number;
+      lg: number;
+      xl: number;
+    };
+  };
+};
+//#endregion
+//#region src/core/hooks/useDialog.d.ts
+/**
+ * Use this hook to access the Dialog Service for showing various dialog types.
+ *
+ * @example
+ * ```tsx
+ * const dialog = useDialog();
+ * await dialog.alert({ title: "Alert", message: "This is an alert message" });
+ * const confirmed = await dialog.confirm({ title: "Confirm", message: "Are you sure?" });
+ * const input = await dialog.prompt({ title: "Input", message: "Enter your name:" });
+ * ```
+ */
+declare const useDialog: () => DialogService;
+//#endregion
+//#region src/core/services/ToastService.d.ts
+interface ToastServiceOptions {
+  default?: Partial<NotificationData>;
+}
+declare class ToastService {
+  protected readonly raw: {
+    readonly show: typeof _mantine_notifications0.showNotification;
+    readonly hide: typeof _mantine_notifications0.hideNotification;
+    readonly update: typeof _mantine_notifications0.updateNotification;
+    readonly clean: typeof _mantine_notifications0.cleanNotifications;
+    readonly cleanQueue: typeof _mantine_notifications0.cleanNotificationsQueue;
+    readonly updateState: typeof _mantine_notifications0.updateNotificationsState;
+  };
+  readonly options: ToastServiceOptions;
+  show(options: NotificationData): void;
+  info(options: Partial<NotificationData> | string): void;
+  success(options: Partial<NotificationData> | string): void;
+  warning(options: Partial<NotificationData> | string): void;
+  danger(options: Partial<NotificationData> | string): void;
+}
+//#endregion
+//#region src/core/hooks/useToast.d.ts
+/**
+ * Use this hook to access the Toast Service for showing notifications.
+ *
+ * @example
+ * ```tsx
+ * const toast = useToast();
+ * toast.success({ message: "Operation completed successfully!" });
+ * toast.error({ title: "Error", message: "Something went wrong" });
+ * ```
+ */
+declare const useToast: () => ToastService;
+//#endregion
+//#region src/core/RootRouter.d.ts
+declare class RootRouter {
+  readonly root: PageDescriptor<PageConfigSchema, any, TPropsParentDefault>;
+}
+//#endregion
+//#region src/core/utils/extractSchemaFields.d.ts
+interface SchemaField {
+  name: string;
+  path: string;
+  type: string;
+  enum?: readonly any[];
+  format?: string;
+  description?: string;
+  nested?: SchemaField[];
+}
+/**
+ * Extract field information from a TypeBox schema for query building.
+ * Supports nested objects and provides field metadata for autocomplete.
+ */
+declare function extractSchemaFields(schema: TObject | TProperties, prefix?: string): SchemaField[];
+/**
+ * Get suggested operators based on field type
+ */
+declare function getOperatorsForField(field: SchemaField): string[];
+/**
+ * Get operator symbol and description
+ */
+declare const OPERATOR_INFO: Record<string, {
+  symbol: string;
+  label: string;
+  example: string;
+}>;
+//#endregion
+//#region src/core/utils/icons.d.ts
+type IconSize = keyof typeof ui.sizes.icon;
+/**
+ * Get the default icon for an input based on its type, format, or name.
+ */
+declare const getDefaultIcon: (params: {
+  type?: string;
+  format?: string;
+  name?: string;
+  isEnum?: boolean;
+  isArray?: boolean;
+  size?: IconSize;
+}) => ReactElement;
+//#endregion
+//#region src/core/utils/string.d.ts
+/**
+ * Capitalizes the first letter of a string.
+ *
+ * @example
+ * capitalize("hello") // "Hello"
+ */
+declare const capitalize: (str: string) => string;
+/**
+ * Converts a path or identifier string into a pretty display name.
+ * Removes slashes and capitalizes the first letter.
+ *
+ * @example
+ * prettyName("/userName") // "UserName"
+ * prettyName("email") // "Email"
+ */
+declare const prettyName: (name: string) => string;
+//#endregion
+//#region src/core/index.d.ts
+declare module "typebox" {
+  interface TSchemaOptions {
+    $control?: Omit<ControlProps, "input">;
+  }
+}
+declare module "@alepha/react" {
+  interface PageDescriptorOptions {
+    /**
+     * Human-readable title for the page.
+     * - for Sidebar navigation
+     * - for Omnibar navigation
+     * (soon)
+     * - for Breadcrumbs
+     * - for document title (with AlephaReactHead)
+     */
+    label?: string;
+    /**
+     * Optional description of the page.
+     */
+    description?: string;
+    /**
+     * Optional icon for the page.
+     */
+    icon?: ReactNode;
+  }
+}
+/**
+ * Mantine
+ *
+ * @module alepha.ui
+ */
+declare const AlephaUI: alepha79.Service<alepha79.Module>;
+//#endregion
+export { ActionButton, type ActionClickButtonProps, type ActionCommonProps, type ActionMenuConfig, type ActionMenuItem, type ActionNavigationButtonProps, type ActionProps, type ActionSubmitButtonProps, AdminShell, type AdminShellProps, AlephaMantineProvider, AlephaUI, AlertDialog, type AlertDialogOptions, type AlertDialogProps, AppBar, type AppBarBurger, type AppBarDark, type AppBarDivider, type AppBarElement, type AppBarItem, type AppBarLang, type AppBarProps, type AppBarSearch, type AppBarSpacer, type BaseDialogOptions, BurgerButton, ClipboardButton, type ClipboardButtonProps, ConfirmDialog, type ConfirmDialogOptions, type ConfirmDialogProps, Control, ControlDate, ControlQueryBuilder, ControlSelect, DarkModeButton, DataTable, type DataTableColumn, type DataTableProps, DialogService, Flex, IconSize, JsonViewer, LanguageButton, OPERATOR_INFO, Omnibar, OmnibarButton, PromptDialog, type PromptDialogOptions, type PromptDialogProps, RootRouter, SchemaField, Sidebar, type SidebarAbstractItem, type SidebarButtonTheme, type SidebarDivider, type SidebarElement, type SidebarItemProps, type SidebarMenuItem, type SidebarNode, type SidebarProps, type SidebarSearch, type SidebarSection, type SidebarSpacer, type SidebarTheme, Text, ToastService, TypeForm, capitalize, extractSchemaFields, getDefaultIcon, getOperatorsForField, prettyName, ui, useDialog, useToast };
+//# sourceMappingURL=index.d.ts.map