@m2c2kit/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1125 @@
+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;
+}
+
+declare class GlobalVariables {
+    canvasKit: CanvasKit;
+    fontManager: FontManager;
+    imageManager: ImageManager;
+    now: number;
+    deltaTime: number;
+    canvasScale: number;
+    rootScale: number;
+    canvasCssWidth: number;
+    canvasCssHeight: number;
+}
+
+declare global {
+    var Globals: GlobalVariables;
+}
+
+/**
+ * Position in two-dimensional space.
+ */
+declare class Point {
+    x: number;
+    y: number;
+    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;
+    /** Point that was tapped on entity, relative to the entity coordinate system */
+    point: Point;
+}
+
+interface Constraints {
+    topToTopOf?: Entity | string;
+    topToBottomOf?: Entity | string;
+    bottomToTopOf?: Entity | string;
+    bottomToBottomOf?: Entity | string;
+    startToStartOf?: Entity | string;
+    startToEndOf?: Entity | string;
+    endToEndOf?: Entity | string;
+    endToStartOf?: Entity | string;
+    horizontalBias?: number;
+    verticalBias?: number;
+    [key: string]: Entity | string | number | undefined;
+}
+
+/**
+ * The Layout allows relative positioning via constraints.
+ * This is not fully implemented yet: DO NOT USE!
+ * We use it internally for instructions.
+ */
+interface Layout {
+    height?: number;
+    width?: number;
+    marginStart?: number;
+    marginEnd?: number;
+    marginTop?: number;
+    marginBottom?: number;
+    constraints?: Constraints;
+}
+
+/**
+ * Width and height on two-dimensional space
+ */
+declare class Size {
+    width: number;
+    height: number;
+    constructor(width?: number, height?: number);
+}
+
+interface EntityOptions {
+    name?: string;
+    position?: Point;
+    scale?: number;
+    isUserInteractionEnabled?: boolean;
+    hidden?: boolean;
+    layout?: Layout;
+}
+
+declare enum EntityType {
+    entity = "Entity",
+    scene = "Scene",
+    sprite = "Sprite",
+    label = "Label",
+    textline = "TextLine",
+    shape = "Shape",
+    composite = "Composite"
+}
+
+declare function handleInterfaceOptions(entity: Entity, options: EntityOptions): void;
+declare abstract class Entity {
+    type: EntityType;
+    isDrawable: boolean;
+    isShape: boolean;
+    isText: boolean;
+    name: string;
+    position: Point;
+    scale: number;
+    isUserInteractionEnabled: boolean;
+    hidden: boolean;
+    layout: Layout;
+    parent?: Entity;
+    children: Entity[];
+    absolutePosition: Point;
+    size: Size;
+    absoluteScale: number;
+    actions: Action[];
+    queuedAction?: Action;
+    originalActions: Action[];
+    tapListeners: TapListener[];
+    uuid: string;
+    needsInitialization: boolean;
+    userData: any;
+    loopMessages: Set<string>;
+    constructor(options?: EntityOptions);
+    initialize(): void;
+    /**
+     * Overrides toString() and returns a human-friendly description of the entity.
+     *
+     * @remarks Inspiration from https://stackoverflow.com/a/35361695
+     */
+    toString: () => string;
+    /**
+     * Adds a child to this parent entity. Thows exception if the child's name is not unique with respect to other children of this parent.
+     *
+     * @param child - The child entity to add
+     */
+    addChild(child: Entity): void;
+    /**
+     * Removes all children from the entity
+     */
+    removeAllChildren(): void;
+    /**
+     * Removes the specific child from this parent entity. Throws exception if this parent does not contain the child.
+     *
+     * @param child
+     */
+    removeChild(child: Entity): void;
+    /**
+     * Searches all descendants by name and returns first matching entity. Descendants are children and children of children, recursively.
+     *
+     * @param name - Name of the descendant entity to return
+     * @returns
+     */
+    descendant<T extends Entity>(name: string): T;
+    /**
+     * Returns all descendant entities. Descendants are children and children of children, recursively.
+     */
+    get descendants(): Array<Entity>;
+    onTap(codeCallback: (tapEvent: TapEvent) => void, replaceExistingCodeCallback?: boolean): void;
+    private parseLayoutConstraints;
+    private calculateYFromConstraint;
+    private calculateXFromConstraint;
+    update(): void;
+    /**
+     * Draws each child entity that is Drawable and is not hidden, by zPosition order (highest zPosition on top).
+     *
+     * @param canvas - CanvasKit canvas
+     */
+    drawChildren(canvas: Canvas): void;
+    /**
+     * Runs an action on this entity.
+     *
+     * @remarks If the entity is part of an active scene, the action runs immediately. Otherwise, the action will run when the entity's scene becomes active. Calling run() multiple times on an entity will add to existing actions, not replace them.
+     *
+     * @param action - The action to run
+     * @param key - key (string identifier) used to identify the action. Only needed if the action will be referred to later
+     */
+    run(action: Action, key?: string): void;
+    /**
+     * Remove an action from this entity. If the action is running, it will be stopped.
+     *
+     * @param key - key (string identifier) of the action to remove
+     */
+    removeAction(key: string): void;
+    /**
+     * Remove all actions from this entity. If actions are running, they will be stopped.
+     */
+    removeAllActions(): void;
+    private static getEntityOptions;
+    private static getDrawableOptions;
+    private static getTextOptions;
+    /**
+     * Gets the scene that contains this entity by searching up the ancestor tree recursively. Throws exception if entity is not part of a scene.
+     *
+     * @returns Scene that contains this entity
+     */
+    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
+     */
+    private findTopologicalSort;
+}
+
+interface MoveActionOptions {
+    /** Destination point. The point is relative to the entity's parent coordinate system */
+    point: Point;
+    /** Duration of move, in milliseconds */
+    duration: number;
+    /** Should the action run during screen transitions? Default is no */
+    runDuringTransition?: boolean;
+}
+
+interface WaitActionOptions {
+    /** Duration of wait, in milliseconds */
+    duration: number;
+    /** Should the action run during screen transitions? Default is no */
+    runDuringTransition?: boolean;
+}
+
+interface CustomActionOptions {
+    /** callback - The callback function to be executed  */
+    callback: () => void;
+    /** Should the action run during screen transitions? Default is no */
+    runDuringTransition?: boolean;
+}
+
+interface ScaleActionOptions {
+    /** The scaling ratio. 1 is no change, greater than 1 is make bigger, less than 1 is make smaller */
+    scale: number;
+    /** Duration of scale, in milliseconds */
+    duration: number;
+    /** Should the action run during screen transitions? Default is no */
+    runDuringTransition?: boolean;
+}
+
+interface IActionContainer {
+    children?: Array<Action>;
+}
+
+declare enum ActionType {
+    sequence = "Sequence",
+    group = "Group",
+    wait = "Wait",
+    custom = "Custom",
+    move = "Move",
+    scale = "Scale"
+}
+
+declare abstract class Action {
+    abstract type: ActionType;
+    startOffset: number;
+    endOffset: number;
+    started: boolean;
+    running: boolean;
+    completed: boolean;
+    runStartTime: number;
+    duration: number;
+    runDuringTransition: boolean;
+    parent?: Action;
+    isParent: boolean;
+    isChild: boolean;
+    key?: string;
+    constructor(runDuringTransition?: boolean);
+    /**
+     * Creates an action that will move an entity to a point on the screen.
+     *
+     * @param options - {@link MoveActionOptions}
+     * @returns The move action
+     */
+    static Move(options: MoveActionOptions): Action;
+    /**
+     * 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;
+    /**
+     * Creates an action that will execute a callback function.
+     *
+     * @param options - {@link CustomActionOptions}
+     * @returns The custom action
+     */
+    static Custom(options: CustomActionOptions): Action;
+    /**
+     * Creates an action that will scale the entity's size.
+     *
+     * @remarks Scaling is relative to any inherited scaling, which is multiplicative. For example, if the entity's parent is scaled to 2.0 and this entity's action scales to 3.0, then the entity will appear 6 times as large as original.
+     *
+     * @param options - {@link ScaleActionOptions}
+     * @returns The scale action
+     */
+    static Scale(options: ScaleActionOptions): Action;
+    /**
+     * 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.
+     *
+     * @param actions - One or more actions that form the sequence
+     * @returns
+     */
+    static Sequence(actions: Array<Action>): Action;
+    /**
+     * 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.
+     *
+     * @param actions - One or more actions that form the group
+     * @returns
+     */
+    static Group(actions: Array<Action>): Action;
+    initialize(entity: Entity, key?: string): Array<Action>;
+    static cloneAction(action: Action, key?: string): Action;
+    static evaluateAction(action: Action, entity: Entity, now: number, dt: number): void;
+    private calculateDuration;
+    private calculateStartEndOffsets;
+    private flattenActions;
+    private assignParents;
+}
+declare class SequenceAction extends Action implements IActionContainer {
+    type: ActionType;
+    children: Array<Action>;
+    constructor(actions: Array<Action>);
+}
+declare class GroupAction extends Action implements IActionContainer {
+    type: ActionType;
+    children: Action[];
+    constructor(actions: Array<Action>);
+}
+declare class CustomAction extends Action {
+    type: ActionType;
+    codeCallback: () => void;
+    constructor(codeCallback: () => void, runDuringTransition?: boolean);
+}
+declare class WaitAction extends Action {
+    type: ActionType;
+    constructor(duration: number, runDuringTransition: boolean);
+}
+declare class MoveAction extends Action {
+    type: ActionType;
+    point: Point;
+    dx: number;
+    dy: number;
+    constructor(point: Point, duration: number, runDuringTransition: boolean);
+}
+declare class ScaleAction extends Action {
+    type: ActionType;
+    scale: number;
+    delta: number;
+    constructor(scale: number, duration: number, runDuringTransition?: boolean);
+}
+
+interface IDrawable {
+    draw(canvas: Canvas): void;
+    anchorPoint: Point;
+    zPosition: number;
+}
+
+interface DrawableOptions {
+    anchorPoint?: Point;
+    zPosition?: number;
+}
+
+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;
+}
+
+/**
+ * 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];
+
+/**
+ * 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 SceneOptions extends EntityOptions, DrawableOptions {
+    backgroundColor?: RgbaColor;
+}
+
+declare class Scene extends Entity implements IDrawable {
+    readonly type = EntityType.scene;
+    isDrawable: boolean;
+    anchorPoint: Point;
+    zPosition: number;
+    private _backgroundColor;
+    _active: boolean;
+    _transitioning: boolean;
+    _setupCallback?: (scene: Scene) => void;
+    private _game?;
+    private backgroundPaint?;
+    /**
+     * Top-level entity that holds all other entities, 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
+     * @see {@link SceneOptions}
+     */
+    constructor(options?: SceneOptions);
+    initialize(): void;
+    set game(game: Game);
+    get game(): Game;
+    get backgroundColor(): RgbaColor;
+    set backgroundColor(backgroundColor: RgbaColor);
+    /**
+     * Code that will be called every time the screen is shown.
+     *
+     * @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.
+     *
+     * @param codeCallback
+     */
+    setup(codeCallback: (scene: Scene) => void): void;
+    draw(canvas: Canvas): void;
+}
+
+declare abstract class Transition {
+    abstract type: TransitionType;
+    duration: number;
+    static push(direction: TransitionDirection, duration: number): PushTransition;
+}
+declare class PushTransition extends Transition {
+    type: TransitionType;
+    direction: TransitionDirection;
+    constructor(direction: TransitionDirection, duration: number);
+}
+declare enum TransitionType {
+    push = "Push"
+}
+declare enum TransitionDirection {
+    up = "Up",
+    down = "Down",
+    right = "Right",
+    left = "Left"
+}
+declare class SceneTransition {
+    scene: Scene;
+    transition?: Transition | undefined;
+    constructor(scene: Scene, transition?: Transition | undefined);
+}
+
+/**
+ * Options to specify HTML canvas, set game canvas size, and load game assets.
+ */
+interface GameInitOptions {
+    /** Id of the HTML canvas that game will be drawn on. If not provided, the first canvas found will be used */
+    canvasId?: string;
+    /** Width of game canvas */
+    width: number;
+    /** Height of game canvas */
+    height: number;
+    /** Stretch to fill screen? Default is false */
+    stretch?: boolean;
+    /** Schema of trial data; JSON object where key is variable name, value is data type */
+    trialSchema?: object;
+    /** Default game parameters; JSON object where key is the game parameter, value is default value */
+    defaultParameters?: object;
+    /** 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[];
+    /** Show FPS in upper left corner? Default is false */
+    showFps?: boolean;
+    /** Color of the html body, if the game does not fill the screen. Useful for showing scene boundaries. Default is the scene background color */
+    bodyBackgroundColor?: RgbaColor;
+    /** Adapt execution for unit testing? Default is false */
+    _unitTesting?: boolean;
+}
+
+interface TrialData {
+    [key: string]: string | number | boolean | undefined | null;
+}
+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 {
+    entryScene?: Scene | string;
+    parameters: any;
+    private defaultParameters;
+    data: GameData;
+    trialNumber: number;
+    trialSchema: {};
+    lifecycle: LifecycleCallbacks;
+    private trialSchemaMap;
+    private htmlCanvas?;
+    private scratchHtmlCanvas?;
+    private surface?;
+    private showFps?;
+    private bodyBackgroundColor?;
+    private currentScene?;
+    private priorUpdateTime?;
+    private fpsTextFont?;
+    private fpsTextPaint?;
+    private drawnFrames;
+    private lastFpsUpdate;
+    private nextFpsUpdate;
+    private fps;
+    private animationFramesRequested;
+    private limitFps;
+    private unitTesting;
+    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) => void): void;
+    /**
+     * Adds a scene to the game.
+     *
+     * @remarks A scene, and its children entities, cannot be preseneted unless it has been added to the game object.
+     *
+     * @param scene
+     */
+    addScene(scene: Scene): void;
+    addScenes(scenes: Array<Scene>): void;
+    /**
+     * Specifies the scene that will be presented upon the next frame draw.
+     *
+     * @param scene
+     * @param transition
+     */
+    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.
+     * @param parameterName - the name of the game parameter whose value is requested
+     * @returns
+     */
+    getParameter<T>(parameterName: string): T;
+    /**
+     * Starts the game loop. If entryScene is undefined, the game object's entryScene must be set.
+     *
+     * @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;
+    addTrialData(variableName: string, value: any): void;
+    private loadCanvasKit;
+    private setupHtmlCanvases;
+    private fetchFonts;
+    private renderSvgImages;
+    private loadFonts;
+    private setupCanvasKitSurface;
+    private setupFpsFont;
+    private setupEventHandlers;
+    private loop;
+    private updateGameTime;
+    private handleIncomingSceneTransitions;
+    private update;
+    private draw;
+    private takeCurrentSceneSnapshot;
+    private animateSceneTransition;
+    private drawFps;
+    /**
+     * Creates a tap 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.
+     *
+     * @param entityName
+     * @param codeCallback
+     * @param replaceExistingCodeCallback
+     */
+    createTapListener(entityName: string, codeCallback: (tapEvent: TapEvent) => void, replaceExistingCodeCallback?: boolean): void;
+    /**
+     * Returns array of all entities that have been added to the game object.
+     */
+    get entities(): Array<Entity>;
+    private htmlCanvasMouseDownHandler;
+    private htmlCanvasTouchStartHandler;
+    private processTaps;
+    private handleEntityTapped;
+    private tapIsWithinEntityBounds;
+    private calculateEntityAbsoluteBoundingBox;
+}
+
+interface IText {
+    text?: string;
+    fontName?: string;
+    fontColor?: RgbaColor;
+    fontSize?: number;
+}
+
+interface TextOptions {
+    text?: string;
+    fontName?: string;
+    fontColor?: RgbaColor;
+    fontSize?: number;
+}
+
+declare enum LabelHorizontalAlignmentMode {
+    center = 0,
+    left = 1,
+    right = 2
+}
+
+interface LabelOptions extends EntityOptions, DrawableOptions, TextOptions {
+    horizontalAlignmentMode?: LabelHorizontalAlignmentMode;
+    preferredMaxLayoutWidth?: number;
+    backgroundColor?: RgbaColor;
+}
+
+declare class Label extends Entity implements IDrawable, IText {
+    readonly type = EntityType.label;
+    isDrawable: boolean;
+    isText: boolean;
+    anchorPoint: Point;
+    zPosition: number;
+    private _text;
+    private _fontName;
+    private _fontColor;
+    private _fontSize;
+    private _horizontalAlignmentMode;
+    private _preferredMaxLayoutWidth;
+    private _backgroundColor?;
+    private paragraph?;
+    private paraStyle?;
+    /**
+     * Single or multi-line text formatted and rendered on the screen.
+     *
+     * @remarks  Label (in contrast to TextLine) has enhanced text support for line wrapping, centering/alignment, and background colors.
+     *
+     * @param options
+     */
+    constructor(options?: LabelOptions);
+    initialize(): void;
+    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 horizontalAlignmentMode(): LabelHorizontalAlignmentMode;
+    set horizontalAlignmentMode(horizontalAlignmentMode: LabelHorizontalAlignmentMode);
+    get preferredMaxLayoutWidth(): number | undefined;
+    set preferredMaxLayoutWidth(preferredMaxLayoutWidth: number | undefined);
+    get backgroundColor(): RgbaColor | undefined;
+    set backgroundColor(backgroundColor: RgbaColor | undefined);
+    update(): void;
+    draw(canvas: Canvas): void;
+}
+
+/**
+ * This class is used internally for processing layout constraints that
+ * have been defined according to the Contraints interface.
+ *
+ * Imagine we have two entities, A and B. B's position is set
+ * using its position property. A's position is set using the layout
+ * constraint "bottomToTopOf B." A is the focal entity in this example.
+ * What this means is that A's y coordinate will be computed such that
+ * the bottom of A is the top of B. If A and B are squares, then A sits
+ * on top of B with no gap.
+ */
+declare class LayoutConstraint {
+    type: ConstraintType;
+    alterEntity: Entity;
+    verticalConstraint: boolean;
+    focalEntityMinimum: boolean;
+    alterEntityMinimum: boolean;
+    verticalTypes: ConstraintType[];
+    focalEntityMinimumTypes: ConstraintType[];
+    alterEntityMinimumTypes: ConstraintType[];
+    constructor(type: ConstraintType, alterEntity: Entity);
+}
+
+declare class RandomDraws {
+    /**
+     * Draw random integers, without replacement, from a uniform distribution.
+     *
+     * @param n
+     * @param minimumInclusive
+     * @param maximumInclusive
+     * @returns array of integers
+     */
+    static FromRangeWithoutReplacement(n: number, minimumInclusive: number, maximumInclusive: number): Array<number>;
+    /**
+     * Draw random grid cell locations, without replacement, from a uniform distribution of all grid cells. Grid cell locations are zero-based, i.e., upper-left is (0,0).
+     *
+     * @param n - Number of draws
+     * @param rows  - Number of rows in grid; must be at least 1
+     * @param columns - Number of columns in grid; must be at least 1
+     * @param predicate - Optional lambda function that takes a grid row number and grid column number pair and returns a boolean to indicate if the pair should be allowed. For example, if one wanted to constrain the random grid location to be along the diagonal, the predicate would be: (row, column) => row === column
+     * @returns array of grid cells. Each cell is object in form of { row: number, column: number }). Grid cell locations are zero-based
+     */
+    static FromGridWithoutReplacement(n: number, rows: number, columns: number, predicate?: (row: number, column: number) => boolean): Array<{
+        row: number;
+        column: number;
+    }>;
+}
+
+interface RectOptions {
+    origin?: Point;
+    size?: Size;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+}
+
+declare class Rect implements RectOptions {
+    origin?: Point;
+    size?: Size;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    constructor(options: RectOptions);
+}
+
+interface ShapeOptions extends EntityOptions, DrawableOptions {
+    circleOfRadius?: number;
+    rect?: Rect;
+    cornerRadius?: number;
+    fillColor?: RgbaColor;
+    strokeColor?: RgbaColor;
+    lineWidth?: number;
+}
+
+declare enum ShapeType {
+    undefined = "Undefined",
+    rectangle = "Rectangle",
+    circle = "Circle"
+}
+
+declare class Shape extends Entity implements IDrawable {
+    readonly type = EntityType.shape;
+    isDrawable: boolean;
+    isShape: boolean;
+    anchorPoint: Point;
+    zPosition: number;
+    shapeType: ShapeType;
+    circleOfRadius?: number;
+    rect?: Rect;
+    cornerRadius: number;
+    private _fillColor;
+    private _strokeColor?;
+    lineWidth?: number;
+    private fillColorPaint?;
+    private strokeColorPaint?;
+    /**
+     * Rectangular shape
+     *
+     * @param options
+     */
+    constructor(options?: ShapeOptions);
+    initialize(): void;
+    get fillColor(): RgbaColor;
+    set fillColor(fillColor: RgbaColor);
+    get strokeColor(): RgbaColor | undefined;
+    set strokeColor(strokeColor: RgbaColor | undefined);
+    update(): void;
+    draw(canvas: Canvas): void;
+}
+
+interface SpriteOptions extends EntityOptions, DrawableOptions {
+    imageName?: string;
+}
+
+declare class Sprite extends Entity implements IDrawable {
+    readonly type = EntityType.sprite;
+    isDrawable: boolean;
+    anchorPoint: Point;
+    zPosition: number;
+    private _imageName;
+    private loadedImage?;
+    /**
+     * Visual image displayed on the screen.
+     *
+     * @remarks Sprites must be loaded during the Game.init() method prior to their use.
+     *
+     * @param options
+     */
+    constructor(options?: SpriteOptions);
+    initialize(): void;
+    set imageName(imageName: string);
+    get imageName(): string;
+    update(): void;
+    draw(canvas: Canvas): void;
+}
+
+interface StoryOptions {
+    sceneNamePrefix: string;
+}
+
+declare abstract class Story {
+    static Create(options: StoryOptions): Array<Scene>;
+}
+
+interface TextLineOptions extends EntityOptions, DrawableOptions, TextOptions {
+    width?: number;
+}
+
+declare class TextLine extends Entity implements IDrawable, IText {
+    readonly type = EntityType.textline;
+    isDrawable: boolean;
+    isText: boolean;
+    zPosition: number;
+    anchorPoint: Point;
+    private _text;
+    private _fontName;
+    private _fontColor;
+    private _fontSize;
+    private paint?;
+    private font?;
+    /**
+     * Single-line text rendered on the screen.
+     *
+     * @remarks TextLine has no paragraph formatting options; Label will be preferred in most use cases.
+     *
+     * @param options
+     */
+    constructor(options?: TextLineOptions);
+    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);
+    update(): void;
+    initialize(): void;
+    draw(canvas: Canvas): void;
+}
+
+declare class Timer {
+    private originTime;
+    private startTime;
+    private stopTime;
+    private stopped;
+    private _elapsed;
+    private name;
+    private static _timers;
+    constructor(name: string);
+    static Start(name: string): void;
+    static Stop(name: string): void;
+    static Restart(name: string): void;
+    static Elapsed(name: string): number;
+    static Remove(name: string): void;
+    static Exists(name: string): boolean;
+    static RemoveAll(): void;
+}
+
+declare class WebColors {
+    static Transparent: RgbaColor;
+    static MediumVioletRed: RgbaColor;
+    static DeepPink: RgbaColor;
+    static PaleVioletRed: RgbaColor;
+    static HotPink: RgbaColor;
+    static LightPink: RgbaColor;
+    static Pink: RgbaColor;
+    static DarkRed: RgbaColor;
+    static Red: RgbaColor;
+    static Firebrick: RgbaColor;
+    static Crimson: RgbaColor;
+    static IndianRed: RgbaColor;
+    static LightCoral: RgbaColor;
+    static Salmon: RgbaColor;
+    static DarkSalmon: RgbaColor;
+    static LightSalmon: RgbaColor;
+    static OrangeRed: RgbaColor;
+    static Tomato: RgbaColor;
+    static DarkOrange: RgbaColor;
+    static Coral: RgbaColor;
+    static Orange: RgbaColor;
+    static DarkKhaki: RgbaColor;
+    static Gold: RgbaColor;
+    static Khaki: RgbaColor;
+    static PeachPuff: RgbaColor;
+    static Yellow: RgbaColor;
+    static PaleGoldenrod: RgbaColor;
+    static Moccasin: RgbaColor;
+    static PapayaWhip: RgbaColor;
+    static LightGoldenrodYellow: RgbaColor;
+    static LemonChiffon: RgbaColor;
+    static LightYellow: RgbaColor;
+    static Maroon: RgbaColor;
+    static Brown: RgbaColor;
+    static SaddleBrown: RgbaColor;
+    static Sienna: RgbaColor;
+    static Chocolate: RgbaColor;
+    static DarkGoldenrod: RgbaColor;
+    static Peru: RgbaColor;
+    static RosyBrown: RgbaColor;
+    static Goldenrod: RgbaColor;
+    static SandyBrown: RgbaColor;
+    static Tan: RgbaColor;
+    static Burlywood: RgbaColor;
+    static Wheat: RgbaColor;
+    static NavajoWhite: RgbaColor;
+    static Bisque: RgbaColor;
+    static BlanchedAlmond: RgbaColor;
+    static Cornsilk: RgbaColor;
+    static DarkGreen: RgbaColor;
+    static Green: RgbaColor;
+    static DarkOliveGreen: RgbaColor;
+    static ForestGreen: RgbaColor;
+    static SeaGreen: RgbaColor;
+    static Olive: RgbaColor;
+    static OliveDrab: RgbaColor;
+    static MediumSeaGreen: RgbaColor;
+    static LimeGreen: RgbaColor;
+    static Lime: RgbaColor;
+    static SpringGreen: RgbaColor;
+    static MediumSpringGreen: RgbaColor;
+    static DarkSeaGreen: RgbaColor;
+    static MediumAquamarine: RgbaColor;
+    static YellowGreen: RgbaColor;
+    static LawnGreen: RgbaColor;
+    static Chartreuse: RgbaColor;
+    static LightGreen: RgbaColor;
+    static GreenYellow: RgbaColor;
+    static PaleGreen: RgbaColor;
+    static Teal: RgbaColor;
+    static DarkCyan: RgbaColor;
+    static LightSeaGreen: RgbaColor;
+    static CadetBlue: RgbaColor;
+    static DarkTurquoise: RgbaColor;
+    static MediumTurquoise: RgbaColor;
+    static Turquoise: RgbaColor;
+    static Aqua: RgbaColor;
+    static Cyan: RgbaColor;
+    static Aquamarine: RgbaColor;
+    static PaleTurquoise: RgbaColor;
+    static LightCyan: RgbaColor;
+    static Navy: RgbaColor;
+    static DarkBlue: RgbaColor;
+    static MediumBlue: RgbaColor;
+    static Blue: RgbaColor;
+    static MidnightBlue: RgbaColor;
+    static RoyalBlue: RgbaColor;
+    static SteelBlue: RgbaColor;
+    static DodgerBlue: RgbaColor;
+    static DeepSkyBlue: RgbaColor;
+    static CornflowerBlue: RgbaColor;
+    static SkyBlue: RgbaColor;
+    static LightSkyBlue: RgbaColor;
+    static LightSteelBlue: RgbaColor;
+    static LightBlue: RgbaColor;
+    static PowderBlue: RgbaColor;
+    static Indigo: RgbaColor;
+    static Purple: RgbaColor;
+    static DarkMagenta: RgbaColor;
+    static DarkViolet: RgbaColor;
+    static DarkSlateBlue: RgbaColor;
+    static BlueViolet: RgbaColor;
+    static DarkOrchid: RgbaColor;
+    static Fuchsia: RgbaColor;
+    static Magenta: RgbaColor;
+    static SlateBlue: RgbaColor;
+    static MediumSlateBlue: RgbaColor;
+    static MediumOrchid: RgbaColor;
+    static MediumPurple: RgbaColor;
+    static Orchid: RgbaColor;
+    static Violet: RgbaColor;
+    static Plum: RgbaColor;
+    static Thistle: RgbaColor;
+    static Lavender: RgbaColor;
+    static MistyRose: RgbaColor;
+    static AntiqueWhite: RgbaColor;
+    static Linen: RgbaColor;
+    static Beige: RgbaColor;
+    static WhiteSmoke: RgbaColor;
+    static LavenderBlush: RgbaColor;
+    static OldLace: RgbaColor;
+    static AliceBlue: RgbaColor;
+    static Seashell: RgbaColor;
+    static GhostWhite: RgbaColor;
+    static Honeydew: RgbaColor;
+    static FloralWhite: RgbaColor;
+    static Azure: RgbaColor;
+    static MintCream: RgbaColor;
+    static Snow: RgbaColor;
+    static Ivory: RgbaColor;
+    static White: RgbaColor;
+    static Black: RgbaColor;
+    static DarkSlateGray: RgbaColor;
+    static DimGray: RgbaColor;
+    static SlateGray: RgbaColor;
+    static Gray: RgbaColor;
+    static LightSlateGray: RgbaColor;
+    static DarkGray: RgbaColor;
+    static Silver: RgbaColor;
+    static LightGray: RgbaColor;
+    static Gainsboro: RgbaColor;
+    static RebeccaPurple: RgbaColor;
+}
+
+export { Action, Composite, CompositeOptions, Constants, ConstraintType, Constraints, CustomAction, CustomActionOptions, Dimensions, DrawableOptions, Entity, EntityOptions, EntityType, FontData, FontManager, Game, 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 };