@m2c2kit/core 0.3.17 → 0.3.19

package/dist/index.d.ts

@@ -1,87 +1,4 @@
-import { Canvas, Typeface, TypefaceFontProvider, Image, CanvasKit, Surface, Font, Paint, 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;
-}
+import { Canvas, Typeface, TypefaceFontProvider, Image, Paint, CanvasKit, Surface, Font, ParagraphBuilder, Paragraph, FontMgr, Path, PaintStyle } from 'canvaskit-wasm';
 
 /**
  * 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,32 +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];
-
-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;
-}
-
-/**
- * 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;
@@ -215,208 +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"
-}
-
-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.
-     *
-     * @param options - {@link SceneOptions}
-     */
-    constructor(options?: SceneOptions);
-    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);
-    /**
-     * 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;
-    /**
-     * 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 options - {@link SlideTransitionOptions}
-     * @returns
-     */
-    static slide(options: SlideTransitionOptions): SlideTransition;
-    /**
-     * Creates a scene transition with no animation or duration. The next scene is immediately drawn.
-     */
-    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);
+     * Base Drawable object for creating custom nodes ("composites") composed of primitive nodes.
+     *
+     * @param options
+     */
+    constructor(options?: CompositeOptions);
+    initialize(): void;
+    get anchorPoint(): Point;
+    set anchorPoint(anchorPoint: Point);
+    get zPosition(): number;
+    set zPosition(zPosition: number);
+    dispose(): void;
+    update(): void;
+    draw(canvas: Canvas): void;
+    abstract warmup(canvas: Canvas): void;
+    /**
+     * Event handler for custom events a `Composite` may generate.
+     *
+     * @remarks If the `Composite` generates custom events, this method is
+     * necessary for the `Composite` to work in replay mode.
+     *
+     * @param event - event to handle
+     */
+    handleCompositeEvent(event: CompositeEvent): void;
 }
 
 /** Base interface for all Activity events. */
@@ -551,19 +282,26 @@ interface IDataStore {
     /** Sets the value of an item. The key will be saved to the store as provided;
      * if namespacing or other formatting is desired, it must be done before
      * calling this method. activityId can be used by the store for indexing. */
-    setItem(key: string, value: string | number | boolean | object | undefined | null, activityId: string): Promise<string>;
+    setItem(key: string, value: string | number | boolean | object | undefined | null, activityPublishUuid: string): Promise<string>;
     /** Gets the value of an item by its key. */
     getItem<T extends string | number | boolean | object | undefined | null>(key: string): Promise<T>;
     /** Deletes an item by its key. */
     deleteItem(key: string): Promise<void>;
     /** Deletes all items. */
-    clearItemsByActivityId(activityId: string): Promise<void>;
+    clearItemsByActivityPublishUuid(activityPublishUuid: string): Promise<void>;
     /** Returns keys of all items. */
-    itemsKeysByActivityId(activityId: string): Promise<string[]>;
+    itemsKeysByActivityPublishUuid(activityPublishUuid: string): Promise<string[]>;
     /** Determines if the key exists. */
     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;
@@ -621,14 +359,20 @@ interface Activity {
      * @param options - options for the callback.
      */
     onData(callback: (activityResultsEvent: ActivityResultsEvent) => void, options?: CallbackOptions): void;
-    /** The activity's parent session unique identifier. */
+    /** The activity's parent session unique identifier. This is newly generated each session. */
     sessionUuid: string;
-    /** The activity's unique identifier. NOTE: This is newly generated each session. The uuid for an activity will vary across sessions. */
+    /** 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 */
@@ -641,6 +385,207 @@ interface Activity {
     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}
+     */
+    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;
+    /**
+     * 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 options - {@link SlideTransitionOptions}
+     * @returns
+     */
+    static slide(options: SlideTransitionOptions): SlideTransition;
+    /**
+     * Creates a scene transition with no animation or duration. The next scene is immediately drawn.
+     */
+    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);
+}
+
 /**
  * Image that can be rendered by a browser from a URL or from a
  * HTML svg tag in string form. Provide either url or svgString, not both.
@@ -658,10 +603,16 @@ 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 localized images or large "banks"
-     * of images. These should be lazy loaded because they may not be needed. */
+     * is false. Lazy loading is useful for large "banks" of images. These should
+     * be lazy loaded because they may not be needed. */
     lazy?: boolean;
+    /** If true, try to use a localized version of the image. Localized images
+     * are loaded on demand and are not preloaded. Only an image whose asset
+     * is provided as a URL can be localized. Default is false. */
+    localize?: boolean;
 }
 
 /**
@@ -690,78 +641,250 @@ interface DefaultParameter extends JsonSchema {
 }
 
 /**
- * Translations is a map of a locale to a map of keys to translations.
+ * Font url and raw data that has been shared with other games in the session.
+ *
+ * @remarks Font sharing will happen only if the font filename is the same AND
+ * a game's `shareAssets` property is not false.
+ */
+interface SharedFont {
+    /** url that the shared font was loaded from */
+    url: string;
+    /** raw data of the shared font */
+    data: ArrayBuffer;
+}
+
+/**
+ * Font asset to use in the game.
+ */
+interface FontAsset {
+    /** Name of the font to use when referring to it within m2c2kit */
+    fontName: string;
+    /** URL of font (TrueType font) to load */
+    url: string;
+    /** If true, the font will not be fully loaded until it is needed. Default
+     * is false. Lazy loading is useful for fonts involved in localization.
+     * These should be lazy loaded because they may not be needed.
+     */
+    lazy?: boolean;
+    /** Font url and raw data that has been shared with other games in the session. Undefined if this font was not shared. @internal For m2c2kit library use only */
+    sharedFont?: SharedFont;
+}
+
+/**
+ * Game's module name, version, and dependencies.
+ */
+interface ModuleMetadata {
+    /** name property from package.json */
+    name: string;
+    /** version property from package.json */
+    version: string;
+    /** dependency property from package.json */
+    dependencies: {
+        [key: string]: string;
+    };
+}
+
+interface SoundAsset {
+    /** Name of the sound to use when referring to it within m2c2kit, such as
+     * when creating a `SoundPlayer` node. */
+    soundName: string;
+    /** URL of sound to load */
+    url: string;
+    /** If true, the sound will not be fully loaded until it is needed. Default
+     * is false. Lazy loading is useful for sounds involved in localization.
+     * These should be lazy loaded because they may not be needed.
+     */
+    lazy?: boolean;
+}
+
+/**
+ * A map of a locale to a map of keys to translated text and font information.
+ *
+ * @remarks When it comes to fonts, the `Translation` object only specifies
+ * which fonts to use for text. The actual fonts must be provided as part of
+ * the `GameOptions` object with names that match the names specified in the
+ * `Translation` object.
+ *
+ * The below example defines a translation object for use in three locales:
+ * en-US, es-MX, and hi-IN.
+ *
+ * In the `configuration` object, the `baseLocale` property is en-US. This
+ * means that the en-US locale is the locale from which the "native"
+ * resources originate.
+ *
+ * The property `localeName` is human-readable text of the locale that can
+ * be displayed to the user. For example, `en-US` might have the locale name
+ * `English`. The property `localeSvg` is an image of the locale, as an SVG
+ * string and its height and width. This is so the locale can be displayed to
+ * the user if the locale uses a script that is not supported in the default
+ * font, and a locale-specific font is not yet loaded.
+ *
+ * For en-US and es-MX, the game's default font will be used for all text
+ * because the `fontName` property is not specified for these locales. For
+ * hi-IN, the `devanagari` font will be used for all text.
+ *
+ * `EMOJI_WELCOME` uses an emoji, and it will not display properly unless an
+ * `emoji` font is added. The `additionalFontName` property is used to
+ * specify an additional font or fonts to use as well as the locale's font.
+ * For en-US and es-MX, the `emoji` font plus the game's default font will be
+ * used for the `EMOJI_WELCOME` text. For hi-IN, the `emoji` font plus the
+ * `devanagari` font will be used for the `EMOJI_WELCOME` text.
+ *
+ * `OK_BUTTON` uses the game's default font for all locales. Because hi-IN
+ * specified a font name, the `overrideFontName` property with a value of
+ * `default` is used to specify that the game's default font should be used
+ * instead of the locale's font, devanagari.
+ *
+ * `BYE` uses interpolation. `{{name}}` is a placeholder that will be replaced,
+ * at runtime, with the value of the `name` key in the `options` object passed
+ * to the `t` or `tf` methods of the `I18n` object. If the placeholder is not
+ * found in `options`, an error will be thrown.
  *
  * @example
+ *
  * ```
- * const translations: Translations = {
+ * const translation: Translation = {
+ *   "configuration": {
+ *    "baseLocale": "en-US"
+ *   },
  *   "en-US": {
+ *     localeName: "English",
  *     "NEXT_BUTTON": "Next"
+ *     "EMOJI_WELCOME": {
+ *       text: "👋 Hello",
+ *       additionalFontName: ["emoji"]
+ *     },
+ *     "OK_BUTTON": "OK",
+ *     "BYE": "Goodbye, {{name}}."
  *   },
  *   "es-MX": {
+ *     localeName: "Español",
  *     "NEXT_BUTTON": "Siguiente"
+ *     "EMOJI_WELCOME": {
+ *       text: "👋 Hola",
+ *       additionalFontName: ["emoji"]
+ *     },
+ *     "OK_BUTTON": "OK",
+ *     "BYE": "Adiós, {{name}}."
+ *   },
+ *   "hi-IN": {
+ *     localeName: "Hindi",
+ *     localeSvg: {
+ *       // from https://commons.wikimedia.org/wiki/File:Hindi.svg, not copyrighted
+ *       // note: To save space, the next line is not the full, working SVG string from the above URL.
+ *       svgString: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 304 168" xml:space="preserve"><path d="m45.223..."/></svg>`,
+ *       height: 44,
+ *       width: 80,
+ *     },
+ *     fontName: "devanagari",
+ *     "NEXT_BUTTON": "अगला"
+ *     "EMOJI_WELCOME": {
+ *       text: "👋 नमस्कार",
+ *       additionalFontName: ["emoji"]
+ *     },
+ *     "OK_BUTTON": {
+ *       text: "OK",
+ *       overrideFontName: "default"
+ *     },
+ *    "BYE": "अलविदा {{name}}."
  *   }
  * }
+ *
+ * ...
+ *
+ * const nextButton = new Button({
+ *  text: "NEXT_BUTTON"
+ *  ...
+ * })
+ *
+ * const byeLabel = new Label({
+ *  text: "BYE",
+ *  interpolation: {
+ *    name: "Alice"
+ *  }
+ *  ...
+ * }
  * ```
  */
-interface Translations {
+type Translation = LocaleTranslationMap & {
+    configuration?: TranslationConfiguration;
+};
+interface TranslationConfiguration {
+    /** The locale from which translations and adaptations are made to adjust to different regions and languages. This is the locale from which the base or unlocalized resources originate. */
+    baseLocale: string;
+}
+interface LocaleSvg {
+    /** The HTML SVG tag, in string form, that will be rendered and loaded.
+     * Must begin with &#60;svg> and end with &#60;/svg> */
+    svgString: string;
+    /** Height to scale image to */
+    height: number;
+    /** Width to scale image to */
+    width: number;
+}
+type LocaleTranslationMap = {
     [locale: string]: {
-        [key: string]: string;
+        /** The font name or names to use for all text in the locale. If omitted,
+         * the game's default font will be used. */
+        fontName?: string | string[];
+        /** Human-readable text of the locale that can be displayed to the user. For example, `en-US` might have the locale name `English` */
+        localeName?: string;
+        /** Image of the locale, as an SVG string, that can be displayed to the user. Some locales, in their native script, might not be supported in the default font. For example, Hindi script cannot be displayed in Roboto font. It would be inefficient to load all the possible extra fonts simply to display the locale to the user. Thus, in lieu of a string, the locale can be displayed to the user as an SVG. Only if that locale is selected, the font supporting that locale will be loaded. */
+        localeSvg?: LocaleSvg;
+    } & {
+        /** The translated text or the translated text with custom font information. Note: `LocaleSvg` is included in the union only to satisfy TypeScript compiler. */
+        [key: string]: string | TextWithFontCustomization | LocaleSvg;
     };
-}
-
+};
 /**
- * Font url and raw data that has been shared with other games in the session.
- *
- * @remarks Font sharing will happen only if the font filename is the same AND
- * a game's `shareAssets` property is not false.
+ * A translated string with custom font information to be applied only to this
+ * string.
  */
-interface SharedFont {
-    /** url that the shared font was loaded from */
-    url: string;
-    /** raw data of the shared font */
-    data: ArrayBuffer;
+interface TextWithFontCustomization {
+    /** The translated string. */
+    text: string;
+    /** Font name(s) to _add to_ the locale's font name(s) when displaying text. */
+    additionalFontName?: string | Array<string>;
+    /** Font name(s) to use _in place of_ the locale's font name(s) when
+     * displaying text. Use `default` to indicate that the game's default font
+     * should be used instead of the locale's font names(s) */
+    overrideFontName?: string | Array<string>;
 }
-
-/**
- * Font asset to use in the game.
- */
-interface FontAsset {
-    /** Name of the font to use when referring to it within m2c2kit */
-    fontName: string;
-    /** URL of font (TrueType font) to load */
-    url: string;
-    /** If true, the font will not be fully loaded until it is needed. Default
-     * is false. Lazy loading is useful for fonts involved in localization.
-     * These should be lazy loaded because they may not be needed.
-     */
-    lazy?: boolean;
-    /** Font url and raw data that has been shared with other games in the session. Undefined if this font was not shared. @internal For m2c2kit library use only */
-    sharedFont?: SharedFont;
+interface TextAndFont {
+    /** The translated string. */
+    text?: string;
+    /** Font name to use when displaying the text. */
+    fontName?: string;
+    /** Font names to use when displaying the text. */
+    fontNames?: Array<string>;
 }
 
 /**
- * Game's module name, version, and dependencies.
+ * Localization information that is passed to the I18n constructor.
  */
-interface ModuleMetadata {
-    /** name property from package.json */
-    name: string;
-    /** version property from package.json */
-    version: string;
-    /** dependency property from package.json */
-    dependencies: {
-        [key: string]: string;
-    };
+interface LocalizationOptions {
+    /** Locale to use for localization when running the game, or "auto" to request from the environment. */
+    locale?: string;
+    /** Locale to use if requested locale translation is not available, or if "auto" locale was requested and environment cannot provide a locale. Default is `en-US`.*/
+    fallbackLocale?: string;
+    /** Font color for strings or outline color for images when a requested locale's translation or image is missing. This is useful in development to call attention to missing localization assets. */
+    missingLocalizationColor?: RgbaColor;
+    /** Translation for localization. */
+    translation?: Translation;
+    /** Additional translation for localization. This will typically be provided through `setParameters()` at runtime. This translation be merged into the existing translation and will overwrite any existing translation with the same key-value pairs. Thus, this can be used to modify an existing translation, either in whole or in part. */
+    additionalTranslation?: Translation;
 }
 
 /**
  * Options to specify HTML canvas, set game canvas size, and load game assets.
  */
-interface GameOptions {
+interface GameOptions extends LocalizationOptions {
     /** Human-friendly name of this game */
     name: string;
-    /** Short identifier of this game; unique among published games and url-friendly (no spaces, special characters, or slashes)*/
+    /** Short identifier of this game; unique among published games and url-friendly (no spaces, special characters, or slashes). */
     id: string;
+    /** Persistent unique identifier (UUID) of this game; unique among published games. The m2c2kit CLI will generate this property automatically, and you should not change it. If not using the CLI, use a website like https://www.uuidgenerator.net/version4 to generate this value. */
+    publishUuid: string;
     /** Version of this game */
     version: string;
     /** Uri (repository, webpage, or other location where full information about the game can be found) */
@@ -786,6 +909,8 @@ interface GameOptions {
     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 */
@@ -796,8 +921,10 @@ interface GameOptions {
     fpsMetricReportThreshold?: number;
     /** Advance through time step-by-step, for development and debugging */
     timeStepping?: boolean;
-    /** Translations for localization. */
-    translations?: Translations;
+    /** 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. */
@@ -810,37 +937,6 @@ interface GameData extends ActivityKeyValueData {
     trials: Array<TrialData>;
 }
 
-/**
- * Localization information that is passed to the I18n constructor.
- */
-interface LocalizationOptions {
-    /** Locale to use for localization, or "auto" to request from the environment. */
-    locale: string;
-    /** Locale to use if requested locale translation is not available, or if "auto" locale was requested and environment cannot provide a locale. */
-    fallbackLocale?: string;
-    /** Font color for strings that are missing translation and use the fallback locale or untranslated string. */
-    missingTranslationFontColor?: RgbaColor;
-    /** Translations for localization. */
-    translations?: Translations;
-    /** Additional translations for localization provided through game parameters. These will be merged into existing translations. */
-    additionalTranslations?: Translations;
-}
-
-declare class I18n {
-    private _translations;
-    locale: string;
-    fallbackLocale: string;
-    private environmentLocale;
-    options: LocalizationOptions;
-    static makeLocalizationParameters(): GameParameters;
-    constructor(options: LocalizationOptions);
-    t(key: string, useFallback?: boolean): string | undefined;
-    get translations(): Translations;
-    set translations(value: Translations);
-    private getEnvironmentLocale;
-    private mergeAdditionalTranslations;
-}
-
 /**
  * A Plugin is code that can be registered to run at certain points in the game loop.
  */
@@ -995,13 +1091,26 @@ declare class FontManager {
  * additional properties.
  */
 interface M2Image {
+    /** Name of the image, as it will be referred to when creating a sprite. */
     imageName: string;
+    /** The image in CanvasKit format. */
     canvaskitImage: Image | undefined;
     width: number;
     height: number;
+    /** Status of the image: Deferred, Loading, Ready, or Error. */
     status: M2ImageStatus;
+    /** For an image that will be fetched, this is the URL that will be attempted. This may have localization applied. */
     url?: string;
+    /** Is this image a fallback localized image? */
+    isFallback: boolean;
+    /** For an image that will be fetched, the original URL before any localization. */
+    originalUrl?: string;
+    /** For a localized image that will be fetched, additional URLs to try if the URL in `url` fails. */
+    fallbackLocalizationUrls?: Array<string>;
+    /** An image defined by an SVG string. */
     svgString?: string;
+    /** Try to localize the image by fetching a locale-specific image? Default is false. */
+    localize: boolean;
 }
 declare const M2ImageStatus: {
     /** Image was set for lazy loading, and loading has not yet been requested. */
@@ -1026,6 +1135,7 @@ declare class ImageManager {
     private scale?;
     private game;
     private baseUrls;
+    missingLocalizationImagePaint?: Paint;
     constructor(game: Game, baseUrls: GameBaseUrls);
     /**
      * Loads image assets and makes them ready to use during the game initialization.
@@ -1051,6 +1161,25 @@ declare class ImageManager {
      * @returns A promise that completes when all images have loaded
      */
     loadImages(browserImages: Array<BrowserImage>): Promise<void>;
+    private configureImageLocalization;
+    /**
+     * Localizes the image URL by appending the locale to the image URL,
+     * immediately before the file extension.
+     *
+     * @remarks For example, `https://url.com/file.png` in en-US locale
+     * becomes `https://url.com/file.en-US.png`. A URL without an extension
+     * will throw an error.
+     *
+     * @param url - url of the image
+     * @param locale - locale in format of xx-YY, where xx is the language code
+     * and YY is the country code
+     * @returns localized url
+     */
+    private localizeImageUrl;
+    /**
+     * Sets an image to be re-rendered within the current locale.
+     */
+    reinitializeLocalizedImages(): void;
     private checkImageNamesForDuplicates;
     /**
      * Makes ready to the game a m2c2kit image ({@link M2Image}) that was
@@ -1113,6 +1242,142 @@ declare class ImageManager {
     private removeScratchCanvas;
 }
 
+interface M2Sound {
+    soundName: string;
+    data: ArrayBuffer | undefined;
+    audioBuffer: AudioBuffer | undefined;
+    url: string;
+    status: M2SoundStatus;
+}
+declare const M2SoundStatus: {
+    /** Sound was set for lazy loading, and loading has not yet been requested. */
+    readonly Deferred: "Deferred";
+    /** Sound is indicated for fetching, but fetching has not begun. */
+    readonly WillFetch: "WillFetch";
+    /** Sound is being fetched. */
+    readonly Fetching: "Fetching";
+    /** Sound has been fetched. */
+    readonly Fetched: "Fetched";
+    /** Sound is being decoded. */
+    readonly Decoding: "Decoding";
+    /** Sound has fully finished loading and is ready to use. */
+    readonly Ready: "Ready";
+    /** Error occurred in loading. */
+    readonly Error: "Error";
+};
+type M2SoundStatus = (typeof M2SoundStatus)[keyof typeof M2SoundStatus];
+
+/**
+ * Fetches, loads, and provides sounds to the game.
+ *
+ * @internal For m2c2kit library use only
+ */
+declare class SoundManager {
+    private sounds;
+    private game;
+    private baseUrls;
+    private _audioContext?;
+    constructor(game: Game, baseUrls: GameBaseUrls);
+    get audioContext(): AudioContext;
+    /**
+     * Loads sound assets during the game initialization.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @remarks Typically, a user won't call this because the m2c2kit
+     * framework will call this automatically. At initialization, sounds can
+     * only be fetched, not decoded because the AudioContext can not yet
+     * be created (it requires a user interaction).
+     *
+     * @param soundAssets - array of SoundAsset objects
+     */
+    initializeSounds(soundAssets: Array<SoundAsset> | undefined): Promise<void>;
+    /**
+     * Loads an array of sound assets and makes them ready for the game.
+     *
+     * @remarks Loading a sound consists of 1) fetching the sound file and 2)
+     * decoding the sound data. The sound is then ready to be played. Step 1
+     * can be done at any time, but step 2 requires an `AudioContext`, which
+     * can only be created after a user interaction. If a play `Action` is
+     * attempted before the sound is ready (either it has not been fetched or
+     * decoded), the play `Action` will log a warning to the console and the
+     * loading process will continue in the background, and the sound will play
+     * when ready. This `loadSounds()` method **does not** have to be awaited.
+     *
+     * @param soundAssets - an array of {@link SoundAsset}
+     * @returns A promise that completes when all sounds have loaded
+     */
+    loadSounds(soundAssets: Array<SoundAsset>): Promise<void>;
+    private fetchSounds;
+    /**
+     * Fetches a m2c2kit sound ({@link M2Sound}) that was previously
+     * initialized with lazy loading.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @param m2Sound - M2Sound to fetch
+     * @returns A promise that completes when sounds have been fetched
+     */
+    fetchDeferredSound(m2Sound: M2Sound): Promise<void>;
+    /**
+     * Checks if the SoundManager has sounds needing decoding.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @returns true if there are sounds that have been fetched and are waiting
+     * to be decoded (status is `M2SoundStatus.Fetched`)
+     */
+    hasSoundsToDecode(): boolean;
+    /**
+     * Decodes all fetched sounds from bytes to an `AudioBuffer`.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @remarks This method will be called after the `AudioContext` has been
+     * created and if there are fetched sounds waiting to be decoded.
+     *
+     * @returns A promise that completes when all fetched sounds have been decoded
+     */
+    decodeFetchedSounds(): Promise<void[]>;
+    /**
+     * Decodes a sound from bytes to an `AudioBuffer`.
+     *
+     * @param sound - sound to decode
+     */
+    private decodeSound;
+    /**
+     * Returns a m2c2kit sound ({@link M2Sound}) that has been entered into the
+     * SoundManager.
+     *
+     * @internal For m2c2kit library use only
+     *
+     * @remarks Typically, a user won't need to call this because sound
+     * initialization and processing is handled by the framework.
+     *
+     * @param soundName - sound's name as defined in the game's sound assets
+     * @returns a m2c2kit sound
+     */
+    getSound(soundName: string): M2Sound;
+    /**
+     * Frees up resources allocated by the SoundManager.
+     *
+     * @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;
+    /**
+     * Gets names of sounds entered in the `SoundManager`.
+     *
+     * @remarks These are sounds that the `SoundManager` is aware of. The sounds
+     * may not be ready to play (may not have been fetched or decoded yet).
+     *
+     * @returns array of sound names
+     */
+    getSoundNames(): Array<string>;
+}
+
 /** Key value pairs of file URLs and hashed file URLs */
 type Manifest = {
     [originalUrl: string]: string;
@@ -1123,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;
 }
@@ -1133,6 +1491,9 @@ declare class Game implements Activity {
     uuid: string;
     name: string;
     id: string;
+    publishUuid: string;
+    studyId?: string;
+    studyUuid?: string;
     moduleMetadata: ModuleMetadata;
     readonly canvasKitWasmVersion = "__CANVASKITWASM_VERSION__";
     options: GameOptions;
@@ -1155,13 +1516,20 @@ declare class Game implements Activity {
     };
     private _fontManager?;
     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>;
@@ -1187,6 +1555,7 @@ declare class Game implements Activity {
      * @returns base URLs for game assets and CanvasKit wasm binary
      */
     resolveGameBaseUrls(game: Game): Promise<GameBaseUrls>;
+    private configureI18n;
     initialize(): Promise<void>;
     /**
      * Returns the manifest, if manifest.json was created during the build.
@@ -1205,6 +1574,24 @@ declare class Game implements Activity {
     set fontManager(fontManager: FontManager);
     get imageManager(): ImageManager;
     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.
+     *
+     * @remarks When a value is saved to the key-value data store, the key must
+     * be prefixed with additional information to ensure that keys are unique.
+     * The prefixes will include the activity id and publish UUID, and possibly
+     * the study id and study UUID, if they are set (this is so that keys are
+     * unique across different studies that might use the same activity).
+     *
+     * @param key - item key to add prefixes to
+     * @returns the item key with prefixes added
+     */
+    private addPrefixesToKey;
     /**
      * Saves an item to the activity's key-value store.
      *
@@ -1308,6 +1695,7 @@ declare class Game implements Activity {
     storeItemExists(key: string, globalStore?: boolean): Promise<boolean>;
     get dataStores(): IDataStore[];
     set dataStores(dataStores: IDataStore[]);
+    hasDataStores(): boolean;
     private getLocalizationOptionsFromGameParameters;
     private isLocalizationRequested;
     setParameters(additionalParameters: unknown): void;
@@ -1322,7 +1710,7 @@ declare class Game implements Activity {
     surface?: Surface;
     private showFps?;
     private bodyBackgroundColor?;
-    private currentScene?;
+    currentScene?: Scene;
     private priorUpdateTime?;
     private fpsTextFont?;
     private fpsTextPaint?;
@@ -1337,7 +1725,7 @@ declare class Game implements Activity {
     canvasCssWidth: number;
     canvasCssHeight: number;
     scenes: Scene[];
-    private freeNodesScene;
+    freeNodesScene: Scene;
     private incomingSceneTransitions;
     private currentSceneSnapshot?;
     private pendingScreenshot?;
@@ -1399,6 +1787,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.
      *
@@ -1414,10 +1815,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.
@@ -1456,6 +1857,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;
@@ -1627,7 +2033,23 @@ declare class Game implements Activity {
      * @param plugin - Plugin to register
      */
     registerPlugin(plugin: Plugin): Promise<void>;
+    /**
+     * Updates active scenes and executes plugins.
+     *
+     */
     private update;
+    /**
+     * Updates all active scenes and their children.
+     */
+    private updateScenes;
+    /**
+     * Executes all active plugins before scenes are updated.
+     */
+    private executeBeforeUpdatePlugins;
+    /**
+     * Executes all active plugins after scenes have been updated.
+     */
+    private executeAfterUpdatePlugins;
     private draw;
     private calculateFps;
     private takeCurrentSceneSnapshot;
@@ -1765,6 +2187,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.
  *
@@ -1784,31 +2526,36 @@ 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;
-    isUserInteractionEnabled: boolean;
-    draggable: boolean;
-    hidden: boolean;
+    protected _isUserInteractionEnabled: 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;
     actions: Action[];
     queuedAction?: Action;
-    originalActions: Action[];
     eventListeners: M2NodeEventListener<M2NodeEvent>[];
     readonly uuid: string;
     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;
@@ -1829,6 +2576,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.
      *
@@ -1855,6 +2624,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.
      */
@@ -2086,12 +2864,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
@@ -2155,8 +2945,27 @@ interface RotateActionOptions {
     runDuringTransition?: boolean;
 }
 
-interface IActionContainer {
-    children?: Array<Action>;
+interface PlayActionOptions {
+    /** Should the action run during screen transitions? Default is no */
+    runDuringTransition?: boolean;
+}
+
+/**
+ * An ActionContainer is an Action that can contain other actions.
+ *
+ * @remarks An ActionContainer is a parent action that can have other
+ * actions as children. The `Sequence`, `Group`, `Repeat,` and
+ * `RepeatForever` actions implement `ActionContainer`.
+ */
+interface ActionContainer extends Action {
+    /**
+     * Immediate children of a parent action.
+     */
+    children: Array<Action>;
+    /**
+     * All children of a parent action and those children's children, recursively.
+     */
+    descendants: Array<Action>;
 }
 
 /** The type of action */
@@ -2168,7 +2977,140 @@ declare enum ActionType {
     Move = "Move",
     Scale = "Scale",
     FadeAlpha = "FadeAlpha",
-    Rotate = "Rotate"
+    Rotate = "Rotate",
+    Play = "Play",
+    Repeat = "Repeat",
+    RepeatForever = "RepeatForever"
+}
+
+/**
+ * A class for for working with numeric values that may be currently unknown,
+ * but may be known in the future.
+ *
+ * @remarks Most m2c2kit actions have a known duration, such as waiting for a
+ * given duration or moving a node to a specific position across a specific
+ * duration: the duration is explicitly provided when the `Action` is created.
+ * However, some actions have a duration that is not known when the `Action` is
+ * created, but it will be known in the future. So far, the only action that
+ * requires this is the `play` action. In the browser, a sound file cannot be
+ * decoded by the `AudioContext` interface (which will calculate the duration)
+ * until the user has interacted with the page, which could be after the
+ * `Action` has been created. This is a problem because a `sequence` action
+ * needs to know the duration of all its children in order to calculate its own
+ * duration and when each of the child actions will start. To solve this
+ * problem, the `Futurable` class is a simple implementation of the Composite
+ * pattern that allows for the creation of a numeric value that may be known in
+ * the future. If a value is not known at creation time, it is represented by
+ * `Infinity`. The `Futurable` class supports addition and subtraction of
+ * another `Futurable` and numbers. When the numeric value of a `Futurable` is
+ * requested, it evaluates the expression and returns the numeric value. If any
+ * of the terms in the expression is a `Futurable`, it will recursively
+ * evaluate them. If any of the terms are unknown (represented by `Infinity`),
+ * it will return `Infinity`. If a previous unknown value becomes known, any
+ * other `Futurable` that depends on it will also become known.
+ */
+declare class Futurable {
+    /** The numbers, operators, and other Futurables that represent a value. */
+    private expression;
+    /** Log a warning to console if a expression is this length. */
+    private readonly WARNING_EXPRESSION_LENGTH;
+    constructor(value?: Futurable | number);
+    /**
+     * Appends a number or another Futurable to this Futurable's expression.
+     *
+     * @remarks This method does a simple array push, but checks the length of
+     * the expression array and warns if it gets "too long." This may indicate
+     * a logic error, unintended recursion, etc. because our use cases will
+     * likely not have expressions that are longer than
+     * `Futural.WARNING_EXPRESSION_LENGTH` elements.
+     *
+     * @param value - value to add to the expression.
+     */
+    private pushToExpression;
+    /**
+     * Assigns a value, either known or Futurable, to this Futurable.
+     *
+     * @remarks This method clears the current expression.
+     *
+     * @param value - value to assign to this Futurable.
+     */
+    assign(value: number | Futurable): void;
+    /**
+     * Performs addition on this Futurable.
+     *
+     * @remarks This method modifies the Futurable by adding the term(s) to the
+     * Futurable's expression.
+     *
+     * @param terms - terms to add to this Futurable.
+     * @returns the modified Futurable.
+     */
+    add(...terms: Array<Futurable | number>): this;
+    /**
+     * Performs subtraction on this Futurable.
+     *
+     * @remarks This method modifies the Futurable by subtracting the term(s)
+     * from the Futurable's expression.
+     *
+     * @param terms - terms to subtract from this Futurable.
+     * @returns the modified Futurable.
+     */
+    subtract(...terms: Array<Futurable | number>): this;
+    /**
+     * Adds an operation (an operator and term(s)) to the Futurable's
+     * expression.
+     *
+     * @param operator - Add or Subtract.
+     * @param terms - terms to add to the expression.
+     */
+    private appendOperation;
+    /**
+     * Gets the numeric value of this Futurable.
+     *
+     * @remarks This method evaluates the expression of the Futurable and
+     * returns the numeric value. If any of the terms in the expression are
+     * Futurables, it will recursively evaluate them. If any of the terms are
+     * unknown (represented by Infinity), it will return Infinity.
+     *
+     * @returns the numeric value of this Futurable.
+     */
+    get value(): number;
+}
+
+/**
+ * An extension of `ActionContainer` that can repeat another action.
+ *
+ * @remarks A `RepeatingActionContainer` is a parent action that repeats
+ * another action for a specified number of repetitions, as provided in the
+ * `count` property. The `Repeat` and `RepeatForever` actions implement
+ * `RepeatingActionContainer`.
+ */
+interface RepeatingActionContainer extends ActionContainer {
+    /** Number of times the action will repeat. */
+    count: number;
+    /** Number of completions done. */
+    completedRepetitions: number;
+    /** How long, in milliseconds, the repeating action has run. This is updated
+     * only at the end of a repetition. */
+    cumulativeDuration: number;
+    /** Returns true when the action is running and the action's children have
+     * just completed a repetition */
+    repetitionHasCompleted: boolean;
+}
+
+interface RepeatActionOptions {
+    /** Action to repeat */
+    action: Action;
+    /** Number of times to repeat the action */
+    count: number;
+    /** Should the action run during screen transitions? Default is no */
+    runDuringTransition?: boolean;
+}
+
+interface RepeatForeverActionOptions {
+    /** Action to repeat */
+    action: Action;
+    /** Should the action run during screen transitions? Default is no */
+    runDuringTransition?: boolean;
 }
 
 /**
@@ -2177,151 +3119,362 @@ declare enum ActionType {
  */
 declare abstract class Action {
     abstract type: ActionType;
-    startOffset: number;
-    endOffset: number;
+    startOffset: Futurable;
     started: boolean;
     running: boolean;
-    completed: boolean;
+    private _completed;
+    /**
+     * Start time of a running action is always known; it is not a `Futurable`.
+     * -1 indicates that the root action has not yet started running.
+     */
     runStartTime: number;
-    duration: number;
+    duration: Futurable;
     runDuringTransition: boolean;
-    parent?: Action;
-    isParent: boolean;
-    isChild: boolean;
+    parent?: ActionContainer;
     key?: string;
     constructor(runDuringTransition?: boolean);
+    /**
+     * Prepares the Action for evaluation.
+     *
+     * @remarks Calculates start times for all actions in the hierarchy
+     * and returns a copy of the action that is prepared for evaluation during
+     * the update loop.
+     *
+     * @param key - optional string to identify an action
+     * @returns action prepared for evaluation
+     */
+    initialize(key?: string): Action;
+    /**
+     * Clones the action, and any actions it contains, recursively.
+     *
+     * @remarks We need to clone an action before running it because actions
+     * have state that is updated over time such as whether they are running or
+     * not, etc. If we didn't clone actions, two nodes reusing the same action
+     * would share state. On `Action`, this method is abstract and is
+     * implemented in each subclass.
+     *
+     * @returns a clone of the action
+     */
+    abstract clone(): Action;
+    /**
+     * Parses the action hierarchy and assigns each action its parent and
+     * root action.
+     *
+     * @remarks Uses recursion to handle arbitrary level of nesting parent
+     * actions within parent actions. When this method is called from the
+     * `initialize()` method, the root action is both the `action` and the
+     * `rootAction`. This is because the action is the top-level action in the
+     * hierarchy. When the method calls itself recursively, the `rootAction`
+     * remains the same, but the `action` is a child action or the action of a
+     * repeating action.
+     *
+     * @param action - the action to assign parents to
+     * @param rootAction - top-level action passed to the run method
+     * @param key - optional string to identify an action. The key is assigned
+     * to every action in the hierarchy.
+     */
+    private assignParents;
+    /**
+     * Sets the runDuringTransition property based on descendants.
+     *
+     * @remarks This ensures that a parent action has its `runDuringTransition`
+     * property set to true if any of its descendants have their
+     * `runDuringTransition` property set to true. Parent actions do not have a
+     * way for the user to set this property directly; it is inferred (propagated
+     * up) from the descendants.
+     *
+     * @param action to propagate runDuringTransition property to
+     */
+    private propagateRunDuringTransition;
+    /**
+     * Assigns durations to all actions in the hierarchy.
+     *
+     * @remarks Uses recursion to handle arbitrary level of nesting parent
+     * actions within parent actions.
+     *
+     * @param action - the action to assign durations to
+     */
+    private assignDurations;
+    /**
+     * Calculates the duration of an action, including any children actions
+     * the action may contain.
+     *
+     * @remarks Uses recursion to handle arbitrary level of nesting parent
+     * actions within parent actions
+     *
+     * @param action
+     * @returns the calculated duration
+     */
+    private calculateDuration;
+    /**
+     * Assigns start offsets to all actions in the hierarchy.
+     *
+     * @remarks Uses recursion to handle arbitrary level of nesting parent
+     * actions within parent actions.
+     *
+     * @param action - the action to assign start offsets to
+     */
+    private assignStartOffsets;
+    /**
+     * Calculates the start offset. This is when an action should start,
+     * relative to the start time of its parent (if it has a parent).
+     *
+     * @param action - the action to calculate the start offset for
+     * @returns the start offset as a Futurable
+     */
+    private calculateStartOffset;
+    /**
+     * Evaluates an action, updating the node's properties as needed.
+     *
+     * @remarks This method is called every frame by the M2Node's `update()`
+     * method.
+     *
+     * @param action - the Action to be evaluated and possibly run
+     * @param node - the `M2Node` that the action will be run on
+     * @param now - the current elapsed time, from `performance.now()`
+     * @param dt - the time since the last frame (delta time)
+     */
+    static evaluateAction(action: Action, node: M2Node, now: number, dt: number): void;
+    private static evaluateRepeatingActions;
+    private static evaluateRotateAction;
+    private static evaluateFadeAlphaAction;
+    private static evaluateScaleAction;
+    private static evaluateMoveAction;
+    private static evaluateWaitAction;
+    private static evaluatePlayAction;
+    private static evaluateCustomAction;
+    /**
+     * Assigns RunStartTime to all actions in the hierarchy.
+     *
+     * @remarks Uses recursion to handle arbitrary level of nesting parent
+     * actions within parent actions.
+     *
+     * @param action - the action to assign RunStartTime to
+     */
+    assignRunStartTimes(action: Action, runStartTime: number): void;
+    /**
+     * Configures action to be run again.
+     *
+     * @remarks This method is called on a repeating action's children when they
+     * need to be run again.
+     *
+     * @param action - action to restart
+     * @param now - current time
+     */
+    restartAction(action: Action, now: number): void;
+    /**
+     * Determines if the action should be running.
+     *
+     * @remarks An action should be running if current time is in the interval
+     * [ start time + start offset, start time + start offset + duration ]
+     *
+     * @param now - current time
+     * @returns true if the action should be running
+     */
+    shouldBeRunning(now: number): boolean;
     /**
      * Creates an action that will move a node to a point on the screen.
      *
      * @param options - {@link MoveActionOptions}
      * @returns The move action
      */
-    static move(options: MoveActionOptions): Action;
+    static move(options: MoveActionOptions): MoveAction;
     /**
-     * Creates an action that will wait a given duration before it is considered complete.
+     * Creates an action that will wait a given duration before it is considered
+     * complete.
      *
      * @param options - {@link WaitActionOptions}
      * @returns The wait action
      */
-    static wait(options: WaitActionOptions): Action;
+    static wait(options: WaitActionOptions): WaitAction;
     /**
      * Creates an action that will execute a callback function.
      *
      * @param options - {@link CustomActionOptions}
      * @returns The custom action
      */
-    static custom(options: CustomActionOptions): Action;
+    static custom(options: CustomActionOptions): CustomAction;
+    /**
+     * Creates an action that will play a sound.
+     *
+     * @remarks This action can only be used with a SoundPlayer node.
+     * It will throw an error if used with any other node type.
+     *
+     * @param options - {@link PlayActionOptions}
+     * @returns The play action
+     */
+    static play(options?: PlayActionOptions): PlayAction;
     /**
      * Creates an action that will scale the node's size.
      *
-     * @remarks Scaling is relative to any inherited scaling, which is multiplicative. For example, if the node's parent is scaled to 2.0 and this node's action scales to 3.0, then the node will appear 6 times as large as original.
+     * @remarks Scaling is relative to any inherited scaling, which is
+     * multiplicative. For example, if the node's parent is scaled to 2.0 and
+     * this node's action scales to 3.0, then the node will appear 6 times as
+     * large as original.
      *
      * @param options - {@link ScaleActionOptions}
      * @returns The scale action
      */
-    static scale(options: ScaleActionOptions): Action;
+    static scale(options: ScaleActionOptions): ScaleAction;
     /**
      * Creates an action that will change the node's alpha (opacity).
      *
-     * @remarks Alpha has multiplicative inheritance. For example, if the node's parent is alpha .5 and this node's action fades alpha to .4, then the node will appear with alpha .2.
+     * @remarks Alpha has multiplicative inheritance. For example, if the node's
+     * parent is alpha .5 and this node's action fades alpha to .4, then the
+     * node will appear with alpha .2.
      *
      * @param options - {@link FadeAlphaActionOptions}
      * @returns The fadeAlpha action
      */
-    static fadeAlpha(options: FadeAlphaActionOptions): Action;
+    static fadeAlpha(options: FadeAlphaActionOptions): FadeAlphaAction;
     /**
      * Creates an action that will rotate the node.
      *
-     * @remarks Rotate actions are applied to their children. In addition to this node's rotate action, all ancestors' rotate actions will also be applied.
+     * @remarks Rotate actions are applied to their children. In addition to this
+     * node's rotate action, all ancestors' rotate actions will also be applied.
      *
      * @param options - {@link RotateActionOptions}
      * @returns The rotate action
      */
-    static rotate(options: RotateActionOptions): Action;
+    static rotate(options: RotateActionOptions): RotateAction;
     /**
      * Creates an array of actions that will be run in order.
      *
-     * @remarks The next action will not begin until the current one has finished. The sequence will be considered completed when the last action has completed.
+     * @remarks The next action will not begin until the current one has
+     * finished. The sequence will be considered completed when the last action
+     * has completed.
      *
      * @param actions - One or more actions that form the sequence
      * @returns
      */
-    static sequence(actions: Array<Action>): Action;
+    static sequence(actions: Array<Action>): SequenceAction;
     /**
      * Create an array of actions that will be run simultaneously.
      *
-     * @remarks All actions within the group will begin to run at the same time. The group will be considered completed when the longest-running action has completed.
+     * @remarks All actions within the group will begin to run at the same time.
+     * The group will be considered completed when the longest-running action
+     * has completed.
      *
      * @param actions - One or more actions that form the group
      * @returns
      */
-    static group(actions: Array<Action>): Action;
-    initialize(node: M2Node, key?: string): Array<Action>;
-    static cloneAction(action: Action, key?: string): Action;
-    static evaluateAction(action: Action, node: M2Node, now: number, dt: number): void;
+    static group(actions: Array<Action>): GroupAction;
     /**
-     * Calculates the duration of an action, including any children actions
-     * the action may contain.
-     *
-     * @remarks Uses recursion to handle arbitrary level of nesting parent
-     * actions within parent actions
+     * Creates an action that will repeat another action a given number of times.
      *
-     * @param action
-     * @returns the calculated duration
+     * @param options - {@link RepeatActionOptions}
+     * @returns The repeat action
      */
-    private calculateDuration;
+    static repeat(options: RepeatActionOptions): RepeatAction;
     /**
-     * Update each action's start and end offsets.
+     * Creates an action that will repeat another action forever.
      *
-     * @remarks Uses recursion to handle arbitrary level of nesting parent
-     * actions within parent actions.
+     * @remarks A repeat forever action is a special case of a repeat action
+     * where the count is set to infinity.
      *
-     * @param action that needs assigning start and end offsets
+     * @param options - {@link RepeatForeverActionOptions}
+     * @returns The repeat forever action
      */
-    private calculateStartEndOffsets;
+    static repeatForever(options: RepeatForeverActionOptions): RepeatForeverAction;
     /**
-     * Takes an action hierarchy and flattens to an array of non-nested actions
+     * Type guard that returns true if the action is a parent action.
      *
-     * @remarks Uses recursion to handle arbitrary level of nesting parent
-     * actions within parent actions
+     * @remarks Parent actions are Group, Sequence, Repeat, and RepeatForever
+     * actions.
      *
-     * @param action - the action to flatten
-     * @param actions - the accumulator array of flattened actions. This will be
-     * undefined on the first call, and an array on recursive calls
-     * @returns flattened array of actions
+     * @param action - action to check
+     * @returns true if the action is a parent action
      */
-    private flattenActions;
+    isParent(action: Action): action is ActionContainer;
     /**
-     * Parses the action hierarchy and assigns each action its parent and
-     * root action.
+     * Type guard that returns true if the action can repeat.
      *
-     * @remarks Uses recursion to handle arbitrary level of nesting parent
-     * actions within parent actions
+     * @remarks Repeating actions are Repeat and RepeatForever actions.
      *
-     * @param action
-     * @param rootAction - top-level action passed to the run method
-     * @param key - optional string to identify an action
+     * @param action - action to check
+     * @returns true if the action is a RepeatAction or RepeatForeverAction
      */
-    private assignParents;
+    private isRepeating;
+    /**
+     * Indicates whether the action has completed.
+     */
+    get completed(): boolean;
+    set completed(value: boolean);
 }
-declare class SequenceAction extends Action implements IActionContainer {
+declare class SequenceAction extends Action implements ActionContainer {
     type: ActionType;
     children: Array<Action>;
     constructor(actions: Array<Action>);
+    clone(): SequenceAction;
+    /**
+     * Indicates whether the action has completed, taking into account all its
+     * child actions.
+     *
+     * @remarks Is read-only for parent actions.
+     */
+    get completed(): boolean;
+    get descendants(): Action[];
+}
+declare class GroupAction extends Action implements ActionContainer {
+    type: ActionType;
+    children: Action[];
+    constructor(actions: Array<Action>);
+    clone(): GroupAction;
+    /**
+     * Indicates whether the action has completed, taking into account all its
+     * child actions.
+     *
+     * @remarks Is read-only for parent actions.
+     */
+    get completed(): boolean;
+    get descendants(): Action[];
+}
+declare class RepeatAction extends Action implements RepeatingActionContainer {
+    type: ActionType;
+    count: number;
+    children: Array<Action>;
+    completedRepetitions: number;
+    cumulativeDuration: number;
+    constructor(action: Action, count: number, runDuringTransition?: boolean);
+    clone(): RepeatAction;
+    /**
+     * Indicates whether the action has completed, taking into account all its
+     * child actions and the number of repetitions.
+     *
+     * @remarks Is read-only for parent actions.
+     */
+    get completed(): boolean;
+    get descendantsAreCompleted(): boolean;
+    /**
+     * Indicates whether a single repetition of a repeating action has just
+     * completed.
+     *
+     * @returns returns true if a repetition has completed
+     */
+    get repetitionHasCompleted(): boolean;
+    get descendants(): Action[];
 }
-declare class GroupAction extends Action implements IActionContainer {
+declare class RepeatForeverAction extends RepeatAction {
     type: ActionType;
-    children: Action[];
-    constructor(actions: Array<Action>);
+    count: number;
+    constructor(action: Action, runDuringTransition?: boolean);
+    clone(): RepeatForeverAction;
 }
 declare class CustomAction extends Action {
     type: ActionType;
     callback: () => void;
     constructor(callback: () => void, runDuringTransition?: boolean);
+    clone(): CustomAction;
+}
+declare class PlayAction extends Action {
+    type: ActionType;
+    constructor(runDuringTransition?: boolean);
+    clone(): PlayAction;
 }
 declare class WaitAction extends Action {
     type: ActionType;
-    constructor(duration: number, runDuringTransition: boolean);
+    constructor(duration: Futurable, runDuringTransition: boolean);
+    clone(): WaitAction;
 }
 declare class MoveAction extends Action {
     type: ActionType;
@@ -2330,19 +3483,22 @@ declare class MoveAction extends Action {
     dx: number;
     dy: number;
     easing: EasingFunction;
-    constructor(point: Point, duration: number, easing: EasingFunction, runDuringTransition: boolean);
+    constructor(point: Point, duration: Futurable, easing: EasingFunction, runDuringTransition: boolean);
+    clone(): MoveAction;
 }
 declare class ScaleAction extends Action {
     type: ActionType;
     scale: number;
     delta: number;
-    constructor(scale: number, duration: number, runDuringTransition?: boolean);
+    constructor(scale: number, duration: Futurable, runDuringTransition?: boolean);
+    clone(): ScaleAction;
 }
 declare class FadeAlphaAction extends Action {
     type: ActionType;
     alpha: number;
     delta: number;
-    constructor(alpha: number, duration: number, runDuringTransition?: boolean);
+    constructor(alpha: number, duration: Futurable, runDuringTransition?: boolean);
+    clone(): FadeAlphaAction;
 }
 declare class RotateAction extends Action {
     type: ActionType;
@@ -2351,7 +3507,8 @@ declare class RotateAction extends Action {
     shortestUnitArc?: boolean;
     delta: number;
     finalValue: number;
-    constructor(byAngle: number | undefined, toAngle: number | undefined, shortestUnitArc: boolean | undefined, duration: number, runDuringTransition?: boolean);
+    constructor(byAngle: number | undefined, toAngle: number | undefined, shortestUnitArc: boolean | undefined, duration: Futurable, runDuringTransition?: boolean);
+    clone(): RotateAction;
 }
 
 interface ActivityCallbacks {
@@ -2473,28 +3630,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.
  */
@@ -2553,10 +3688,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.
      *
@@ -2570,6 +3774,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;
 }
 
 /**
@@ -2614,6 +3840,57 @@ declare class M2c2KitHelpers {
      * "https://", "file://", etc.)
      */
     static urlHasScheme(url: string): boolean;
+    /**
+     * 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
@@ -2755,11 +4032,44 @@ 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;
+    /**
+     * 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;
     fontColor?: RgbaColor;
     fontSize?: number;
+    interpolation?: StringInterpolationMap;
+    localize?: boolean;
 }
 
 declare enum LabelHorizontalAlignmentMode {
@@ -2783,25 +4093,25 @@ 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;
     private _fontColor;
     private _fontSize;
+    private _interpolation;
     private _horizontalAlignmentMode;
     private _preferredMaxLayoutWidth;
     private _backgroundColor?;
+    private _localize;
     private paragraph?;
     private paraStyle?;
     private builder?;
     private _fontPaint?;
     private _backgroundPaint?;
-    private _translatedText;
+    private localizedFontName;
+    private localizedFontNames;
     /**
      * Single or multi-line text formatted and rendered on the screen.
      *
@@ -2810,6 +4120,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
@@ -2825,7 +4160,8 @@ declare class Label extends M2Node implements IDrawable, IText, LabelOptions {
     dispose(): void;
     get text(): string;
     set text(text: string);
-    get translatedText(): string;
+    get interpolation(): StringInterpolationMap;
+    set interpolation(interpolation: StringInterpolationMap);
     get fontName(): string | undefined;
     set fontName(fontName: string | undefined);
     get fontNames(): Array<string> | undefined;
@@ -2840,6 +4176,12 @@ declare class Label extends M2Node implements IDrawable, IText, LabelOptions {
     set preferredMaxLayoutWidth(preferredMaxLayoutWidth: number | undefined);
     get backgroundColor(): RgbaColor | undefined;
     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();
@@ -3003,17 +4345,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;
@@ -3061,21 +4392,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",
@@ -3083,20 +4399,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 */
@@ -3123,22 +4425,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?;
@@ -3159,7 +4458,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.
@@ -3197,6 +4524,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;
@@ -3213,6 +4550,131 @@ declare class Shape extends M2Node implements IDrawable, ShapeOptions {
     set strokeColorPaintNotAntialiased(value: Paint);
 }
 
+interface SoundPlayerOptions extends M2NodeOptions {
+    /** Name of sound to play. Must have been previously loaded */
+    soundName: string;
+}
+
+declare class SoundPlayer extends M2Node implements SoundPlayerOptions {
+    readonly type = M2NodeType.SoundPlayer;
+    isDrawable: boolean;
+    soundName: string;
+    /**
+     * Node for playing sounds.
+     *
+     * @param options - {@link SoundPlayerOptions}
+     */
+    constructor(options: SoundPlayerOptions);
+    initialize(): void;
+    dispose(): void;
+    /**
+     * 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): SoundPlayer;
+}
+
+interface SoundRecorderOptions extends M2NodeOptions {
+    /** Preferred MIME type to use for recording audio. `audio/webm` or `audio/mp4` is recommended. If omitted, it will use any MIME type supported by the device. */
+    mimeType?: string;
+    /** Additional MIME types to use for recording audio, in order of preference, if preferred type is not supported. `["audio/webm", "audio/mp4"]` is recommended. */
+    backupMimeTypes?: Array<string>;
+    /** Maximum duration, in milliseconds, to allow recording. If recording lasts longer than this duration, it will automatically be paused. This can be used to prevent excessively long recording and memory usage. */
+    maximumDuration?: number;
+    /** Additional audio constraints to be applied when requesting the audio device.
+     * see https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints
+     * @remarks Use with caution. All kinds of constraints may not be supported
+     * on all browsers, and specifying too restrictive constraints will result in
+     * no available user audio device and an exception. Unusual constraints may
+     * also result in an unexpected device being selected.
+     * @example
+     *  audioTrackConstraints: {
+     *    channelCount: 1,
+     *    noiseSuppression: { ideal: true },
+     *  }
+     * */
+    audioTrackConstraints?: MediaTrackConstraints;
+}
+
+interface SoundRecorderResults {
+    /** The MIME type of the recorded audio, possibly including the codec. */
+    mimeType: string;
+    /** The ISO 8601 device timestamp when the recording began. */
+    beginIso8601Timestamp: string;
+    /** The ISO 8601 device timestamp when the recording ended. */
+    endIso8601Timestamp: string;
+    /** The duration of the recording in milliseconds. @remarks The duration may be different from the timestamp end minus begin times if the recording was paused. */
+    duration: number;
+    /** The settings of the audio tracks when the recording began. */
+    audioTrackSettings?: Array<MediaTrackSettings>;
+    /** The recorded audio as a base 64 string. */
+    audioBase64: string;
+    /** The recorded audio as a Blob. */
+    audioBlob: Blob;
+}
+
+declare class SoundRecorder extends M2Node implements Omit<SoundRecorderOptions, "backupMimeTypes"> {
+    readonly type = M2NodeType.SoundRecorder;
+    isDrawable: boolean;
+    mimeType?: string;
+    audioTrackConstraints?: MediaTrackConstraints;
+    maximumDuration?: number;
+    private _isRecording;
+    private _isPaused;
+    private mediaRecorder?;
+    private audioChunks;
+    private mediaTrackSettings?;
+    private beginIso8601Timestamp?;
+    private endIso8601Timestamp?;
+    private timerUuid;
+    /**
+     * Node for recording sounds.
+     *
+     * @param options - {@link SoundRecorderOptions}
+     */
+    constructor(options?: SoundRecorderOptions);
+    initialize(): void;
+    start(): Promise<void>;
+    stop(): Promise<SoundRecorderResults>;
+    pause(): void;
+    resume(): void;
+    /** Is the `SoundRecorder` currently recording? */
+    get isRecording(): boolean;
+    /** Is the `SoundRecorder` currently paused? */
+    get isPaused(): boolean;
+    update(): void;
+    /**
+     * Returns an array of supported audio MIME types for MediaRecorder.
+     *
+     * @remarks Adapted from https://stackoverflow.com/a/68236494
+     * License: https://creativecommons.org/licenses/by-sa/4.0/
+     *
+     * @returns
+     */
+    private getMediaRecorderSupportedAudioMimeTypes;
+    private blobToBase64;
+    private getMimeTypeWithoutCodecs;
+    private getSupportedBackupMimeType;
+    dispose(): void;
+    /**
+     * 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): SoundRecorder;
+}
+
 interface SpriteOptions extends M2NodeOptions, DrawableOptions {
     /** Name of image to use for sprite. Must have been previously loaded */
     imageName?: string;
@@ -3221,11 +4683,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?;
@@ -3237,10 +4696,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();
     /**
@@ -3257,6 +4736,18 @@ declare class Sprite extends M2Node implements IDrawable, SpriteOptions {
     update(): void;
     draw(canvas: Canvas): void;
     warmup(canvas: Canvas): void;
+    /**
+     * Draws a rectangle border around the image to indicate that a fallback
+     * image is being used.
+     *
+     * @remarks The size of the rectangle is the same as the image, but because
+     * the stroke width of the paint is wider than 1 pixel (see method
+     * `configureImageLocalization()` in `ImageManager.ts`), the rectangle will
+     * be larger than the image and thus be visible.
+     *
+     * @param canvas - CanvasKit canvas to draw on
+     */
+    private drawFallbackImageBorder;
 }
 
 interface StoryOptions {
@@ -3275,20 +4766,22 @@ 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;
     private _fontSize;
+    private _interpolation;
+    private _localize;
     private paint?;
     private font?;
     private typeface;
-    private _translatedText;
-    private missingTranslationPaint?;
+    private tryMissingTranslationPaint;
+    private textForDraw;
+    private fontForDraw?;
+    private localizedFontName;
+    private localizedFontNames;
     /**
      * Single-line text rendered on the screen.
      *
@@ -3297,16 +4790,28 @@ declare class TextLine extends M2Node implements IDrawable, IText, TextLineOptio
      * @param options - {@link TextLineOptions}
      */
     constructor(options?: TextLineOptions);
-    get text(): string;
-    set text(text: string);
-    get translatedText(): string;
-    get fontName(): string | undefined;
-    set fontName(fontName: string | undefined);
-    get fontColor(): RgbaColor;
-    set fontColor(fontColor: RgbaColor);
-    get fontSize(): number;
-    set fontSize(fontSize: number);
-    update(): void;
+    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
@@ -3319,6 +4824,24 @@ declare class TextLine extends M2Node implements IDrawable, IText, TextLineOptio
      * @returns a M2Font object that is required for the TextLine
      */
     private getRequiredTextLineFont;
+    private createFontPaint;
+    private createFont;
+    get text(): string;
+    set text(text: string);
+    get fontName(): string | undefined;
+    set fontName(fontName: string | undefined);
+    get fontColor(): RgbaColor;
+    set fontColor(fontColor: RgbaColor);
+    get fontSize(): number;
+    set fontSize(fontSize: number);
+    get interpolation(): StringInterpolationMap;
+    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.
@@ -3331,6 +4854,7 @@ declare class TextLine extends M2Node implements IDrawable, IText, TextLineOptio
      * provided, name will be the new uuid
      */
     duplicate(newName?: string): TextLine;
+    update(): void;
     draw(canvas: Canvas): void;
     warmup(canvas: Canvas): void;
 }
@@ -3447,6 +4971,15 @@ declare class Timer {
 
 declare class Uuid {
     static generate(): string;
+    /**
+     * Tests if a string is a valid UUID.
+     *
+     * @remarks Will match UUID versions 1 through 8, plus the nil UUID.
+     *
+     * @param uuid - the string to test
+     * @returns true if the string is a valid UUID
+     */
+    static isValid(uuid: string | undefined | null): boolean;
 }
 
 declare class WebColors {
@@ -3611,4 +5144,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 M2ColorfulPath, type M2DragEvent, type M2Event, type M2EventListener, M2EventType, type M2Image, M2ImageStatus, M2Node, type M2NodeEvent, type M2NodeEventListener, type M2NodeOptions, M2NodeType, type M2Path, type M2PointerEvent, M2c2KitHelpers, MoveAction, type MoveActionOptions, MutablePath, NoneTransition, type Plugin, type PluginEvent, type Point, RandomDraws, type RectOptions, type RgbaColor, RotateAction, ScaleAction, type ScaleActionOptions, Scene, type SceneOptions, SceneTransition, SequenceAction, Shape, type ShapeOptions, ShapeType, type Size, SlideTransition, type SlideTransitionOptions, Sprite, type SpriteOptions, Story, type StoryOptions, type TapEvent, TextLine, type TextLineOptions, type TextOptions, Timer, Transition, TransitionDirection, TransitionType, type Translations, 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 };