alepha 0.8.1 → 0.9.0

package/react.d.ts

@@ -1,19 +1,20 @@
-import * as _alepha_core11 from "alepha";
-import * as _alepha_core24 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 * as _alepha_core8 from "alepha";
+import * as _alepha_core14 from "alepha";
+import * as _alepha_core12 from "alepha";
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha, Async, Descriptor, KIND, 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 react20 from "react";
-import * as react23 from "react";
+import * as react0$1 from "react";
+import * as react0 from "react";
 import React, { AnchorHTMLAttributes, ErrorInfo, FC, PropsWithChildren, ReactNode } from "react";
-import * as react_jsx_runtime18 from "react/jsx-runtime";
-import * as react_jsx_runtime21 from "react/jsx-runtime";
-import * as react_jsx_runtime22 from "react/jsx-runtime";
-import { ServerStaticProvider } from "alepha/server/static";
+import * as react_jsx_runtime1 from "react/jsx-runtime";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import * as react_jsx_runtime2 from "react/jsx-runtime";
 import { Route, RouterProvider } from "alepha/router";
+import { ServerStaticProvider } from "alepha/server/static";
 import { Root } from "react-dom/client";
 
 //#region src/components/ClientOnly.d.ts
@@ -34,20 +35,13 @@ interface ClientOnlyProps {
 declare const ClientOnly: (props: PropsWithChildren<ClientOnlyProps>) => ReactNode;
 //#endregion
 //#region src/descriptors/$page.d.ts
-declare const KEY = "PAGE";
 /**
  * Main descriptor for defining a React route in the application.
  */
 declare const $page: {
   <TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = any, TPropsParent extends object = TPropsParentDefault>(options: PageDescriptorOptions<TConfig, TProps, TPropsParent>): PageDescriptor<TConfig, TProps, TPropsParent>;
-  [KIND]: string;
+  [KIND]: typeof PageDescriptor;
 };
-interface PageConfigSchema {
-  query?: TSchema;
-  params?: TSchema;
-}
-type TPropsDefault = any;
-type TPropsParentDefault = {};
 interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
   /**
    * Name your page.
@@ -111,14 +105,8 @@ interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSch
    *
    * If you still want to render at this pathname, add a child page with an empty path.
    */
-  children?: Array<{
-    [OPTIONS]: PageDescriptorOptions;
-  }> | (() => Array<{
-    [OPTIONS]: PageDescriptorOptions;
-  }>);
-  parent?: {
-    [OPTIONS]: PageDescriptorOptions<PageConfigSchema, TPropsParent>;
-  };
+  children?: Array<PageDescriptor> | (() => Array<PageDescriptor>);
+  parent?: PageDescriptor<PageConfigSchema, TPropsParent>;
   can?: () => boolean;
   errorHandler?: (error: Error) => ReactNode;
   /**
@@ -137,15 +125,20 @@ interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSch
   afterHandler?: (request: ServerRequest) => any;
   cache?: ServerRouteCache;
 }
-interface PageDescriptor<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
-  [KIND]: typeof KEY;
-  [OPTIONS]: PageDescriptorOptions<TConfig, TProps, TPropsParent>;
+declare class PageDescriptor<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> extends Descriptor<PageDescriptorOptions<TConfig, TProps, TPropsParent>> {
+  get name(): string;
   /**
    * For testing or build purposes, this will render the page (with or without the HTML layout) and return the HTML and context.
    * Only valid for server-side rendering, it will throw an error if called on the client-side.
    */
-  render: (options?: PageDescriptorRenderOptions) => Promise<PageDescriptorRenderResult>;
+  render(options?: PageDescriptorRenderOptions): Promise<PageDescriptorRenderResult>;
+}
+interface PageConfigSchema {
+  query?: TSchema;
+  params?: TSchema;
 }
+type TPropsDefault = any;
+type TPropsParentDefault = {};
 interface PageDescriptorRenderOptions {
   params?: Record<string, string>;
   query?: Record<string, string>;
@@ -161,16 +154,17 @@ interface PageRequestConfig<TConfig extends PageConfigSchema = PageConfigSchema>
   query: TConfig["query"] extends TSchema ? Static<TConfig["query"]> : Record<string, string>;
 }
 type PageResolve<TConfig extends PageConfigSchema = PageConfigSchema, TPropsParent extends object = TPropsParentDefault> = PageRequestConfig<TConfig> & TPropsParent & PageReactContext;
+//# sourceMappingURL=$page.d.ts.map
 //#endregion
 //#region src/providers/PageDescriptorProvider.d.ts
-declare const envSchema$1: _alepha_core11.TObject<{
-  REACT_STRICT_MODE: _alepha_core11.TBoolean;
+declare const envSchema$1: _alepha_core8.TObject<{
+  REACT_STRICT_MODE: _alepha_core8.TBoolean;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$1>> {}
 }
 declare class PageDescriptorProvider {
-  protected readonly log: _alepha_core11.Logger;
+  protected readonly log: _alepha_core8.Logger;
   protected readonly env: {
     REACT_STRICT_MODE: boolean;
   };
@@ -195,14 +189,8 @@ 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_core11.HookDescriptor<"configure">;
-  protected map(pages: Array<{
-    value: {
-      [OPTIONS]: PageDescriptorOptions;
-    };
-  }>, target: {
-    [OPTIONS]: PageDescriptorOptions;
-  }): PageRouteEntry;
+  protected readonly configure: _alepha_core8.HookDescriptor<"configure">;
+  protected map(pages: Array<PageDescriptor>, target: PageDescriptor): PageRouteEntry;
   add(entry: PageRouteEntry): void;
   protected createMatch(page: PageRoute): string;
   protected _next: number;
@@ -284,11 +272,11 @@ interface BrowserRoute extends Route {
   page: PageRoute;
 }
 declare class BrowserRouterProvider extends RouterProvider<BrowserRoute> {
-  protected readonly log: _alepha_core24.Logger;
+  protected readonly log: _alepha_core14.Logger;
   protected readonly alepha: Alepha;
   protected readonly pageDescriptorProvider: PageDescriptorProvider;
   add(entry: PageRouteEntry): void;
-  protected readonly configure: _alepha_core24.HookDescriptor<"configure">;
+  protected readonly configure: _alepha_core14.HookDescriptor<"configure">;
   transition(url: URL, options?: TransitionOptions): Promise<RouterRenderResult>;
   root(state: RouterState, context: PageReactContext): ReactNode;
 }
@@ -296,7 +284,7 @@ declare class BrowserRouterProvider extends RouterProvider<BrowserRoute> {
 //#endregion
 //#region src/providers/ReactBrowserProvider.d.ts
 declare class ReactBrowserProvider {
-  protected readonly log: _alepha_core16.Logger;
+  protected readonly log: _alepha_core12.Logger;
   protected readonly client: LinkProvider;
   protected readonly alepha: Alepha;
   protected readonly router: BrowserRouterProvider;
@@ -320,7 +308,7 @@ declare class ReactBrowserProvider {
    * Get embedded layers from the server.
    */
   protected getHydrationState(): ReactHydrationState | undefined;
-  readonly ready: _alepha_core16.HookDescriptor<"ready">;
+  readonly ready: _alepha_core12.HookDescriptor<"ready">;
 }
 interface RouterGoOptions {
   replace?: boolean;
@@ -378,7 +366,7 @@ interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
   to: string | PageDescriptor;
   children?: React.ReactNode;
 }
-declare const Link: (props: LinkProps) => react_jsx_runtime18.JSX.Element | null;
+declare const Link: (props: LinkProps) => react_jsx_runtime1.JSX.Element | null;
 //#endregion
 //#region src/components/NestedView.d.ts
 interface NestedViewProps {
@@ -405,10 +393,10 @@ interface NestedViewProps {
  * }
  * ```
  */
-declare const NestedView: (props: NestedViewProps) => react_jsx_runtime21.JSX.Element;
+declare const NestedView: (props: NestedViewProps) => react_jsx_runtime0.JSX.Element;
 //#endregion
 //#region src/components/NotFound.d.ts
-declare function NotFoundPage(): react_jsx_runtime22.JSX.Element;
+declare function NotFoundPage(): react_jsx_runtime2.JSX.Element;
 //# sourceMappingURL=NotFound.d.ts.map
 //#endregion
 //#region src/contexts/RouterContext.d.ts
@@ -417,7 +405,7 @@ interface RouterContextValue {
   state: RouterState;
   context: PageReactContext;
 }
-declare const RouterContext: react20.Context<RouterContextValue | undefined>;
+declare const RouterContext: react0$1.Context<RouterContextValue | undefined>;
 //# sourceMappingURL=RouterContext.d.ts.map
 //#endregion
 //#region src/contexts/RouterLayerContext.d.ts
@@ -425,7 +413,7 @@ interface RouterLayerContextValue {
   index: number;
   path: string;
 }
-declare const RouterLayerContext: react23.Context<RouterLayerContextValue | undefined>;
+declare const RouterLayerContext: react0.Context<RouterLayerContextValue | undefined>;
 //# sourceMappingURL=RouterLayerContext.d.ts.map
 //#endregion
 //#region src/hooks/RouterHookApi.d.ts
@@ -550,11 +538,11 @@ declare const useRouterState: () => RouterState;
 
 //#endregion
 //#region src/providers/ReactServerProvider.d.ts
-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 const envSchema: _alepha_core0$1.TObject<{
+  REACT_SERVER_DIST: _alepha_core0$1.TString;
+  REACT_SERVER_PREFIX: _alepha_core0$1.TString;
+  REACT_SSR_ENABLED: _alepha_core0$1.TOptional<_alepha_core0$1.TBoolean>;
+  REACT_ROOT_ID: _alepha_core0$1.TString;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
@@ -564,7 +552,7 @@ declare module "alepha" {
   }
 }
 declare class ReactServerProvider {
-  protected readonly log: _alepha_core1.Logger;
+  protected readonly log: _alepha_core0$1.Logger;
   protected readonly alepha: Alepha;
   protected readonly pageDescriptorProvider: PageDescriptorProvider;
   protected readonly serverStaticProvider: ServerStaticProvider;
@@ -577,7 +565,7 @@ declare class ReactServerProvider {
     REACT_ROOT_ID: string;
   };
   protected readonly ROOT_DIV_REGEX: RegExp;
-  readonly onConfigure: _alepha_core1.HookDescriptor<"configure">;
+  readonly onConfigure: _alepha_core0$1.HookDescriptor<"configure">;
   get template(): string;
   protected registerPages(templateLoader: TemplateLoader): Promise<void>;
   protected getPublicDirectory(): string;
@@ -651,134 +639,10 @@ declare module "alepha" {
  * 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.
  *
- * **Key Features:**
- * - Declarative page definition with `$page` descriptor
- * - Server-side rendering (SSR) with automatic hydration
- * - Type-safe routing with parameter validation
- * - Schema-based data resolution and validation
- * - SEO-friendly meta tag management
- * - Automatic code splitting and lazy loading
- * - Client-side navigation with browser history
- *
- * **Basic Usage:**
- * ```ts
- * import { Alepha, run, t } from "alepha";
- * import { AlephaReact, $page } from "alepha/react";
- *
- * class AppRoutes {
- *   // Home page
- *   home = $page({
- *     path: "/",
- *     component: () => (
- *       <div>
- *         <h1>Welcome to Alepha</h1>
- *         <p>Build amazing React applications!</p>
- *       </div>
- *     ),
- *   });
- *
- *   // About page with meta tags
- *   about = $page({
- *     path: "/about",
- *     head: {
- *       title: "About Us",
- *       description: "Learn more about our mission",
- *     },
- *     component: () => (
- *       <div>
- *         <h1>About Us</h1>
- *         <p>Learn more about our mission.</p>
- *       </div>
- *     ),
- *   });
- * }
- *
- * const alepha = Alepha.create()
- *   .with(AlephaReact)
- *   .with(AppRoutes);
- *
- * run(alepha);
- * ```
- *
- * **Dynamic Routes with Parameters:**
- * ```tsx
- * class UserRoutes {
- *   userProfile = $page({
- *     path: "/users/:id",
- *     schema: {
- *       params: t.object({
- *         id: t.string(),
- *       }),
- *     },
- *     resolve: async ({ params }) => {
- *       // Fetch user data server-side
- *       const user = await getUserById(params.id);
- *       return { user };
- *     },
- *     head: ({ user }) => ({
- *       title: `${user.name} - Profile`,
- *       description: `View ${user.name}'s profile`,
- *     }),
- *     component: ({ user }) => (
- *       <div>
- *         <h1>{user.name}</h1>
- *         <p>Email: {user.email}</p>
- *       </div>
- *     ),
- *   });
- *
- *   userSettings = $page({
- *     path: "/users/:id/settings",
- *     schema: {
- *       params: t.object({
- *         id: t.string(),
- *       }),
- *     },
- *     component: ({ params }) => (
- *       <UserSettings userId={params.id} />
- *     ),
- *   });
- * }
- * ```
- *
- * **Static Generation:**
- * ```tsx
- * class BlogRoutes {
- *   blogPost = $page({
- *     path: "/blog/:slug",
- *     schema: {
- *       params: t.object({
- *         slug: t.string(),
- *       }),
- *     },
- *     static: {
- *       entries: [
- *         { params: { slug: "getting-started" } },
- *         { params: { slug: "advanced-features" } },
- *         { params: { slug: "deployment" } },
- *       ],
- *     },
- *     resolve: ({ params }) => {
- *       const post = getBlogPost(params.slug);
- *       return { post };
- *     },
- *     component: ({ post }) => (
- *       <article>
- *         <h1>{post.title}</h1>
- *         <div>{post.content}</div>
- *       </article>
- *     ),
- *   });
- * }
- * ```
- *
  * @see {@link $page}
  * @module alepha.react
  */
-declare class AlephaReact implements Module {
-  readonly name = "alepha.react";
-  readonly $services: (alepha: Alepha) => Alepha;
-}
+declare const AlephaReact: _alepha_core0.ModuleDescriptor;
 //# sourceMappingURL=index.d.ts.map
 
 //#endregion

package/redis.d.ts

@@ -1,4 +1,7 @@
-import { Alepha, HookDescriptor, Logger, Static, TNumber, TObject, TOptional, TString } from "alepha";
+import * as _alepha_core2 from "alepha";
+import * as _alepha_core0$1 from "alepha";
+import * as _alepha_core0 from "alepha";
+import { Alepha, Logger, Static, TNumber, TObject, TOptional, TString } from "alepha";
 import { RedisClientType, SetOptions, createClient } from "@redis/client";
 
 //#region src/providers/RedisProvider.d.ts
@@ -16,23 +19,23 @@ type RedisClient = RedisClientType<{}, {}, {}, 3, {
 type RedisClientOptions = Parameters<typeof createClient>[0];
 type RedisSetOptions = SetOptions;
 /**
-* Redis client provider.
-*/
+ * Redis client provider.
+ */
 declare class RedisProvider {
   protected readonly log: Logger;
   protected readonly alepha: Alepha;
   protected readonly env: Static<typeof envSchema>;
   protected readonly client: RedisClient;
   get publisher(): RedisClient;
-  protected readonly start: HookDescriptor<"start">;
-  protected readonly stop: HookDescriptor<"stop">;
+  protected readonly start: _alepha_core2.HookDescriptor<"start">;
+  protected readonly stop: _alepha_core2.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>;
@@ -41,8 +44,8 @@ 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
@@ -53,15 +56,27 @@ declare class RedisSubscriberProvider {
   protected readonly redisProvider: RedisProvider;
   protected readonly client: RedisClient;
   get subscriber(): RedisClient;
-  protected readonly start: HookDescriptor<"start">;
-  protected readonly stop: HookDescriptor<"stop">;
+  protected readonly start: _alepha_core0$1.HookDescriptor<"start">;
+  protected readonly stop: _alepha_core0$1.HookDescriptor<"stop">;
   connect(): Promise<void>;
   close(): Promise<void>;
   /**
-  * Redis subscriber client factory method.
-  */
+   * Redis subscriber client factory method.
+   */
   protected createClient(): RedisClient;
 }
+//# sourceMappingURL=RedisSubscriberProvider.d.ts.map
 //#endregion
-export { RedisClient, RedisClientOptions, RedisProvider, RedisSetOptions, RedisSubscriberProvider };
+//#region src/index.d.ts
+/**
+ * Redis client provider for Alepha applications.
+ *
+ * @see {@link RedisProvider}
+ * @module alepha.redis
+ */
+declare const AlephaRedis: _alepha_core0.ModuleDescriptor;
+//# sourceMappingURL=index.d.ts.map
+
+//#endregion
+export { AlephaRedis, RedisClient, RedisClientOptions, RedisProvider, RedisSetOptions, RedisSubscriberProvider };
 //# sourceMappingURL=index.d.ts.map

package/retry.d.ts

@@ -1,92 +1,103 @@
-import { AlephaError, MaybePromise } from "alepha";
+import { AlephaError, Descriptor, DescriptorArgs, KIND } from "alepha";
 import { DateTimeProvider, DurationLike } from "alepha/datetime";
 
 //#region src/descriptors/$retry.d.ts
 
 /**
-* 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>;
-// ---------------------------------------------------------------------------------------------------------------------
-// TODO: move to RetryProvider
-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;
-}
+ * 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>(options: RetryDescriptorOptions<T>): RetryDescriptorFn<T>;
+  [KIND]: typeof RetryDescriptor;
+};
 interface RetryDescriptorOptions<T extends (...args: any[]) => any> {
   /**
-  * The function to retry.
-  */
+   * The function to retry.
+   */
   handler: T;
   /**
-  * The maximum number of attempts.
-  *
-  * @default 3
-  */
+   * The maximum number of attempts.
+   *
+   * @default 3
+   */
   max?: 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 }
-  */
+   * 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']`
-  */
+   * An overall time limit for all retry attempts combined.
+   *
+   * e.g., `[5, 'seconds']`
+   */
   maxDuration?: DurationLike;
   /**
-  * A function that determines if a retry should be attempted based on the error.
-  *
-  * @default (error) => true (retries on any error)
-  */
+   * 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;
   /**
-  * A custom callback for when a retry attempt fails.
-  * This is called before the delay.
-  */
+   * A custom callback for when a retry attempt fails.
+   * This is called before the delay.
+   */
   onError?: (error: Error, attempt: number, ...args: Parameters<T>) => void;
   /**
-  * An AbortSignal to allow for external cancellation of the retry loop.
-  */
+   * 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>>;
+declare class RetryDescriptor<T extends (...args: any[]) => any> extends Descriptor<RetryDescriptorOptions<T>> {
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected appAbortController: AbortController;
+  constructor(args: DescriptorArgs<RetryDescriptorOptions<T>>);
+  run(...args: Parameters<T>): Promise<ReturnType<T>>;
+}
+interface RetryDescriptorFn<T extends (...args: any[]) => any> extends RetryDescriptor<T> {
+  (...args: Parameters<T>): Promise<ReturnType<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;
+}
+//# sourceMappingURL=$retry.d.ts.map
 //#endregion
 //#region src/errors/RetryCancelError.d.ts
 declare class RetryCancelError extends AlephaError {
   constructor();
 }
+//# sourceMappingURL=RetryCancelError.d.ts.map
 //#endregion
 //#region src/errors/RetryTimeoutError.d.ts
 declare class RetryTimeoutError extends AlephaError {
   constructor(duration: number);
 }
+//# sourceMappingURL=RetryTimeoutError.d.ts.map
+
 //#endregion
-export { $retry, RetryBackoffOptions, RetryCancelError, RetryDescriptor, RetryDescriptorOptions, RetryTimeoutError, createRetryHandler };
+export { $retry, RetryBackoffOptions, RetryCancelError, RetryDescriptor, RetryDescriptorFn, RetryDescriptorOptions, RetryTimeoutError };
 //# sourceMappingURL=index.d.ts.map

package/router.d.ts

@@ -1,10 +1,9 @@
 //#region src/providers/RouterProvider.d.ts
-declare class RouterProvider<T extends Route = Route> {
+declare abstract class RouterProvider<T extends Route = Route> {
   protected routePathRegex: RegExp;
   protected tree: Tree<T>;
-  readonly routes: T[];
-  push(route: T): void;
   match(path: string): RouteMatch<T>;
+  protected push(route: T): void;
   protected createRouteMatch(path: string): RouteMatch<T>;
   protected mapParams(match: RouteMatch<T>): RouteMatch<T>;
   protected createParts(path: string): string[];
@@ -16,12 +15,12 @@ interface RouteMatch<T extends Route> {
 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.
-  */
+   * 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 extends Route> {
@@ -40,6 +39,7 @@ interface Tree<T extends Route> {
     route: T;
   };
 }
+//# sourceMappingURL=RouterProvider.d.ts.map
 //#endregion
 export { Route, RouteMatch, RouterProvider, Tree };
 //# sourceMappingURL=index.d.ts.map