alepha 0.7.6 → 0.8.0

package/react.d.ts

@@ -1,19 +1,18 @@
-import * as _alepha_core2 from "@alepha/core";
-import * as _alepha_core23 from "@alepha/core";
-import * as _alepha_core15 from "@alepha/core";
-import * as _alepha_core11 from "@alepha/core";
-import { Alepha, Async, KIND, Module, OPTIONS, Service, Static, TObject, TSchema } from "@alepha/core";
-import { ApiLinksResponse, ClientScope, HttpClient, HttpVirtualClient, ServerHandler, ServerRequest, ServerRouterProvider, ServerTimingProvider } from "@alepha/server";
-import { ServerRouteCache } from "@alepha/server-cache";
-import * as react18 from "react";
-import * as react21 from "react";
+import * as _alepha_core11 from "alepha";
+import * as _alepha_core18 from "alepha";
+import * as _alepha_core16 from "alepha";
+import * as _alepha_core1 from "alepha";
+import { Alepha, Async, KIND, Module, OPTIONS, Service, Static, TObject, TSchema } from "alepha";
+import { ApiLinksResponse, ServerHandler, ServerRequest, ServerRouterProvider, ServerTimingProvider } from "alepha/server";
+import { ServerRouteCache } from "alepha/server/cache";
+import { ClientScope, HttpVirtualClient, LinkProvider } from "alepha/server/links";
+import * as react23 from "react";
+import * as react24 from "react";
 import React, { AnchorHTMLAttributes, ErrorInfo, FC, PropsWithChildren, ReactNode } from "react";
-import * as react_jsx_runtime20 from "react/jsx-runtime";
 import * as react_jsx_runtime22 from "react/jsx-runtime";
-import { ServerStaticProvider } from "@alepha/server-static";
-import { Route, RouterProvider } from "@alepha/router";
-import * as _sinclair_typebox1 from "@sinclair/typebox";
-import * as _sinclair_typebox6 from "@sinclair/typebox";
+import * as react_jsx_runtime20 from "react/jsx-runtime";
+import { ServerStaticProvider } from "alepha/server/static";
+import { Route, RouterProvider } from "alepha/router";
 import { Root } from "react-dom/client";
 
 //#region src/components/ClientOnly.d.ts
@@ -106,14 +105,21 @@ interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSch
    */
   children?: Array<{
     [OPTIONS]: PageDescriptorOptions;
-  }>;
+  }> | (() => Array<{
+    [OPTIONS]: PageDescriptorOptions;
+  }>);
   parent?: {
     [OPTIONS]: PageDescriptorOptions<PageConfigSchema, TPropsParent>;
   };
   can?: () => boolean;
-  head?: Head | ((props: TProps, previous?: Head) => Head);
   errorHandler?: (error: Error) => ReactNode;
-  prerender?: boolean | {
+  /**
+   * If true, the page will be rendered on the build time.
+   * Works only with viteAlepha plugin.
+   *
+   * Replace boolean by an object to define static entries. (e.g. list of params/query)
+   */
+  static?: boolean | {
     entries?: Array<Partial<PageRequestConfig<TConfig>>>;
   };
   /**
@@ -142,49 +148,13 @@ declare const $page: {
 interface PageDescriptorRenderOptions {
   params?: Record<string, string>;
   query?: Record<string, string>;
-  withLayout?: boolean;
+  html?: boolean;
+  hydration?: boolean;
 }
 interface PageDescriptorRenderResult {
   html: string;
   context: PageReactContext;
 }
-interface Head {
-  title?: string;
-  description?: string;
-  titleSeparator?: string;
-  htmlAttributes?: Record<string, string>;
-  bodyAttributes?: Record<string, string>;
-  meta?: Array<{
-    name: string;
-    content: string;
-  }>;
-  keywords?: string[];
-  author?: string;
-  robots?: string;
-  themeColor?: string;
-  viewport?: string | {
-    width?: string;
-    height?: string;
-    initialScale?: string;
-    maximumScale?: string;
-    userScalable?: "no" | "yes" | "0" | "1";
-    interactiveWidget?: "resizes-visual" | "resizes-content" | "overlays-content";
-  };
-  og?: {
-    title?: string;
-    description?: string;
-    image?: string;
-    url?: string;
-    type?: string;
-  };
-  twitter?: {
-    card?: string;
-    title?: string;
-    description?: string;
-    image?: string;
-    site?: 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>;
@@ -192,14 +162,14 @@ interface PageRequestConfig<TConfig extends PageConfigSchema = PageConfigSchema>
 type PageResolve<TConfig extends PageConfigSchema = PageConfigSchema, TPropsParent extends object = TPropsParentDefault> = PageRequestConfig<TConfig> & TPropsParent & PageReactContext;
 //#endregion
 //#region src/providers/PageDescriptorProvider.d.ts
-declare const envSchema$1: _alepha_core2.TObject<{
-  REACT_STRICT_MODE: _sinclair_typebox1.TBoolean;
+declare const envSchema$1: _alepha_core11.TObject<{
+  REACT_STRICT_MODE: _alepha_core11.TBoolean;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$1>> {}
 }
 declare class PageDescriptorProvider {
-  protected readonly log: _alepha_core2.Logger;
+  protected readonly log: _alepha_core11.Logger;
   protected readonly env: {
     REACT_STRICT_MODE: boolean;
   };
@@ -215,7 +185,6 @@ declare class PageDescriptorProvider {
   createLayers(route: PageRoute, request: PageRequest): Promise<CreateLayersResult>;
   protected getErrorHandler(route: PageRoute): ((error: Error) => ReactNode) | undefined;
   protected createElement(page: PageRoute, props: Record<string, any>): Promise<ReactNode>;
-  protected fillHead(page: PageRoute, ctx: PageRequest, props: Record<string, any>): void;
   renderError(error: Error): ReactNode;
   renderEmptyView(): ReactNode;
   href(page: {
@@ -225,7 +194,7 @@ declare class PageDescriptorProvider {
   }, params?: Record<string, any>): string;
   compile(path: string, params?: Record<string, string>): string;
   protected renderView(index: number, path: string, view: ReactNode | undefined, page: PageRoute): ReactNode;
-  protected readonly configure: _alepha_core2.HookDescriptor<"configure">;
+  protected readonly configure: _alepha_core11.HookDescriptor<"configure">;
   protected map(pages: Array<{
     value: {
       [OPTIONS]: PageDescriptorOptions;
@@ -261,6 +230,7 @@ interface Layer {
   element: ReactNode;
   index: number;
   path: string;
+  route?: PageRoute;
 }
 type PreviousLayerData = Omit<Layer, "element" | "index" | "path">;
 interface AnchorProps {
@@ -302,54 +272,31 @@ interface CreateLayersResult extends RouterState {
  */
 interface PageReactContext {
   url: URL;
-  head: Head;
   onError: (error: Error) => ReactNode;
   links?: ApiLinksResponse;
 }
 //#endregion
-//#region src/providers/ServerHeadProvider.d.ts
-interface Head$1 {
-  title?: string;
-  htmlAttributes?: Record<string, string>;
-  bodyAttributes?: Record<string, string>;
-  meta?: Array<{
-    name: string;
-    content: string;
-  }>;
-}
-declare class ServerHeadProvider {
-  renderHead(template: string, head: Head$1): string;
-  mergeAttributes(existing: string, attrs: Record<string, string>): string;
-  parseAttributes(attrStr: string): Record<string, string>;
-  escapeHtml(str: string): string;
-}
-//#endregion
-//#region src/providers/BrowserHeadProvider.d.ts
-declare class BrowserHeadProvider {
-  renderHead(document: Document, head: Head$1): void;
-}
-//#endregion
 //#region src/providers/BrowserRouterProvider.d.ts
 interface BrowserRoute extends Route {
   page: PageRoute;
 }
 declare class BrowserRouterProvider extends RouterProvider<BrowserRoute> {
-  protected readonly log: _alepha_core23.Logger;
+  protected readonly log: _alepha_core18.Logger;
   protected readonly alepha: Alepha;
   protected readonly pageDescriptorProvider: PageDescriptorProvider;
   add(entry: PageRouteEntry): void;
-  protected readonly configure: _alepha_core23.HookDescriptor<"configure">;
+  protected readonly configure: _alepha_core18.HookDescriptor<"configure">;
   transition(url: URL, options?: TransitionOptions): Promise<RouterRenderResult>;
   root(state: RouterState, context: PageReactContext): ReactNode;
 }
+//# sourceMappingURL=BrowserRouterProvider.d.ts.map
 //#endregion
 //#region src/providers/ReactBrowserProvider.d.ts
 declare class ReactBrowserProvider {
-  protected readonly log: _alepha_core15.Logger;
-  protected readonly client: HttpClient;
+  protected readonly log: _alepha_core16.Logger;
+  protected readonly client: LinkProvider;
   protected readonly alepha: Alepha;
   protected readonly router: BrowserRouterProvider;
-  protected readonly headProvider: BrowserHeadProvider;
   protected root: Root;
   transitioning?: {
     to: string;
@@ -368,8 +315,7 @@ declare class ReactBrowserProvider {
    * Get embedded layers from the server.
    */
   protected getHydrationState(): ReactHydrationState | undefined;
-  readonly ready: _alepha_core15.HookDescriptor<"ready">;
-  readonly onTransitionEnd: _alepha_core15.HookDescriptor<"react:transition:end">;
+  readonly ready: _alepha_core16.HookDescriptor<"ready">;
 }
 interface RouterGoOptions {
   replace?: boolean;
@@ -380,6 +326,7 @@ interface ReactHydrationState {
   layers?: Array<PreviousLayerData>;
   links?: ApiLinksResponse;
 }
+//# sourceMappingURL=ReactBrowserProvider.d.ts.map
 //#endregion
 //#region src/components/ErrorBoundary.d.ts
 /**
@@ -426,7 +373,7 @@ interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
   to: string | PageDescriptor;
   children?: React.ReactNode;
 }
-declare const Link: (props: LinkProps) => react_jsx_runtime20.JSX.Element | null;
+declare const Link: (props: LinkProps) => react_jsx_runtime22.JSX.Element | null;
 //#endregion
 //#region src/components/NestedView.d.ts
 interface NestedViewProps {
@@ -439,7 +386,7 @@ interface NestedViewProps {
  *
  * @example
  * ```tsx
- * import { NestedView } from "@alepha/react";
+ * import { NestedView } from "alepha/react";
  *
  * class App {
  *   parent = $page({
@@ -453,7 +400,7 @@ interface NestedViewProps {
  * }
  * ```
  */
-declare const NestedView: (props: NestedViewProps) => react_jsx_runtime22.JSX.Element;
+declare const NestedView: (props: NestedViewProps) => react_jsx_runtime20.JSX.Element;
 //#endregion
 //#region src/contexts/RouterContext.d.ts
 interface RouterContextValue {
@@ -461,14 +408,16 @@ interface RouterContextValue {
   state: RouterState;
   context: PageReactContext;
 }
-declare const RouterContext: react18.Context<RouterContextValue | undefined>;
+declare const RouterContext: react23.Context<RouterContextValue | undefined>;
+//# sourceMappingURL=RouterContext.d.ts.map
 //#endregion
 //#region src/contexts/RouterLayerContext.d.ts
 interface RouterLayerContextValue {
   index: number;
   path: string;
 }
-declare const RouterLayerContext: react21.Context<RouterLayerContextValue | undefined>;
+declare const RouterLayerContext: react24.Context<RouterLayerContextValue | undefined>;
+//# sourceMappingURL=RouterLayerContext.d.ts.map
 //#endregion
 //#region src/hooks/RouterHookApi.d.ts
 declare class RouterHookApi {
@@ -524,12 +473,14 @@ type HrefLike = string | {
   };
 };
 type VirtualRouter<T> = { [K in keyof T as T[K] extends PageDescriptor ? K : never]: T[K] };
+//# sourceMappingURL=RouterHookApi.d.ts.map
 //#endregion
 //#region src/errors/RedirectionError.d.ts
 declare class RedirectionError extends Error {
   readonly page: HrefLike;
   constructor(page: HrefLike);
 }
+//# sourceMappingURL=RedirectionError.d.ts.map
 //#endregion
 //#region src/hooks/useActive.d.ts
 declare const useActive: (path: HrefLike) => UseActiveHook;
@@ -539,15 +490,19 @@ interface UseActiveHook {
   isPending: boolean;
   name?: string;
 }
+//# sourceMappingURL=useActive.d.ts.map
 //#endregion
 //#region src/hooks/useAlepha.d.ts
 declare const useAlepha: () => Alepha;
+//# sourceMappingURL=useAlepha.d.ts.map
 //#endregion
 //#region src/hooks/useClient.d.ts
 declare const useClient: <T extends object>(_scope?: ClientScope) => HttpVirtualClient<T>;
+//# sourceMappingURL=useClient.d.ts.map
 //#endregion
 //#region src/hooks/useInject.d.ts
 declare const useInject: <T extends object>(clazz: Service<T>) => T;
+//# sourceMappingURL=useInject.d.ts.map
 //#endregion
 //#region src/hooks/useQueryParams.d.ts
 interface UseQueryParamsHookOptions {
@@ -556,9 +511,11 @@ interface UseQueryParamsHookOptions {
   push?: boolean;
 }
 declare const useQueryParams: <T extends TObject>(schema: T, options?: UseQueryParamsHookOptions) => [Static<T>, (data: Static<T>) => void];
+//# sourceMappingURL=useQueryParams.d.ts.map
 //#endregion
 //#region src/hooks/useRouter.d.ts
 declare const useRouter: () => RouterHookApi;
+//# sourceMappingURL=useRouter.d.ts.map
 //#endregion
 //#region src/hooks/useRouterEvents.d.ts
 declare const useRouterEvents: (opts?: {
@@ -573,18 +530,21 @@ declare const useRouterEvents: (opts?: {
     error: Error;
   }) => void;
 }, deps?: any[]) => void;
+//# sourceMappingURL=useRouterEvents.d.ts.map
 //#endregion
 //#region src/hooks/useRouterState.d.ts
 declare const useRouterState: () => RouterState;
+//# sourceMappingURL=useRouterState.d.ts.map
+
 //#endregion
 //#region src/providers/ReactServerProvider.d.ts
-declare const envSchema: _alepha_core11.TObject<{
-  REACT_SERVER_DIST: _sinclair_typebox6.TString;
-  REACT_SERVER_PREFIX: _sinclair_typebox6.TString;
-  REACT_SSR_ENABLED: _sinclair_typebox6.TOptional<_sinclair_typebox6.TBoolean>;
-  REACT_ROOT_ID: _sinclair_typebox6.TString;
+declare const envSchema: _alepha_core1.TObject<{
+  REACT_SERVER_DIST: _alepha_core1.TString;
+  REACT_SERVER_PREFIX: _alepha_core1.TString;
+  REACT_SSR_ENABLED: _alepha_core1.TOptional<_alepha_core1.TBoolean>;
+  REACT_ROOT_ID: _alepha_core1.TString;
 }>;
-declare module "alepha/core" {
+declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
   interface State {
     "ReactServerProvider.template"?: string;
@@ -592,12 +552,11 @@ declare module "alepha/core" {
   }
 }
 declare class ReactServerProvider {
-  protected readonly log: _alepha_core11.Logger;
+  protected readonly log: _alepha_core1.Logger;
   protected readonly alepha: Alepha;
   protected readonly pageDescriptorProvider: PageDescriptorProvider;
   protected readonly serverStaticProvider: ServerStaticProvider;
   protected readonly serverRouterProvider: ServerRouterProvider;
-  protected readonly headProvider: ServerHeadProvider;
   protected readonly serverTimingProvider: ServerTimingProvider;
   protected readonly env: {
     REACT_SSR_ENABLED?: boolean | undefined;
@@ -606,8 +565,8 @@ declare class ReactServerProvider {
     REACT_ROOT_ID: string;
   };
   protected readonly ROOT_DIV_REGEX: RegExp;
-  readonly onConfigure: _alepha_core11.HookDescriptor<"configure">;
-  get template(): string | undefined;
+  readonly onConfigure: _alepha_core1.HookDescriptor<"configure">;
+  get template(): string;
   protected registerPages(templateLoader: TemplateLoader): Promise<void>;
   protected getPublicDirectory(): string;
   protected configureStaticServer(root: string): Promise<void>;
@@ -615,15 +574,16 @@ declare class ReactServerProvider {
   /**
    * For testing purposes, creates a render function that can be used.
    */
-  protected createRenderFunction(name: string, withIndex?: boolean): (options?: {
-    params?: Record<string, string>;
-    query?: Record<string, string>;
-  }) => Promise<{
+  protected createRenderFunction(name: string, withIndex?: boolean): (options?: PageDescriptorRenderOptions) => Promise<{
+    context: PageRequest;
+    state: CreateLayersResult;
+    html: string;
+  } | {
     context: PageRequest;
     html: string;
   }>;
   protected createHandler(page: PageRoute, templateLoader: TemplateLoader): ServerHandler;
-  renderToHtml(template: string, state: RouterState, context: PageReactContext): string;
+  renderToHtml(template: string, state: RouterState, context: PageReactContext, hydration?: boolean): string;
   protected fillTemplate(response: {
     html: string;
   }, app: string, script: string): void;
@@ -631,23 +591,35 @@ declare class ReactServerProvider {
 type TemplateLoader = () => Promise<string | undefined>;
 //#endregion
 //#region src/index.d.ts
-declare module "@alepha/core" {
+declare module "alepha" {
   interface Hooks {
+    "react:router:createLayers": {
+      request: ServerRequest;
+      context: PageRequest;
+      layers: PageRequest[];
+    };
+    "react:server:render:begin": {
+      request?: ServerRequest;
+      context: PageRequest;
+    };
+    "react:server:render:end": {
+      request?: ServerRequest;
+      context: PageRequest;
+      state: RouterState;
+      html: string;
+    };
     "react:browser:render": {
       state: RouterState;
       context: PageReactContext;
       hydration?: ReactHydrationState;
     };
-    "react:server:render": {
-      request: ServerRequest;
-      pageRequest: PageRequest;
-    };
     "react:transition:begin": {
       state: RouterState;
       context: PageReactContext;
     };
     "react:transition:success": {
       state: RouterState;
+      context: PageReactContext;
     };
     "react:transition:error": {
       error: Error;
@@ -673,6 +645,8 @@ declare class AlephaReact implements Module {
   readonly name = "alepha.react";
   readonly $services: (alepha: Alepha) => Alepha;
 }
+//# sourceMappingURL=index.d.ts.map
+
 //#endregion
-export { $page, AlephaReact, AnchorProps, ClientOnly, CreateLayersResult, ErrorBoundary, Head, HrefLike, Layer, Link, NestedView, PageConfigSchema, PageDescriptor, PageDescriptorOptions, PageDescriptorProvider, PageDescriptorRenderOptions, PageDescriptorRenderResult, PageReactContext, PageRequest, PageRequestConfig, PageResolve, PageRoute, PageRouteEntry, PreviousLayerData, ReactBrowserProvider, ReactHydrationState, ReactServerProvider, RedirectionError, RouterContext, RouterContextValue, RouterGoOptions, RouterHookApi, RouterLayerContext, RouterLayerContextValue, RouterRenderResult, RouterStackItem, RouterState, TPropsDefault, TPropsParentDefault, TransitionOptions, UseActiveHook, UseQueryParamsHookOptions, VirtualRouter, isPageRoute, useActive, useAlepha, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState };
+export { $page, AlephaReact, AnchorProps, ClientOnly, CreateLayersResult, ErrorBoundary, HrefLike, Layer, Link, NestedView, PageConfigSchema, PageDescriptor, PageDescriptorOptions, PageDescriptorProvider, PageDescriptorRenderOptions, PageDescriptorRenderResult, PageReactContext, PageRequest, PageRequestConfig, PageResolve, PageRoute, PageRouteEntry, PreviousLayerData, ReactBrowserProvider, ReactHydrationState, ReactServerProvider, RedirectionError, RouterContext, RouterContextValue, RouterGoOptions, RouterHookApi, RouterLayerContext, RouterLayerContextValue, RouterRenderResult, RouterStackItem, RouterState, TPropsDefault, TPropsParentDefault, TransitionOptions, UseActiveHook, UseQueryParamsHookOptions, VirtualRouter, isPageRoute, useActive, useAlepha, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState };
 //# sourceMappingURL=index.d.ts.map

package/redis.d.ts

@@ -1,14 +1,11 @@
-import * as _alepha_core7 from "@alepha/core";
-import * as _alepha_core0 from "@alepha/core";
-import { Alepha, Static } from "@alepha/core";
+import { Alepha, HookDescriptor, Logger, Static, TNumber, TObject, TOptional, TString } from "alepha";
 import { RedisClientType, SetOptions, createClient } from "@redis/client";
-import * as _sinclair_typebox3 from "@sinclair/typebox";
 
 //#region src/providers/RedisProvider.d.ts
-declare const envSchema: _alepha_core7.TObject<{
-  REDIS_PORT: _sinclair_typebox3.TNumber;
-  REDIS_HOST: _sinclair_typebox3.TString;
-  REDIS_PASSWORD: _sinclair_typebox3.TOptional<_sinclair_typebox3.TString>;
+declare const envSchema: TObject<{
+  REDIS_PORT: TNumber;
+  REDIS_HOST: TString;
+  REDIS_PASSWORD: TOptional<TString>;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
@@ -19,24 +16,20 @@ type RedisClient = RedisClientType<{}, {}, {}, 3, {
 type RedisClientOptions = Parameters<typeof createClient>[0];
 type RedisSetOptions = SetOptions;
 declare class RedisProvider {
-  protected readonly log: _alepha_core7.Logger;
+  protected readonly log: Logger;
   protected readonly alepha: Alepha;
-  protected readonly env: {
-    REDIS_PASSWORD?: string | undefined;
-    REDIS_PORT: number;
-    REDIS_HOST: string;
-  };
+  protected readonly env: Static<typeof envSchema>;
   protected readonly client: RedisClient;
   get publisher(): RedisClient;
-  protected readonly start: _alepha_core7.HookDescriptor<"start">;
-  protected readonly stop: _alepha_core7.HookDescriptor<"stop">;
+  protected readonly start: HookDescriptor<"start">;
+  protected readonly stop: HookDescriptor<"stop">;
   /**
-   * Connect to the Redis server.
-   */
+  * Connect to the Redis server.
+  */
   connect(): Promise<void>;
   /**
-   * Close the connection to the Redis server.
-   */
+  * Close the connection to the Redis server.
+  */
   close(): Promise<void>;
   duplicate(options?: Partial<RedisClientOptions>): RedisClient;
   get(key: string): Promise<Buffer | undefined>;
@@ -45,25 +38,25 @@ declare class RedisProvider {
   keys(pattern: string): Promise<string[]>;
   del(keys: string[]): Promise<void>;
   /**
-   * Redis subscriber client factory method.
-   */
+  * Redis subscriber client factory method.
+  */
   protected createClient(): RedisClient;
 }
 //#endregion
 //#region src/providers/RedisSubscriberProvider.d.ts
 declare class RedisSubscriberProvider {
-  protected readonly log: _alepha_core0.Logger;
+  protected readonly log: Logger;
   protected readonly alepha: Alepha;
   protected readonly redisProvider: RedisProvider;
   protected readonly client: RedisClient;
   get subscriber(): RedisClient;
-  protected readonly start: _alepha_core0.HookDescriptor<"start">;
-  protected readonly stop: _alepha_core0.HookDescriptor<"stop">;
+  protected readonly start: HookDescriptor<"start">;
+  protected readonly stop: HookDescriptor<"stop">;
   connect(): Promise<void>;
   close(): Promise<void>;
   /**
-   * Redis subscriber client factory method.
-   */
+  * Redis subscriber client factory method.
+  */
   protected createClient(): RedisClient;
 }
 //#endregion

package/retry.d.ts

@@ -1,71 +1,91 @@
-import { MaybePromise } from "@alepha/core";
+import { AlephaError, MaybePromise } from "alepha";
+import { DateTimeProvider, DurationLike } from "alepha/datetime";
 
 //#region src/descriptors/$retry.d.ts
 
+// TODO: move to RetryProvider
 /**
- * `$retry` creates a retry descriptor.
- *
- * It will retry the given function up to `max` times with a delay of `delay` milliseconds between attempts.
- *
- * @example
- * ```ts
- * import { $retry } from "@alepha/core";
- *
- * class MyService {
- * 	fetchData = $retry({
- * 		max: 5, // maximum number of attempts
- * 		delay: 1000, // ms
- * 		when: (error) => error.message.includes("Network Error"),
- * 		handler: async (url: string) => {
- * 			const response = await fetch(url);
- * 			if (!response.ok) {
- * 				throw new Error(`Failed to fetch: ${response.statusText}`);
- * 			}
- * 			return response.json();
- * 		},
- * 		onError: (error, attempt, url) => {
- * 	    // error happened, log it or handle it
- * 			console.error(`Attempt ${attempt} failed for ${url}:`, error);
- * 		},
- * 	});
- * }
- * ```
- */
+* Creates a function that automatically retries a handler upon failure,
+* with support for exponential backoff, max duration, and cancellation.
+*/
 declare const $retry: <T extends (...args: any[]) => any>(opts: RetryDescriptorOptions<T>) => RetryDescriptor<T>;
-/**
- * Retry Descriptor options.
- */
+declare const createRetryHandler: <T extends (...args: any[]) => any>(opts: RetryDescriptorOptions<T>, dateTimeProvider: DateTimeProvider, appAbortController?: AbortController) => RetryDescriptor<T>;
+// ---------------------------------------------------------------------------------------------------------------------
+interface RetryBackoffOptions {
+  /**
+  * Initial delay in milliseconds.
+  *
+  * @default 200
+  */
+  initial?: number;
+  /**
+  * Multiplier for each subsequent delay.
+  *
+  * @default 2
+  */
+  factor?: number;
+  /**
+  * Maximum delay in milliseconds.
+  */
+  max?: number;
+  /**
+  * If true, adds a random jitter to the delay to prevent thundering herd.
+  *
+  * @default true
+  */
+  jitter?: boolean;
+}
 interface RetryDescriptorOptions<T extends (...args: any[]) => any> {
   /**
-   * Maximum number of attempts.
-   *
-   * @default 3
-   */
+  * The function to retry.
+  */
+  handler: T;
+  /**
+  * The maximum number of attempts.
+  *
+  * @default 3
+  */
   max?: number;
   /**
-   * Delay in milliseconds.
-   *
-   * @default 0
-   */
-  delay?: number;
+  * The backoff strategy for delays between retries.
+  * Can be a fixed number (in ms) or a configuration object for exponential backoff.
+  *
+  * @default { initial: 200, factor: 2, jitter: true }
+  */
+  backoff?: number | RetryBackoffOptions;
+  /**
+  * An overall time limit for all retry attempts combined.
+  *
+  * e.g., `[5, 'seconds']`
+  */
+  maxDuration?: DurationLike;
   /**
-   * Optional condition to determine when to retry.
-   */
+  * A function that determines if a retry should be attempted based on the error.
+  *
+  * @default (error) => true (retries on any error)
+  */
   when?: (error: Error) => boolean;
   /**
-   * The function to retry.
-   */
-  handler: T;
+  * A custom callback for when a retry attempt fails.
+  * This is called before the delay.
+  */
+  onError?: (error: Error, attempt: number, ...args: Parameters<T>) => void;
   /**
-   * Optional error handler.
-   *
-   * This will be called when an error occurs.
-   *
-   * @default undefined
-   */
-  onError?: (error: Error, attempt: number, ...parameters: Parameters<T>) => void;
+  * An AbortSignal to allow for external cancellation of the retry loop.
+  */
+  signal?: AbortSignal;
 }
 type RetryDescriptor<T extends (...args: any[]) => any> = (...parameters: Parameters<T>) => MaybePromise<ReturnType<T>>;
 //#endregion
-export { $retry, RetryDescriptor, RetryDescriptorOptions };
+//#region src/errors/RetryCancelError.d.ts
+declare class RetryCancelError extends AlephaError {
+  constructor();
+}
+//#endregion
+//#region src/errors/RetryTimeoutError.d.ts
+declare class RetryTimeoutError extends AlephaError {
+  constructor(duration: number);
+}
+//#endregion
+export { $retry, RetryBackoffOptions, RetryCancelError, RetryDescriptor, RetryDescriptorOptions, RetryTimeoutError, createRetryHandler };
 //# sourceMappingURL=index.d.ts.map