@m2c2kit/core 0.1.3 → 0.1.7

package/dist/index.d.ts

@@ -1,67 +1,6 @@
-import { FontMgr, Typeface, Image, CanvasKit, Canvas } from 'canvaskit-wasm';
-
-interface FontData {
-    fontUrl: string;
-    fontArrayBuffer: ArrayBuffer;
-}
-
-declare class FontManager {
-    _fontMgr?: FontMgr;
-    private _typefaces;
-    _getTypeface(name: string): Typeface;
-    FetchFontsAsArrayBuffers(fontUrls: Array<string>): Promise<FontData>[];
-    LoadFonts(fonts: Array<ArrayBuffer>): void;
-}
-
-declare class LoadedImage {
-    name: string;
-    image: Image;
-    width: number;
-    height: number;
-    constructor(name: string, image: Image, width: number, height: number);
-}
-
-declare class RenderedDataUrlImage {
-    name: string;
-    dataUrlImage: string;
-    width: number;
-    height: number;
-    constructor(name: string, dataUrlImage: string, width: number, height: number);
-}
-
-/**
- * SVG image to be rendered and loaded from a URL or HTML svg tag in string form.
- */
-interface SvgImage {
-    /** Name that will be used to refer to the SVG image. Must be unique among all images */
-    name: string;
-    /** Width to scale SVG image to */
-    width: number;
-    /** Height to scale SVG image to */
-    height: number;
-    /** 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;
-    /** URL of SVG asset to render and load */
-    url?: string;
-}
-
-declare class ImageManager {
-    private scratchCanvas?;
-    private ctx?;
-    private scale?;
-    _renderedDataUrlImages: Record<string, RenderedDataUrlImage>;
-    _loadedImages: Record<string, LoadedImage>;
-    initialize(scratchCanvas: HTMLCanvasElement): void;
-    renderSvgImage(svgImage: SvgImage): Promise<RenderedDataUrlImage>;
-    LoadRenderedSvgImages(urls: RenderedDataUrlImage[]): void;
-    private convertRenderedDataUrlImage;
-    private dataURLtoArrayBuffer;
-}
+import { Canvas, CanvasKit, Image, FontMgr, Typeface } from 'canvaskit-wasm';
 
 declare class GlobalVariables {
-    canvasKit: CanvasKit;
-    fontManager: FontManager;
-    imageManager: ImageManager;
     now: number;
     deltaTime: number;
     canvasScale: number;
@@ -75,6 +14,16 @@ declare global {
 }
 //# sourceMappingURL=Globals.d.ts.map
 
+interface EntityEvent {
+    target: Entity;
+}
+
+interface EntityEventListener {
+    eventType: string;
+    entityName: string;
+    callback: (event: EntityEvent) => void;
+}
+
 /**
  * Position in two-dimensional space.
  */
@@ -86,16 +35,7 @@ declare class Point {
     constructor(x?: number, y?: number);
 }
 
-declare class TapListener {
-    entityName?: string;
-    codeCallback?: (tapevent: TapEvent) => void;
-}
-/**
- * Object passed to the tap event handler when the entity is tapped.
- */
-interface TapEvent {
-    /** The entity that was tapped */
-    tappedEntity: Entity;
+interface TapEvent extends EntityEvent {
     /** Point that was tapped on entity, relative to the entity coordinate system */
     point: Point;
 }
@@ -193,7 +133,7 @@ declare abstract class Entity implements EntityOptions {
     actions: Action[];
     queuedAction?: Action;
     originalActions: Action[];
-    tapListeners: TapListener[];
+    eventListeners: EntityEventListener[];
     uuid: string;
     needsInitialization: boolean;
     userData: any;
@@ -234,12 +174,12 @@ declare abstract class Entity implements EntityOptions {
      */
     get descendants(): Array<Entity>;
     /**
-     * Provides the callback function to be executed when the user taps the entity.
+     * Takes the callback function to be executed when the user taps down on the entity. A TapDown is either a mouse click within the bounds of an entity OR the beginning of touches within the bounds of an entity.
      *
-     * @param codeCallback - function to execute
-     * @param replaceExistingCodeCallback  - should the provided callback replace any existing callbacks? Usually we want to have only one callback defined, instead of chaining multiple ones. It is strongly recommended not to change this, unless you have a special use case. Default is true.
+     * @param callback - function to execute
+     * @param replaceExistingCallback  - should the provided callback replace any existing callbacks? Usually we want to have only one callback defined, instead of chaining multiple ones. It is strongly recommended not to change this, unless you have a special use case. Default is true.
      */
-    onTap(codeCallback: (tapEvent: TapEvent) => void, replaceExistingCodeCallback?: boolean): void;
+    onTapDown(callback: (tapEvent: TapEvent) => void, replaceExistingCallback?: boolean): void;
     private parseLayoutConstraints;
     private calculateYFromConstraint;
     private calculateXFromConstraint;
@@ -277,8 +217,8 @@ declare abstract class Entity implements EntityOptions {
      *
      * @returns Scene that contains this entity
      */
+    get canvasKit(): CanvasKit;
     get parentSceneAsEntity(): Entity;
-    private generateUUID;
     /**
      * 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
@@ -414,8 +354,8 @@ declare class GroupAction extends Action implements IActionContainer {
 }
 declare class CustomAction extends Action {
     type: ActionType;
-    codeCallback: () => void;
-    constructor(codeCallback: () => void, runDuringTransition?: boolean);
+    callback: () => void;
+    constructor(callback: () => void, runDuringTransition?: boolean);
 }
 declare class WaitAction extends Action {
     type: ActionType;
@@ -435,73 +375,171 @@ declare class ScaleAction extends Action {
     constructor(scale: number, duration: number, runDuringTransition?: boolean);
 }
 
-interface IDrawable {
-    draw(canvas: Canvas): void;
-    anchorPoint: Point;
-    zPosition: number;
+declare class LoadedImage {
+    name: string;
+    image: Image;
+    width: number;
+    height: number;
+    constructor(name: string, image: Image, width: number, height: number);
 }
 
-interface DrawableOptions {
-    anchorPoint?: Point;
-    zPosition?: number;
+/**
+ * Image that can be rendered by a browser and loaded from a URL or HTML svg tag in string form.
+ */
+interface BrowserImage {
+    /** Name that will be used to refer to the SVG image. Must be unique among all images */
+    name: string;
+    /** Width to scale SVG image to */
+    width: number;
+    /** Height to scale SVG image to */
+    height: number;
+    /** 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;
+    /** URL of SVG asset to render and load */
+    url?: string;
 }
 
-interface CompositeOptions extends EntityOptions, DrawableOptions {
+interface GameImages {
+    uuid: string;
+    images: Array<BrowserImage>;
 }
 
-declare abstract class Composite extends Entity implements IDrawable {
-    readonly type = EntityType.composite;
-    compositeType: string;
-    isDrawable: boolean;
-    anchorPoint: Point;
-    zPosition: number;
+declare class ImageManager {
+    canvasKit?: CanvasKit;
+    private renderedImages;
+    private loadedImages;
+    private _scratchCanvas?;
+    private ctx?;
+    private scale?;
+    getLoadedImage(gameUuid: string, imageName: string): LoadedImage;
     /**
-     * Base Drawable object for creating custom entities ("composites") composed of primitive entities.
+     * Adds a CanvasKit image to the images available to a given game.
+     * Typically, this won't be called directly because images will be
+     * automatically rendered and loaded in the Activity async init.
+     * The only time this function is called in-game is to add
+     * screenshot images needed for transitions
      *
-     * @param options
+     * @param loadedImage
+     * @param gameUuid
      */
-    constructor(options?: CompositeOptions);
-    initialize(): void;
-    update(): void;
-    draw(canvas: Canvas): void;
+    addLoadedImage(loadedImage: LoadedImage, gameUuid: string): void;
+    renderImages(allGamesImages: Array<GameImages>): Promise<void[]>;
+    loadAllGamesRenderedImages(): void;
+    private renderBrowserImage;
+    private convertRenderedDataUrlImageToCanvasKitImage;
+    /**
+     * scratchCanvas is an extra, non-visible canvas in the DOM we use so the native browser can render images
+     */
+    private get scratchCanvas();
+    private dataURLtoArrayBuffer;
 }
 
-/**
- * Color in red (0-255), green (0-255), blue (0-255), alpha (0-1) format. Must be numeric array of length 4.
- */
-declare type RgbaColor = [number, number, number, number];
+interface GameFontUrls {
+    uuid: string;
+    fontUrls: Array<string>;
+}
 
-/**
- * Reasonable defaults to use if values are not specified.
- */
-declare class Constants {
-    static readonly FPS_DISPLAY_TEXT_FONT_SIZE = 12;
-    static readonly FPS_DISPLAY_TEXT_COLOR: RgbaColor;
-    static readonly FPS_DISPLAY_UPDATE_INTERVAL = 500;
-    static readonly DEFAULT_SCENE_BACKGROUND_COLOR: RgbaColor;
-    static readonly DEFAULT_SHAPE_FILL_COLOR: RgbaColor;
-    static readonly DEFAULT_FONT_COLOR: RgbaColor;
-    static readonly DEFAULT_FONT_SIZE = 16;
-    static readonly LIMITED_FPS_RATE = 5;
+declare class FontManager {
+    canvasKit?: CanvasKit;
+    fontMgr?: FontMgr;
+    private gameTypefaces;
+    private allGamesFontData?;
+    /**
+     * Gets a typeface that was previously loaded for the specified game.
+     *
+     * @param gameUuid
+     * @param fontFamily
+     * @returns the requested Typeface
+     */
+    getTypeface(gameUuid: string, fontFamily: string): Typeface;
+    /**
+     * Fetches all fonts for all games.
+     *
+     * @param allGamesFontUrls
+     * @returns
+     */
+    fetchFonts(allGamesFontUrls: Array<GameFontUrls>): Promise<void>;
+    /**
+     * Takes the fonts, which have been previously fetched and converted into
+     * Array Buffers using FontManager.fetchFonts(), and makes them available
+     * to our engine
+     */
+    loadAllGamesFontData(): void;
+    /**
+     * For the specified game, fetches all fonts in the array of urls and
+     * stores fonts as array buffers.
+     *
+     * @param gameUuid
+     * @param fontUrls - array of font urls
+     * @returns
+     */
+    private fetchGameFontsAsArrayBuffers;
+    /**
+     * For the specified game, loads all fonts from array buffers and makes
+     * fonts available within canvaskit as a Typeface
+     *
+     * @param gameUuid
+     * @param fonts - array of fonts in array buffer form
+     */
+    private loadGameFonts;
+}
+
+interface EventBase {
+    eventType: EventType;
+}
+/** Note: I would have named it Event, but that would collide with
+ * the existing, and much more well-known, Web API Event */
+declare enum EventType {
+    sessionLifecycle = "SessionLifecycle",
+    gameLifecycle = "GameLifecycle",
+    gameTrial = "GameTrial"
+}
+
+interface SessionEvent extends EventBase {
+}
+
+interface SessionLifecycleEvent extends SessionEvent {
+    initialized: boolean;
+    ended: boolean;
+}
+
+interface SessionCallbacks {
+    /** Callback executed when the session lifecycle changes, such as when it is initialized. */
+    onSessionLifecycleChange?: (event: SessionLifecycleEvent) => void;
+}
+
+interface GameEvent extends EventBase {
+    gameUuid: string;
+    gameName: string;
+}
+
+interface GameLifecycleEvent extends GameEvent {
+    ended: boolean;
+}
+
+interface GameParameters {
+    [key: string]: DefaultParameter;
+}
+interface DefaultParameter {
+    value: any;
+    type?: "number" | "string" | "boolean" | "object";
+    description?: string;
+}
+
+interface IDrawable {
+    draw(canvas: Canvas): void;
+    anchorPoint: Point;
+    zPosition: number;
 }
 
 /**
- * This enum is used interally for processing the layout constraints. We use
- * an enum to avoid magic strings.
+ * Color in red (0-255), green (0-255), blue (0-255), alpha (0-1) format. Must be numeric array of length 4.
  */
-declare enum ConstraintType {
-    topToTopOf = "topToTopOf",
-    topToBottomOf = "topToBottomOf",
-    bottomToTopOf = "bottomToTopOf",
-    bottomToBottomOf = "bottomToBottomOf",
-    startToStartOf = "startToStartOf",
-    startToEndOf = "startToEndOf",
-    endToEndOf = "endToEndOf",
-    endToStartOf = "endToStartOf"
-}
+declare type RgbaColor = [number, number, number, number];
 
-declare enum Dimensions {
-    MATCH_CONSTRAINT = 0
+interface DrawableOptions {
+    anchorPoint?: Point;
+    zPosition?: number;
 }
 
 interface SceneOptions extends EntityOptions, DrawableOptions {
@@ -534,13 +572,13 @@ declare class Scene extends Entity implements IDrawable, SceneOptions {
     get backgroundColor(): RgbaColor;
     set backgroundColor(backgroundColor: RgbaColor);
     /**
-     * Code that will be called every time the screen is shown.
+     * Code that will be called every time the screen is first presented.
      *
-     * @remarks Use this callback to "reset" entities to their initial state. For example, if a screen 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 screen may have been displayed. In addition, if entities should vary in each iteration, that should be done here.
+     * @remarks Use this callback to set entities 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 entities should vary in each iteration, that should be done here.
      *
-     * @param codeCallback
+     * @param callback
      */
-    setup(codeCallback: (scene: Scene) => void): void;
+    setup(callback: (scene: Scene) => void): void;
     draw(canvas: Canvas): void;
 }
 
@@ -576,10 +614,28 @@ declare class SceneTransition {
     constructor(scene: Scene, transition?: Transition | undefined);
 }
 
+interface TrialSchema {
+    [key: string]: PropertySchema;
+}
+interface PropertySchema {
+    type: "number" | "string" | "boolean" | "object";
+    description?: string;
+}
+
 /**
  * Options to specify HTML canvas, set game canvas size, and load game assets.
  */
-interface GameInitOptions {
+interface GameOptions {
+    /** Human-friendly name of this game */
+    name: string;
+    /** Version of this game */
+    version?: string;
+    /** Uri (repository, webpage, or other location where full information about the game can be found) */
+    uri?: string;
+    /** Brief description of game */
+    shortDescription?: string;
+    /** Full description of game */
+    longDescription?: string;
     /** Id of the HTML canvas that game will be drawn on. If not provided, the first canvas found will be used */
     canvasId?: string;
     /** Width of game canvas */
@@ -589,13 +645,13 @@ interface GameInitOptions {
     /** Stretch to fill screen? Default is false */
     stretch?: boolean;
     /** Schema of trial data; JSON object where key is variable name, value is data type */
-    trialSchema?: object;
+    trialSchema?: TrialSchema;
     /** Default game parameters; JSON object where key is the game parameter, value is default value */
-    defaultParameters?: object;
+    parameters?: GameParameters;
     /** String array of urls from which to load fonts. The first element will be the default font */
     fontUrls?: Array<string>;
-    /** Array of SvgImage objects to render and load */
-    svgImages?: SvgImage[];
+    /** Array of BrowserImage objects to render and load */
+    images?: Array<BrowserImage>;
     /** 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 */
@@ -610,25 +666,21 @@ interface TrialData {
 interface Metadata {
     userAgent?: string;
 }
-interface GameData {
-    trials: Array<TrialData>;
-    metadata: Metadata;
-}
-interface LifecycleCallbacks {
-    trialComplete: (trialNumber: number, data: GameData, trialSchema: object) => void;
-    allTrialsComplete: (data: GameData, trialSchema: object) => void;
-}
-declare class Game {
+declare class Game implements Activity {
+    _canvasKit?: CanvasKit;
+    _session?: Session;
+    uuid: string;
+    options: GameOptions;
+    constructor(options: GameOptions);
+    setParameters(newParameters: any): void;
+    get canvasKit(): CanvasKit;
+    set canvasKit(canvasKit: CanvasKit);
+    get session(): Session;
+    set session(session: Session);
     entryScene?: Scene | string;
-    parameters: any;
-    private defaultParameters;
     data: GameData;
-    trialNumber: number;
-    trialSchema: {};
-    lifecycle: LifecycleCallbacks;
-    private trialSchemaMap;
+    trialIndex: number;
     private htmlCanvas?;
-    private scratchHtmlCanvas?;
     private surface?;
     private showFps?;
     private bodyBackgroundColor?;
@@ -643,32 +695,12 @@ declare class Game {
     private animationFramesRequested;
     private limitFps;
     private unitTesting;
+    private gameStopRequested;
     canvasCssWidth: number;
     canvasCssHeight: number;
     private scenes;
     private incomingSceneTransitions;
     private currentSceneSnapshot?;
-    /**
-     * Asynchronously initializes the game engine and load assets
-     *
-     * @param gameInitOptions
-     * @returns Promise<void>
-     */
-    init(gameInitOptions: GameInitOptions): Promise<void>;
-    /**
-     * Provide a callback function to be invoked when a trial has completed.
-     * It is the responsibility of the the game programmer to call this
-     * at the appropriate time. It is not triggered automatically.
-     * @param codeCallback
-     */
-    onTrialComplete(codeCallback: (trialNumber: number, data: GameData, trialSchema: object) => void): void;
-    /**
-     * Provide a callback function to be invoked when all trials are complete.
-     * It is the responsibility of the the game programmer to call this
-     * at the appropriate time. It is not triggered automatically.
-     * @param codeCallback
-     */
-    onAllTrialsComplete(codeCallback: (data: GameData, trialSchema: object) => void): void;
     /**
      * Adds a scene to the game.
      *
@@ -691,10 +723,8 @@ declare class Game {
      */
     presentScene(scene: string | Scene, transition?: Transition): void;
     /**
-     * Gets the value of the specified game parameter. If the value was not
-     * provided in the parameters property above, then return the value in
-     * defaultParameters. If the parameterName is still not found, then
-     * throw exception.
+     * Gets the value of the game parameter. If parameterName
+     * is not found, then throw exception.
      * @param parameterName - the name of the game parameter whose value is requested
      * @returns
      */
@@ -705,7 +735,8 @@ declare class Game {
      * @param entryScene - The scene (Scene object or its string name) to display when the game starts
      */
     start(entryScene?: Scene | string): void;
-    initData(trialSchema: object): void;
+    stop(): void;
+    initData(): void;
     /**
      * Adds data to the game's TrialData object.
      *
@@ -715,11 +746,26 @@ declare class Game {
      * @param value - value of the variable to set
      */
     addTrialData(variableName: string, value: any): void;
-    private loadCanvasKit;
+    /**
+     * Should be called when the current trial has completed. It will
+     * also increment the trial index.
+     * Calling this will trigger the onGameTrialComplete callback function,
+     * if one was provided in SessionOptions. This is how the game communicates
+     * trial data to the parent session, which can then save or process the data.
+     * It is the responsibility of the the game programmer to call this at
+     * the appropriate time. It is not triggered automatically.
+     */
+    trialComplete(): void;
+    /**
+     * Should be called when the current game has ended. This will trigger
+     * the onGameLifecycleChange callback function, if one was provided in
+     * SessionOptions. This is how the game can communicate its ended or
+     * "finished" state to the parent session.
+     * It is the responsibility of the the game programmer to call this at
+     * the appropriate time. It is not triggered automatically.
+     */
+    end(): void;
     private setupHtmlCanvases;
-    private fetchFonts;
-    private renderSvgImages;
-    private loadFonts;
     private setupCanvasKitSurface;
     private setupFpsFont;
     private setupEventHandlers;
@@ -732,27 +778,180 @@ declare class Game {
     private animateSceneTransition;
     private drawFps;
     /**
-     * Creates a tap listener for an entity based on the entity name
+     * Creates an event listener for an entity based on the entity name
      *
-     * @remarks Typically, tap listeners will be created using the onTap() method of each entity. This alternative allows creation with entity name.
+     * @remarks Typically, event listeners will be created using a method specific to the event, such as onTapDown(). This alternative allows creation with entity name.
      *
-     * @param entityName
-     * @param codeCallback
-     * @param replaceExistingCodeCallback
+     * @param eventType - the type of event to listen for, e.g., "tapdown"
+     * @param entityName - the entity name for which an event will be listened
+     * @param callback
+     * @param replaceExistingCallback
      */
-    createTapListener(entityName: string, codeCallback: (tapEvent: TapEvent) => void, replaceExistingCodeCallback?: boolean): void;
+    createEventListener(eventType: string, entityName: string, callback: (event: EntityEvent) => void, replaceExistingCallback?: boolean): void;
     /**
      * Returns array of all entities that have been added to the game object.
      */
     get entities(): Array<Entity>;
     private htmlCanvasMouseDownHandler;
     private htmlCanvasTouchStartHandler;
+    private sceneCanReceiveUserInteraction;
     private processTaps;
     private handleEntityTapped;
     private tapIsWithinEntityBounds;
     private calculateEntityAbsoluteBoundingBox;
 }
 
+interface GameData {
+    trials: Array<TrialData>;
+    metadata: Metadata;
+}
+
+interface GameTrialEvent extends GameEvent {
+    trialIndex: number;
+    trialSchema: TrialSchema;
+    gameData: GameData;
+    gameParameters: GameParameters;
+}
+
+interface GameCallbacks {
+    /** Callback executed when the game lifecycle changes, such as when it ends. */
+    onGameLifecycleChange?: (event: GameLifecycleEvent) => void;
+    /** Callback executed when a game trial completes. */
+    onGameTrialComplete?: (event: GameTrialEvent) => void;
+}
+
+interface SessionOptions {
+    /** The activities that compose this session */
+    activities: Array<Activity>;
+    /** Callbacks executed when trials are completed and when game ends */
+    gameCallbacks?: GameCallbacks;
+    /** Callbacks executed when session events occur */
+    sessionCallbacks?: SessionCallbacks;
+}
+
+declare class Session {
+    options: SessionOptions;
+    fontManager: FontManager;
+    imageManager: ImageManager;
+    currentActivity?: Activity;
+    uuid: string;
+    private canvasKit?;
+    /**
+     * A Session contains one or more activities; currently, the only
+     * class that implements Activity is Game, but Survey is planned.
+     * The session manages the start and stop of activities, and
+     * advancement to next activity
+     *
+     * @param options
+     */
+    constructor(options: SessionOptions);
+    /**
+     * Asynchronously initializes the m2c2kit engine and loads assets
+     */
+    init(): Promise<void>;
+    /**
+     * Starts the session and starts the first activity.
+     */
+    start(): void;
+    /**
+     * Declares the session ended and sends callback.
+     */
+    end(): void;
+    /**
+     * Stops the current activity and advances to next activity in the session.
+     * If there is no activity after the current activity, throws error
+     */
+    advanceToNextActivity(): void;
+    /**
+     * Gets the next activity after the current one, or undefined if
+     * this is the last activity.
+     */
+    get nextActivity(): Activity | undefined;
+    private logStartingActivity;
+    /**
+     * Gets asynchronous assets, including initialization of canvaskit wasm,
+     * fetching of fonts from specified urls, and rendering and fetching
+     * of images
+     * @returns
+     */
+    private getAsynchronousAssets;
+    private loadCanvasKit;
+    private loadAssets;
+    private assignCanvasKit;
+    private getFontsConfigurationFromGames;
+    private getImagesConfigurationFromGames;
+}
+
+interface Activity {
+    /** Starts the activity */
+    start(): void;
+    /** Stops the activity */
+    stop(): void;
+    /** The activity's parent session */
+    session: Session;
+    /** The activity's unique identifier. NOTE: This is newly generated each session. The uuid for an activity will vary across sessions. */
+    uuid: string;
+}
+
+interface CompositeOptions extends EntityOptions, DrawableOptions {
+}
+
+declare abstract class Composite extends Entity implements IDrawable {
+    readonly type = EntityType.composite;
+    compositeType: string;
+    isDrawable: boolean;
+    anchorPoint: Point;
+    zPosition: number;
+    /**
+     * Base Drawable object for creating custom entities ("composites") composed of primitive entities.
+     *
+     * @param options
+     */
+    constructor(options?: CompositeOptions);
+    initialize(): void;
+    update(): void;
+    draw(canvas: Canvas): void;
+}
+
+/**
+ * Reasonable defaults to use if values are not specified.
+ */
+declare class Constants {
+    static readonly FPS_DISPLAY_TEXT_FONT_SIZE = 12;
+    static readonly FPS_DISPLAY_TEXT_COLOR: RgbaColor;
+    static readonly FPS_DISPLAY_UPDATE_INTERVAL = 500;
+    static readonly DEFAULT_SCENE_BACKGROUND_COLOR: RgbaColor;
+    static readonly DEFAULT_SHAPE_FILL_COLOR: RgbaColor;
+    static readonly DEFAULT_FONT_COLOR: RgbaColor;
+    static readonly DEFAULT_FONT_SIZE = 16;
+    static readonly LIMITED_FPS_RATE = 5;
+}
+
+/**
+ * This enum is used interally for processing the layout constraints. We use
+ * an enum to avoid magic strings.
+ */
+declare enum ConstraintType {
+    topToTopOf = "topToTopOf",
+    topToBottomOf = "topToBottomOf",
+    bottomToTopOf = "bottomToTopOf",
+    bottomToBottomOf = "bottomToBottomOf",
+    startToStartOf = "startToStartOf",
+    startToEndOf = "startToEndOf",
+    endToEndOf = "endToEndOf",
+    endToStartOf = "endToStartOf"
+}
+
+declare enum Dimensions {
+    MATCH_CONSTRAINT = 0
+}
+
+interface FontData {
+    gameUuid: string;
+    fontUrl: string;
+    fontArrayBuffer: ArrayBuffer;
+}
+
 interface IText {
     text?: string;
     fontName?: string;
@@ -1042,6 +1241,10 @@ declare class Timer {
     static RemoveAll(): void;
 }
 
+declare class Uuid {
+    static generate(): string;
+}
+
 declare class WebColors {
     static Transparent: RgbaColor;
     static MediumVioletRed: RgbaColor;
@@ -1187,4 +1390,4 @@ declare class WebColors {
     static RebeccaPurple: RgbaColor;
 }
 
-export { Action, Composite, CompositeOptions, Constants, ConstraintType, Constraints, CustomAction, CustomActionOptions, Dimensions, DrawableOptions, Entity, EntityOptions, EntityType, FontData, FontManager, Game, GameData, GameInitOptions, GlobalVariables, GroupAction, IDrawable, IText, ImageManager, Label, LabelHorizontalAlignmentMode, LabelOptions, Layout, LayoutConstraint, LoadedImage, MoveAction, MoveActionOptions, Point, PushTransition, RandomDraws, Rect, RectOptions, RgbaColor, ScaleAction, ScaleActionOptions, Scene, SceneOptions, SceneTransition, SequenceAction, Shape, ShapeOptions, ShapeType, Size, Sprite, SpriteOptions, Story, StoryOptions, SvgImage, TapEvent, TapListener, TextLine, TextLineOptions, TextOptions, Timer, Transition, TransitionDirection, TransitionType, WaitAction, WaitActionOptions, WebColors, handleInterfaceOptions };
+export { Action, Activity, BrowserImage, Composite, CompositeOptions, Constants, ConstraintType, Constraints, CustomAction, CustomActionOptions, DefaultParameter, Dimensions, DrawableOptions, Entity, EntityEventListener, EntityOptions, EntityType, EventBase, EventType, FontData, FontManager, Game, GameCallbacks, GameData, GameLifecycleEvent, GameOptions, GameParameters, GameTrialEvent, GlobalVariables, GroupAction, IDrawable, IText, ImageManager, Label, LabelHorizontalAlignmentMode, LabelOptions, Layout, LayoutConstraint, LoadedImage, Metadata, MoveAction, MoveActionOptions, Point, PropertySchema, PushTransition, RandomDraws, Rect, RectOptions, RgbaColor, ScaleAction, ScaleActionOptions, Scene, SceneOptions, SceneTransition, SequenceAction, Session, SessionLifecycleEvent, SessionOptions, Shape, ShapeOptions, ShapeType, Size, Sprite, SpriteOptions, Story, StoryOptions, TextLine, TextLineOptions, TextOptions, Timer, Transition, TransitionDirection, TransitionType, TrialData, TrialSchema, Uuid, WaitAction, WaitActionOptions, WebColors, handleInterfaceOptions };