@m2c2kit/core 0.3.18 → 0.3.20

package/dist/index.d.ts

@@ -1,88 +1,5 @@
 import { Canvas, Typeface, TypefaceFontProvider, Image, Paint, CanvasKit, Surface, Font, ParagraphBuilder, Paragraph, FontMgr, Path, PaintStyle } from 'canvaskit-wasm';
 
-declare class GlobalVariables {
-    now: number;
-    deltaTime: number;
-    canvasScale: number;
-    rootScale: number;
-    canvasCssWidth: number;
-    canvasCssHeight: number;
-}
-
-declare global {
-    var Globals: GlobalVariables;
-}
-//# sourceMappingURL=Globals.d.ts.map
-
-/**
- * Base interface for all m2c2kit events.
- *
- * @remarks I would have named it Event, but that would collide with
- * the existing DOM Event
- */
-interface M2Event<T> {
-    /** Type of event. */
-    type: M2EventType | string;
-    /** The object on which the event occurred. */
-    target: T;
-    /** Has the event been taken care of by the listener and not be dispatched to other targets? */
-    handled?: boolean;
-}
-/**
- * The different events that are dispatched by m2c2kit core.
- */
-declare const M2EventType: {
-    readonly ActivityStart: "ActivityStart";
-    readonly ActivityEnd: "ActivityEnd";
-    readonly ActivityCancel: "ActivityCancel";
-    readonly ActivityData: "ActivityData";
-    readonly GameWarmupStart: "GameWarmupStart";
-    readonly GameWarmupEnd: "GameWarmupEnd";
-    readonly TapDown: "TapDown";
-    readonly TapUp: "TapUp";
-    readonly TapUpAny: "TapUpAny";
-    readonly TapLeave: "TapLeave";
-    readonly PointerDown: "PointerDown";
-    readonly PointerUp: "PointerUp";
-    readonly PointerMove: "PointerMove";
-    readonly PointerLeave: "PointerLeave";
-    readonly Drag: "Drag";
-    readonly DragStart: "DragStart";
-    readonly DragEnd: "DragEnd";
-    readonly CompositeCustom: "CompositeCustom";
-    readonly FrameDidSimulatePhysics: "FrameDidSimulatePhysics";
-    readonly SceneSetup: "SceneSetup";
-    readonly SceneAppear: "SceneAppear";
-};
-type M2EventType = (typeof M2EventType)[keyof typeof M2EventType];
-
-/**
- * Base interface for all m2c2kit event listeners.
- */
-interface M2EventListener<T> {
-    /** Type of event to listen for. */
-    type: M2EventType | string;
-    /** Callback function to be called when the event is dispatched. */
-    callback: (event: T) => void;
-    /** Optional key (string identifier) used to identify the event listener. */
-    key?: string;
-}
-
-interface M2NodeEventListener<M2NodeEvent> extends M2EventListener<M2NodeEvent> {
-    /** For composites that raise events, type of the composite custom event. */
-    compositeType?: string;
-    /** UUID of the node that the event listener is listening for. */
-    nodeUuid: string;
-}
-
-/** Base interface for all M2Node events. */
-interface M2NodeEvent extends M2Event<M2Node> {
-    /** The M2Node on which the event occurred. */
-    target: M2Node;
-    /** For composites that raise events, type of the composite custom event. */
-    compositeType?: string;
-}
-
 /**
  * Position in two-dimensional space.
  */
@@ -93,30 +10,32 @@ interface Point {
     y: number;
 }
 
-/**
- * Describes an interaction between the pointer (mouse, touches) and a node.
- *
- * @remarks I would have named it PointerEvent, but that would collide with
- * the existing DOM PointerEvent.
- */
-interface M2PointerEvent extends M2NodeEvent {
-    /** Point that was tapped on node, relative to the node coordinate system */
-    point: Point;
-    /** Buttons being pressed when event was fired. Taken from DOM MouseEvent.buttons */
-    buttons: number;
+interface IDrawable {
+    draw(canvas: Canvas): void;
+    warmup(canvas: Canvas): void;
+    /**
+     * Frees up resources allocated by the Drawable M2Node.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @remarks This will be done automatically by the m2c2kit library; the
+     * end-user must not call this.
+     */
+    dispose(): void;
+    anchorPoint: Point;
+    zPosition: number;
 }
 
-/**
- * Describes an interaction of a pointer (mouse, touches) pressing a node.
- *
- * @remarks Unlike M2PointerEvent, TapEvent considers how the pointer, while
- * in the down state, moves in relation to the bounds of the node.
- */
-interface TapEvent extends M2NodeEvent {
-    /** Point that was tapped on node, relative to the node coordinate system */
-    point: Point;
-    /** Buttons being pressed when event was fired. Taken from DOM MouseEvent.buttons */
-    buttons: number;
+declare enum M2NodeType {
+    Node = "Node",
+    Scene = "Scene",
+    Sprite = "Sprite",
+    Label = "Label",
+    TextLine = "TextLine",
+    Shape = "Shape",
+    Composite = "Composite",
+    SoundPlayer = "SoundPlayer",
+    SoundRecorder = "SoundRecorder"
 }
 
 interface DrawableOptions {
@@ -170,43 +89,6 @@ interface Layout {
     constraints?: Constraints;
 }
 
-/**
- * Color in red (0-255), green (0-255), blue (0-255), alpha (0-1) format. Must be numeric array of length 4.
- */
-type RgbaColor = [number, number, number, number];
-
-/**
- * Map of placeholders to values for use in string interpolation.
- */
-interface StringInterpolationMap {
-    [placeholder: string]: string;
-}
-
-interface TextOptions {
-    /** Text to be displayed */
-    text?: string;
-    /** Name of font to use for text. Must have been previously loaded */
-    fontName?: string;
-    /** Color of text. Default is Constants.DEFAULT_FONT_COLOR (WebColors.Black) */
-    fontColor?: RgbaColor;
-    /** Size of text. Default is Constants.DEFAULT_FONT_SIZE (16) */
-    fontSize?: number;
-    /** Map of placeholders to values for use in string interpolation during localization. */
-    interpolation?: StringInterpolationMap;
-    /** If true, try to use a localized version of the text. Default is true. */
-    localize?: boolean;
-}
-
-/**
- * Width and height on two-dimensional space
- */
-interface Size {
-    /** Horizontal width, x-axis */
-    width: number;
-    /** Vertical height, y-axis */
-    height: number;
-}
-
 interface M2NodeOptions {
     /** Name of the node. Only needed if the node will be referred to by name in a later function */
     name?: string;
@@ -226,210 +108,46 @@ interface M2NodeOptions {
     hidden?: boolean;
     /** FOR INTERNAL USE ONLY */
     layout?: Layout;
+    /** Unique identifier (UUID). Will be generated automatically. @internal For m2c2kit library use only */
+    uuid?: string;
+    /** Should the node not emit events to the EventStore? Default is false.
+     * @remarks This property is for use by authors of `Composite` nodes. It is not intended for general use. */
+    suppressEvents?: boolean;
 }
 
-declare enum M2NodeType {
-    Node = "Node",
-    Scene = "Scene",
-    Sprite = "Sprite",
-    Label = "Label",
-    TextLine = "TextLine",
-    Shape = "Shape",
-    Composite = "Composite",
-    SoundPlayer = "SoundPlayer",
-    SoundRecorder = "SoundRecorder"
-}
-
-type EasingFunction = (
-/** elapsed time since start of action */
-t: number, 
-/** start value of value to be eased */
-b: number, 
-/** total change of value to be eased */
-c: number, 
-/** total duration of action */
-d: number) => number;
-/**
- * The Easings class has static methods for creating easings to be used in actions.
- */
-declare class Easings {
-    static none: EasingFunction;
-    static linear: EasingFunction;
-    static quadraticIn: EasingFunction;
-    static quadraticOut: EasingFunction;
-    static quadraticInOut: EasingFunction;
-    static cubicIn: EasingFunction;
-    static cubicOut: EasingFunction;
-    static cubicInOut: EasingFunction;
-    static quarticIn: EasingFunction;
-    static quarticOut: EasingFunction;
-    static quarticInOut: EasingFunction;
-    static quinticIn: EasingFunction;
-    static quinticOut: EasingFunction;
-    static quinticInOut: EasingFunction;
-    static sinusoidalIn: EasingFunction;
-    static sinusoidalOut: EasingFunction;
-    static sinusoidalInOut: EasingFunction;
-    static exponentialIn: EasingFunction;
-    static exponentialOut: EasingFunction;
-    static exponentialInOut: EasingFunction;
-    static circularIn: EasingFunction;
-    static circularOut: EasingFunction;
-    static circularInOut: EasingFunction;
-}
-
-interface IDrawable {
-    draw(canvas: Canvas): void;
-    warmup(canvas: Canvas): void;
-    /**
-     * Frees up resources allocated by the Drawable M2Node.
-     *
-     * @internal For m2c2kit library use only
-     *
-     * @remarks This will be done automatically by the m2c2kit library; the
-     * end-user must not call this.
-     */
-    dispose(): void;
-    anchorPoint: Point;
-    zPosition: number;
-}
-
-interface SceneOptions extends M2NodeOptions, DrawableOptions {
-    /** Background color of the scene. Default is Constants.DEFAULT_SCENE_BACKGROUND_COLOR (WebColors.White) */
-    backgroundColor?: RgbaColor;
-}
-
-interface CallbackOptions {
-    /** Should the provided callback replace any existing callbacks of the same event type for this target? Default is false */
-    replaceExisting?: boolean;
-    /** String identifier used to identify the callback. Only needed if the callback will be removed later */
-    key?: string;
+interface CompositeOptions extends M2NodeOptions, DrawableOptions {
 }
 
-declare class Scene extends M2Node implements IDrawable, SceneOptions {
-    readonly type = M2NodeType.Scene;
+declare abstract class Composite extends M2Node implements IDrawable {
+    readonly type = M2NodeType.Composite;
+    compositeType: string;
     isDrawable: boolean;
-    anchorPoint: {
-        x: number;
-        y: number;
-    };
-    zPosition: number;
-    private _backgroundColor;
-    _active: boolean;
-    _transitioning: boolean;
-    private backgroundPaint?;
+    private _anchorPoint;
+    private _zPosition;
     /**
-     * Top-level node that holds all other nodes, such as sprites, rectangles, or labels, that will be displayed on the screen
-     *
-     * @remarks The scene is the game screen or stage, and fills the entire available screen. There are usually multiple screens to contain multiple stages of the game, such as various instruction pages or phases of a game.
+     * Base Drawable object for creating custom nodes ("composites") composed of primitive nodes.
      *
-     * @param options - {@link SceneOptions}
+     * @param options
      */
-    constructor(options?: SceneOptions);
+    constructor(options?: CompositeOptions);
     initialize(): void;
+    get anchorPoint(): Point;
+    set anchorPoint(anchorPoint: Point);
+    get zPosition(): number;
+    set zPosition(zPosition: number);
     dispose(): void;
-    set game(game: Game);
-    /**
-     * The game which this scene is a part of.
-     *
-     * @remarks Throws error if scene is not part of the game object.
-     */
-    get game(): Game;
-    get backgroundColor(): RgbaColor;
-    set backgroundColor(backgroundColor: RgbaColor);
-    /**
-     * Duplicates a node using deep copy.
-     *
-     * @remarks This is a deep recursive clone (node and children).
-     * The uuid property of all duplicated nodes will be newly created,
-     * because uuid must be unique.
-     *
-     * @param newName - optional name of the new, duplicated node. If not
-     * provided, name will be the new uuid
-     */
-    duplicate(newName?: string): Scene;
-    /**
-     * Code that will be called every time the scene is presented.
-     *
-     * @remarks Use this callback to set nodes to their initial state, if
-     * that state might be changed later. For example, if a scene allows
-     * players to place dots on a grid, the setup() method should ensure the
-     * grid is clear of any prior dots from previous times this scene may
-     * have been displayed. In addition, if nodes should vary in each
-     * iteration, that should be done here.
-     *
-     * @param callback - function to execute
-     * @param options - {@link CallbackOptions}
-     */
-    onSetup(callback: (nodeEvent: M2NodeEvent) => void, options?: CallbackOptions): void;
-    /**
-     *
-     * Code that will be called after the scene has finished any transitions
-     * and has fully appeared on the screen.
-     *
-     * @param callback - function to execute
-     * @param options - {@link CallbackOptions}
-     */
-    onAppear(callback: (nodeEvent: M2NodeEvent) => void, options?: CallbackOptions): void;
     update(): void;
     draw(canvas: Canvas): void;
-    warmup(canvas: Canvas): void;
-}
-
-interface SlideTransitionOptions {
-    /** Direction in which the slide action goes */
-    direction: TransitionDirection;
-    /** Duration, in milliseconds, of the transition */
-    duration: number;
-    /** Easing function for movement; default is linear */
-    easing?: EasingFunction;
-}
-/**
- * The Transition class has static methods for creating animations that run as one scene transitions to another.
- */
-declare abstract class Transition {
-    abstract type: TransitionType;
-    abstract easing: EasingFunction;
-    abstract duration: number;
+    abstract warmup(canvas: Canvas): void;
     /**
-     * Creates a scene transition in which the outgoing scene slides out and the incoming scene slides in, as if the incoming scene pushes it.
+     * Event handler for custom events a `Composite` may generate.
      *
-     * @param options - {@link SlideTransitionOptions}
-     * @returns
-     */
-    static slide(options: SlideTransitionOptions): SlideTransition;
-    /**
-     * Creates a scene transition with no animation or duration. The next scene is immediately drawn.
+     * @remarks If the `Composite` generates custom events, this method is
+     * necessary for the `Composite` to work in replay mode.
+     *
+     * @param event - event to handle
      */
-    static none(): NoneTransition;
-}
-declare class NoneTransition extends Transition {
-    type: TransitionType;
-    easing: EasingFunction;
-    duration: number;
-    constructor();
-}
-declare class SlideTransition extends Transition {
-    type: TransitionType;
-    easing: EasingFunction;
-    duration: number;
-    direction: TransitionDirection;
-    constructor(direction: TransitionDirection, duration: number, easing: EasingFunction);
-}
-declare enum TransitionType {
-    Slide = "Slide",
-    None = "None"
-}
-declare enum TransitionDirection {
-    Up = "Up",
-    Down = "Down",
-    Right = "Right",
-    Left = "Left"
-}
-declare class SceneTransition {
-    scene: Scene;
-    transition: Transition;
-    constructor(scene: Scene, transition: Transition);
+    handleCompositeEvent(event: CompositeEvent): void;
 }
 
 /** Base interface for all Activity events. */
@@ -577,6 +295,13 @@ interface IDataStore {
     itemExists(key: string): Promise<boolean>;
 }
 
+interface CallbackOptions {
+    /** Should the provided callback replace any existing callbacks of the same event type for this target? Default is false */
+    replaceExisting?: boolean;
+    /** String identifier used to identify the callback. Only needed if the callback will be removed later */
+    key?: string;
+}
+
 interface Activity {
     /** The type of activity: Game or Survey */
     type: ActivityType;
@@ -616,48 +341,249 @@ interface Activity {
     /**
      * Executes a callback when the activity is canceled.
      *
-     * @param callback - function to execute.
-     * @param options - options for the callback.
+     * @param callback - function to execute.
+     * @param options - options for the callback.
+     */
+    onCancel(callback: (activityLifecycleEvent: ActivityLifecycleEvent) => void, options?: CallbackOptions): void;
+    /**
+     * Executes a callback when the activity ends.
+     *
+     * @param callback - function to execute.
+     * @param options - options for the callback.
+     */
+    onEnd(callback: (activityLifecycleEvent: ActivityLifecycleEvent) => void, options?: CallbackOptions): void;
+    /**
+     * Executes a callback when the activity generates data.
+     *
+     * @param callback - function to execute.
+     * @param options - options for the callback.
+     */
+    onData(callback: (activityResultsEvent: ActivityResultsEvent) => void, options?: CallbackOptions): void;
+    /** The activity's parent session unique identifier. This is newly generated each session. */
+    sessionUuid: string;
+    /** The activity's unique identifier. This is newly generated each session. The UUID for an activity will vary across sessions. */
+    uuid: string;
+    /** Human-friendly name of this activity */
+    name: string;
+    /** Short identifier of this activity */
+    id: string;
+    /** Persistent unique identifier (UUID) of the activity. Required for games. Optional or empty string if a survey. */
+    publishUuid: string;
+    /** The ID of the study (protocol, experiment, or other aggregate) that contains the repeated administrations of this activity. The ID should be short, url-friendly, human-readable text (no spaces, special characters, or slashes), e.g., `nyc-aging-cohort`. */
+    studyId?: string;
+    /** Unique identifier (UUID) of the study (protocol, experiment, or other aggregate) that contains the administration of this activity. */
+    studyUuid?: string;
+    /** The value of performance.now() immediately before the activity begins */
+    beginTimestamp: number;
+    /** The value of new Date().toISOString() immediately before the activity begins */
+    beginIso8601Timestamp: string;
+    /** Sets additional activity parameters if defaults are not sufficient. */
+    setParameters(additionalParameters: unknown): void;
+    /** Additional activity parameters that were set. */
+    readonly additionalParameters?: unknown;
+    /** Optional stores to use for saving data. The implementation of the store is not provided by the \@m2c2kit/core library. */
+    dataStores?: IDataStore[];
+}
+
+/** Base interface for all M2Node events. */
+interface M2NodeEvent extends M2Event<M2Node> {
+    /** The M2Node on which the event occurred. If the event has gone through serialization, the string will be the node's UUID. */
+    target: M2Node | string;
+}
+
+/**
+ * Color in red (0-255), green (0-255), blue (0-255), alpha (0-1) format. Must be numeric array of length 4.
+ */
+type RgbaColor = [number, number, number, number];
+
+interface SceneOptions extends M2NodeOptions, DrawableOptions {
+    /** Background color of the scene. Default is Constants.DEFAULT_SCENE_BACKGROUND_COLOR (WebColors.White) */
+    backgroundColor?: RgbaColor;
+}
+
+declare class Scene extends M2Node implements IDrawable, SceneOptions {
+    readonly type = M2NodeType.Scene;
+    isDrawable: boolean;
+    private _anchorPoint;
+    private _zPosition;
+    private _backgroundColor;
+    _active: boolean;
+    _transitioning: boolean;
+    private backgroundPaint?;
+    /**
+     * Top-level node that holds all other nodes, such as sprites, rectangles, or labels, that will be displayed on the screen
+     *
+     * @remarks The scene is the game screen or stage, and fills the entire available screen. There are usually multiple screens to contain multiple stages of the game, such as various instruction pages or phases of a game.
+     *
+     * @param options - {@link SceneOptions}
+     */
+    constructor(options?: SceneOptions);
+    get completeNodeOptions(): {
+        backgroundColor: RgbaColor;
+        anchorPoint?: Point;
+        zPosition?: number;
+        name?: string;
+        position?: Point;
+        scale?: number;
+        alpha?: number;
+        zRotation?: number;
+        isUserInteractionEnabled?: boolean;
+        draggable?: boolean;
+        hidden?: boolean;
+        layout?: Layout;
+        uuid?: string;
+        suppressEvents?: boolean;
+    };
+    initialize(): void;
+    dispose(): void;
+    set game(game: Game);
+    /**
+     * The game which this scene is a part of.
+     *
+     * @remarks Throws error if scene is not part of the game object.
+     */
+    get game(): Game;
+    get backgroundColor(): RgbaColor;
+    set backgroundColor(backgroundColor: RgbaColor);
+    get anchorPoint(): Point;
+    set anchorPoint(anchorPoint: Point);
+    get zPosition(): number;
+    set zPosition(zPosition: number);
+    /**
+     * Duplicates a node using deep copy.
+     *
+     * @remarks This is a deep recursive clone (node and children).
+     * The uuid property of all duplicated nodes will be newly created,
+     * because uuid must be unique.
+     *
+     * @param newName - optional name of the new, duplicated node. If not
+     * provided, name will be the new uuid
+     */
+    duplicate(newName?: string): Scene;
+    /**
+     * Code that will be called every time the scene is presented.
+     *
+     * @remarks Use this callback to set nodes to their initial state, if
+     * that state might be changed later. For example, if a scene allows
+     * players to place dots on a grid, the setup() method should ensure the
+     * grid is clear of any prior dots from previous times this scene may
+     * have been displayed. In addition, if nodes should vary in each
+     * iteration, that should be done here.
+     *
+     * @param callback - function to execute
+     * @param options - {@link CallbackOptions}
+     */
+    onSetup(callback: (nodeEvent: M2NodeEvent) => void, options?: CallbackOptions): void;
+    /**
+     *
+     * Code that will be called after the scene has finished any transitions
+     * and has fully appeared on the screen.
+     *
+     * @param callback - function to execute
+     * @param options - {@link CallbackOptions}
      */
-    onCancel(callback: (activityLifecycleEvent: ActivityLifecycleEvent) => void, options?: CallbackOptions): void;
+    onAppear(callback: (nodeEvent: M2NodeEvent) => void, options?: CallbackOptions): void;
+    update(): void;
+    draw(canvas: Canvas): void;
+    warmup(canvas: Canvas): void;
+}
+
+type EasingFunction = (
+/** elapsed time since start of action */
+t: number, 
+/** start value of value to be eased */
+b: number, 
+/** total change of value to be eased */
+c: number, 
+/** total duration of action */
+d: number) => number;
+/**
+ * The Easings class has static methods for creating easings to be used in actions.
+ */
+declare class Easings {
+    static none: EasingFunction;
+    static linear: EasingFunction;
+    static quadraticIn: EasingFunction;
+    static quadraticOut: EasingFunction;
+    static quadraticInOut: EasingFunction;
+    static cubicIn: EasingFunction;
+    static cubicOut: EasingFunction;
+    static cubicInOut: EasingFunction;
+    static quarticIn: EasingFunction;
+    static quarticOut: EasingFunction;
+    static quarticInOut: EasingFunction;
+    static quinticIn: EasingFunction;
+    static quinticOut: EasingFunction;
+    static quinticInOut: EasingFunction;
+    static sinusoidalIn: EasingFunction;
+    static sinusoidalOut: EasingFunction;
+    static sinusoidalInOut: EasingFunction;
+    static exponentialIn: EasingFunction;
+    static exponentialOut: EasingFunction;
+    static exponentialInOut: EasingFunction;
+    static circularIn: EasingFunction;
+    static circularOut: EasingFunction;
+    static circularInOut: EasingFunction;
+    static toTypeAsString(easingFunction: EasingFunction): string;
+    static fromTypeAsString(easingType: string): EasingFunction;
+}
+
+interface SlideTransitionOptions {
+    /** Direction in which the slide action goes */
+    direction: TransitionDirection;
+    /** Duration, in milliseconds, of the transition */
+    duration: number;
+    /** Easing function for movement or a string identifier of the easing function, e.g., `SinusoidalInOut`. Default is a linear easing function. */
+    easing?: EasingFunction | string;
+}
+/**
+ * The Transition class has static methods for creating animations that run as one scene transitions to another.
+ */
+declare abstract class Transition {
+    abstract type: TransitionType;
+    abstract easing: EasingFunction;
+    abstract duration: number;
     /**
-     * Executes a callback when the activity ends.
+     * Creates a scene transition in which the outgoing scene slides out and the incoming scene slides in, as if the incoming scene pushes it.
      *
-     * @param callback - function to execute.
-     * @param options - options for the callback.
+     * @param options - {@link SlideTransitionOptions}
+     * @returns
      */
-    onEnd(callback: (activityLifecycleEvent: ActivityLifecycleEvent) => void, options?: CallbackOptions): void;
+    static slide(options: SlideTransitionOptions): SlideTransition;
     /**
-     * Executes a callback when the activity generates data.
-     *
-     * @param callback - function to execute.
-     * @param options - options for the callback.
+     * Creates a scene transition with no animation or duration. The next scene is immediately drawn.
      */
-    onData(callback: (activityResultsEvent: ActivityResultsEvent) => void, options?: CallbackOptions): void;
-    /** The activity's parent session unique identifier. This is newly generated each session. */
-    sessionUuid: string;
-    /** The activity's unique identifier. This is newly generated each session. The UUID for an activity will vary across sessions. */
-    uuid: string;
-    /** Human-friendly name of this activity */
-    name: string;
-    /** Short identifier of this activity */
-    id: string;
-    /** Persistent unique identifier (UUID) of the activity. Required for games. Optional or empty string if a survey. */
-    publishUuid: string;
-    /** The ID of the study (protocol, experiment, or other aggregate) that contains the repeated administrations of this activity. The ID should be short, url-friendly, human-readable text (no spaces, special characters, or slashes), e.g., `nyc-aging-cohort`. */
-    studyId?: string;
-    /** Unique identifier (UUID) of the study (protocol, experiment, or other aggregate) that contains the administration of this activity. */
-    studyUuid?: string;
-    /** The value of performance.now() immediately before the activity begins */
-    beginTimestamp: number;
-    /** The value of new Date().toISOString() immediately before the activity begins */
-    beginIso8601Timestamp: string;
-    /** Sets additional activity parameters if defaults are not sufficient. */
-    setParameters(additionalParameters: unknown): void;
-    /** Additional activity parameters that were set. */
-    readonly additionalParameters?: unknown;
-    /** Optional stores to use for saving data. The implementation of the store is not provided by the \@m2c2kit/core library. */
-    dataStores?: IDataStore[];
+    static none(): NoneTransition;
+}
+declare class NoneTransition extends Transition {
+    type: "None";
+    easing: EasingFunction;
+    duration: number;
+    constructor();
+}
+declare class SlideTransition extends Transition {
+    type: "Slide";
+    easing: EasingFunction;
+    duration: number;
+    direction: TransitionDirection;
+    constructor(direction: TransitionDirection, duration: number, easing: EasingFunction);
+}
+declare const TransitionType: {
+    readonly Slide: "Slide";
+    readonly None: "None";
+};
+type TransitionType = (typeof TransitionType)[keyof typeof TransitionType];
+declare const TransitionDirection: {
+    readonly Up: "Up";
+    readonly Down: "Down";
+    readonly Right: "Right";
+    readonly Left: "Left";
+};
+type TransitionDirection = (typeof TransitionDirection)[keyof typeof TransitionDirection];
+declare class SceneTransition {
+    scene: Scene;
+    transition: Transition;
+    constructor(scene: Scene, transition: Transition);
 }
 
 /**
@@ -677,6 +603,8 @@ interface BrowserImage {
     svgString?: string;
     /** URL of image asset (svg, png, jpg) to render and load */
     url?: string;
+    /** Image asset as a Data URL. @internal For m2c2kit library use only */
+    dataUrl?: string;
     /** If true, the image will not be fully loaded until it is needed. Default
      * is false. Lazy loading is useful for large "banks" of images. These should
      * be lazy loaded because they may not be needed. */
@@ -965,143 +893,48 @@ interface GameOptions extends LocalizationOptions {
     shortDescription?: string;
     /** Full description of game */
     longDescription?: string;
-    /** Id of the HTML canvas that game will be drawn on. If not provided, the first canvas found will be used */
-    canvasId?: string;
-    /** Width of game canvas */
-    width: number;
-    /** Height of game canvas */
-    height: number;
-    /** Stretch to fill screen? Default is false */
-    stretch?: boolean;
-    /** Schema of trial data; JSON object where key is variable name, value is data type */
-    trialSchema?: TrialSchema;
-    /** Default game parameters; JSON object where key is the game parameter, value is default value */
-    parameters?: GameParameters;
-    /** Font assets to use. The first element will be the default font */
-    fonts?: Array<FontAsset>;
-    /** Array of BrowserImage objects to render and load */
-    images?: Array<BrowserImage>;
-    /** Array of SoundAsset objects to fetch and decode */
-    sounds?: Array<SoundAsset>;
-    /** Show FPS in upper left corner? Default is false */
-    showFps?: boolean;
-    /** Color of the html body, if the game does not fill the screen. Useful for showing scene boundaries. Default is the scene background color */
-    bodyBackgroundColor?: RgbaColor;
-    /** Maximum number of activity metrics to log. */
-    maximumRecordedActivityMetrics?: number;
-    /** The FPS will be logged in game metrics if the FPS is lower than this value. Default is 59, as defined in Constants.FPS_METRIC_REPORT_THRESHOLD */
-    fpsMetricReportThreshold?: number;
-    /** Advance through time step-by-step, for development and debugging */
-    timeStepping?: boolean;
-    /** Show logs for WebGl activity? */
-    logWebGl?: boolean;
-    /** Should games within a session share wasm and font assets that have identical filenames, in order to reduce bandwidth? Default is true. */
-    shareAssets?: boolean;
-    /** Game's module name, version, and dependencies. @internal For m2c2kit library use only */
-    moduleMetadata?: ModuleMetadata;
-}
-
-interface GameData extends ActivityKeyValueData {
-    trials: Array<TrialData>;
-}
-
-interface TranslationOptions {
-    [key: string]: unknown;
-}
-interface TextLocalizationResult {
-    text: string;
-    fontName?: string;
-    fontNames?: string[];
-    isFallbackOrMissingTranslation: boolean;
-}
-declare class I18n {
-    private _translation;
-    locale: string;
-    fallbackLocale: string;
-    baseLocale: string;
-    missingLocalizationColor: RgbaColor | undefined;
-    game: Game;
-    /**
-     * The I18n class localizes text and images.
-     *
-     * @param game - game instance
-     * @param options - {@link LocalizationOptions}
-     */
-    constructor(game: Game, options: LocalizationOptions);
-    /**
-     * Initializes the I18n instance and sets the initial locale.
-     *
-     * @remarks If the game instance has been configured to use a data store,
-     * the previously used locale and fallback locale will be retrieved from the
-     * data store if they have been previously set.
-     */
-    initialize(): Promise<void>;
-    private configureInitialLocale;
-    private localeTranslationAvailable;
-    switchToLocale(locale: string): void;
-    /**
-     *
-     * @param key - Translation key
-     * @param interpolation - Interpolation keys and values to replace
-     * placeholders in the translated text
-     * @returns a `TextLocalizationResult` object with the localized text, font
-     * information, and whether the translation is a fallback.
-     */
-    getTextLocalization(key: string, interpolation?: StringInterpolationMap): TextLocalizationResult;
-    /**
-     * Returns the translation text for the given key in the current locale.
-     *
-     * @remarks Optional interpolation keys and values can be provided to replace
-     * placeholders in the translated text. Placeholders are denoted by double
-     * curly braces.
-     *
-     * @param key - key to look up in the translation
-     * @param options - `TranslationOptions`, such as interpolation keys/values
-     * and whether to translate using the fallback locale
-     * @returns the translation text for the key in the current locale, or
-     * undefined if the key is not found
-     *
-     * @example
-     *
-     * ```
-     * const translation: Translation = {
-     *   "en-US": {
-     *     "GREETING": "Hello, {{name}}."
-     *   }
-     * }
-     * ...
-     * i18n.t("GREETING", { name: "World" }); // returns "Hello, World."
-     *
-     * ```
-     */
-    t(key: string, options?: TranslationOptions): string | undefined;
-    /**
-     * Returns the translation text and font information for the given key in the
-     * current locale.
-     *
-     * @remarks Optional interpolation keys and values can be provided to replace
-     * placeholders in the translated text. Placeholders are denoted by double
-     * curly braces. See method {@link I18n.t()} for interpolation example.
-     *
-     * @param key - key to look up in the translation
-     * @param options - `TranslationOptions`, such as interpolation keys/values
-     * and whether to translate using the fallback locale
-     * @returns the translation text and font information for the key in the
-     * current locale, or undefined if the key is not found
-     */
-    tf(key: string, options?: TranslationOptions): TextAndFont | undefined;
-    private getKeyText;
-    private getKeyTextAndFont;
-    private insertInterpolations;
-    get translation(): Translation;
-    set translation(value: Translation);
-    private getEnvironmentLocale;
-    private mergeAdditionalTranslation;
-    static makeLocalizationParameters(): GameParameters;
-    private isTextWithFontCustomization;
-    private isStringOrTextWithFontCustomization;
-    private isStringArray;
-    private isString;
+    /** Id of the HTML canvas that game will be drawn on. If not provided, the first canvas found will be used */
+    canvasId?: string;
+    /** Width of game canvas */
+    width: number;
+    /** Height of game canvas */
+    height: number;
+    /** Stretch to fill screen? Default is false */
+    stretch?: boolean;
+    /** Schema of trial data; JSON object where key is variable name, value is data type */
+    trialSchema?: TrialSchema;
+    /** Default game parameters; JSON object where key is the game parameter, value is default value */
+    parameters?: GameParameters;
+    /** Font assets to use. The first element will be the default font */
+    fonts?: Array<FontAsset>;
+    /** Array of BrowserImage objects to render and load */
+    images?: Array<BrowserImage>;
+    /** Array of SoundAsset objects to fetch and decode */
+    sounds?: Array<SoundAsset>;
+    /** Show FPS in upper left corner? Default is false */
+    showFps?: boolean;
+    /** Color of the html body, if the game does not fill the screen. Useful for showing scene boundaries. Default is the scene background color */
+    bodyBackgroundColor?: RgbaColor;
+    /** Maximum number of activity metrics to log. */
+    maximumRecordedActivityMetrics?: number;
+    /** The FPS will be logged in game metrics if the FPS is lower than this value. Default is 59, as defined in Constants.FPS_METRIC_REPORT_THRESHOLD */
+    fpsMetricReportThreshold?: number;
+    /** Advance through time step-by-step, for development and debugging */
+    timeStepping?: boolean;
+    /** Show controls for replaying and viewing the event store? Default is false */
+    showEventStoreControls?: boolean;
+    /** Should the game events be saved to the event store? Default is false */
+    recordEvents?: boolean;
+    /** Show logs for WebGl activity? */
+    logWebGl?: boolean;
+    /** Should games within a session share wasm and font assets that have identical filenames, in order to reduce bandwidth? Default is true. */
+    shareAssets?: boolean;
+    /** Game's module name, version, and dependencies. @internal For m2c2kit library use only */
+    moduleMetadata?: ModuleMetadata;
+}
+
+interface GameData extends ActivityKeyValueData {
+    trials: Array<TrialData>;
 }
 
 /**
@@ -1555,6 +1388,99 @@ interface GameEvent extends M2Event<Activity> {
     target: Game;
 }
 
+type M2EventTarget = M2Node | Element | ImageManager | I18n;
+
+/**
+ * Event store mode.
+ */
+declare const EventStoreMode: {
+    readonly Disabled: "Disabled";
+    readonly Record: "Record";
+    readonly Replay: "Replay";
+};
+type EventStoreMode = (typeof EventStoreMode)[keyof typeof EventStoreMode];
+declare class EventStore {
+    private events;
+    private replayBeginTimestamp;
+    private firstTimestamp;
+    replayThoughSequence: number;
+    serializedEventsBeforeReplay: string;
+    mode: EventStoreMode;
+    private serializeEvent;
+    addEvent(event: M2Event<M2EventTarget>): void;
+    addEvents(events: Array<M2Event<M2EventTarget>>): void;
+    clearEvents(): void;
+    record(): void;
+    replay(events?: M2Event<M2EventTarget>[]): void;
+    getEvents(): M2Event<M2EventTarget>[];
+    dequeueEvents(timestamp: number): M2Event<M2EventTarget>[];
+    get eventQueueLength(): number;
+    /**
+     * Sorts the events in the event store.
+     *
+     * @remarks The events are sorted by sequence number in ascending order.
+     */
+    private sortEventStore;
+}
+
+declare class M2NodeFactory {
+    /**
+     * The `M2NodeFactory` creates nodes of the specified type with the specified
+     * options for event replay.
+     */
+    constructor();
+    /**
+     * Creates a new node of the specified type with the specified options.
+     *
+     * @param type - The type of node to create
+     * @param compositeType - The composite type of the node to create
+     * @param options - The options to use when creating the node
+     * @returns created node
+     */
+    createNode(type: string, compositeType: string | undefined, options: M2NodeOptions): M2Node;
+    private hasClassRegistration;
+}
+
+interface EventMaterializerOptions {
+    game: Game;
+    nodeFactory: M2NodeFactory;
+    freeNodesScene: Scene;
+    configureI18n(localizationOptions: LocalizationOptions): Promise<void>;
+}
+declare class EventMaterializer {
+    private game;
+    private nodeFactory;
+    private freeNodesScene;
+    private eventMaterializers;
+    private configureI18n;
+    /**
+     * The `EventMaterializer` class is responsible for taking serialized events
+     * from an event store and replaying them in the game.
+     */
+    constructor(options: EventMaterializerOptions);
+    /**
+     * Deserialize the events by materializing them into the game.
+     *
+     * @remarks This method is called when the game is replaying events from the
+     * event store. Materializing an event means to take the event and apply its
+     * changes to the game. For example, a `NodeNew` event will create a new node
+     * in the game. A `NodePropertyChange` event will change a property of a node
+     * in the game.
+     *
+     * @param events - The events to materialize
+     */
+    materialize(events: ReadonlyArray<M2Event<M2EventTarget>>): void;
+    private materializeCompositeEvent;
+    private materializeNodeNewEvent;
+    private materializeNodePropertyChangeEvent;
+    private materializeNodeAddChildEvent;
+    private materializeNodeRemoveChildEvent;
+    private materializeDomPointerDownEvent;
+    private materializeBrowserImageDataReadyEvent;
+    private materializeI18nDataReadyEvent;
+    private materializeScenePresentEvent;
+}
+
 interface TrialData {
     [key: string]: string | number | boolean | object | undefined | null;
 }
@@ -1592,12 +1518,18 @@ declare class Game implements Activity {
     private _imageManager?;
     private _soundManager?;
     manifest?: Manifest;
+    eventStore: EventStore;
+    private nodeFactory;
+    private _eventMaterializer?;
+    /** Nodes created during event replay */
+    materializedNodes: M2Node[];
     /**
      * The base class for all games. New games should extend this class.
      *
      * @param options - {@link GameOptions}
      */
     constructor(options: GameOptions);
+    private createFreeNodesScene;
     private getImportedModuleBaseUrl;
     private addLocalizationParametersToGameParameters;
     init(): Promise<void>;
@@ -1623,6 +1555,8 @@ declare class Game implements Activity {
      * @returns base URLs for game assets and CanvasKit wasm binary
      */
     resolveGameBaseUrls(game: Game): Promise<GameBaseUrls>;
+    private configureI18n;
+    private waitForErudaInitialization;
     initialize(): Promise<void>;
     /**
      * Returns the manifest, if manifest.json was created during the build.
@@ -1643,6 +1577,8 @@ declare class Game implements Activity {
     set imageManager(imageManager: ImageManager);
     get soundManager(): SoundManager;
     set soundManager(soundManager: SoundManager);
+    get eventMaterializer(): EventMaterializer;
+    set eventMaterializer(eventMaterializer: EventMaterializer);
     /**
      * Adds prefixes to a key to ensure that keys are unique across activities
      * and studies.
@@ -1775,7 +1711,7 @@ declare class Game implements Activity {
     surface?: Surface;
     private showFps?;
     private bodyBackgroundColor?;
-    private currentScene?;
+    currentScene?: Scene;
     private priorUpdateTime?;
     private fpsTextFont?;
     private fpsTextPaint?;
@@ -1790,7 +1726,7 @@ declare class Game implements Activity {
     canvasCssWidth: number;
     canvasCssHeight: number;
     scenes: Scene[];
-    private freeNodesScene;
+    freeNodesScene: Scene;
     private incomingSceneTransitions;
     private currentSceneSnapshot?;
     private pendingScreenshot?;
@@ -1852,6 +1788,19 @@ declare class Game implements Activity {
      * @param scene
      */
     addScene(scene: Scene): void;
+    /**
+     * Adds events from a node and its children to the game's event store.
+     *
+     * @remarks This method is first called when a scene is added to the game.
+     * If the scene or any of its descendants was constructed or had its
+     * properties changed before it was added to the game, these events were
+     * stored within the node (because the game event store was not yet
+     * available). This method retrieves these events from the node and adds
+     * them to the game's event store.
+     *
+     * @param node - node that contains events to add
+     */
+    private addNodeEvents;
     /**
      * Adds multiple scenes to the game.
      *
@@ -1867,10 +1816,10 @@ declare class Game implements Activity {
     /**
      * Specifies the scene that will be presented upon the next frame draw.
      *
-     * @param scene
+     * @param scene - the scene, its string name, or UUID
      * @param transition
      */
-    presentScene(scene: string | Scene, transition?: NoneTransition): void;
+    presentScene(scene: string | Scene, transition?: Transition): void;
     /**
      * Gets the value of the game parameter. If parameterName
      * is not found, then throw exception.
@@ -1909,6 +1858,11 @@ declare class Game implements Activity {
      * @param entryScene - The scene (Scene object or its string name) to display when the game starts
      */
     start(entryScene?: Scene | string): Promise<void>;
+    playEventsHandler(mouseEvent: MouseEvent): void;
+    private replayEventsButtonEnabled;
+    private setReplayEventsButtonEnabled;
+    private setStopReplayButtonEnabled;
+    private addEventControlsToDom;
     private addTimeSteppingControlsToDom;
     private updateTimeSteppingOutput;
     private advanceStepsHandler;
@@ -2234,6 +2188,326 @@ declare class Game implements Activity {
     private IsCanvasPointWithinNodeBounds;
 }
 
+/**
+ * Map of placeholders to values for use in string interpolation.
+ */
+interface StringInterpolationMap {
+    [placeholder: string]: string;
+}
+
+interface TranslationOptions {
+    [key: string]: unknown;
+}
+interface TextLocalizationResult {
+    text: string;
+    fontName?: string;
+    fontNames?: string[];
+    isFallbackOrMissingTranslation: boolean;
+}
+declare class I18n {
+    private _translation;
+    locale: string;
+    fallbackLocale: string;
+    baseLocale: string;
+    missingLocalizationColor: RgbaColor | undefined;
+    game: Game;
+    /**
+     * The I18n class localizes text and images.
+     *
+     * @param game - game instance
+     * @param options - {@link LocalizationOptions}
+     */
+    constructor(game: Game, options: LocalizationOptions);
+    /**
+     * Initializes the I18n instance and sets the initial locale.
+     *
+     * @remarks If the game instance has been configured to use a data store,
+     * the previously used locale and fallback locale will be retrieved from the
+     * data store if they have been previously set.
+     */
+    initialize(): Promise<void>;
+    private configureInitialLocale;
+    private localeTranslationAvailable;
+    switchToLocale(locale: string): void;
+    /**
+     *
+     * @param key - Translation key
+     * @param interpolation - Interpolation keys and values to replace
+     * placeholders in the translated text
+     * @returns a `TextLocalizationResult` object with the localized text, font
+     * information, and whether the translation is a fallback.
+     */
+    getTextLocalization(key: string, interpolation?: StringInterpolationMap): TextLocalizationResult;
+    /**
+     * Returns the translation text for the given key in the current locale.
+     *
+     * @remarks Optional interpolation keys and values can be provided to replace
+     * placeholders in the translated text. Placeholders are denoted by double
+     * curly braces.
+     *
+     * @param key - key to look up in the translation
+     * @param options - `TranslationOptions`, such as interpolation keys/values
+     * and whether to translate using the fallback locale
+     * @returns the translation text for the key in the current locale, or
+     * undefined if the key is not found
+     *
+     * @example
+     *
+     * ```
+     * const translation: Translation = {
+     *   "en-US": {
+     *     "GREETING": "Hello, {{name}}."
+     *   }
+     * }
+     * ...
+     * i18n.t("GREETING", { name: "World" }); // returns "Hello, World."
+     *
+     * ```
+     */
+    t(key: string, options?: TranslationOptions): string | undefined;
+    /**
+     * Returns the translation text and font information for the given key in the
+     * current locale.
+     *
+     * @remarks Optional interpolation keys and values can be provided to replace
+     * placeholders in the translated text. Placeholders are denoted by double
+     * curly braces. See method {@link I18n.t()} for interpolation example.
+     *
+     * @param key - key to look up in the translation
+     * @param options - `TranslationOptions`, such as interpolation keys/values
+     * and whether to translate using the fallback locale
+     * @returns the translation text and font information for the key in the
+     * current locale, or undefined if the key is not found
+     */
+    tf(key: string, options?: TranslationOptions): TextAndFont | undefined;
+    private getKeyText;
+    private getKeyTextAndFont;
+    private insertInterpolations;
+    get translation(): Translation;
+    set translation(value: Translation);
+    private getEnvironmentLocale;
+    private mergeAdditionalTranslation;
+    static makeLocalizationParameters(): GameParameters;
+    private isTextWithFontCustomization;
+    private isStringOrTextWithFontCustomization;
+    private isStringArray;
+    private isString;
+}
+
+/**
+ * Base interface for all m2c2kit events.
+ *
+ * @remarks I would have named it Event, but that would collide with
+ * the existing DOM Event
+ */
+interface M2Event<T> {
+    /** Type of event. */
+    type: M2EventType | string;
+    /** The object on which the event occurred. If the event has gone through serialization, the string will be the object's UUID (if an `M2Node`) or class name. */
+    target: T | string;
+    /** Has the event been taken care of by the listener and not be dispatched to other targets? */
+    handled?: boolean;
+    /** Timestamp of the event, `from performance.now()` */
+    timestamp: number;
+    /** Timestamp of th event, from `new Date().toISOString()` */
+    iso8601Timestamp: string;
+    /** Sequence number of event.
+     * @remarks Sequence number is guaranteed to reflect order of events, but
+     * not necessarily contiguous, e.g., could be 1, 2, 5, 10, 11, 24.
+     * */
+    sequence?: number;
+}
+interface DomPointerDownEvent extends M2Event<Element> {
+    type: "DomPointerDown";
+    target: Element;
+    x: number;
+    y: number;
+}
+interface CompositeEvent extends M2NodeEvent {
+    /** The Composite on which the event occurred. If the event has gone through serialization, the string will be the composite's UUID.  */
+    target: Composite | string;
+    type: "Composite";
+    /** The type of the composite node. */
+    compositeType: string;
+    /** The type of the composite event. */
+    compositeEventType: string;
+    /** The composite event properties */
+    [key: string]: number | string | boolean | object | null | undefined;
+}
+interface M2NodeNewEvent extends M2Event<M2Node> {
+    type: "NodeNew";
+    target: M2Node;
+    /** The type of the new node. */
+    nodeType: M2NodeType | string;
+    /** If a composite node, the type of the composite. */
+    compositeType?: string;
+    /** The options of the at the time of instantiation. This includes options for any base types and interfaces. */
+    nodeOptions: M2NodeOptions;
+}
+interface M2NodeAddChildEvent extends M2Event<M2Node> {
+    type: "NodeAddChild";
+    target: M2Node;
+    /** The node's unique identifier (UUID). */
+    uuid: string;
+    /** The child node's unique identifier (UUID). */
+    childUuid: string;
+}
+interface M2NodeRemoveChildEvent extends M2Event<M2Node> {
+    type: "NodeRemoveChild";
+    target: M2Node;
+    /** The node's unique identifier (UUID). */
+    uuid: string;
+    /** The child node's unique identifier (UUID). */
+    childUuid: string;
+}
+interface ScenePresentEvent extends M2Event<M2Node> {
+    type: "ScenePresent";
+    target: Scene;
+    /** The node's unique identifier (UUID). */
+    uuid: string;
+    /** Transition type of the presented scene. */
+    transitionType: TransitionType;
+    direction?: TransitionDirection;
+    duration?: number;
+    easingType?: string;
+}
+interface M2NodePropertyChangeEvent extends M2Event<M2Node> {
+    type: "NodePropertyChange";
+    target: M2Node;
+    /** The node's unique identifier (UUID). */
+    uuid: string;
+    /** The property that changed. */
+    property: string;
+    /** The new value of the property. */
+    value: string | number | boolean | object | null | undefined;
+}
+interface BrowserImageDataReadyEvent extends M2Event<ImageManager> {
+    type: "BrowserImageDataReady";
+    target: ImageManager;
+    /** The image name. */
+    imageName: string;
+    /** Width to scale image to */
+    width: number;
+    /** Height to scale image to */
+    height: number;
+    /** The image data URL. */
+    dataUrl?: string;
+    /** SVG string */
+    svgString?: string;
+}
+interface I18nDataReadyEvent extends M2Event<I18n> {
+    type: "I18nDataReadyEvent";
+    target: I18n;
+    localizationOptions: LocalizationOptions;
+}
+/**
+ * The different events that are dispatched by m2c2kit core.
+ */
+declare const M2EventType: {
+    readonly ActivityStart: "ActivityStart";
+    readonly ActivityEnd: "ActivityEnd";
+    readonly ActivityCancel: "ActivityCancel";
+    readonly ActivityData: "ActivityData";
+    readonly GameWarmupStart: "GameWarmupStart";
+    readonly GameWarmupEnd: "GameWarmupEnd";
+    readonly TapDown: "TapDown";
+    readonly TapUp: "TapUp";
+    readonly TapUpAny: "TapUpAny";
+    readonly TapLeave: "TapLeave";
+    readonly PointerDown: "PointerDown";
+    readonly PointerUp: "PointerUp";
+    readonly PointerMove: "PointerMove";
+    readonly PointerLeave: "PointerLeave";
+    readonly Drag: "Drag";
+    readonly DragStart: "DragStart";
+    readonly DragEnd: "DragEnd";
+    readonly Composite: "Composite";
+    readonly FrameDidSimulatePhysics: "FrameDidSimulatePhysics";
+    readonly SceneSetup: "SceneSetup";
+    readonly SceneAppear: "SceneAppear";
+    readonly ScenePresent: "ScenePresent";
+    readonly NodeNew: "NodeNew";
+    readonly NodeAddChild: "NodeAddChild";
+    readonly NodeRemoveChild: "NodeRemoveChild";
+    readonly NodePropertyChange: "NodePropertyChange";
+    readonly DomPointerDown: "DomPointerDown";
+    readonly BrowserImageDataReady: "BrowserImageDataReady";
+    readonly I18nDataReadyEvent: "I18nDataReadyEvent";
+};
+type M2EventType = (typeof M2EventType)[keyof typeof M2EventType];
+
+/**
+ * Base interface for all m2c2kit event listeners.
+ */
+interface M2EventListener<T> {
+    /** Type of event to listen for. */
+    type: M2EventType | string;
+    /** Callback function to be called when the event is dispatched. */
+    callback: (event: T) => void;
+    /** Optional key (string identifier) used to identify the event listener. */
+    key?: string;
+}
+
+interface M2NodeEventListener<M2NodeEvent> extends M2EventListener<M2NodeEvent> {
+    /** For composites that raise events, type of the composite node. */
+    compositeType?: string;
+    /** For composites that raise events, type of the composite event. */
+    compositeEventType?: string;
+    /** UUID of the node that the event listener is listening for. */
+    nodeUuid: string;
+}
+
+/**
+ * Describes an interaction between the pointer (mouse, touches) and a node.
+ *
+ * @remarks I would have named it PointerEvent, but that would collide with
+ * the existing DOM PointerEvent.
+ */
+interface M2PointerEvent extends M2NodeEvent {
+    /** Point that was tapped on node, relative to the node coordinate system */
+    point: Point;
+    /** Buttons being pressed when event was fired. Taken from DOM MouseEvent.buttons */
+    buttons: number;
+}
+
+/**
+ * Describes an interaction of a pointer (mouse, touches) pressing a node.
+ *
+ * @remarks Unlike M2PointerEvent, TapEvent considers how the pointer, while
+ * in the down state, moves in relation to the bounds of the node.
+ */
+interface TapEvent extends M2NodeEvent {
+    /** Point that was tapped on node, relative to the node coordinate system */
+    point: Point;
+    /** Buttons being pressed when event was fired. Taken from DOM MouseEvent.buttons */
+    buttons: number;
+}
+
+interface TextOptions {
+    /** Text to be displayed */
+    text?: string;
+    /** Name of font to use for text. Must have been previously loaded */
+    fontName?: string;
+    /** Color of text. Default is Constants.DEFAULT_FONT_COLOR (WebColors.Black) */
+    fontColor?: RgbaColor;
+    /** Size of text. Default is Constants.DEFAULT_FONT_SIZE (16) */
+    fontSize?: number;
+    /** Map of placeholders to values for use in string interpolation during localization. */
+    interpolation?: StringInterpolationMap;
+    /** If true, try to use a localized version of the text. Default is true. */
+    localize?: boolean;
+}
+
+/**
+ * Width and height on two-dimensional space
+ */
+interface Size {
+    /** Horizontal width, x-axis */
+    width: number;
+    /** Vertical height, y-axis */
+    height: number;
+}
+
 /**
  * Describes a drag and drop operation.
  *
@@ -2253,20 +2527,25 @@ declare abstract class M2Node implements M2NodeOptions {
     isDrawable: boolean;
     isShape: boolean;
     isText: boolean;
+    private _suppressEvents;
+    options: M2NodeOptions;
+    constructionTimeStamp: number;
+    constructionIso8601TimeStamp: string;
+    constructionSequence: number;
     name: string;
     _position: Point;
     _scale: number;
-    alpha: number;
+    _alpha: number;
     _zRotation: number;
     protected _isUserInteractionEnabled: boolean;
-    draggable: boolean;
-    hidden: boolean;
+    protected _draggable: boolean;
+    protected _hidden: boolean;
     layout: Layout;
     _game?: Game;
     parent?: M2Node;
     children: M2Node[];
     absolutePosition: Point;
-    size: Size;
+    protected _size: Size;
     absoluteScale: number;
     absoluteAlpha: number;
     absoluteAlphaChange: number;
@@ -2277,6 +2556,7 @@ declare abstract class M2Node implements M2NodeOptions {
     needsInitialization: boolean;
     userData: any;
     loopMessages: Set<string>;
+    nodeEvents: M2Event<M2Node>[];
     /** Is the node in a pressed state? E.g., did the user put the pointer
      * down on the node and not yet release it? */
     pressed: boolean;
@@ -2297,6 +2577,28 @@ declare abstract class M2Node implements M2NodeOptions {
     dragging: boolean;
     constructor(options?: M2NodeOptions);
     initialize(): void;
+    protected get completeNodeOptions(): M2NodeOptions;
+    /**
+     * Save the node's construction event in the event store.
+     */
+    protected saveNodeNewEvent(): void;
+    /**
+     * Saves the node's property change event in the event store.
+     *
+     * @param property - property name
+     * @param value - property value
+     */
+    protected savePropertyChangeEvent(property: string, value: string | number | boolean | object | null | undefined): void;
+    /**
+     * Saves the node's event.
+     *
+     * @remarks If the game event store is not available, the event is saved
+     * within the node's `nodeEvents` event array. It will be added to the game
+     * event store when the node is added to the game.
+     *
+     * @param event - event to save
+     */
+    protected saveEvent(event: M2Event<M2Node>): void;
     /**
      * The game which this node is a part of.
      *
@@ -2323,6 +2625,15 @@ declare abstract class M2Node implements M2NodeOptions {
      * @param child - The child node to add
      */
     addChild(child: M2Node): void;
+    /**
+     * Saves the child's events to the parent node.
+     *
+     * @remarks When a child is added to a parent, the parent receives all the
+     * child's events and saves them.
+     *
+     * @param child - child node to save events to parent node
+     */
+    private saveChildEvents;
     /**
      * Removes all children from the node.
      */
@@ -2554,14 +2865,24 @@ declare abstract class M2Node implements M2NodeOptions {
      */
     get canvasKit(): CanvasKit;
     get parentSceneAsNode(): M2Node;
+    get size(): Size;
+    set size(size: Size);
     get position(): Point;
     set position(position: Point);
     get zRotation(): number;
     set zRotation(zRotation: number);
     get scale(): number;
     set scale(scale: number);
+    get alpha(): number;
+    set alpha(alpha: number);
     get isUserInteractionEnabled(): boolean;
     set isUserInteractionEnabled(isUserInteractionEnabled: boolean);
+    get hidden(): boolean;
+    set hidden(hidden: boolean);
+    get draggable(): boolean;
+    set draggable(draggable: boolean);
+    get suppressEvents(): boolean;
+    set suppressEvents(value: boolean);
     /**
      * For a given directed acyclic graph, topological ordering of the vertices will be identified using BFS
      * @param adjList Adjacency List that represent a graph with vertices and edges
@@ -3310,28 +3631,6 @@ declare class ColorfulMutablePath extends MutablePath {
     duplicate(): ColorfulMutablePath;
 }
 
-interface CompositeOptions extends M2NodeOptions, DrawableOptions {
-}
-
-declare abstract class Composite extends M2Node implements IDrawable {
-    readonly type = M2NodeType.Composite;
-    compositeType: string;
-    isDrawable: boolean;
-    anchorPoint: Point;
-    zPosition: number;
-    /**
-     * Base Drawable object for creating custom nodes ("composites") composed of primitive nodes.
-     *
-     * @param options
-     */
-    constructor(options?: CompositeOptions);
-    initialize(): void;
-    dispose(): void;
-    update(): void;
-    draw(canvas: Canvas): void;
-    abstract warmup(canvas: Canvas): void;
-}
-
 /**
  * Reasonable defaults to use if values are not specified.
  */
@@ -3367,6 +3666,7 @@ declare class Constants {
     /** Placeholder that will be populated during the build process. */
     static readonly MODULE_METADATA_PLACEHOLDER: ModuleMetadata;
     static readonly DEFAULT_ROOT_ELEMENT_ID = "m2c2kit";
+    static readonly ERUDA_URL = "https://cdn.jsdelivr.net/npm/eruda@3.2.1/eruda.js";
 }
 
 /**
@@ -3390,10 +3690,79 @@ declare enum Dimensions {
     MatchConstraint = 0
 }
 
+type M2NodeConstructor = new (options?: M2NodeOptions) => M2Node;
+
 /**
  * Utility class for comparing equality of m2c2kit objects.
+ *
+ * @deprecated Use the class `Equal` instead.
  */
 declare class Equals {
+    /**
+     * Compares two RgbaColor objects and returns true if they are equal.
+     *
+     * @remarks If either of the colors is undefined, the comparison will
+     * return false. RgbaColor is an array of 4 numbers, and thus is a
+     * reference type. We need this method to compare two RgbaColor objects
+     * for value equality.
+     *
+     * @deprecated Use the methods in `Equal` instead.
+     *
+     * @param color1
+     * @param color2
+     * @returns
+     */
+    static rgbaColor(color1?: RgbaColor, color2?: RgbaColor): boolean;
+}
+
+interface RectOptions {
+    /** Position of rectangle */
+    origin?: Point;
+    /** Size of rectangle */
+    size?: Size;
+    /** X coordinate of rectangle position; this can be used instead of setting the origin property */
+    x?: number;
+    /** Y coordinate of rectangle position; this can be used instead of setting the origin property */
+    y?: number;
+    /** Width of rectangle; this can be used instead of setting the size property */
+    width?: number;
+    /** Height of rectangle; this can be used instead of setting the size property */
+    height?: number;
+}
+
+/**
+ * A collection of multi-color lines to draw.
+ *
+ * @remarks Unlike `M2Path`, this interface allows for lines of different
+ * colors and widths to be drawn in the same path.
+ */
+interface M2ColorfulPath extends M2Path {
+    /** Colors and widths of lines in the path. */
+    linePresentations: Array<LinePresentation>;
+}
+
+/**
+ * A path created from an SVG string path.
+ */
+interface SvgStringPath {
+    /** SVG string from which to create the path */
+    pathString?: string;
+    /** SVG string from which to create the path @deprecated Use `pathString` */
+    svgPathString?: string;
+    /** If provided, scale the SVG path to this height, and scale the width to keep the original SVG proportions */
+    height?: number;
+    /** If provided, scale the SVG path to this width, and scale the height to keep the original SVG proportions */
+    width?: number;
+}
+
+type ValueType = string | number | boolean | null | undefined | Array<ValueType> | {
+    [key: string]: ValueType;
+} | Point | RectOptions | M2Path | M2ColorfulPath | SvgStringPath | Size;
+/**
+ * Utility class for comparing equality of m2c2kit objects.
+ *
+ */
+declare class Equal {
     /**
      * Compares two RgbaColor objects and returns true if they are equal.
      *
@@ -3407,6 +3776,28 @@ declare class Equals {
      * @returns
      */
     static rgbaColor(color1?: RgbaColor, color2?: RgbaColor): boolean;
+    /**
+     * Compares two values for deep equality.
+     *
+     * @remarks Supported values are string, number, boolean, null, undefined,
+     * and object (note that arrays are objects in JavaScript).
+     *
+     * @param value1 - value to compare
+     * @param value2 - value to compare
+     * @returns true if values have deep equality
+     */
+    static value(value1: ValueType, value2: ValueType): boolean;
+    /**
+     * Compares two objects for deep equality.
+     *
+     * @remarks In JavaScript, arrays are objects, so this method will also
+     * compare arrays for deep equality.
+     *
+     * @param obj1 - object to compare
+     * @param obj2 - object to compare
+     * @returns true if objects have deep equality
+     */
+    private static objectsDeepEqual;
 }
 
 /**
@@ -3451,6 +3842,80 @@ declare class M2c2KitHelpers {
      * "https://", "file://", etc.)
      */
     static urlHasScheme(url: string): boolean;
+    /**
+     * Load scripts from URLs.
+     *
+     * @remarks This is for debugging purposes only. If this is unwanted, it
+     * can be disabled on the server side with an appropriate Content
+     * Security Policy (CSP) header.
+     *
+     * @param urls - URLs with scripts to load
+     */
+    static loadScriptUrls(urls: string[]): void;
+    /**
+     * Loads eruda from a CDN and initializes it.
+     *
+     * @remarks This is for debugging purposes only. If this is unwanted, it
+     * can be disabled on the server side with an appropriate Content
+     * Security Policy (CSP) header.
+     * eruda is a dev console overlay for mobile web browsers and web views.
+     * see https://github.com/liriliri/eruda
+     *
+     * @param pollingIntervalMs - milliseconds between each attempt
+     * @param maxAttempts - how many attempts to make
+     */
+    static loadEruda(pollingIntervalMs?: number, maxAttempts?: number): void;
+    /**
+     * Registers a `M2Node` class with the global class registry.
+     *
+     * @remarks This is used to register a class so that it can be
+     * instantiated by the `M2NodeFactory`.
+     *
+     * @param nodeClass - class or classes to register.
+     */
+    static registerM2NodeClass(...nodeClass: Array<M2NodeConstructor>): void;
+    /**
+     * Creates timestamps based on when the current frame's update began.
+     *
+     * @remarks When recording events related to node creation, node
+     * parent-child relationships, and node properties, the timestamps should be
+     * based on when current frame's update began -- not the current time. While
+     * current time is most accurate for recording user interactions (use
+     * `M2c2KitHelpers.createTimestamps()` for user interactions), the frame's
+     * update is the best way to ensure that node events that occurred in the same
+     * frame are recorded with the same timestamp and thus are replayed in the
+     * correct order. For example, a node may be created, added to a scene, and
+     * have its hidden property set to true, all in the same frame. If the
+     * current timestamps were used for all these events, it could happen that
+     * the hidden property is set slightly after the node is added to the scene.
+     * When replayed, this could cause the node to be visible for a single frame
+     * if the queue of replay events pulls only the creation and addition events.
+     * By using the frame's update time, we ensure that all events related to a
+     * node are recorded with the same timestamp and are replayed in the same
+     * frame.
+     * If game has not yet begun to run (i.e., frame updates have not yet started),
+     * the timestamps will be based on the current time.
+     *
+     * @returns object with timestamps
+     */
+    static createFrameUpdateTimestamps(): {
+        timestamp: number;
+        iso8601Timestamp: string;
+    };
+    /**
+     * Creates timestamps based on the current time.
+     *
+     * @remarks Use `M2c2KitHelpers.createFrameUpdateTimestamps()` when requesting
+     * timestamps for events related to node creation, parent-child
+     * relationships, and properties.
+     * See {@link createFrameUpdateTimestamps()} for explanation.
+     *
+     * @returns object with `timestamp` and `iso8601Timestamp` properties
+     */
+    static createTimestamps(): {
+        timestamp: number;
+        iso8601Timestamp: string;
+    };
     /**
      * Calculates the four points of the bounding box of the node, taking
      * into account the node's rotation (as well as the rotation of its
@@ -3592,6 +4057,40 @@ interface FontData {
     isDefault: boolean;
 }
 
+declare global {
+    var m2c2Globals: GlobalVariables;
+}
+interface GlobalVariables {
+    now: number;
+    iso8601Now: string;
+    deltaTime: number;
+    canvasScale: number;
+    /**
+     * rootScale is the scaling factor to be applied to scenes to scale up or
+     * down to fit the device's window while preserving the aspect ratio the
+     * game was designed for
+     */
+    rootScale: number;
+    canvasCssWidth: number;
+    canvasCssHeight: number;
+    erudaRequested?: boolean;
+    erudaInitialized?: boolean;
+    addedScriptUrls: string[];
+    /**
+     * A dictionary of all `M2Node` classes that have been registered.
+     * This is used to instantiate `M2Node` objects from their class name.
+     *
+     * @remarks The type should be `{ [key: string]: M2NodeConstructor }` or
+     * `M2NodeClassRegistry`. But, this creates problems in Jest: I could not
+     *  get ts-jest to compile when the type of a global variable is not a
+     * simple type. Instead, the type of `m2NodeClassRegistry` is `object`,
+     * and I will assert it to `M2NodeClassRegistry` when needed.
+     */
+    m2NodeClassRegistry: object;
+    get eventSequence(): number;
+    __sequence: number;
+}
+
 interface IText {
     text?: string;
     fontName?: string;
@@ -3622,11 +4121,8 @@ declare class Label extends M2Node implements IDrawable, IText, LabelOptions {
     readonly type = M2NodeType.Label;
     isDrawable: boolean;
     isText: boolean;
-    anchorPoint: {
-        x: number;
-        y: number;
-    };
-    zPosition: number;
+    private _anchorPoint;
+    private _zPosition;
     private _text;
     private _fontName;
     private _fontNames;
@@ -3652,6 +4148,31 @@ declare class Label extends M2Node implements IDrawable, IText, LabelOptions {
      * @param options - {@link LabelOptions}
      */
     constructor(options?: LabelOptions);
+    get completeNodeOptions(): {
+        horizontalAlignmentMode: LabelHorizontalAlignmentMode;
+        preferredMaxLayoutWidth: number | undefined;
+        backgroundColor: RgbaColor | undefined;
+        fontNames: string[] | undefined;
+        text?: string;
+        fontName?: string;
+        fontColor?: RgbaColor;
+        fontSize?: number;
+        interpolation?: StringInterpolationMap;
+        localize?: boolean;
+        anchorPoint?: Point;
+        zPosition?: number;
+        name?: string;
+        position?: Point;
+        scale?: number;
+        alpha?: number;
+        zRotation?: number;
+        isUserInteractionEnabled?: boolean;
+        draggable?: boolean;
+        hidden?: boolean;
+        layout?: Layout;
+        uuid?: string;
+        suppressEvents?: boolean;
+    };
     initialize(): void;
     /**
      * Determines the M2Font objects that need to be ready in order to draw
@@ -3685,6 +4206,10 @@ declare class Label extends M2Node implements IDrawable, IText, LabelOptions {
     set backgroundColor(backgroundColor: RgbaColor | undefined);
     get localize(): boolean;
     set localize(localize: boolean);
+    get anchorPoint(): Point;
+    set anchorPoint(anchorPoint: Point);
+    get zPosition(): number;
+    set zPosition(zPosition: number);
     private get backgroundPaint();
     private set backgroundPaint(value);
     private get fontPaint();
@@ -3848,17 +4373,6 @@ declare class LegacyTimer {
     static exists(name: string): boolean;
 }
 
-/**
- * A collection of multi-color lines to draw.
- *
- * @remarks Unlike `M2Path`, this interface allows for lines of different
- * colors and widths to be drawn in the same path.
- */
-interface M2ColorfulPath extends M2Path {
-    /** Colors and widths of lines in the path. */
-    linePresentations: Array<LinePresentation>;
-}
-
 /** Base interface for all Plugin events. */
 interface PluginEvent extends M2Event<Plugin> {
     target: Plugin;
@@ -3906,21 +4420,6 @@ declare class RandomDraws {
     }>;
 }
 
-interface RectOptions {
-    /** Position of rectangle */
-    origin?: Point;
-    /** Size of rectangle */
-    size?: Size;
-    /** X coordinate of rectangle position; this can be used instead of setting the origin property */
-    x?: number;
-    /** Y coordinate of rectangle position; this can be used instead of setting the origin property */
-    y?: number;
-    /** Width of rectangle; this can be used instead of setting the size property */
-    width?: number;
-    /** Height of rectangle; this can be used instead of setting the size property */
-    height?: number;
-}
-
 declare enum ShapeType {
     Undefined = "Undefined",
     Rectangle = "Rectangle",
@@ -3928,20 +4427,6 @@ declare enum ShapeType {
     Path = "Path"
 }
 
-/**
- * A path created from an SVG string path.
- */
-interface SvgStringPath {
-    /** SVG string from which to create the path */
-    pathString?: string;
-    /** SVG string from which to create the path @deprecated Use `pathString` */
-    svgPathString?: string;
-    /** If provided, scale the SVG path to this height, and scale the width to keep the original SVG proportions */
-    height?: number;
-    /** If provided, scale the SVG path to this width, and scale the height to keep the original SVG proportions */
-    width?: number;
-}
-
 interface ShapeOptions extends M2NodeOptions, DrawableOptions {
     shapeType?: ShapeType;
     /** If provided, shape will be a circle with given radius */
@@ -3968,22 +4453,19 @@ declare class Shape extends M2Node implements IDrawable, ShapeOptions {
     readonly type = M2NodeType.Shape;
     isDrawable: boolean;
     isShape: boolean;
-    anchorPoint: {
-        x: number;
-        y: number;
-    };
-    zPosition: number;
+    private _anchorPoint;
+    private _zPosition;
     shapeType: ShapeType;
-    circleOfRadius?: number;
-    rect?: RectOptions;
-    path?: M2Path | M2ColorfulPath | SvgStringPath;
+    private _circleOfRadius?;
+    private _rect?;
+    private _path?;
     ckPath: Path | null;
     ckPathWidth?: number;
     ckPathHeight?: number;
-    cornerRadius: number;
+    private _cornerRadius;
     private _fillColor;
     private _strokeColor?;
-    lineWidth?: number;
+    private _lineWidth?;
     private _isAntialiased;
     private _fillColorPaintAntialiased?;
     private _strokeColorPaintAntialiased?;
@@ -4004,7 +4486,35 @@ declare class Shape extends M2Node implements IDrawable, ShapeOptions {
      * @param options - {@link ShapeOptions}
      */
     constructor(options?: ShapeOptions);
+    get completeNodeOptions(): {
+        circleOfRadius: number | undefined;
+        rect: RectOptions | undefined;
+        cornerRadius: number;
+        fillColor: RgbaColor;
+        strokeColor: RgbaColor | undefined;
+        lineWidth: number | undefined;
+        path: M2Path | M2ColorfulPath | SvgStringPath | undefined;
+        size: Size | undefined;
+        isAntialiased: boolean;
+        anchorPoint?: Point;
+        zPosition?: number;
+        name?: string;
+        position?: Point;
+        scale?: number;
+        alpha?: number;
+        zRotation?: number;
+        isUserInteractionEnabled?: boolean;
+        draggable?: boolean;
+        hidden?: boolean;
+        layout?: Layout;
+        uuid?: string;
+        suppressEvents?: boolean;
+    };
     initialize(): void;
+    get anchorPoint(): Point;
+    set anchorPoint(anchorPoint: Point);
+    get zPosition(): number;
+    set zPosition(zPosition: number);
     dispose(): void;
     /**
      * Duplicates a node using deep copy.
@@ -4042,6 +4552,16 @@ declare class Shape extends M2Node implements IDrawable, ShapeOptions {
     private warmupStrokedCircle;
     private warmupFilledRectangle;
     private warmupStrokedRectangle;
+    get circleOfRadius(): number | undefined;
+    set circleOfRadius(circleOfRadius: number | undefined);
+    get rect(): RectOptions | undefined;
+    set rect(rect: RectOptions | undefined);
+    get cornerRadius(): number;
+    set cornerRadius(cornerRadius: number | undefined);
+    get lineWidth(): number | undefined;
+    set lineWidth(lineWidth: number | undefined);
+    get path(): M2Path | M2ColorfulPath | SvgStringPath | undefined;
+    set path(path: M2Path | M2ColorfulPath | SvgStringPath | undefined);
     get fillColor(): RgbaColor;
     set fillColor(fillColor: RgbaColor);
     get strokeColor(): RgbaColor | undefined;
@@ -4191,11 +4711,8 @@ interface SpriteOptions extends M2NodeOptions, DrawableOptions {
 declare class Sprite extends M2Node implements IDrawable, SpriteOptions {
     readonly type = M2NodeType.Sprite;
     isDrawable: boolean;
-    anchorPoint: {
-        x: number;
-        y: number;
-    };
-    zPosition: number;
+    private _anchorPoint;
+    private _zPosition;
     private _imageName;
     private m2Image?;
     private _paint?;
@@ -4207,10 +4724,30 @@ declare class Sprite extends M2Node implements IDrawable, SpriteOptions {
      * @param options - {@link SpriteOptions}
      */
     constructor(options?: SpriteOptions);
+    get completeNodeOptions(): {
+        imageName: string;
+        anchorPoint?: Point;
+        zPosition?: number;
+        name?: string;
+        position?: Point;
+        scale?: number;
+        alpha?: number;
+        zRotation?: number;
+        isUserInteractionEnabled?: boolean;
+        draggable?: boolean;
+        hidden?: boolean;
+        layout?: Layout;
+        uuid?: string;
+        suppressEvents?: boolean;
+    };
     initialize(): void;
     dispose(): void;
-    set imageName(imageName: string);
     get imageName(): string;
+    set imageName(imageName: string);
+    get anchorPoint(): Point;
+    set anchorPoint(anchorPoint: Point);
+    get zPosition(): number;
+    set zPosition(zPosition: number);
     private set paint(value);
     private get paint();
     /**
@@ -4257,11 +4794,8 @@ declare class TextLine extends M2Node implements IDrawable, IText, TextLineOptio
     readonly type = M2NodeType.TextLine;
     isDrawable: boolean;
     isText: boolean;
-    zPosition: number;
-    anchorPoint: {
-        x: number;
-        y: number;
-    };
+    private _zPosition;
+    private _anchorPoint;
     private _text;
     private _fontName;
     private _fontColor;
@@ -4284,6 +4818,28 @@ declare class TextLine extends M2Node implements IDrawable, IText, TextLineOptio
      * @param options - {@link TextLineOptions}
      */
     constructor(options?: TextLineOptions);
+    get completeNodeOptions(): {
+        width: number;
+        text?: string;
+        fontName?: string;
+        fontColor?: RgbaColor;
+        fontSize?: number;
+        interpolation?: StringInterpolationMap;
+        localize?: boolean;
+        anchorPoint?: Point;
+        zPosition?: number;
+        name?: string;
+        position?: Point;
+        scale?: number;
+        alpha?: number;
+        zRotation?: number;
+        isUserInteractionEnabled?: boolean;
+        draggable?: boolean;
+        hidden?: boolean;
+        layout?: Layout;
+        uuid?: string;
+        suppressEvents?: boolean;
+    };
     initialize(): void;
     /**
      * Determines the M2Font object that needs to be ready in order to draw
@@ -4310,6 +4866,10 @@ declare class TextLine extends M2Node implements IDrawable, IText, TextLineOptio
     set interpolation(interpolation: StringInterpolationMap);
     get localize(): boolean;
     set localize(localize: boolean);
+    get anchorPoint(): Point;
+    set anchorPoint(anchorPoint: Point);
+    get zPosition(): number;
+    set zPosition(zPosition: number);
     dispose(): void;
     /**
      * Duplicates a node using deep copy.
@@ -4612,4 +5172,4 @@ declare class WebGlInfo {
     static dispose(): void;
 }
 
-export { Action, type Activity, type ActivityCallbacks, type ActivityEvent, type ActivityEventListener, type ActivityKeyValueData, type ActivityLifecycleEvent, type ActivityResultsEvent, ActivityType, type BrowserImage, type CallbackOptions, CanvasKitHelpers, ColorfulMutablePath, Composite, type CompositeOptions, Constants, ConstraintType, type Constraints, CustomAction, type CustomActionOptions, type DefaultParameter, Dimensions, type DrawableOptions, type EasingFunction, Easings, Equals, FadeAlphaAction, type FadeAlphaActionOptions, type FontAsset, type FontData, FontManager, Game, type GameData, type GameEvent, type GameOptions, type GameParameters, GlobalVariables, GroupAction, I18n, type IDataStore, type IDrawable, type IText, ImageManager, Label, LabelHorizontalAlignmentMode, type LabelOptions, type Layout, LayoutConstraint, LegacyTimer, type LocaleSvg, type M2ColorfulPath, type M2DragEvent, type M2Event, type M2EventListener, M2EventType, type M2Image, M2ImageStatus, M2Node, type M2NodeEvent, type M2NodeEventListener, type M2NodeOptions, M2NodeType, type M2Path, type M2PointerEvent, type M2Sound, M2SoundStatus, M2c2KitHelpers, MoveAction, type MoveActionOptions, MutablePath, NoneTransition, PlayAction, type PlayActionOptions, type Plugin, type PluginEvent, type Point, RandomDraws, type RectOptions, RepeatAction, RepeatForeverAction, type RgbaColor, RotateAction, ScaleAction, type ScaleActionOptions, Scene, type SceneOptions, SceneTransition, SequenceAction, Shape, type ShapeOptions, ShapeType, type Size, SlideTransition, type SlideTransitionOptions, type SoundAsset, SoundManager, SoundPlayer, type SoundPlayerOptions, SoundRecorder, type SoundRecorderOptions, type SoundRecorderResults, Sprite, type SpriteOptions, Story, type StoryOptions, type StringInterpolationMap, type TapEvent, type TextAndFont, TextLine, type TextLineOptions, type TextLocalizationResult, type TextOptions, type TextWithFontCustomization, Timer, Transition, TransitionDirection, TransitionType, type Translation, type TranslationConfiguration, type TranslationOptions, type TrialData, type TrialSchema, Uuid, WaitAction, type WaitActionOptions, WebColors, WebGlInfo, handleInterfaceOptions };
+export { Action, type Activity, type ActivityCallbacks, type ActivityEvent, type ActivityEventListener, type ActivityKeyValueData, type ActivityLifecycleEvent, type ActivityResultsEvent, ActivityType, type BrowserImage, type BrowserImageDataReadyEvent, type CallbackOptions, CanvasKitHelpers, ColorfulMutablePath, Composite, type CompositeEvent, type CompositeOptions, Constants, ConstraintType, type Constraints, CustomAction, type CustomActionOptions, type DefaultParameter, Dimensions, type DomPointerDownEvent, type DrawableOptions, type EasingFunction, Easings, Equal, Equals, EventStore, EventStoreMode, FadeAlphaAction, type FadeAlphaActionOptions, type FontAsset, type FontData, FontManager, Game, type GameData, type GameEvent, type GameOptions, type GameParameters, type GlobalVariables, GroupAction, I18n, type I18nDataReadyEvent, type IDataStore, type IDrawable, type IText, ImageManager, Label, LabelHorizontalAlignmentMode, type LabelOptions, type Layout, LayoutConstraint, LegacyTimer, type LocaleSvg, type M2ColorfulPath, type M2DragEvent, type M2Event, type M2EventListener, M2EventType, type M2Image, M2ImageStatus, M2Node, type M2NodeAddChildEvent, type M2NodeConstructor, type M2NodeEvent, type M2NodeEventListener, M2NodeFactory, type M2NodeNewEvent, type M2NodeOptions, type M2NodePropertyChangeEvent, type M2NodeRemoveChildEvent, M2NodeType, type M2Path, type M2PointerEvent, type M2Sound, M2SoundStatus, M2c2KitHelpers, MoveAction, type MoveActionOptions, MutablePath, NoneTransition, PlayAction, type PlayActionOptions, type Plugin, type PluginEvent, type Point, RandomDraws, type RectOptions, RepeatAction, RepeatForeverAction, type RgbaColor, RotateAction, ScaleAction, type ScaleActionOptions, Scene, type SceneOptions, type ScenePresentEvent, SceneTransition, SequenceAction, Shape, type ShapeOptions, ShapeType, type Size, SlideTransition, type SlideTransitionOptions, type SoundAsset, SoundManager, SoundPlayer, type SoundPlayerOptions, SoundRecorder, type SoundRecorderOptions, type SoundRecorderResults, Sprite, type SpriteOptions, Story, type StoryOptions, type StringInterpolationMap, type TapEvent, type TextAndFont, TextLine, type TextLineOptions, type TextLocalizationResult, type TextOptions, type TextWithFontCustomization, Timer, Transition, TransitionDirection, TransitionType, type Translation, type TranslationConfiguration, type TranslationOptions, type TrialData, type TrialSchema, Uuid, WaitAction, type WaitActionOptions, WebColors, WebGlInfo, handleInterfaceOptions };