narraleaf-react 0.6.0 → 0.8.0

package/dist/game/nlcore/common/core.d.ts

@@ -5,4 +5,5 @@ export * from "./player";
 export * from "./types";
 export * from "./position";
 export * from "./transition";
-export { i, c, b, };
+export * from "./interface";
+export { i, c, b };

package/dist/game/nlcore/common/game.d.ts

@@ -4,5 +4,6 @@ import { Storable, Namespace } from "../elements/persistent/storable";
 import { LiveGame } from "../game/liveGame";
 import { Preference } from "../game/preference";
 import type { SavedGame } from "../gameTypes";
-export { LiveGame, GameState, Game, Storable, Namespace, Preference, };
+import { KeyMap } from "../game/keyMap";
+export { LiveGame, GameState, Game, Storable, Namespace, Preference, KeyMap, };
 export type { SavedGame, };

package/dist/game/nlcore/common/interface.d.ts

@@ -0,0 +1 @@
+export { Gallery } from "../elements/built-in/Gallery";

package/dist/game/nlcore/common/player.d.ts

@@ -2,6 +2,7 @@ import Player from "../../player/elements/Player";
 import GameProviders from "../../player/provider/providers";
 import { useGame } from "../../../game/player/provider/game-state";
 import { useRouter } from "../../player/lib/PageRouter/router";
+import { usePathname, useParams, useQueryParams } from "../../player/lib/PageRouter/routerHooks";
 export * from "../../player/type";
 export * from "../../player/libElements";
-export { GameProviders, Player, useGame, useRouter, };
+export { GameProviders, Player, useGame, useRouter, usePathname, useParams, useQueryParams, };

package/dist/game/nlcore/common/types.d.ts

@@ -5,5 +5,9 @@ import { IGamePluginRegistry } from "../game/plugin/plugin";
 import { LiveGameEventToken } from "../types";
 import { GameHistory } from "../action/gameHistory";
 import { GameConfig, SavedGame, NotificationToken, SavedGameMetaData } from "../gameTypes";
+import type { LayoutRouter } from "../../../game/player/lib/PageRouter/router";
+import { KeyBindingType, WebKeyboardKey } from "../game/types";
+import { KeyBindingValue } from "../game/keyMap";
 export * from "../elements/type";
-export type { GameHistory, IGamePluginRegistry, LiveGameEventToken, Origins, ServiceHandlerCtx, TransformDefinitions, GameConfig, SavedGame, NotificationToken, SavedGameMetaData, };
+export type { GameHistory, IGamePluginRegistry, LiveGameEventToken, Origins, ServiceHandlerCtx, TransformDefinitions, GameConfig, SavedGame, NotificationToken, SavedGameMetaData, LayoutRouter, KeyBindingValue, WebKeyboardKey, };
+export { KeyBindingType, };

package/dist/game/nlcore/elements/built-in/Gallery.d.ts

@@ -0,0 +1,151 @@
+import { Lambda } from "../condition";
+import { ScriptCtx } from "../script";
+import { Service } from "../service";
+type GalleryActions<T extends Record<string, any>> = {
+    "add": [name: string, metadata: T | ((ctx: ScriptCtx) => T)];
+    "remove": [name: string];
+    "clear": [];
+};
+/**
+ * A utility to manage a gallery of items
+ * @template Metadata - The metadata of the items
+ * @class
+ * @example
+ * ```ts
+ * const gallery = new Gallery<{timestamp: number}>();
+ *
+ * scene.action([
+ *   gallery.add("item", () => ({
+ *     timestamp: Date.now(),
+ *   }))
+ * ]);
+ *
+ * scene.action([
+ *   gallery.remove("item")
+ * ]);
+ *
+ * scene.action([
+ *   Condition.If(gallery.has("item"), [
+ *     // ...
+ *   ])
+ * ]);
+ * ```
+ *
+ * to use this class, you need to register it in the story:
+ * ```ts
+ * story.registerService("gallery", gallery);
+ * ```
+ *
+ * After registering, you can access the gallery using game context:
+ * ```ts
+ * const liveGame = useLiveGame();
+ *
+ * const gallery = liveGame.story?.getService<Gallery<{timestamp: number}>>("gallery");
+ *
+ * if (gallery) {
+ *   console.log("All items in the gallery:", gallery.$getAll());
+ * }
+ * ```
+ */
+export declare class Gallery<Metadata extends Record<string, any>> extends Service<GalleryActions<Metadata>> {
+    private unlocked;
+    constructor();
+    serialize(): Record<string, any> | null;
+    deserialize(data: Record<string, any>): void;
+    /**
+     * Add an item to the gallery
+     * @chainable
+     * @param name - The name of the item to add
+     * @example
+     * ```ts
+     * scene.action([
+     *   gallery.add("item", {
+     *     // ...
+     *   })
+     * ]);
+     *
+     * // or
+     *
+     * scene.action([
+     *   gallery.add("item", (ctx) => {
+     *     return {
+     *       timestamp: Date.now(),
+     *     };
+     *   })
+     * ]);
+     * ```
+     */
+    add(name: string, metadata: Metadata | ((ctx: ScriptCtx) => Metadata)): never;
+    /**
+     * Check if an item is in the gallery
+     * @param name - The name of the item to check
+     * @returns A lambda that returns true if the item is in the gallery, false otherwise
+     * @example
+     * ```ts
+     * Condition.If(gallery.has("item"), [
+     *     // ...
+     * ])
+     * ```
+     */
+    has(name: string): Lambda<boolean>;
+    /**
+     * Remove an item from the gallery
+     * @chainable
+     * @param name - The name of the item to remove
+     * @example
+     * ```ts
+     * scene.action([
+     *   gallery
+     *     .remove("item")
+     *     .remove("item2"),
+     * ]);
+     * ```
+     */
+    remove(name: string): never;
+    /**
+     * Clear the gallery
+     * @chainable
+     * @example
+     * ```ts
+     * scene.action([
+     *   gallery.clear()
+     * ]);
+     * ```
+     */
+    clear(): never;
+    /**
+     * Remove an item from the gallery INSTANTLY
+     * @param name - The name of the item to remove
+     */
+    $remove(name: string): void;
+    /**
+     * Clear the gallery
+     *
+     * After calling this method, the gallery will be empty INSTANTLY
+     */
+    $clear(): void;
+    /**
+     * Get the metadata of an item
+     * @param name - The name of the item to get the metadata of
+     * @returns The metadata of the item
+     */
+    $get(name: string): Metadata;
+    /**
+     * Set the metadata of an item
+     * @param name - The name of the item to set the metadata of
+     * @param metadata - The metadata of the item to set
+     */
+    $set(name: string, metadata: Metadata): void;
+    /**
+     * Get all the items in the gallery
+     * @returns All the items in the gallery
+     */
+    $getAll(): Record<string, Metadata>;
+    /**
+     * Check if an item is in the gallery
+     * @param name - The name of the item to check
+     * @returns True if the item is in the gallery, false otherwise
+     */
+    $has(name: string): boolean;
+}
+export {};

package/dist/game/nlcore/elements/built-in/built-in.d.ts

@@ -0,0 +1 @@
+export { Gallery } from "./Gallery";

package/dist/game/nlcore/elements/displayable/displayable.d.ts

@@ -15,13 +15,33 @@ export declare abstract class Displayable<StateData extends Record<string, any>,
      */
     pos(position: TransformDefinitions.ImageTransformProps["position"], duration?: number, easing?: TransformDefinitions.EasingDefinition): Proxied<Self, Chained<LogicAction.Actions>>;
     /**
-     * Set Image Scale
-     * @param scale - The scale of the image, between 0 and 1
-     * @param duration - The duration of the scale animation
-     * @param easing - The easing of the scale animation
-     * @chainable
+     * Set the zoom of the current staging sequence.
+     * @param zoom - The zoom of the transform. use `1` to keep the original size
+     */
+    zoom(zoom: number, duration?: number, easing?: TransformDefinitions.EasingDefinition): Proxied<Self, Chained<LogicAction.Actions>>;
+    /**
+     * Set the scale of the current staging sequence on x axis.
+     * @param scaleX - The scale of the transform on x axis.
+     */
+    scaleX(scaleX: number, duration?: number, easing?: TransformDefinitions.EasingDefinition): Proxied<Self, Chained<LogicAction.Actions>>;
+    /**
+     * Set the scale of the current staging sequence on y axis.
+     * @param scaleY - The scale of the transform on y axis.
+     */
+    scaleY(scaleY: number, duration?: number, easing?: TransformDefinitions.EasingDefinition): Proxied<Self, Chained<LogicAction.Actions>>;
+    /**
+     * Set the scale of the current staging sequence.
+     * @param scaleX - The scale of the transform on x axis. use negative value to invert the scale
+     * @param scaleY - The scale of the transform on y axis. use negative value to invert the scale
+     */
+    scale(scaleX: number, scaleY: number, duration?: number, easing?: TransformDefinitions.EasingDefinition): Proxied<Self, Chained<LogicAction.Actions>>;
+    /**
+     * Set the scale of the current staging sequence on x and y axis.
+     * @param scaleX - The scale of the transform on x axis. use negative value to invert the scale
+     * @param scaleY - The scale of the transform on y axis. use negative value to invert the scale
+     * @alias {@link Displayable.scale}
      */
-    scale(scale: number, duration?: number, easing?: TransformDefinitions.EasingDefinition): Proxied<Self, Chained<LogicAction.Actions>>;
+    scaleXY(scaleX: number, scaleY: number, duration?: number, easing?: TransformDefinitions.EasingDefinition): Proxied<Self, Chained<LogicAction.Actions>>;
     /**
      * Set Image Rotation
      * @param rotation - The rotation of the image, in degrees

package/dist/game/nlcore/elements/service.d.ts

@@ -51,9 +51,5 @@ export declare abstract class Service<Content extends ServiceContentType = Servi
      * @param data data exported from toData
      */
     abstract deserialize?(data: RawData): void;
-    /**
-     * Called when the service is initialized
-     */
-    abstract init?(): void;
 }
 export {};

package/dist/game/nlcore/elements/transform/transform.d.ts

@@ -1,13 +1,7 @@
-import React from "react";
 import type { CommonDisplayableConfig } from "../../types";
-import type { DOMKeyframesDefinition } from "motion";
 import { TransformDefinitions } from "./type";
 import { CSSProps } from "../../elements/transition/type";
-export type Transformers = "position" | "opacity" | "scale" | "rotation" | "display" | "src" | "backgroundColor" | "backgroundOpacity" | "transform" | "fontColor";
-export type TransformHandler<T> = (value: T) => DOMKeyframesDefinition;
 type OverwriteMap = {
-    transform: React.CSSProperties["transform"];
-    scale: React.CSSProperties["scale"];
     overwrite: CSSProps;
 };
 export type OverwriteDefinition = {
@@ -86,11 +80,26 @@ export declare class Transform<T extends TransformDefinitions.Types = CommonDisp
      */
     commit(options?: Partial<TransformDefinitions.SequenceOptions>): this;
     /**
-     * Scale the current staging sequence.
-     * @param {number} scale - The scale of the transform.
-     * @returns {this} The current Transform instance for method chaining.
+     * Set the zoom of the current staging sequence.
+     * @param zoom - The zoom of the transform. use `1` to keep the original size
+     */
+    zoom(zoom: TransformDefinitions.Types["zoom"]): this;
+    /**
+     * Set the scale of the current staging sequence on x axis.
+     * @param scaleX - The scale of the transform on x axis.
+     */
+    scaleX(scaleX: TransformDefinitions.Types["scaleX"]): this;
+    /**
+     * Set the scale of the current staging sequence on y axis.
+     * @param scaleY - The scale of the transform on y axis.
+     */
+    scaleY(scaleY: TransformDefinitions.Types["scaleY"]): this;
+    /**
+     * Set the scale of the current staging sequence.
+     * @param scaleX - The scale of the transform on x axis. use negative value to invert the scale
+     * @param scaleY - The scale of the transform on y axis. use negative value to invert the scale
      */
-    scale(scale: TransformDefinitions.Types["scale"]): this;
+    scale(scaleX: TransformDefinitions.Types["scaleX"], scaleY: TransformDefinitions.Types["scaleY"]): this;
     /**
      * Rotate the current staging sequence.
      * @param {number} rotation - The rotation of the transform.

package/dist/game/nlcore/game/keyMap.d.ts

@@ -0,0 +1,82 @@
+import { EventDispatcher } from "../../../util/data";
+import { KeyBindingType, WebKeyboardKey } from "./types";
+export type KeyBindingValue = WebKeyboardKey[] | WebKeyboardKey | null;
+export declare class KeyMap {
+    private keyMap;
+    readonly events: EventDispatcher<{
+        "event:keyMap.change": [KeyBindingType | string, KeyBindingValue];
+    }>;
+    constructor(keyMap?: Record<KeyBindingType | string, KeyBindingValue>);
+    /**
+     * Set a key binding (case-insensitive)
+     * @param type - The type of key binding
+     * @param value - The value of the key binding
+     *
+     * @example
+     * ```ts
+     * // Set the skip action to the space key
+     * game.keyMap.setKeyBinding(KeyBindingType.skipAction, " ");
+     *
+     * // Press either Control or F3 to skip the action
+     * game.keyMap.setKeyBinding(KeyBindingType.skipAction, ["Control", "F3"]);
+     *
+     * // Remove the key binding
+     * game.keyMap.setKeyBinding(KeyBindingType.skipAction, null);
+     * ```
+     */
+    setKeyBinding(type: KeyBindingType | string, value: KeyBindingValue): void;
+    /**
+     * Get a key binding
+     * @param type - The type of key binding
+     * @returns The value of the key binding
+     *
+     * @example
+     * ```ts
+     * const skipKeyBinding = game.keyMap.getKeyBinding(KeyBindingType.skipAction);
+     * // ["Control"]
+     * ```
+     */
+    getKeyBinding(type: KeyBindingType | string): KeyBindingValue;
+    /**
+     * Add a key binding (case-insensitive)
+     * @param type - The type of key binding
+     * @param value - The value of the key binding
+     *
+     * @example
+     * ```ts
+     * game.keyMap.addKeyBinding(KeyBindingType.skipAction, "F3");
+     * // Now you can press F3 to skip the action
+     *
+     * // equivalent to
+     * const currentKeyBinding = game.keyMap.getKeyBinding(KeyBindingType.skipAction);
+     * game.keyMap.setKeyBinding(
+     *  KeyBindingType.skipAction,
+     *  [
+     *      ...(Array.isArray(currentKeyBinding) ? currentKeyBinding :
+     *          currentKeyBinding !== null ? [currentKeyBinding] : []),
+     *      "F3"
+     *  ]
+     * );
+     * ```
+     */
+    addKeyBinding(type: KeyBindingType | string, value: KeyBindingValue): void;
+    getKeyBindings(): Record<KeyBindingType | string, KeyBindingValue>;
+    onKeyBindingChange(type: KeyBindingType | string, listener: (value: KeyBindingValue) => void): import("../../../util/data").EventToken<import("../../../util/data").EventTypes>;
+    importKeyBindings(keyBindings: Record<KeyBindingType | string, KeyBindingValue>): void;
+    exportKeyBindings(): Record<KeyBindingType | string, KeyBindingValue>;
+    /**
+     * Check if a key matches a key binding (case-insensitive)
+     * @param type - The type of key binding
+     * @param key - The key to check
+     * @returns True if the key matches the key binding, false otherwise
+     *
+     * @example
+     * ```ts
+     * // if the skip action is set to [" ", "F3"]
+     * game.keyMap.match(KeyBindingType.skipAction, " "); // true
+     * game.keyMap.match(KeyBindingType.skipAction, "F3"); // true
+     * game.keyMap.match(KeyBindingType.skipAction, "A"); // false
+     * ```
+     */
+    match(type: KeyBindingType | string, key: WebKeyboardKey): boolean;
+}

package/dist/game/nlcore/game/liveGame.d.ts

@@ -1,4 +1,5 @@
 import { Storable } from "../elements/persistent/storable";
+import { Story } from "../elements/story";
 import { Game } from "../game";
 import type { NotificationToken, SavedGame } from "../gameTypes";
 import { LiveGameEventHandler, LiveGameEventToken } from "../types";
@@ -19,6 +20,7 @@ export declare class LiveGame {
     };
     game: Game;
     events: EventDispatcher<LiveGameEvent>;
+    story: Story | null;
     getStorable(): Storable;
     get storable(): Storable;
     /**

package/dist/game/nlcore/game/types.d.ts

@@ -0,0 +1,22 @@
+/**
+ * See [Key_Values](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values)
+ *
+ * Case-insensitive
+ */
+export type WebKeyboardKey = string;
+export declare enum KeyBindingType {
+    /**
+     * When the player presses one of these keys, the game will show the next sentence
+     *
+     * See [Key_Values](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values)
+     * @default [" "]
+     */
+    skipAction = "skipAction",
+    /**
+     * When the player presses one of these keys, the game will skip the current action
+     *
+     * See [Key_Values](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values)
+     * @default ["Control"]
+     */
+    nextAction = "nextAction"
+}

package/dist/game/nlcore/game.d.ts

@@ -4,6 +4,8 @@ import { LogicAction } from "./action/logicAction";
 import { LiveGame } from "./game/liveGame";
 import { Preference } from "./game/preference";
 import { Plugins, IGamePluginRegistry } from "./game/plugin/plugin";
+import { LayoutRouter } from "../player/lib/PageRouter/router";
+import { KeyMap } from "./game/keyMap";
 declare enum GameSettingsNamespace {
     game = "game"
 }
@@ -31,10 +33,15 @@ export declare class Game {
      * Game settings
      */
     preference: Preference<GamePreference>;
+    /**
+     * Game key bindings
+     */
+    keyMap: KeyMap;
     /**
      * Plugin registry
      */
     plugins: Plugins;
+    router: LayoutRouter;
     /**
      * Create a new game
      * @param config - Game configuration

package/dist/game/nlcore/gameTypes.d.ts

@@ -87,13 +87,6 @@ export type GameConfig = {
      * @default 1080
      */
     height: number;
-    /**
-     * When the player presses one of these keys, the game will skip the current action
-     *
-     * See [Key_Values](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values)
-     * @default ["Control"]
-     */
-    skipKey: React.KeyboardEvent["key"][];
     /**
      * If true, the game will listen to the window events instead of the player element
      *
@@ -173,13 +166,6 @@ export type GameConfig = {
      * @default 1
      */
     screenshotQuality: number;
-    /**
-     * When the player presses one of these keys, the game will show the next sentence
-     *
-     * See [Key_Values](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values)
-     * @default [" "]
-     */
-    nextKey: React.KeyboardEvent["key"][];
     /**
      * If true, the game will scale the dialog to fit the screen
      *
@@ -231,6 +217,13 @@ export type GameConfig = {
      * @default true
      */
     allowSkipTextTransition: boolean;
+    /**
+     * If true, the animation will propagate to the children
+     *
+     * This behavior is controlled by [motion](https://motion.dev): `When true, exit animations will be propagated to nested AnimatePresence components.`
+     * @default true
+     */
+    animationPropagate: boolean;
     /**
      * Base width of the dialog in pixels
      *

package/dist/game/nlcore/types.d.ts

@@ -28,11 +28,6 @@ export type Length = number | `${number}px`;
 export type RelativeLength = Length | "100%";
 export type CommonImagePosition = "left" | "center" | "right";
 export type CommonDisplayableConfig = {
-    /**
-     * Scale of the element, between 0 and 1
-     * @default 1
-     */
-    scale?: number;
     /**
      * Rotation of the element, in degrees
      * @default 0
@@ -52,6 +47,21 @@ export type CommonDisplayableConfig = {
      * Alt text of the element
      */
     alt?: string;
+    /**
+     * Scale of the element on x axis, use negative value to invert the scale
+     * @default 1
+     */
+    scaleX?: number;
+    /**
+     * Scale of the element on y axis, use negative value to invert the scale
+     * @default 1
+     */
+    scaleY?: number;
+    /**
+     * Zoom of the element, use `1` to keep the original size
+     * @default 1
+     */
+    zoom?: number;
 };
 export declare const ImagePosition: {
     [K in CommonImagePosition]: K;

package/dist/game/player/elements/Player.d.ts

@@ -1,4 +1,4 @@
 import "client-only";
 import { PlayerProps } from "../elements/type";
 import React from "react";
-export default function Player({ story, width, height, className, onReady, onEnd, children, active, }: Readonly<PlayerProps>): React.JSX.Element;
+export default function Player({ story, width, height, className, onReady, onEnd, onError, children, active, }: Readonly<PlayerProps>): React.JSX.Element;

package/dist/game/player/elements/type.d.ts

@@ -1,4 +1,4 @@
-import React from "react";
+import React, { ErrorInfo } from "react";
 import { IDialogProps, SayElementProps } from "../elements/say/type";
 import { IUserMenuProps, MenuElementProps } from "../elements/menu/type";
 import { Story } from "../../nlcore/elements/story";
@@ -41,6 +41,12 @@ export interface PlayerProps {
      * only called each lifecycle once
      */
     onEnd?: (ctx: PlayerEventContext) => void;
+    /**
+     * Once the game encounters an error
+     *
+     * only called each lifecycle once
+     */
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
     children?: React.ReactNode;
     /**
      * Whether to show the player

package/dist/game/player/gameState.d.ts

@@ -24,7 +24,6 @@ import { Timelines } from "./Tasks";
 import { Notification, NotificationManager } from "./lib/notification";
 import { ActionHistoryManager } from "../../game/nlcore/action/actionHistory";
 import { GameHistoryManager } from "../../game/nlcore/action/gameHistory";
-import { Router } from "./lib/PageRouter/router";
 type Legacy_PlayerStateElement = {
     texts: Clickable<TextElement>[];
     menus: Clickable<MenuElement, Chosen>[];
@@ -105,7 +104,7 @@ export declare class GameState {
     readonly idManager: IdManager;
     readonly actionHistory: ActionHistoryManager;
     readonly gameHistory: GameHistoryManager;
-    pageRouter: Router | null;
+    pageRouter: null;
     constructor(game: Game, stage: StageUtils);
     get deps(): number;
     addVideo(video: Video): this;

package/dist/game/player/lib/ErrorBoundary.d.ts

@@ -1,6 +1,7 @@
 import React, { ErrorInfo, ReactNode } from "react";
 interface ErrorBoundaryProps {
     children: ReactNode;
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
 }
 interface ErrorBoundaryState {
     hasError: boolean;

package/dist/game/player/lib/PageRouter/AnimatePresence.d.ts

@@ -1,4 +1,5 @@
 import { FirstParam } from "../../../../util/data";
-import { AnimatePresence } from "motion/react";
 import { JSX } from "react";
-export type AnimatePresenceComponent = (arg0: FirstParam<typeof AnimatePresence>) => JSX.Element;
+import { AnimatePresence as OriginalAnimatePresence } from "motion/react";
+export type AnimatePresenceComponent = (arg0: FirstParam<typeof OriginalAnimatePresence>) => JSX.Element;
+export declare const AnimatePresence: AnimatePresenceComponent;

package/dist/game/player/lib/PageRouter/Layout.d.ts

@@ -0,0 +1,48 @@
+import React from "react";
+import { LayoutRouter } from "./router";
+type LayoutContextType = {
+    router: LayoutRouter;
+    path: string | null;
+    consumedBy?: string;
+};
+type LayoutContextProviderProps = {
+    children: React.ReactNode;
+    path: string | null;
+    consumedBy?: string;
+};
+export declare function LayoutRouterProvider({ children, path, consumedBy }: LayoutContextProviderProps): React.JSX.Element;
+export declare function useLayout(): Omit<LayoutContextType, "path"> & {
+    path: string;
+};
+export type LayoutProps = {
+    children: React.ReactNode;
+    /**
+     * The relative path of the layout. It can be a path or a path pattern.
+     *
+     * @example
+     * ```typescript
+     * // Can be navigated to by "/home"
+     * <Layout name="home">
+     *     <div>Home</div>
+     * </Layout>
+     *
+     * <Layout name="user">
+     *     // equivalent to "/user/:id"
+     *     // Can be navigated to by "/user/123"
+     *     <Layout name=":id">
+     *         <div>User</div>
+     *     </Layout>
+     * </Layout>
+     * ```
+     */
+    name: string;
+    /**
+     * When true, exit animations will be propagated to nested AnimatePresence components.
+     */
+    propagate?: boolean;
+};
+export declare function Layout({ children, name, propagate }: LayoutProps): React.JSX.Element;
+export declare function RootLayout({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+export {};