@alepha/react 0.5.1 → 0.6.0

package/dist/{index.d.cts → index.d.ts}

@@ -1,25 +1,14 @@
 import * as _alepha_core from '@alepha/core';
-import { Static as Static$1, TSchema as TSchema$1, Async, KIND, EventEmitter, Alepha, ClassEntry, TObject as TObject$1 } from '@alepha/core';
+import { EventEmitter, Alepha, TSchema as TSchema$1, Static as Static$1, Async, KIND, Class, TObject as TObject$1 } from '@alepha/core';
 import * as react from 'react';
-import { ReactNode, FC } from 'react';
+import react__default, { ReactNode, AnchorHTMLAttributes, FC } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { UserAccountToken } from '@alepha/security';
 import * as _alepha_server from '@alepha/server';
-import { ServerProvider, HttpClient, ServeDescriptorOptions, RouteObject } from '@alepha/server';
-import * as _alepha_cache from '@alepha/cache';
-import { SecurityProvider, UserAccountToken, UserAccountInfo } from '@alepha/security';
-import { Configuration } from 'openid-client';
-import { MatchFunction, ParamData } from 'path-to-regexp';
+import { FastifyCookieProvider, CookieManager, HttpClient, ServerProvider, ServeDescriptorOptions, CreateRoute } from '@alepha/server';
 import { Root } from 'react-dom/client';
-
-interface NestedViewProps {
-    children?: ReactNode;
-}
-/**
- * Nested view component
- *
- * @param props
- * @constructor
- */
-declare const NestedView: (props: NestedViewProps) => string | number | boolean | react.ReactElement<any, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null;
+import { MatchFunction, ParamData } from 'path-to-regexp';
+import { Configuration } from 'openid-client';
 
 /** Symbol key applied to readonly types */
 declare const ReadonlyKind: unique symbol;
@@ -62,23 +51,23 @@ interface TBoolean extends TSchema {
     type: 'boolean';
 }
 
+interface NumberOptions extends SchemaOptions {
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    maximum?: number;
+    minimum?: number;
+    multipleOf?: number;
+}
+interface TNumber extends TSchema, NumberOptions {
+    [Kind]: 'Number';
+    static: number;
+    type: 'number';
+}
+
 type TOptional<T extends TSchema> = T & {
     [OptionalKind]: 'Optional';
 };
 
-type RecordStatic<Key extends TSchema, Type extends TSchema, P extends unknown[]> = (Evaluate<{
-    [_ in Assert<Static<Key>, PropertyKey>]: Static<Type, P>;
-}>);
-interface TRecord<Key extends TSchema = TSchema, Type extends TSchema = TSchema> extends TSchema {
-    [Kind]: 'Record';
-    static: RecordStatic<Key, Type, this['params']>;
-    type: 'object';
-    patternProperties: {
-        [pattern: string]: Type;
-    };
-    additionalProperties: TAdditionalProperties;
-}
-
 /** Creates a static type from a TypeBox type */
 type Static<Type extends TSchema, Params extends unknown[] = [], Result = (Type & {
     params: Params;
@@ -118,7 +107,6 @@ interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOp
     required?: string[];
 }
 
-type Assert<T, E> = T extends E ? T : never;
 type Evaluate<T> = T extends infer O ? {
     [K in keyof O]: O[K];
 } : never;
@@ -152,607 +140,728 @@ interface TSchema extends TKind, SchemaOptions {
     static: unknown;
 }
 
-declare const sessionUserSchema: _alepha_core.TObject<{
-    id: TString;
-    name: TOptional<TString>;
-}>;
-declare const sessionSchema: _alepha_core.TObject<{
-    user: TOptional<_alepha_core.TObject<{
-        id: TString;
-        name: TOptional<TString>;
-    }>>;
-}>;
-type Session = Static$1<typeof sessionSchema>;
-declare const envSchema$1: _alepha_core.TObject<{
-    REACT_OIDC_ISSUER: TOptional<TString>;
-    REACT_OIDC_CLIENT_ID: TOptional<TString>;
-    REACT_OIDC_CLIENT_SECRET: TOptional<TString>;
-    REACT_OIDC_REDIRECT_URI: TOptional<TString>;
-}>;
-declare module "fastify" {
-    interface FastifyRequest {
-        session?: ReactServerSession;
-    }
+interface NestedViewProps {
+    children?: ReactNode;
 }
-declare module "@alepha/core" {
-    interface Env extends Partial<Static$1<typeof envSchema$1>> {
-    }
+/**
+ * Nested view component
+ *
+ * @param props
+ * @constructor
+ */
+declare const NestedView: (props: NestedViewProps) => string | number | boolean | react.ReactElement<any, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null;
+
+interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    to: string;
+    children?: react__default.ReactNode;
 }
-declare class ReactSessionProvider {
-    protected readonly SSID = "ssid";
+declare const Link: (props: LinkProps) => react_jsx_runtime.JSX.Element;
+
+declare class Router extends EventEmitter<RouterEvents> {
     protected readonly log: _alepha_core.Logger;
-    protected readonly env: {
-        REACT_OIDC_ISSUER?: string | undefined;
-        REACT_OIDC_CLIENT_ID?: string | undefined;
-        REACT_OIDC_CLIENT_SECRET?: string | undefined;
-        REACT_OIDC_REDIRECT_URI?: string | undefined;
-    };
-    protected readonly serverProvider: ServerProvider;
-    protected readonly securityProvider: SecurityProvider;
-    protected readonly sessions: _alepha_cache.CacheDescriptor<ReactServerSession, any[]>;
-    protected clients: Configuration[];
-    get redirectUri(): string;
-    protected readonly configure: _alepha_core.HookDescriptor<"configure">;
+    protected readonly alepha: Alepha;
+    protected readonly pages: PageRoute[];
+    protected notFoundPageRoute?: PageRoute;
     /**
+     * Get the page by name.
      *
-     * @param sessionId
-     * @param session
-     * @protected
+     * @param name - Page name
+     * @return PageRoute
      */
-    protected setSession(sessionId: string, session: ReactServerSession): Promise<void>;
+    page(name: string): PageRoute;
     /**
      *
-     * @param sessionId
-     * @protected
      */
-    protected getSession(sessionId: string): Promise<ReactServerSession | undefined>;
+    root(state: RouterState, context?: PageContext): ReactNode;
     /**
      *
-     * @protected
+     * @param url
+     * @param options
      */
-    protected readonly beforeRequest: _alepha_core.HookDescriptor<"configure:fastify">;
+    render(url: string, options?: RouterRenderOptions): Promise<RouterRenderResult>;
     /**
      *
+     * @param url
+     * @param options
+     * @param context
+     * @protected
      */
-    readonly login: _alepha_server.RouteDescriptor<{
-        query: _alepha_core.TObject<{
-            redirect: TOptional<TString>;
-        }>;
-    }>;
+    match(url: string, options?: RouterMatchOptions, context?: RouterRenderContext): Promise<Layer[]>;
     /**
+     * Create layers for the given route.
      *
+     * @param url
+     * @param route
+     * @param params
+     * @param query
+     * @param previous
+     * @param args
+     * @param renderContext
+     * @protected
      */
-    readonly callback: _alepha_server.RouteDescriptor<{
-        headers: TRecord<TString, TString>;
-        cookies: _alepha_core.TObject<{
-            ssid: TString;
-        }>;
-    }>;
-    readonly logout: _alepha_server.RouteDescriptor<{
-        query: _alepha_core.TObject<{
-            redirect: TOptional<TString>;
-        }>;
-        cookies: _alepha_core.TObject<{
-            ssid: TString;
-        }>;
-    }>;
-    readonly session: _alepha_server.RouteDescriptor<{
-        headers: _alepha_core.TObject<{
-            authorization: TString;
-        }>;
-        response: _alepha_core.TObject<{
-            user: TOptional<_alepha_core.TObject<{
-                id: TString;
-                name: TOptional<TString>;
-            }>>;
-        }>;
-    }>;
-}
-interface ReactServerSession {
-    access_token?: string;
-    expires_in?: number;
-    refresh_token?: string;
-    id_token?: string;
-    scope?: string;
-    issued_at?: number;
-    authorizationCodeGrant?: {
-        codeVerifier: string;
-        redirectUri: string;
-        nonce?: string;
-        max_age?: number;
-        state?: string;
-    };
-}
-
-declare class ReactBrowserProvider {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly client: HttpClient;
-    protected readonly router: Router;
-    protected root: Root;
-    transitioning?: {
-        to: string;
-    };
-    state: RouterState;
+    createLayers(url: string, route: PageRoute, params?: Record<string, any>, query?: Record<string, string>, previous?: PreviousLayerData[], args?: PageContext, renderContext?: RouterRenderContext): Promise<Layer[]>;
     /**
      *
+     * @param route
+     * @protected
      */
-    get document(): Document;
+    protected getErrorHandler(route: PageRoute): react.FC<{
+        error: Error;
+        url: string;
+    }> | undefined;
     /**
      *
+     * @param page
+     * @param props
+     * @protected
      */
-    get history(): History;
+    protected createElement(page: PageRoute, props: Record<string, any>): Promise<ReactNode>;
     /**
+     * Merge the render context with the page context.
      *
+     * @param page
+     * @param ctx
+     * @param props
+     * @protected
      */
-    get url(): string;
+    protected mergeRenderContext(page: PageRoute, ctx: RouterRenderContext, props: Record<string, any>): void;
     /**
      *
-     * @param props
+     * @param e
+     * @protected
      */
-    invalidate(props?: Record<string, any>): Promise<void>;
+    protected renderError(e: Error): ReactNode;
     /**
+     * Render an empty view.
      *
-     * @param url
-     * @param options
+     * @protected
      */
-    go(url: string, options?: RouterGoOptions): Promise<void>;
+    protected renderEmptyView(): ReactNode;
+    /**
+     * Create a valid href for the given page.
+     * @param page
+     * @param params
+     */
+    href(page: {
+        options: {
+            name?: string;
+        };
+    }, params?: Record<string, any>): string;
     /**
      *
-     * @param options
+     * @param index
+     * @param path
+     * @param view
      * @protected
      */
-    protected render(options?: {
-        url?: string;
-        previous?: PreviousLayerData[];
-    }): Promise<{
-        url: string;
-    }>;
+    protected renderView(index: number, path: string, view?: ReactNode): ReactNode;
     /**
-     * Get embedded layers from the server.
      *
+     * @param entry
+     */
+    add(entry: PageRouteEntry): void;
+    /**
+     * Create a match function for the given page.
+     *
+     * @param page
      * @protected
      */
-    protected getEmbeddedCache(): {
-        session?: Session;
-        layers?: PreviousLayerData[];
+    protected createMatchFunction(page: PageRoute): {
+        exec: MatchFunction<ParamData>;
+        path: string;
     } | undefined;
     /**
      *
-     * @protected
      */
-    protected getRootElement(): HTMLElement;
+    empty(): boolean;
     /**
      *
      * @protected
      */
-    protected ready: _alepha_core.HookDescriptor<"ready">;
+    protected _next: number;
     /**
      *
      * @protected
      */
-    protected stop: _alepha_core.HookDescriptor<"stop">;
-}
-/**
- *
- */
-interface RouterGoOptions {
-    replace?: boolean;
-    match?: RouterMatchOptions;
+    protected nextId(): string;
 }
-
-declare class RouterHookApi {
-    private readonly state;
-    private readonly layer;
-    private readonly browser?;
-    constructor(state: RouterState, layer: {
+interface PageRouteEntry extends Omit<PageDescriptorOptions, "children" | "parent"> {
+    /**
+     *
+     */
+    name?: string;
+    /**
+     *
+     */
+    match?: {
+        /**
+         *
+         */
+        exec: MatchFunction<ParamData>;
+        /**
+         *
+         */
         path: string;
-    }, browser?: ReactBrowserProvider | undefined);
+    };
     /**
      *
      */
-    get current(): RouterState;
+    children?: PageRouteEntry[];
     /**
      *
      */
-    get pathname(): string;
+    parent?: PageRoute;
+}
+interface PageRoute extends PageRouteEntry {
     /**
      *
      */
-    get query(): Record<string, string>;
+    name: string;
     /**
      *
      */
-    back(): Promise<void>;
+    parent?: PageRoute;
+}
+interface Layer {
     /**
      *
      */
-    forward(): Promise<void>;
+    config?: {
+        /**
+         *
+         */
+        query?: Record<string, any>;
+        /**
+         *
+         */
+        params?: Record<string, any>;
+        /**
+         *
+         */
+        context?: Record<string, any>;
+    };
     /**
      *
-     * @param props
      */
-    invalidate(props?: Record<string, any>): Promise<void>;
+    name: string;
     /**
-     * Create a valid href for the given pathname.
      *
-     * @param pathname
-     * @param layer
      */
-    createHref(pathname: HrefLike, layer?: {
-        path: string;
-    }): string;
+    props?: Record<string, any>;
     /**
      *
-     * @param path
-     * @param options
      */
-    go(path: HrefLike, options?: RouterGoOptions): Promise<void>;
+    part?: string;
     /**
      *
-     * @param path
      */
-    createAnchorProps(path: string): AnchorProps;
+    element: ReactNode;
     /**
-     * Set query params.
      *
-     * @param record
-     * @param options
      */
-    setQueryParams(record: Record<string, any>, options?: {
-        /**
-         * If true, this will merge current query params with the new ones.
-         */
-        merge?: boolean;
-        /**
-         * If true, this will add a new entry to the history stack.
-         */
-        push?: boolean;
-    }): void;
+    index: number;
+    /**
+     *
+     */
+    path: string;
 }
-type HrefLike = string | {
-    options: {
-        path?: string;
-        name?: string;
-    };
-};
-
-declare const pageDescriptorKey = "PAGE";
-interface PageDescriptorConfigSchema {
-    query?: TSchema$1;
-    params?: TSchema$1;
+/**
+ *
+ */
+type PreviousLayerData = Omit<Layer, "element">;
+interface AnchorProps {
+    /**
+     *
+     */
+    href?: string;
+    /**
+     *
+     * @param ev
+     */
+    onClick?: (ev: any) => any;
 }
-type TPropsDefault = any;
-type TPropsParentDefault = object;
-interface PageDescriptorOptions<TConfig extends PageDescriptorConfigSchema = PageDescriptorConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
-    parent?: {
-        options: PageDescriptorOptions<any, TPropsParent>;
-    };
-    name?: string;
-    path?: string;
-    schema?: TConfig;
-    abstract?: boolean;
-    resolve?: (config: PageDescriptorConfigValue<TConfig> & TPropsParent & {
-        user?: UserAccountToken;
-    }) => Async<TProps>;
-    component?: FC<TProps & TPropsParent>;
-    lazy?: () => Promise<{
-        default: FC<TProps & TPropsParent>;
-    }>;
-    children?: () => Array<{
-        options: PageDescriptorOptions;
-    }>;
-    notFoundHandler?: FC<{
-        error: Error;
-    }>;
-    errorHandler?: FC<{
-        error: Error;
-        url: string;
-    }>;
+interface RouterMatchOptions {
+    /**
+     *
+     */
+    previous?: PreviousLayerData[];
+    /**
+     *
+     */
+    args?: PageContext;
 }
-interface PageDescriptorConfigValue<TConfig extends PageDescriptorConfigSchema = PageDescriptorConfigSchema> {
-    query: TConfig["query"] extends TSchema$1 ? Static$1<TConfig["query"]> : Record<string, string>;
-    params: TConfig["params"] extends TSchema$1 ? Static$1<TConfig["params"]> : Record<string, string>;
+interface RouterEvents {
+    /**
+     *
+     */
+    begin: undefined;
+    /**
+     *
+     */
+    success: undefined;
+    /**
+     *
+     */
+    error: Error;
+    /**
+     *
+     */
+    end: RouterState;
+}
+interface RouterState {
+    /**
+     *
+     */
     pathname: string;
+    /**
+     *
+     */
+    search: string;
+    /**
+     *
+     */
+    layers: Array<Layer>;
+    /**
+     *
+     */
+    context: RouterRenderContext;
 }
-interface PageDescriptor<TConfig extends PageDescriptorConfigSchema = PageDescriptorConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
-    [KIND]: typeof pageDescriptorKey;
-    render: (options?: {
-        params?: Record<string, string>;
-        query?: Record<string, string>;
-    }) => Promise<string>;
-    go: () => void;
-    createAnchorProps: (routerHook: RouterHookApi) => {
-        href: string;
-        onClick: () => void;
-    };
-    options: PageDescriptorOptions<TConfig, TProps, TPropsParent>;
+interface RouterRenderContext {
+    /**
+     *
+     */
+    helmet?: RouterRenderHelmetContext;
 }
-declare const $page: {
-    <TConfig extends PageDescriptorConfigSchema = PageDescriptorConfigSchema, TProps extends object = any, TPropsParent extends object = object>(options: PageDescriptorOptions<TConfig, TProps, TPropsParent>): PageDescriptor<TConfig, TProps, TPropsParent>;
-    [KIND]: string;
-};
-
-declare class RedirectException extends Error {
-    readonly page: HrefLike;
-    constructor(page: HrefLike);
+interface RouterRenderOptions extends RouterMatchOptions {
+    /**
+     * State to update.
+     */
+    state?: RouterState;
 }
-declare class Router extends EventEmitter<RouterEvents> {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly alepha: Alepha;
-    protected readonly pages: PageRoute[];
-    protected notFoundPageRoute?: PageRoute;
+interface RouterStackItem {
     /**
-     * Get the page by name.
      *
-     * @param name - Page name
-     * @return PageRoute
      */
-    page(name: string): PageRoute;
+    route: PageRoute;
     /**
      *
      */
-    root(state: RouterState, opts?: {
-        user?: UserAccountInfo;
-    }): ReactNode;
+    config?: Record<string, any>;
     /**
      *
-     * @param url
-     * @param options
      */
-    render(url: string, options?: RouterRenderOptions): Promise<{
-        element: ReactNode;
-        layers: Layer[];
-        redirect?: string;
-    }>;
+    props?: Record<string, any>;
     /**
      *
-     * @param url
-     * @param options
-     * @protected
      */
-    match(url: string, options?: RouterMatchOptions): Promise<Layer[]>;
+    error?: Error;
+}
+interface RouterRenderHelmetContext {
     /**
-     * Create layers for the given route.
      *
-     * @param route
-     * @param params
-     * @param query
-     * @param previous
-     * @param user
-     * @protected
      */
-    createLayers(url: string, route: PageRoute, params?: Record<string, any>, query?: Record<string, string>, previous?: PreviousLayerData[], user?: UserAccountInfo): Promise<Layer[]>;
+    title?: string;
     /**
      *
-     * @param route
-     * @protected
      */
-    protected getErrorHandler(route: PageRoute): react.FC<{
-        error: Error;
-        url: string;
-    }> | undefined;
+    html?: {
+        attributes?: Record<string, string>;
+    };
     /**
      *
-     * @param page
-     * @param props
-     * @protected
      */
-    protected createElement(page: PageRoute, props: Record<string, any>): Promise<ReactNode>;
+    body?: {
+        attributes?: Record<string, string>;
+    };
     /**
      *
-     * @param e
-     * @protected
      */
-    protected renderError(e: Error): ReactNode;
+    meta?: Array<{
+        name: string;
+        content: string;
+    }>;
+}
+interface RouterRenderResult {
     /**
-     * Render an empty view.
      *
-     * @protected
      */
-    protected renderEmptyView(): ReactNode;
+    element: ReactNode;
     /**
-     * Create a valid href for the given page.
-     * @param page
-     * @param params
+     *
      */
-    href(page: {
-        options: {
-            name?: string;
-        };
-    }, params?: Record<string, any>): string;
+    layers: Layer[];
     /**
      *
-     * @param index
-     * @param path
-     * @param view
-     * @protected
      */
-    protected renderView(index: number, path: string, view?: ReactNode): ReactNode;
+    redirect?: string;
     /**
      *
-     * @param entry
      */
-    add(entry: PageRouteEntry): void;
+    context: RouterRenderContext;
+}
+
+declare class ReactAuthProvider {
+    protected readonly log: _alepha_core.Logger;
+    protected readonly alepha: Alepha;
+    protected readonly fastifyCookieProvider: FastifyCookieProvider;
+    protected authProviders: AuthProvider[];
+    protected readonly authorizationCode: _alepha_server.CookieDescriptor<TObject<{
+        codeVerifier: TOptional<TString>;
+        redirectUri: TOptional<TString>;
+    }>>;
+    protected readonly tokens: _alepha_server.CookieDescriptor<TObject<{
+        access_token: TOptional<TString>;
+        expires_in: TOptional<TNumber>;
+        refresh_token: TOptional<TString>;
+        id_token: TOptional<TString>;
+        scope: TOptional<TString>;
+        issued_at: TOptional<TNumber>;
+    }>>;
+    protected readonly user: _alepha_server.CookieDescriptor<TObject<{
+        id: TString;
+        name: TOptional<TString>;
+        email: TOptional<TString>;
+    }>>;
+    protected readonly configure: _alepha_core.HookDescriptor<"configure">;
+    /**
+     * Configure Fastify to forward Session Access Token to Header Authorization.
+     */
+    protected readonly configureFastify: _alepha_core.HookDescriptor<"configure:fastify">;
     /**
-     * Create a match function for the given page.
      *
-     * @param page
+     * @param cookies
      * @protected
      */
-    protected createMatchFunction(page: PageRoute): {
-        exec: MatchFunction<ParamData>;
-        path: string;
-    } | undefined;
+    protected refresh(cookies: CookieManager): Promise<SessionTokens | undefined>;
     /**
      *
      */
-    empty(): boolean;
+    readonly login: _alepha_server.RouteDescriptor<{
+        query: TObject<{
+            redirect: TOptional<TString>;
+            provider: TOptional<TString>;
+        }>;
+    }, false>;
     /**
      *
-     * @protected
      */
-    protected _next: number;
+    readonly callback: _alepha_server.RouteDescriptor<{
+        query: TObject<{
+            provider: TOptional<TString>;
+        }>;
+    }, false>;
     /**
      *
+     * @param accessToken
      * @protected
      */
-    protected nextId(): string;
-}
-interface PageRouteEntry extends Omit<PageDescriptorOptions, "children" | "parent"> {
+    protected userFromAccessToken(accessToken: string): {
+        id: any;
+        name: any;
+        email: any;
+    } | undefined;
     /**
      *
      */
-    name?: string;
+    readonly logout: _alepha_server.RouteDescriptor<{
+        query: TObject<{
+            redirect: TOptional<TString>;
+            provider: TOptional<TString>;
+        }>;
+    }, false>;
     /**
      *
+     * @param name
+     * @protected
      */
-    match?: {
-        /**
-         *
-         */
-        exec: MatchFunction<ParamData>;
-        /**
-         *
-         */
-        path: string;
-    };
+    protected provider(name?: string): AuthProvider;
     /**
      *
+     * @param file
+     * @protected
      */
-    children?: PageRouteEntry[];
+    protected isViteFile(file: string): boolean;
+}
+interface SessionTokens {
+    access_token?: string;
+    expires_in?: number;
+    refresh_token?: string;
+    id_token?: string;
+    scope?: string;
+    issued_at?: number;
+}
+interface SessionAuthorizationCode {
+    codeVerifier?: string;
+    redirectUri?: string;
+    nonce?: string;
+    max_age?: number;
+    state?: string;
+}
+interface AuthProvider {
+    name: string;
+    redirectUri: string;
+    client: Configuration;
+}
+interface ReactUser {
+    id: string;
+    name?: string;
+    email?: string;
+}
+interface ReactHydrationState {
+    user?: ReactUser;
+    auth?: "server" | "client";
+    layers?: PreviousLayerData[];
+}
+
+declare class ReactBrowserProvider {
+    protected readonly log: _alepha_core.Logger;
+    protected readonly client: HttpClient;
+    protected readonly router: Router;
+    protected root: Root;
+    transitioning?: {
+        to: string;
+    };
+    state: RouterState;
     /**
      *
      */
-    parent?: PageRoute;
-}
-interface PageRoute extends PageRouteEntry {
+    get document(): Document;
     /**
      *
      */
-    name: string;
+    get history(): History;
     /**
      *
      */
-    parent?: PageRoute;
-}
-interface Layer {
+    get url(): string;
     /**
      *
+     * @param props
      */
-    config?: {
-        /**
-         *
-         */
-        query?: Record<string, any>;
-        /**
-         *
-         */
-        params?: Record<string, any>;
-        /**
-         *
-         */
-        context?: Record<string, any>;
-    };
+    invalidate(props?: Record<string, any>): Promise<void>;
     /**
      *
+     * @param url
+     * @param options
      */
-    name: string;
+    go(url: string, options?: RouterGoOptions): Promise<void>;
     /**
      *
+     * @param options
+     * @protected
      */
-    props?: Record<string, any>;
+    protected render(options?: {
+        url?: string;
+        previous?: PreviousLayerData[];
+    }): Promise<{
+        url: string;
+    }>;
+    protected renderHelmetContext(ctx: RouterRenderHelmetContext): void;
     /**
+     * Get embedded layers from the server.
      *
+     * @protected
      */
-    part?: string;
+    protected getHydrationState(): ReactHydrationState | undefined;
     /**
      *
+     * @protected
      */
-    element: ReactNode;
+    protected getRootElement(): HTMLElement;
+    protected getUserFromCookies(): UserAccountToken | undefined;
     /**
      *
+     * @protected
      */
-    index: number;
+    protected ready: _alepha_core.HookDescriptor<"ready">;
     /**
      *
+     * @protected
      */
-    path: string;
+    protected stop: _alepha_core.HookDescriptor<"stop">;
 }
 /**
  *
  */
-type PreviousLayerData = Omit<Layer, "element">;
-interface AnchorProps {
+interface RouterGoOptions {
+    replace?: boolean;
+    match?: RouterMatchOptions;
+}
+
+declare class RouterHookApi {
+    private readonly state;
+    private readonly layer;
+    private readonly browser?;
+    constructor(state: RouterState, layer: {
+        path: string;
+    }, browser?: ReactBrowserProvider | undefined);
     /**
      *
      */
-    href?: string;
+    get current(): RouterState;
     /**
      *
-     * @param ev
      */
-    onClick?: (ev: any) => any;
-}
-interface RouterMatchOptions {
+    get pathname(): string;
     /**
      *
      */
-    previous?: PreviousLayerData[];
+    get query(): Record<string, string>;
     /**
      *
      */
-    user?: UserAccountInfo;
-}
-interface RouterEvents {
+    back(): Promise<void>;
     /**
      *
      */
-    begin: undefined;
+    forward(): Promise<void>;
     /**
      *
+     * @param props
      */
-    success: undefined;
+    invalidate(props?: Record<string, any>): Promise<void>;
     /**
+     * Create a valid href for the given pathname.
      *
+     * @param pathname
+     * @param layer
      */
-    error: Error;
+    createHref(pathname: HrefLike, layer?: {
+        path: string;
+    }): string;
     /**
      *
+     * @param path
+     * @param options
      */
-    end: RouterState;
+    go(path: HrefLike, options?: RouterGoOptions): Promise<void>;
+    /**
+     *
+     * @param path
+     */
+    createAnchorProps(path: string): AnchorProps;
+    /**
+     * Set query params.
+     *
+     * @param record
+     * @param options
+     */
+    setQueryParams(record: Record<string, any>, options?: {
+        /**
+         * If true, this will merge current query params with the new ones.
+         */
+        merge?: boolean;
+        /**
+         * If true, this will add a new entry to the history stack.
+         */
+        push?: boolean;
+    }): void;
 }
-interface RouterState {
+type HrefLike = string | {
+    options: {
+        path?: string;
+        name?: string;
+    };
+};
+
+declare const pageDescriptorKey = "PAGE";
+interface PageDescriptorConfigSchema {
+    query?: TSchema$1;
+    params?: TSchema$1;
+}
+type TPropsDefault = any;
+type TPropsParentDefault = object;
+interface PageDescriptorOptions<TConfig extends PageDescriptorConfigSchema = PageDescriptorConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
     /**
      *
      */
-    pathname: string;
+    name?: string;
     /**
      *
      */
-    search: string;
+    path?: string;
     /**
      *
      */
-    layers: Array<Layer>;
-}
-interface RouterRenderOptions extends RouterMatchOptions {
+    schema?: TConfig;
     /**
-     * State to update.
+     * Function to call when the page is loaded.
      */
-    state?: RouterState;
+    resolve?: (config: PageDescriptorConfigValue<TConfig> & TPropsParent & {
+        context: PageContext;
+    }, context: PageContext) => Async<TProps>;
+    /**
+     * Component to render when the page is loaded.
+     */
+    component?: FC<TProps & TPropsParent>;
+    /**
+     * Component to render when the page is loaded. (like .component)
+     */
+    lazy?: () => Promise<{
+        default: FC<TProps & TPropsParent>;
+    }>;
+    /**
+     *
+     */
+    children?: () => Array<{
+        options: PageDescriptorOptions;
+    }>;
+    /**
+     *
+     */
+    parent?: {
+        options: PageDescriptorOptions<any, TPropsParent>;
+    };
+    /**
+     *
+     */
+    helmet?: RouterRenderHelmetContext | ((props: TProps) => RouterRenderHelmetContext);
+    /**
+     *
+     */
+    notFoundHandler?: FC<{
+        error: Error;
+    }>;
+    /**
+     *
+     */
+    errorHandler?: FC<{
+        error: Error;
+        url: string;
+    }>;
 }
-interface RouterStackItem {
-    route: PageRoute;
-    config?: Record<string, any>;
-    props?: Record<string, any>;
-    error?: Error;
+interface PageContext {
+    user?: UserAccountToken;
+    cookies?: CookieManager;
 }
+interface PageDescriptorConfigValue<TConfig extends PageDescriptorConfigSchema = PageDescriptorConfigSchema> {
+    query: TConfig["query"] extends TSchema$1 ? Static$1<TConfig["query"]> : Record<string, string>;
+    params: TConfig["params"] extends TSchema$1 ? Static$1<TConfig["params"]> : Record<string, string>;
+    pathname: string;
+}
+interface PageDescriptor<TConfig extends PageDescriptorConfigSchema = PageDescriptorConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
+    [KIND]: typeof pageDescriptorKey;
+    render: (options?: {
+        params?: Record<string, string>;
+        query?: Record<string, string>;
+    }) => Promise<string>;
+    go: () => void;
+    createAnchorProps: (routerHook: RouterHookApi) => {
+        href: string;
+        onClick: () => void;
+    };
+    options: PageDescriptorOptions<TConfig, TProps, TPropsParent>;
+}
+declare const $page: {
+    <TConfig extends PageDescriptorConfigSchema = PageDescriptorConfigSchema, TProps extends object = any, TPropsParent extends object = object>(options: PageDescriptorOptions<TConfig, TProps, TPropsParent>): PageDescriptor<TConfig, TProps, TPropsParent>;
+    [KIND]: string;
+};
 
 interface RouterContextValue {
     router: Router;
     alepha: Alepha;
     state: RouterState;
-    session?: Session;
+    args: PageContext;
 }
 declare const RouterContext: react.Context<RouterContextValue | undefined>;
 
@@ -762,17 +871,38 @@ interface RouterLayerContextValue {
 }
 declare const RouterLayerContext: react.Context<RouterLayerContextValue | undefined>;
 
-declare const useActive: (path: HrefLike) => UseActiveHook;
-interface UseActiveHook {
-    isActive: boolean;
-    anchorProps: AnchorProps;
-    isPending: boolean;
+declare class Auth {
+    alepha: Alepha;
+    log: _alepha_core.Logger;
+    client: HttpClient;
+    api: string;
+    start: _alepha_core.HookDescriptor<"start">;
+    login: (provider?: string) => void;
+    logout: () => void;
+}
+
+declare const KEY = "AUTH";
+interface AuthDescriptorOptions {
     name?: string;
+    oidc?: {
+        issuer: string;
+        clientId: string;
+        clientSecret?: string;
+        redirectUri?: string;
+    };
 }
+interface AuthDescriptor {
+    [KIND]: typeof KEY;
+    options: AuthDescriptorOptions;
+}
+declare const $auth: {
+    (options: AuthDescriptorOptions): AuthDescriptor;
+    [KIND]: string;
+};
 
-declare const useClient: () => HttpClient;
+declare const useInject: <T extends object>(clazz: Class<T>) => T;
 
-declare const useInject: <T extends object>(classEntry: ClassEntry<T>) => T;
+declare const useClient: () => HttpClient;
 
 interface UseQueryParamsHookOptions {
     format?: "base64" | "querystring";
@@ -794,6 +924,21 @@ declare const useRouterEvents: (opts?: {
 
 declare const useRouterState: () => RouterState;
 
+declare const useActive: (path: HrefLike) => UseActiveHook;
+interface UseActiveHook {
+    isActive: boolean;
+    anchorProps: AnchorProps;
+    isPending: boolean;
+    name?: string;
+}
+
+declare const useAuth: () => AuthHook;
+interface AuthHook {
+    user?: UserAccountToken;
+    logout: () => void;
+    login: (provider?: string) => void;
+}
+
 declare class PageDescriptorProvider {
     protected readonly alepha: Alepha;
     protected readonly router: Router;
@@ -813,14 +958,17 @@ declare class PageDescriptorProvider {
     }): PageRouteEntry;
 }
 
-declare const envSchema: TObject<{
+declare const envSchema$1: TObject<{
     REACT_SERVER_DIST: TString;
     REACT_SERVER_PREFIX: TString;
     REACT_SSR_ENABLED: TBoolean;
     REACT_SSR_OUTLET: TString;
 }>;
 declare module "@alepha/core" {
-    interface Env extends Partial<Static$1<typeof envSchema>> {
+    interface Env extends Partial<Static$1<typeof envSchema$1>> {
+    }
+    interface State {
+        "ReactServerProvider.template"?: string;
     }
 }
 declare class ReactServerProvider {
@@ -836,6 +984,13 @@ declare class ReactServerProvider {
     };
     protected readonly configure: _alepha_core.HookDescriptor<"configure">;
     protected configureRoutes(): Promise<void>;
+    /**
+     * Check if the template contains the outlet.
+     *
+     * @param template
+     * @protected
+     */
+    protected checkTemplate(template: string): string;
     /**
      *
      * @param root
@@ -847,26 +1002,42 @@ declare class ReactServerProvider {
      * @param templateLoader
      * @protected
      */
-    protected createHandler(templateLoader: () => Promise<string | undefined>): RouteObject;
+    protected createHandler(templateLoader: () => Promise<string | undefined>): CreateRoute;
     protected processDescriptors(): void;
     /**
      *
      * @param url
      * @protected
      */
-    protected notFoundHandler(url: string): Response | undefined;
+    protected notFoundHandler(url: URL): Response | undefined;
     /**
      *
      * @param url
      * @param template
-     * @param user
+     * @param page
      */
-    ssr(url: string, template?: string, user?: UserAccountInfo): Promise<Response>;
+    ssr(url: URL, template?: string, page?: PageContext): Promise<Response>;
+    protected renderHelmetContext(template: string, helmetContext: RouterRenderHelmetContext): string;
+}
+
+declare class RedirectionError extends Error {
+    readonly page: HrefLike;
+    constructor(page: HrefLike);
 }
 
+declare const envSchema: _alepha_core.TObject<{
+    REACT_AUTH_ENABLED: TBoolean;
+}>;
+declare module "@alepha/core" {
+    interface Env extends Partial<Static$1<typeof envSchema>> {
+    }
+}
 declare class ReactModule {
+    protected readonly env: {
+        REACT_AUTH_ENABLED: boolean;
+    };
     protected readonly alepha: Alepha;
     constructor();
 }
 
-export { $page, type AnchorProps, type HrefLike, type Layer, NestedView, type PageDescriptor, type PageDescriptorConfigSchema, type PageDescriptorConfigValue, type PageDescriptorOptions, PageDescriptorProvider, type PageRoute, type PageRouteEntry, type PreviousLayerData, ReactBrowserProvider, ReactModule, ReactServerProvider, type ReactServerSession, ReactSessionProvider, RedirectException, Router, RouterContext, type RouterContextValue, type RouterEvents, type RouterGoOptions, RouterHookApi, RouterLayerContext, type RouterLayerContextValue, type RouterMatchOptions, type RouterRenderOptions, type RouterStackItem, type RouterState, type Session, type TPropsDefault, type TPropsParentDefault, type UseActiveHook, type UseQueryParamsHookOptions, envSchema, pageDescriptorKey, sessionSchema, sessionUserSchema, useActive, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState };
+export { $auth, $page, type AnchorProps, Auth, type AuthDescriptor, type AuthDescriptorOptions, type AuthHook, type AuthProvider, type HrefLike, type Layer, Link, NestedView, type PageContext, type PageDescriptor, type PageDescriptorConfigSchema, type PageDescriptorConfigValue, type PageDescriptorOptions, PageDescriptorProvider, type PageRoute, type PageRouteEntry, type PreviousLayerData, ReactAuthProvider, ReactBrowserProvider, type ReactHydrationState, ReactModule, ReactServerProvider, type ReactUser, RedirectionError, Router, RouterContext, type RouterContextValue, type RouterEvents, type RouterGoOptions, RouterHookApi, RouterLayerContext, type RouterLayerContextValue, type RouterMatchOptions, type RouterRenderContext, type RouterRenderHelmetContext, type RouterRenderOptions, type RouterRenderResult, type RouterStackItem, type RouterState, type SessionAuthorizationCode, type SessionTokens, type TPropsDefault, type TPropsParentDefault, type UseActiveHook, type UseQueryParamsHookOptions, envSchema$1 as envSchema, pageDescriptorKey, useActive, useAuth, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState };