Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

37.1 KB
Raw Blame
/**
 * @file    wasm.generated.ts
 * @brief   ESEngine WASM Bindings TypeScript Definitions
 * @details Generated by EHT - DO NOT EDIT
 */

import type { Entity, Vec2, Vec3, Vec4, Quat } from '../types';

// Additional Math Types
export interface UVec2 { x: number; y: number; }
export interface Padding { left: number; top: number; right: number; bottom: number; }
export interface Dimension { value: number; unit: number; }
export type Mat4 = number[];

// Emscripten Vector Types
export interface VectorEntity {
    size(): number;
    get(index: number): number;
    push_back(value: number): void;
    set(index: number, value: number): boolean;
    delete(): void;
}

export interface VectorFloat {
    size(): number;
    get(index: number): number;
    push_back(value: number): void;
    set(index: number, value: number): boolean;
    delete(): void;
}

// Enums

export enum AlignContent {
    Start = 0,
    Center = 1,
    End = 2,
    Stretch = 3,
    SpaceBetween = 4,
    SpaceAround = 5,
}

export enum AlignItems {
    Start = 0,
    Center = 1,
    End = 2,
    Stretch = 3,
}

export enum AlignSelf {
    Auto = 0,
    Start = 1,
    Center = 2,
    End = 3,
    Stretch = 4,
}

/**
 * The engine's `BillboardMode`, generated from the C++ enum.
 *
 * @beta
 */
export enum BillboardMode {
    ViewPlane = 0,
    Upright = 1,
}

export enum BodyType {
    Static = 0,
    Kinematic = 1,
    Dynamic = 2,
}

export enum CanvasScaleMode {
    FixedWidth = 0,
    FixedHeight = 1,
    Expand = 2,
    Shrink = 3,
    Match = 4,
}

/**
 * The engine's `ClearFlags`, generated from the C++ enum.
 *
 * @beta
 */
export enum ClearFlags {
    Nothing = 0,
    Color = 1,
    Depth = 2,
    ColorAndDepth = 3,
}

/**
 * The engine's `EasingType`, generated from the C++ enum.
 *
 * @experimental
 */
export enum EasingType {
    Linear = 0,
    EaseInQuad = 1,
    EaseOutQuad = 2,
    EaseInOutQuad = 3,
    EaseInCubic = 4,
    EaseOutCubic = 5,
    EaseInOutCubic = 6,
    EaseInBack = 7,
    EaseOutBack = 8,
    EaseInOutBack = 9,
    EaseInElastic = 10,
    EaseOutElastic = 11,
    EaseInOutElastic = 12,
    EaseOutBounce = 13,
    CubicBezier = 14,
    Step = 15,
    EaseInSine = 16,
    EaseOutSine = 17,
    EaseInOutSine = 18,
    EaseInQuart = 19,
    EaseOutQuart = 20,
    EaseInOutQuart = 21,
    EaseInQuint = 22,
    EaseOutQuint = 23,
    EaseInOutQuint = 24,
    EaseInExpo = 25,
    EaseOutExpo = 26,
    EaseInOutExpo = 27,
    EaseInCirc = 28,
    EaseOutCirc = 29,
    EaseInOutCirc = 30,
    EaseInBounce = 31,
    EaseInOutBounce = 32,
    Smoothstep = 33,
    Smootherstep = 34,
}

/**
 * The engine's `EmitterShape`, generated from the C++ enum.
 *
 * @beta
 */
export enum EmitterShape {
    Point = 0,
    Circle = 1,
    Box = 2,
    Cone = 3,
    Sphere = 4,
    Hemisphere = 5,
}

export enum FlexDirection {
    Row = 0,
    Column = 1,
    RowReverse = 2,
    ColumnReverse = 3,
}

export enum FlexWrap {
    NoWrap = 0,
    Wrap = 1,
}

export enum ForceFieldType {
    Directional = 0,
    Point = 1,
    Vortex = 2,
    Drag = 3,
}

export enum JustifyContent {
    Start = 0,
    Center = 1,
    End = 2,
    SpaceBetween = 3,
    SpaceAround = 4,
    SpaceEvenly = 5,
}

export enum LightType {
    Point = 0,
    Directional = 1,
    Ambient = 2,
    Spot = 3,
}

/**
 * The engine's `LoopMode`, generated from the C++ enum.
 *
 * @experimental
 */
export enum LoopMode {
    None = 0,
    Restart = 1,
    PingPong = 2,
}

export enum MaskMode {
    Scissor = 0,
    Stencil = 1,
}

/**
 * The engine's `ParticleColliderShape`, generated from the C++ enum.
 *
 * @beta
 */
export enum ParticleColliderShape {
    Sphere = 0,
    Box = 1,
    Capsule = 2,
}

/**
 * The engine's `ParticleCollisionFallback`, generated from the C++ enum.
 *
 * @beta
 */
export enum ParticleCollisionFallback {
    Floor = 0,
    Skip = 1,
}

/**
 * The engine's `ParticleCollisionMode`, generated from the C++ enum.
 *
 * @beta
 */
export enum ParticleCollisionMode {
    Floor = 0,
    Physics2D = 1,
    Physics3D = 2,
    Depth = 3,
    Sdf = 4,
}

/**
 * The engine's `ParticleEasing`, generated from the C++ enum.
 *
 * @beta
 */
export enum ParticleEasing {
    Linear = 0,
    EaseIn = 1,
    EaseOut = 2,
    EaseInOut = 3,
}

/**
 * The engine's `ParticleRenderMode`, generated from the C++ enum.
 *
 * @beta
 */
export enum ParticleRenderMode {
    Billboard = 0,
    Stretched = 1,
}

/**
 * The engine's `ProjectionType`, generated from the C++ enum.
 *
 * @beta
 */
export enum ProjectionType {
    Perspective = 0,
    Orthographic = 1,
}

export enum ReflectionAxis {
    X = 0,
    Y = 1,
    Z = 2,
}

export enum ReflectionQuality {
    Project = 0,
    Custom = 1,
}

export enum ReflectionUpdate {
    EveryFrame = 0,
    FixedRate = 1,
    OnDemand = 2,
}

export enum ScrollMovement {
    Clamped = 0,
    Elastic = 1,
}

export enum ShapeType {
    Circle = 0,
    Capsule = 1,
    RoundedRect = 2,
}

/**
 * The engine's `SimulationSpace`, generated from the C++ enum.
 *
 * @beta
 */
export enum SimulationSpace {
    World = 0,
    Local = 1,
}

export enum SpringBoneShape {
    Sphere = 0,
    Capsule = 1,
}

/**
 * The engine's `SpriteDrawMode`, generated from the C++ enum.
 *
 * @public
 */
export enum SpriteDrawMode {
    Auto = 0,
    Simple = 1,
    Tiled = 2,
    NineSlice = 3,
}

/**
 * The engine's `SpriteMaskInteraction`, generated from the C++ enum.
 *
 * @public
 */
export enum SpriteMaskInteraction {
    None = 0,
    VisibleInside = 1,
    VisibleOutside = 2,
}

/**
 * The engine's `SubEmitterTrigger`, generated from the C++ enum.
 *
 * @beta
 */
export enum SubEmitterTrigger {
    Death = 0,
    Birth = 1,
    Collision = 2,
}

export enum TextAlign {
    Left = 0,
    Center = 1,
    Right = 2,
}

/**
 * The engine's `TilemapOrientation`, generated from the C++ enum.
 *
 * @beta
 */
export enum TilemapOrientation {
    Orthogonal = 0,
    Isometric = 1,
    Staggered = 2,
    Hexagonal = 3,
}

/**
 * The engine's `TilemapStaggerAxis`, generated from the C++ enum.
 *
 * @beta
 */
export enum TilemapStaggerAxis {
    Y = 0,
    X = 1,
}

/**
 * The engine's `TilemapStaggerIndex`, generated from the C++ enum.
 *
 * @beta
 */
export enum TilemapStaggerIndex {
    Odd = 0,
    Even = 1,
}

/**
 * The engine's `TweenState`, generated from the C++ enum.
 *
 * @experimental
 */
export enum TweenState {
    Running = 0,
    Paused = 1,
    Completed = 2,
    Cancelled = 3,
}

/**
 * The engine's `TweenTarget`, generated from the C++ enum.
 *
 * @experimental
 */
export enum TweenTarget {
    PositionX = 0,
    PositionY = 1,
    PositionZ = 2,
    ScaleX = 3,
    ScaleY = 4,
    RotationZ = 5,
    ColorR = 6,
    ColorG = 7,
    ColorB = 8,
    ColorA = 9,
    SizeX = 10,
    SizeY = 11,
    CameraOrthoSize = 12,
}

export enum UIDisplay {
    Flex = 0,
    None = 1,
}

/**
 * The engine's `UIFillMethod`, generated from the C++ enum.
 *
 * @beta
 */
export enum UIFillMethod {
    Horizontal = 0,
    Vertical = 1,
    Radial360 = 2,
    Radial90 = 3,
    Radial180 = 4,
}

/**
 * The engine's `UIFillOrigin`, generated from the C++ enum.
 *
 * @beta
 */
export enum UIFillOrigin {
    Left = 0,
    Right = 1,
    Bottom = 2,
    Top = 3,
}

export enum UIPointerEvents {
    Auto = 0,
    None = 1,
    Receive = 2,
}

export enum UIPositionType {
    Relative = 0,
    Absolute = 1,
}

/**
 * The engine's `UIVisualFit`, generated from the C++ enum.
 *
 * @beta
 */
export enum UIVisualFit {
    Fill = 0,
    Contain = 1,
    Cover = 2,
}

/**
 * The engine's `UIVisualType`, generated from the C++ enum.
 *
 * @beta
 */
export enum UIVisualType {
    None = 0,
    SolidColor = 1,
    Image = 2,
    NineSlice = 3,
    Tiled = 4,
    Filled = 5,
}

// Components

export interface Billboard {
    mode: number;
    enabled: boolean;
}

export interface BitmapText {
    text: string;
    color: Vec4;
    fontSize: number;
    align: number;
    spacing: number;
    parallax: Vec2;
    layer: number;
    font: number;
    enabled: boolean;
}

export interface BoxCollider2D {
    halfExtents: Vec2;
    offset: Vec2;
    density: number;
    friction: number;
    restitution: number;
    isSensor: boolean;
    enabled: boolean;
    categoryBits: number;
    maskBits: number;
}

export interface BoxCollider3D {
    halfExtents: Vec3;
    center: Vec3;
    friction: number;
    restitution: number;
    isSensor: boolean;
    enabled: boolean;
}

export interface Camera {
    projectionType: number;
    fov: number;
    orthoSize: number;
    nearPlane: number;
    farPlane: number;
    aspectRatio: number;
    isActive: boolean;
    priority: number;
    viewport: Vec4;
    clearFlags: number;
    pixelPerfect: boolean;
    cullingMask: number;
    renderTarget: number;
}

export interface Canvas {
    designResolution: UVec2;
    pixelsPerUnit: number;
    scaleMode: number;
    matchWidthOrHeight: number;
    backgroundColor: Vec4;
    layer: number;
}

export interface CapsuleCollider2D {
    radius: number;
    halfHeight: number;
    offset: Vec2;
    density: number;
    friction: number;
    restitution: number;
    isSensor: boolean;
    enabled: boolean;
    categoryBits: number;
    maskBits: number;
}

export interface CapsuleCollider3D {
    radius: number;
    halfHeight: number;
    center: Vec3;
    friction: number;
    restitution: number;
    isSensor: boolean;
    enabled: boolean;
}

export interface CharacterController3D {
    velocity: Vec3;
    radius: number;
    halfHeight: number;
    maxSlope: number;
    stepHeight: number;
    snapDown: number;
    mass: number;
    pushForce: number;
    enabled: boolean;
    layer: number;
    isOnFloor: boolean;
    floorNormal: Vec3;
    realVelocity: Vec3;
}

export interface Children {
    entities: VectorEntity;
}

export interface CircleCollider2D {
    radius: number;
    offset: Vec2;
    density: number;
    friction: number;
    restitution: number;
    isSensor: boolean;
    enabled: boolean;
    categoryBits: number;
    maskBits: number;
}

export interface ContentRect {
    size: Vec2;
    pivot: Vec2;
}

export interface ConvexCollider3D {
    mesh: number;
    friction: number;
    restitution: number;
    isSensor: boolean;
    enabled: boolean;
}

export interface Draggable {
    enabled: boolean;
    dragThreshold: number;
    lockX: boolean;
    lockY: boolean;
    constrainMin: boolean;
    constraintMin: Vec2;
    constrainMax: boolean;
    constraintMax: Vec2;
}

export interface DragonBonesAnimation {
    skeletonPath: string;
    atlasPath: string;
    armature: string;
    animation: string;
    timeScale: number;
    loop: boolean;
    playing: boolean;
    fadeInTime: number;
    flipX: boolean;
    flipY: boolean;
    color: Vec4;
    layer: number;
    skeletonScale: number;
    material: number;
    enabled: boolean;
}

export interface FlexContainer {
    direction: number;
    wrap: number;
    justifyContent: number;
    alignItems: number;
    alignContent: number;
    gap: Vec2;
    padding: Padding;
}

export interface GroupOpacity {
    opacity: number;
    enabled: boolean;
}

export interface Impostor {
    screenSize: number;
    frames: number;
    resolution: number;
    enabled: boolean;
}

export interface Interactable {
    enabled: boolean;
    blockRaycast: boolean;
    raycastTarget: boolean;
}

export interface LODGroup {
    lod1: number;
    lod2: number;
    lod3: number;
    lod1Size: number;
    lod2Size: number;
    lod3Size: number;
    cullSize: number;
    hysteresis: number;
    enabled: boolean;
}

export interface Light {
    type: number;
    color: Vec4;
    intensity: number;
    radius: number;
    innerRadius: number;
    falloff: number;
    inverseSquare: boolean;
    shadowStrength: number;
    layerMin: number;
    layerMax: number;
    cookie: number;
    cookieSize: Vec2;
    innerAngle: number;
    outerAngle: number;
    shadowSoftness: number;
    sourceAngle: number;
    shadowDistance: number;
    meshShadows: boolean;
    shadowExtent: number;
    followEnvironmentSun: boolean;
    aimFollowedSun: boolean;
    environment: number;
    environmentRotation: number;
    drawEnvironment: boolean;
    reflectionScale: number;
    diffuseScale: number;
    diffuseTint: Vec4;
    reflectionSaturation: number;
    bakedTint: Vec4;
    hemisphere: boolean;
    groundColor: Vec4;
    enabled: boolean;
}

export interface LightProbeVolume {
    probes: number;
    capture: boolean;
    captureInterval: number;
    halfExtents: Vec3;
    spacing: number;
    enabled: boolean;
}

export interface MeshCollider3D {
    mesh: number;
    friction: number;
    restitution: number;
    layer: number;
    enabled: boolean;
}

export interface MeshInstances {
    lod1Mesh: number;
    lodDistance: number;
    minDistance: number;
    drawDistance: number;
    shadowDistance: number;
}

export interface MeshLightmap {
    lightmap: number;
    scaleOffset: Vec4;
}

export interface MeshMorph {
    weights: VectorFloat;
}

export interface MeshRenderer {
    texture: number;
    normalMap: number;
    color: Vec4;
    layer: number;
    opaque: boolean;
    cullBackfaces: boolean;
    lit: boolean;
    castShadows: boolean;
    parallax: Vec2;
    material: number;
    enabled: boolean;
    mesh: number;
}

export interface MeshSkin {
    joints: VectorEntity;
}

export interface Occluder {
    halfExtents: Vec3;
    enabled: boolean;
}

export interface Parent {
    entity: number;
}

export interface ParticleCollider {
    shape: number;
    radius: number;
    halfHeight: number;
    halfExtents: Vec3;
    inverted: boolean;
    mask: number;
    enabled: boolean;
}

export interface ParticleEmitter {
    rate: number;
    burstCount: number;
    burstInterval: number;
    duration: number;
    simulationSpeed: number;
    startDelay: number;
    looping: boolean;
    playOnStart: boolean;
    maxParticles: number;
    gpuSimulation: boolean;
    lifetimeMin: number;
    lifetimeMax: number;
    shape: number;
    shapeRadius: number;
    shapeSize: Vec3;
    shapeAngle: number;
    speedMin: number;
    speedMax: number;
    angleSpreadMin: number;
    angleSpreadMax: number;
    startSizeMin: number;
    startSizeMax: number;
    endSizeMin: number;
    endSizeMax: number;
    sizeEasing: number;
    startColor: Vec4;
    endColor: Vec4;
    colorEasing: number;
    rotationMin: number;
    rotationMax: number;
    angularVelocityMin: number;
    angularVelocityMax: number;
    gravity: Vec3;
    damping: number;
    addedVelocityMin: Vec3;
    addedVelocityMax: Vec3;
    speedLimit: number;
    limitDampen: number;
    noiseStrength: number;
    noiseFrequency: number;
    noiseScrollSpeed: number;
    noiseOctaves: number;
    texture: number;
    spriteColumns: number;
    spriteRows: number;
    spriteFPS: number;
    spriteLoop: boolean;
    blendMode: number;
    layer: number;
    material: number;
    simulationSpace: number;
    renderMode: number;
    velocityScale: number;
    lengthScale: number;
    enabled: boolean;
    subEmitterTrigger: number;
    subEmitterChance: number;
    subEmitterInheritVelocity: number;
    subEmitter: number;
    trailEnabled: boolean;
    trailWidth: number;
    trailPoints: number;
    trailMinDistance: number;
    collisionEnabled: boolean;
    collisionFloor: number;
    collisionMode: number;
    collisionMask: number;
    collisionQueryBudget: number;
    collisionMaxDistance: number;
    collisionFallback: number;
    collisionEvents: boolean;
    collisionEventBudget: number;
    collisionThickness: number;
    collisionBounce: number;
    collisionFriction: number;
    collisionLifetimeLoss: number;
}

export interface ParticleForceField {
    type: number;
    strength: number;
    radius: number;
    direction: Vec3;
    falloff: boolean;
    enabled: boolean;
}

export interface PlanarReflection {
    axis: number;
    clipOffset: number;
    cullingMask: number;
    quality: number;
    resolutionScale: number;
    maxSize: number;
    update: number;
    updatesPerSecond: number;
    revision: number;
    enabled: boolean;
}

export interface ReflectionProbe {
    reflection: number;
    halfExtents: Vec3;
    slot: number;
    enabled: boolean;
}

export interface RigidBody2D {
    bodyType: number;
    gravityScale: number;
    linearDamping: number;
    angularDamping: number;
    fixedRotation: boolean;
    bullet: boolean;
    enabled: boolean;
}

export interface RigidBody3D {
    bodyType: number;
    gravityScale: number;
    linearDamping: number;
    angularDamping: number;
    mass: number;
    fixedRotation: boolean;
    layer: number;
    continuousCollision: boolean;
    enabled: boolean;
}

export interface SegmentCollider2D {
    point1: Vec2;
    point2: Vec2;
    density: number;
    friction: number;
    restitution: number;
    isSensor: boolean;
    enabled: boolean;
    categoryBits: number;
    maskBits: number;
}

export interface ShadowCaster2D {
    size: Vec2;
    path: Vec2[];
    enabled: boolean;
}

export interface ShapeRenderer {
    shapeType: number;
    color: Vec4;
    size: Vec2;
    cornerRadius: number;
    layer: number;
    parallax: Vec2;
    enabled: boolean;
}

export interface SortingGroup {
    layer: number;
    order: number;
    enabled: boolean;
}

export interface SphereCollider3D {
    radius: number;
    center: Vec3;
    friction: number;
    restitution: number;
    isSensor: boolean;
    enabled: boolean;
}

export interface SpineAnimation {
    skeletonPath: string;
    atlasPath: string;
    skin: string;
    animation: string;
    timeScale: number;
    loop: boolean;
    playing: boolean;
    flipX: boolean;
    flipY: boolean;
    color: Vec4;
    layer: number;
    skeletonScale: number;
    material: number;
    enabled: boolean;
}

export interface SpringBone {
    enabled: boolean;
    stiffness: number;
    drag: number;
    gravity: Vec3;
    wind: Vec3;
    windGust: number;
    windFrequency: number;
    endLength: number;
    radius: number;
    weight: number;
    colliders: VectorEntity;
}

export interface SpringBoneCollider {
    shape: number;
    radius: number;
    height: number;
    offset: Vec3;
}

export interface Sprite {
    texture: number;
    color: Vec4;
    size: Vec2;
    pivot: Vec2;
    uvOffset: Vec2;
    uvScale: Vec2;
    layer: number;
    order: number;
    maskInteraction: number;
    lit: boolean;
    flipX: boolean;
    flipY: boolean;
    drawMode: number;
    tileSize: Vec2;
    tileSpacing: Vec2;
    parallax: Vec2;
    material: number;
    enabled: boolean;
}

export interface SpriteMask {
    alphaCutoff: number;
    limitRange: boolean;
    rangeEndLayer: number;
    rangeEndOrder: number;
    enabled: boolean;
}

export interface TilemapLayer {
    cellSize: Vec2;
    orientation: number;
    hexSideLength: number;
    staggerAxis: number;
    staggerIndex: number;
    originOffset: Vec2;
    tileset: number;
    tilesetColumns: number;
    renderLayer: number;
    tintColor: Vec4;
    opacity: number;
    parallaxFactor: Vec2;
    visible: boolean;
    lit: boolean;
}

export interface TrailRenderer {
    time: number;
    minVertexDistance: number;
    emitting: boolean;
    startWidth: number;
    endWidth: number;
    startColor: Vec4;
    endColor: Vec4;
    texture: number;
    blendMode: number;
    layer: number;
    material: number;
    enabled: boolean;
}

export interface Transform {
    position: Vec3;
    rotation: Quat;
    scale: Vec3;
    worldPosition: Vec3;
    worldRotation: Quat;
    worldScale: Vec3;
}

export interface UIInteraction {
    hovered: boolean;
    pressed: boolean;
    justPressed: boolean;
    justReleased: boolean;
}

export interface UIMask {
    enabled: boolean;
    mode: number;
    alphaCutoff: number;
}

export interface UINode {
    position: number;
    display: number;
    opacity: number;
    pointerEvents: number;
    width: Dimension;
    height: Dimension;
    minWidth: Dimension;
    minHeight: Dimension;
    maxWidth: Dimension;
    maxHeight: Dimension;
    flexGrow: number;
    flexShrink: number;
    flexBasis: Dimension;
    alignSelf: number;
    marginLeft: Dimension;
    marginTop: Dimension;
    marginRight: Dimension;
    marginBottom: Dimension;
    insetLeft: Dimension;
    insetTop: Dimension;
    insetRight: Dimension;
    insetBottom: Dimension;
}

export interface UIScroll {
    enabled: boolean;
    content: number;
    horizontal: boolean;
    vertical: boolean;
    movement: number;
    wheelSpeed: number;
    dragScroll: boolean;
    decelerationRate: number;
}

export interface UIVisual {
    visualType: number;
    texture: number;
    color: Vec4;
    fit: number;
    uvOffset: Vec2;
    uvScale: Vec2;
    sliceBorder: Vec4;
    tileSize: Vec2;
    fillMethod: number;
    fillOrigin: number;
    fillAmount: number;
    material: number;
    enabled: boolean;
}

export interface Velocity {
    linear: Vec3;
    angular: Vec3;
}

// Registry
export interface Registry {
    /** A new entity. */
    create(): Entity;
    /** Destroys the entity and its components. */
    destroy(entity: Entity): void;
    /** Whether the id names a live entity. */
    valid(entity: Entity): boolean;
    /** Live entities. */
    entityCount(): number;
    /** Claims the subtree teardown; false when another owner already has it. */
    reserveDestruction(entity: Entity): boolean;
    /** Gives back a claim from reserveDestruction. */
    releaseDestruction(entity: Entity): void;
    /** Whether a teardown has claimed the entity. */
    destructionPending(entity: Entity): boolean;
    /** Sets the entity's own enabled flag; activity follows the hierarchy. */
    setEntityEnabled(entity: Entity, enabled: boolean): boolean;
    /** Enabled itself and under enabled ancestors. */
    isEntityActive(entity: Entity): boolean;
    /** The entity's own flag, ignoring ancestors. */
    isEntityEnabled(entity: Entity): boolean;
    /** Whether any entity is inactive (lets a query skip the activity check). */
    hasInactiveEntities(): boolean;
    /** Bumped by every activity change. */
    activityEpoch(): number;
    /** Stamps the entity's component of that type id (componentTypeId) as written now: a write made from script. */
    markComponentChanged(component: number, entity: Entity): void;
    /** Whether the entity's component of that type id was written after the tick (an answer of beginChangeRead). */
    componentChangedSince(component: number, entity: Entity, tick: number): boolean;
    /** The tick a component write made now is stamped with. */
    changeTick(): number;
    /** For a reader about to look for changes: the tick it looks at; the clock then moves on. */
    beginChangeRead(): number;
    /** Turns on the audit that finds component writes made without a change stamp. */
    setChangeAudit(enabled: boolean): void;
    /** Unstamped component writes since the last audit (0 while the audit is off). */
    auditChanges(): number;
    /** Unstamped component writes the audit has found since it was turned on. */
    changeAuditTotal(): number;
    /** Re-parents child; false when refused (a cycle, an invalid entity). */
    setParent(child: Entity, parent: Entity): boolean;
    /** All generated builtin names, separated by |; absent on older cores. */
    getBuiltinComponentNames?(entity: Entity): string;
    /** Host-local component ID; -1 for an unknown name. */
    componentTypeId?(name: string): number;

    hasBillboard(entity: Entity): boolean;
    getBillboard(entity: Entity): Billboard;
    addBillboard(entity: Entity, component: Billboard): void;
    removeBillboard(entity: Entity): void;
    hasBitmapText(entity: Entity): boolean;
    getBitmapText(entity: Entity): BitmapText;
    addBitmapText(entity: Entity, component: BitmapText): void;
    removeBitmapText(entity: Entity): void;
    hasBoxCollider2D(entity: Entity): boolean;
    getBoxCollider2D(entity: Entity): BoxCollider2D;
    addBoxCollider2D(entity: Entity, component: BoxCollider2D): void;
    removeBoxCollider2D(entity: Entity): void;
    hasBoxCollider3D(entity: Entity): boolean;
    getBoxCollider3D(entity: Entity): BoxCollider3D;
    addBoxCollider3D(entity: Entity, component: BoxCollider3D): void;
    removeBoxCollider3D(entity: Entity): void;
    hasCamera(entity: Entity): boolean;
    getCamera(entity: Entity): Camera;
    addCamera(entity: Entity, component: Camera): void;
    removeCamera(entity: Entity): void;
    hasCanvas(entity: Entity): boolean;
    getCanvas(entity: Entity): Canvas;
    addCanvas(entity: Entity, component: Canvas): void;
    removeCanvas(entity: Entity): void;
    hasCapsuleCollider2D(entity: Entity): boolean;
    getCapsuleCollider2D(entity: Entity): CapsuleCollider2D;
    addCapsuleCollider2D(entity: Entity, component: CapsuleCollider2D): void;
    removeCapsuleCollider2D(entity: Entity): void;
    hasCapsuleCollider3D(entity: Entity): boolean;
    getCapsuleCollider3D(entity: Entity): CapsuleCollider3D;
    addCapsuleCollider3D(entity: Entity, component: CapsuleCollider3D): void;
    removeCapsuleCollider3D(entity: Entity): void;
    hasCharacterController3D(entity: Entity): boolean;
    getCharacterController3D(entity: Entity): CharacterController3D;
    addCharacterController3D(entity: Entity, component: CharacterController3D): void;
    removeCharacterController3D(entity: Entity): void;
    hasChildren(entity: Entity): boolean;
    getChildren(entity: Entity): Children;
    addChildren(entity: Entity, component: Children): void;
    removeChildren(entity: Entity): void;
    hasCircleCollider2D(entity: Entity): boolean;
    getCircleCollider2D(entity: Entity): CircleCollider2D;
    addCircleCollider2D(entity: Entity, component: CircleCollider2D): void;
    removeCircleCollider2D(entity: Entity): void;
    hasContentRect(entity: Entity): boolean;
    getContentRect(entity: Entity): ContentRect;
    addContentRect(entity: Entity, component: ContentRect): void;
    removeContentRect(entity: Entity): void;
    hasConvexCollider3D(entity: Entity): boolean;
    getConvexCollider3D(entity: Entity): ConvexCollider3D;
    addConvexCollider3D(entity: Entity, component: ConvexCollider3D): void;
    removeConvexCollider3D(entity: Entity): void;
    hasDraggable(entity: Entity): boolean;
    getDraggable(entity: Entity): Draggable;
    addDraggable(entity: Entity, component: Draggable): void;
    removeDraggable(entity: Entity): void;
    hasDragonBonesAnimation(entity: Entity): boolean;
    getDragonBonesAnimation(entity: Entity): DragonBonesAnimation;
    addDragonBonesAnimation(entity: Entity, component: DragonBonesAnimation): void;
    removeDragonBonesAnimation(entity: Entity): void;
    hasFlexContainer(entity: Entity): boolean;
    getFlexContainer(entity: Entity): FlexContainer;
    addFlexContainer(entity: Entity, component: FlexContainer): void;
    removeFlexContainer(entity: Entity): void;
    hasGroupOpacity(entity: Entity): boolean;
    getGroupOpacity(entity: Entity): GroupOpacity;
    addGroupOpacity(entity: Entity, component: GroupOpacity): void;
    removeGroupOpacity(entity: Entity): void;
    hasImpostor(entity: Entity): boolean;
    getImpostor(entity: Entity): Impostor;
    addImpostor(entity: Entity, component: Impostor): void;
    removeImpostor(entity: Entity): void;
    hasInteractable(entity: Entity): boolean;
    getInteractable(entity: Entity): Interactable;
    addInteractable(entity: Entity, component: Interactable): void;
    removeInteractable(entity: Entity): void;
    hasLODGroup(entity: Entity): boolean;
    getLODGroup(entity: Entity): LODGroup;
    addLODGroup(entity: Entity, component: LODGroup): void;
    removeLODGroup(entity: Entity): void;
    hasLight(entity: Entity): boolean;
    getLight(entity: Entity): Light;
    addLight(entity: Entity, component: Light): void;
    removeLight(entity: Entity): void;
    hasLightProbeVolume(entity: Entity): boolean;
    getLightProbeVolume(entity: Entity): LightProbeVolume;
    addLightProbeVolume(entity: Entity, component: LightProbeVolume): void;
    removeLightProbeVolume(entity: Entity): void;
    hasMeshCollider3D(entity: Entity): boolean;
    getMeshCollider3D(entity: Entity): MeshCollider3D;
    addMeshCollider3D(entity: Entity, component: MeshCollider3D): void;
    removeMeshCollider3D(entity: Entity): void;
    hasMeshInstances(entity: Entity): boolean;
    getMeshInstances(entity: Entity): MeshInstances;
    addMeshInstances(entity: Entity, component: MeshInstances): void;
    removeMeshInstances(entity: Entity): void;
    hasMeshLightmap(entity: Entity): boolean;
    getMeshLightmap(entity: Entity): MeshLightmap;
    addMeshLightmap(entity: Entity, component: MeshLightmap): void;
    removeMeshLightmap(entity: Entity): void;
    hasMeshMorph(entity: Entity): boolean;
    getMeshMorph(entity: Entity): MeshMorph;
    addMeshMorph(entity: Entity, component: MeshMorph): void;
    removeMeshMorph(entity: Entity): void;
    hasMeshRenderer(entity: Entity): boolean;
    getMeshRenderer(entity: Entity): MeshRenderer;
    addMeshRenderer(entity: Entity, component: MeshRenderer): void;
    removeMeshRenderer(entity: Entity): void;
    hasMeshSkin(entity: Entity): boolean;
    getMeshSkin(entity: Entity): MeshSkin;
    addMeshSkin(entity: Entity, component: MeshSkin): void;
    removeMeshSkin(entity: Entity): void;
    hasOccluder(entity: Entity): boolean;
    getOccluder(entity: Entity): Occluder;
    addOccluder(entity: Entity, component: Occluder): void;
    removeOccluder(entity: Entity): void;
    hasParent(entity: Entity): boolean;
    getParent(entity: Entity): Parent;
    addParent(entity: Entity, component: Parent): void;
    removeParent(entity: Entity): void;
    hasParticleCollider(entity: Entity): boolean;
    getParticleCollider(entity: Entity): ParticleCollider;
    addParticleCollider(entity: Entity, component: ParticleCollider): void;
    removeParticleCollider(entity: Entity): void;
    hasParticleEmitter(entity: Entity): boolean;
    getParticleEmitter(entity: Entity): ParticleEmitter;
    addParticleEmitter(entity: Entity, component: ParticleEmitter): void;
    removeParticleEmitter(entity: Entity): void;
    hasParticleForceField(entity: Entity): boolean;
    getParticleForceField(entity: Entity): ParticleForceField;
    addParticleForceField(entity: Entity, component: ParticleForceField): void;
    removeParticleForceField(entity: Entity): void;
    hasPlanarReflection(entity: Entity): boolean;
    getPlanarReflection(entity: Entity): PlanarReflection;
    addPlanarReflection(entity: Entity, component: PlanarReflection): void;
    removePlanarReflection(entity: Entity): void;
    hasReflectionProbe(entity: Entity): boolean;
    getReflectionProbe(entity: Entity): ReflectionProbe;
    addReflectionProbe(entity: Entity, component: ReflectionProbe): void;
    removeReflectionProbe(entity: Entity): void;
    hasRigidBody2D(entity: Entity): boolean;
    getRigidBody2D(entity: Entity): RigidBody2D;
    addRigidBody2D(entity: Entity, component: RigidBody2D): void;
    removeRigidBody2D(entity: Entity): void;
    hasRigidBody3D(entity: Entity): boolean;
    getRigidBody3D(entity: Entity): RigidBody3D;
    addRigidBody3D(entity: Entity, component: RigidBody3D): void;
    removeRigidBody3D(entity: Entity): void;
    hasSegmentCollider2D(entity: Entity): boolean;
    getSegmentCollider2D(entity: Entity): SegmentCollider2D;
    addSegmentCollider2D(entity: Entity, component: SegmentCollider2D): void;
    removeSegmentCollider2D(entity: Entity): void;
    hasShadowCaster2D(entity: Entity): boolean;
    getShadowCaster2D(entity: Entity): ShadowCaster2D;
    addShadowCaster2D(entity: Entity, component: ShadowCaster2D): void;
    removeShadowCaster2D(entity: Entity): void;
    hasShapeRenderer(entity: Entity): boolean;
    getShapeRenderer(entity: Entity): ShapeRenderer;
    addShapeRenderer(entity: Entity, component: ShapeRenderer): void;
    removeShapeRenderer(entity: Entity): void;
    hasSortingGroup(entity: Entity): boolean;
    getSortingGroup(entity: Entity): SortingGroup;
    addSortingGroup(entity: Entity, component: SortingGroup): void;
    removeSortingGroup(entity: Entity): void;
    hasSphereCollider3D(entity: Entity): boolean;
    getSphereCollider3D(entity: Entity): SphereCollider3D;
    addSphereCollider3D(entity: Entity, component: SphereCollider3D): void;
    removeSphereCollider3D(entity: Entity): void;
    hasSpineAnimation(entity: Entity): boolean;
    getSpineAnimation(entity: Entity): SpineAnimation;
    addSpineAnimation(entity: Entity, component: SpineAnimation): void;
    removeSpineAnimation(entity: Entity): void;
    hasSpringBone(entity: Entity): boolean;
    getSpringBone(entity: Entity): SpringBone;
    addSpringBone(entity: Entity, component: SpringBone): void;
    removeSpringBone(entity: Entity): void;
    hasSpringBoneCollider(entity: Entity): boolean;
    getSpringBoneCollider(entity: Entity): SpringBoneCollider;
    addSpringBoneCollider(entity: Entity, component: SpringBoneCollider): void;
    removeSpringBoneCollider(entity: Entity): void;
    hasSprite(entity: Entity): boolean;
    getSprite(entity: Entity): Sprite;
    addSprite(entity: Entity, component: Sprite): void;
    removeSprite(entity: Entity): void;
    hasSpriteMask(entity: Entity): boolean;
    getSpriteMask(entity: Entity): SpriteMask;
    addSpriteMask(entity: Entity, component: SpriteMask): void;
    removeSpriteMask(entity: Entity): void;
    hasTilemapLayer(entity: Entity): boolean;
    getTilemapLayer(entity: Entity): TilemapLayer;
    addTilemapLayer(entity: Entity, component: TilemapLayer): void;
    removeTilemapLayer(entity: Entity): void;
    hasTrailRenderer(entity: Entity): boolean;
    getTrailRenderer(entity: Entity): TrailRenderer;
    addTrailRenderer(entity: Entity, component: TrailRenderer): void;
    removeTrailRenderer(entity: Entity): void;
    hasTransform(entity: Entity): boolean;
    getTransform(entity: Entity): Transform;
    addTransform(entity: Entity, component: Transform): void;
    removeTransform(entity: Entity): void;
    hasUIInteraction(entity: Entity): boolean;
    getUIInteraction(entity: Entity): UIInteraction;
    addUIInteraction(entity: Entity, component: UIInteraction): void;
    removeUIInteraction(entity: Entity): void;
    hasUIMask(entity: Entity): boolean;
    getUIMask(entity: Entity): UIMask;
    addUIMask(entity: Entity, component: UIMask): void;
    removeUIMask(entity: Entity): void;
    hasUINode(entity: Entity): boolean;
    getUINode(entity: Entity): UINode;
    addUINode(entity: Entity, component: UINode): void;
    removeUINode(entity: Entity): void;
    hasUIScroll(entity: Entity): boolean;
    getUIScroll(entity: Entity): UIScroll;
    addUIScroll(entity: Entity, component: UIScroll): void;
    removeUIScroll(entity: Entity): void;
    hasUIVisual(entity: Entity): boolean;
    getUIVisual(entity: Entity): UIVisual;
    addUIVisual(entity: Entity, component: UIVisual): void;
    removeUIVisual(entity: Entity): void;
    hasVelocity(entity: Entity): boolean;
    getVelocity(entity: Entity): Velocity;
    addVelocity(entity: Entity, component: Velocity): void;
    removeVelocity(entity: Entity): void;
}

// Module
export interface ESEngineModule {
    Registry: new () => Registry;
    /**
     * Authoritative list of component names this WASM build exposes
     * on the Registry. Used by BuiltinBridge to detect drift between
     * the shipped SDK and the actual WASM module.
     */
    getBuiltinComponentNames(): string[];
    Billboard: new () => Billboard;
    BitmapText: new () => BitmapText;
    BoxCollider2D: new () => BoxCollider2D;
    BoxCollider3D: new () => BoxCollider3D;
    Camera: new () => Camera;
    Canvas: new () => Canvas;
    CapsuleCollider2D: new () => CapsuleCollider2D;
    CapsuleCollider3D: new () => CapsuleCollider3D;
    CharacterController3D: new () => CharacterController3D;
    Children: new () => Children;
    CircleCollider2D: new () => CircleCollider2D;
    ContentRect: new () => ContentRect;
    ConvexCollider3D: new () => ConvexCollider3D;
    Draggable: new () => Draggable;
    DragonBonesAnimation: new () => DragonBonesAnimation;
    FlexContainer: new () => FlexContainer;
    GroupOpacity: new () => GroupOpacity;
    Impostor: new () => Impostor;
    Interactable: new () => Interactable;
    LODGroup: new () => LODGroup;
    Light: new () => Light;
    LightProbeVolume: new () => LightProbeVolume;
    MeshCollider3D: new () => MeshCollider3D;
    MeshInstances: new () => MeshInstances;
    MeshLightmap: new () => MeshLightmap;
    MeshMorph: new () => MeshMorph;
    MeshRenderer: new () => MeshRenderer;
    MeshSkin: new () => MeshSkin;
    Occluder: new () => Occluder;
    Parent: new () => Parent;
    ParticleCollider: new () => ParticleCollider;
    ParticleEmitter: new () => ParticleEmitter;
    ParticleForceField: new () => ParticleForceField;
    PlanarReflection: new () => PlanarReflection;
    ReflectionProbe: new () => ReflectionProbe;
    RigidBody2D: new () => RigidBody2D;
    RigidBody3D: new () => RigidBody3D;
    SegmentCollider2D: new () => SegmentCollider2D;
    ShadowCaster2D: new () => ShadowCaster2D;
    ShapeRenderer: new () => ShapeRenderer;
    SortingGroup: new () => SortingGroup;
    SphereCollider3D: new () => SphereCollider3D;
    SpineAnimation: new () => SpineAnimation;
    SpringBone: new () => SpringBone;
    SpringBoneCollider: new () => SpringBoneCollider;
    Sprite: new () => Sprite;
    SpriteMask: new () => SpriteMask;
    TilemapLayer: new () => TilemapLayer;
    TrailRenderer: new () => TrailRenderer;
    Transform: new () => Transform;
    UIInteraction: new () => UIInteraction;
    UIMask: new () => UIMask;
    UINode: new () => UINode;
    UIScroll: new () => UIScroll;
    UIVisual: new () => UIVisual;
    Velocity: new () => Velocity;
}