@cimplify/sdk 0.108.0 → 0.110.2

package/dist/client-hTKbCuhG.d.mts

@@ -0,0 +1,230 @@
+import { T as TransportKind, R as RoomDialer } from './link-BUTqGmyi.mjs';
+
+interface Motion {
+    readonly toleranceUnits: number;
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    spawn(slot: number): void;
+    steer(axisX: number, axisZ: number, buttons: number): void;
+    step(): void;
+    place(x: number, y: number, z: number): void;
+}
+type MotionFactory = (simulationHz: number, physicsHz: number) => Motion;
+declare class LocomotionMotion implements Motion {
+    readonly toleranceUnits = 0;
+    private readonly body;
+    private readonly locomotion;
+    constructor(simulationHz: number, physicsHz: number);
+    get x(): number;
+    get y(): number;
+    get z(): number;
+    spawn(slot: number): void;
+    steer(axisX: number, axisZ: number, buttons: number): void;
+    step(): void;
+    place(x: number, _y: number, z: number): void;
+}
+declare const locomotionMotion: MotionFactory;
+
+interface NetworkMemory {
+    recall(network: string, nowMs: number): TransportKind | null;
+    remember(network: string, transport: TransportKind, nowMs: number): void;
+}
+declare class InMemoryNetworkMemory implements NetworkMemory {
+    private readonly entries;
+    recall(network: string, nowMs: number): TransportKind | null;
+    remember(network: string, transport: TransportKind, nowMs: number): void;
+}
+declare class StorageNetworkMemory implements NetworkMemory {
+    private readonly fallback;
+    recall(network: string, nowMs: number): TransportKind | null;
+    remember(network: string, transport: TransportKind, nowMs: number): void;
+}
+declare function currentNetwork(): string;
+
+declare const RoomPhase: {
+    readonly Idle: 0;
+    readonly Ticketing: 1;
+    readonly Connecting: 2;
+    readonly Joined: 3;
+    readonly Waiting: 4;
+    readonly Refused: 5;
+    readonly Closed: 6;
+};
+type RoomPhase = (typeof RoomPhase)[keyof typeof RoomPhase];
+interface ChannelSink {
+    deliver(slot: number, sender: number, view: DataView, offset: number, length: number): void;
+}
+interface RoomClientOptions {
+    readonly tickets: () => Promise<Uint8Array>;
+    readonly primary?: RoomDialer | null;
+    readonly fallback?: RoomDialer | null;
+    readonly physicsHz?: number;
+    readonly memory?: NetworkMemory;
+    readonly network?: () => string;
+    readonly channels?: ChannelSink | null;
+    readonly motion?: MotionFactory;
+    readonly spectatorAckEvery?: number;
+}
+declare const GAME_CHANNEL_SLOTS: 64;
+declare const GAME_CHANNEL_RELIABLE_BASE: 32;
+interface RoomPose {
+    x: number;
+    y: number;
+    z: number;
+    yaw: number;
+    animation: number;
+}
+interface RoomPresence {
+    tick: number;
+    x: number;
+    y: number;
+    z: number;
+    yaw: number;
+    animation: number;
+    flags: number;
+}
+interface RoomStats {
+    slot: number;
+    transport: TransportKind | null;
+    corrections: number;
+    maxCorrectionM: number;
+    meanCorrectionM: number;
+    inputsSent: number;
+    snapshots: number;
+    deltas: number;
+    keyframes: number;
+    missingBaselines: number;
+    rttMs: number;
+    interpolationDelayMs: number;
+    extrapolatingFrames: number;
+    paceChanges: number;
+    reconnects: number;
+    dropped: number;
+    sendFailures: number;
+    sendStride: number;
+    statesShed: number;
+}
+declare class RoomClient {
+    private readonly tickets;
+    private readonly physicsHz;
+    private readonly connector;
+    private readonly queue;
+    private readonly outbound;
+    private readonly reply;
+    private readonly ack;
+    private readonly streamAcks;
+    private readonly clock;
+    private readonly ticker;
+    private readonly governor;
+    private seenSendFailures;
+    private leadBoost;
+    private readonly log;
+    private readonly store;
+    private readonly tracks;
+    private readonly units;
+    private readonly appliedShort;
+    private readonly appliedSequence;
+    private readonly remoteSlots;
+    private readonly roomInput;
+    private readonly channelSink;
+    private readonly channelHeader;
+    private readonly channelMessage;
+    private channelSequence;
+    private readonly statistics;
+    private readonly motionFactory;
+    private predictor;
+    private predictorRates;
+    private link;
+    private stateValue;
+    private pendingTicket;
+    private ticketFailed;
+    private resumeToken;
+    private joinVersion;
+    private request;
+    private admittedAt;
+    private dialStartedAt;
+    private retryAt;
+    private lastUpdate;
+    private outboundNext;
+    private appliedNext;
+    private remoteCountValue;
+    private joins;
+    private slotValue;
+    private watcher;
+    private started;
+    private freshSnapshot;
+    private lastReconciled;
+    private extrapolating;
+    private ownTick;
+    private ownX;
+    private ownY;
+    private ownZ;
+    private ownVelocityX;
+    private ownVelocityZ;
+    private inputAxisX;
+    private inputAxisZ;
+    private inputYaw;
+    private inputButtons;
+    private inputSubtick;
+    private commandSequence;
+    private cameraSequence;
+    private cameraX;
+    private cameraZ;
+    private cameraRadius;
+    private cameraDirty;
+    private cameraSentAt;
+    private readonly spectatorAckEvery;
+    private unackedSnapshots;
+    constructor(options: RoomClientOptions);
+    get state(): RoomPhase;
+    get slot(): number;
+    ackStream(slot: number, sequence: () => number): void;
+    get watching(): boolean;
+    get extrapolatingLocal(): boolean;
+    get serverTick(): number;
+    get remoteCount(): number;
+    remoteSlot(index: number): number;
+    get stats(): RoomStats;
+    start(nowMs: number): void;
+    close(): void;
+    setInput(axisX: number, axisZ: number, yawRadians: number, buttons: number, nowMs: number): void;
+    setCamera(xMetres: number, zMetres: number, radiusMetres: number): void;
+    sendCommand(action: number, payload: Uint8Array, length: number): number;
+    sendChannel(slot: number, payload: Uint8Array, length: number): number;
+    update(nowMs: number): void;
+    localPose(out: RoomPose, nowMs: number): boolean;
+    presence(slot: number, out: RoomPresence): boolean;
+    remotePose(slot: number, out: RoomPose, nowMs: number): boolean;
+    private capTicks;
+    private fetchTicket;
+    private readonly ticketArrived;
+    private readonly ticketRefused;
+    private dial;
+    private begin;
+    private connecting;
+    private waitAndRetry;
+    private reconnect;
+    private joined;
+    private govern;
+    private drain;
+    private channel;
+    private snapshot;
+    private observeOwn;
+    private acknowledged;
+    private applied;
+    private beginSession;
+    private reconcile;
+    private play;
+    private leadDebt;
+    private cameraDue;
+    private packet;
+    private send;
+    private writeCamera;
+    private receivedMask;
+    private watchLatency;
+}
+declare function sendsOn(tick: number, simulationHz: number, sendHz: number): boolean;
+declare function previousSend(tick: number, simulationHz: number, sendHz: number): number;
+
+export { type ChannelSink as C, GAME_CHANNEL_RELIABLE_BASE as G, InMemoryNetworkMemory as I, LocomotionMotion as L, type Motion as M, type NetworkMemory as N, RoomClient as R, StorageNetworkMemory as S, type RoomClientOptions as a, GAME_CHANNEL_SLOTS as b, type MotionFactory as c, RoomPhase as d, type RoomPose as e, type RoomPresence as f, type RoomStats as g, currentNetwork as h, locomotionMotion as l, previousSend as p, sendsOn as s };

package/dist/clock-B-UAjkKa.d.mts

@@ -0,0 +1,5 @@
+declare const UI_CLOCK_SECONDS = 1;
+type UiClock = Float64Array;
+declare function uiClock(): UiClock;
+
+export { type UiClock as U, UI_CLOCK_SECONDS as a, uiClock as u };

package/dist/clock-B-UAjkKa.d.ts

@@ -0,0 +1,5 @@
+declare const UI_CLOCK_SECONDS = 1;
+type UiClock = Float64Array;
+declare function uiClock(): UiClock;
+
+export { type UiClock as U, UI_CLOCK_SECONDS as a, uiClock as u };

package/dist/config-BlXQluJR.d.mts

@@ -0,0 +1,36 @@
+interface PartedBinary {
+    readonly parts: readonly string[];
+    readonly bytes: number;
+    readonly sha256?: string;
+}
+
+interface EngineVariant {
+    readonly wasm: PartedBinary;
+    readonly glue: PartedBinary | null;
+}
+interface EngineVariants {
+    readonly single: EngineVariant;
+    readonly isolated: EngineVariant | null;
+}
+type WasmFlavor = "raw" | "emscripten";
+interface WasmGameConfig {
+    readonly abi: number;
+    readonly flavor: WasmFlavor;
+    readonly variants: EngineVariants;
+    readonly packs: Readonly<Record<string, PartedBinary>>;
+    readonly pixel_ratio_cap: number;
+}
+interface GodotGameConfig {
+    readonly abi: number;
+    readonly preboot: boolean;
+    readonly variants: EngineVariants;
+    readonly worklets: {
+        readonly audio: PartedBinary;
+        readonly position: PartedBinary;
+    };
+    readonly main_pack: PartedBinary;
+    readonly packs: Readonly<Record<string, PartedBinary>>;
+    readonly pixel_ratio_cap: number;
+}
+
+export type { GodotGameConfig as G, PartedBinary as P, WasmGameConfig as W };

package/dist/config-BlXQluJR.d.ts

@@ -0,0 +1,36 @@
+interface PartedBinary {
+    readonly parts: readonly string[];
+    readonly bytes: number;
+    readonly sha256?: string;
+}
+
+interface EngineVariant {
+    readonly wasm: PartedBinary;
+    readonly glue: PartedBinary | null;
+}
+interface EngineVariants {
+    readonly single: EngineVariant;
+    readonly isolated: EngineVariant | null;
+}
+type WasmFlavor = "raw" | "emscripten";
+interface WasmGameConfig {
+    readonly abi: number;
+    readonly flavor: WasmFlavor;
+    readonly variants: EngineVariants;
+    readonly packs: Readonly<Record<string, PartedBinary>>;
+    readonly pixel_ratio_cap: number;
+}
+interface GodotGameConfig {
+    readonly abi: number;
+    readonly preboot: boolean;
+    readonly variants: EngineVariants;
+    readonly worklets: {
+        readonly audio: PartedBinary;
+        readonly position: PartedBinary;
+    };
+    readonly main_pack: PartedBinary;
+    readonly packs: Readonly<Record<string, PartedBinary>>;
+    readonly pixel_ratio_cap: number;
+}
+
+export type { GodotGameConfig as G, PartedBinary as P, WasmGameConfig as W };

package/dist/courier-Cnn-edJ4.d.ts

@@ -0,0 +1,95 @@
+import { S as SeededRandom, G as Game } from './game-fgQy2YIm.js';
+import { G as GameScene } from './fluid-ARr0qUIL.js';
+import { T as Transforms, E as Entity } from './world-PvILHDR1.js';
+import { bs as ThirdPersonRig } from './play-BRRlfLhX.js';
+import { h as GenreTemplate } from './template-BkEGVTQj.js';
+
+type Vec3Array = Float32Array | Float64Array;
+declare function writePosition(transforms: Transforms, entity: Entity, source: Vec3Array, offset: number): void;
+declare function writeScale(transforms: Transforms, entity: Entity, source: Vec3Array, offset: number): void;
+
+declare const NO_PICKUP = -1;
+declare const PICKUP_STRIDE = 3;
+declare const KEEP_OUT_STRIDE = 3;
+declare const MAX_SCATTER_TRIES = 64;
+declare function withinRadius(source: Vec3Array, offset: number, cx: number, cz: number, radius: number): boolean;
+declare const CIRCLE_X = 0;
+declare const CIRCLE_Z = 1;
+declare const CIRCLE_RADIUS = 2;
+declare const CIRCLE_WORDS = 3;
+declare function withinCircle(source: Vec3Array, offset: number, circle: Float64Array, at: number): boolean;
+declare class KeepOut {
+    readonly circles: Float64Array;
+    private readonly fixed;
+    private readonly squares;
+    private readonly scratch;
+    private used;
+    constructor(capacity: number);
+    get count(): number;
+    add(x: number, z: number, radius: number): number;
+    clearFixed(candidate: Int32Array, at: number): boolean;
+    clear(source: Vec3Array, offset: number): boolean;
+}
+declare class Pickups {
+    readonly positions: Float64Array;
+    readonly active: Uint8Array;
+    readonly kinds: Int32Array;
+    readonly radius: number;
+    private live;
+    private readonly closest;
+    private readonly candidate;
+    constructor(capacity: number, radius: number);
+    get capacity(): number;
+    get count(): number;
+    place(slot: number, x: number, y: number, z: number, kind?: number): void;
+    scatter(slot: number, random: SeededRandom, halfExtent: number, y: number, keepOut?: KeepOut | null, kind?: number): void;
+    respawn(slot: number, random: SeededRandom, halfExtent: number, keepOut?: KeepOut | null): void;
+    remove(slot: number): boolean;
+    nearest(source: Vec3Array, offset: number): number;
+    collect(source: Vec3Array, offset: number): number;
+    private activate;
+}
+
+declare const COURIER: {
+    readonly plazaHalf: 18;
+    readonly wallHeight: 1.2;
+    readonly crates: 6;
+    readonly crateHalf: 0.8;
+    readonly pickupRadius: 1.3;
+    readonly dropX: 0;
+    readonly dropZ: 0;
+    readonly dropRadius: 2.2;
+    readonly parcelSpread: 13;
+    readonly parcelLift: 0.35;
+    readonly carryLift: 2.1;
+    readonly parcelSize: 0.5;
+};
+declare class CourierPlaza implements GameScene<Game> {
+    readonly name = "courier";
+    rig: ThirdPersonRig | null;
+    deliveries: number;
+    readonly pickups: Pickups;
+    readonly parcel: Float64Array<ArrayBufferLike>;
+    readonly crates: Float64Array<ArrayBuffer>;
+    private readonly keepOut;
+    private boxes;
+    get carrying(): boolean;
+    enter(game: Game): void;
+    fixedUpdate(game: Game): void;
+    update(game: Game): void;
+    exit(): void;
+    target(out: Float64Array): void;
+    private placeParcel;
+    private draw;
+}
+declare const courierTemplate: GenreTemplate<CourierPlaza>;
+
+declare const courier_COURIER: typeof COURIER;
+type courier_CourierPlaza = CourierPlaza;
+declare const courier_CourierPlaza: typeof CourierPlaza;
+declare const courier_courierTemplate: typeof courierTemplate;
+declare namespace courier {
+  export { courier_COURIER as COURIER, courier_CourierPlaza as CourierPlaza, courier_courierTemplate as courierTemplate };
+}
+
+export { CIRCLE_RADIUS as C, KEEP_OUT_STRIDE as K, MAX_SCATTER_TRIES as M, NO_PICKUP as N, PICKUP_STRIDE as P, type Vec3Array as V, CIRCLE_WORDS as a, CIRCLE_X as b, CIRCLE_Z as c, KeepOut as d, Pickups as e, courier as f, withinRadius as g, writePosition as h, writeScale as i, COURIER as j, CourierPlaza as k, courierTemplate as l, withinCircle as w };

package/dist/courier-FmGfkvIN.d.mts

@@ -0,0 +1,95 @@
+import { S as SeededRandom, G as Game } from './game-Bx8onkhX.mjs';
+import { G as GameScene } from './fluid-DLlEj2cs.mjs';
+import { T as Transforms, E as Entity } from './world-qekkXjJv.mjs';
+import { bs as ThirdPersonRig } from './play-ClrMd_e8.mjs';
+import { h as GenreTemplate } from './template-AhCdB1kW.mjs';
+
+type Vec3Array = Float32Array | Float64Array;
+declare function writePosition(transforms: Transforms, entity: Entity, source: Vec3Array, offset: number): void;
+declare function writeScale(transforms: Transforms, entity: Entity, source: Vec3Array, offset: number): void;
+
+declare const NO_PICKUP = -1;
+declare const PICKUP_STRIDE = 3;
+declare const KEEP_OUT_STRIDE = 3;
+declare const MAX_SCATTER_TRIES = 64;
+declare function withinRadius(source: Vec3Array, offset: number, cx: number, cz: number, radius: number): boolean;
+declare const CIRCLE_X = 0;
+declare const CIRCLE_Z = 1;
+declare const CIRCLE_RADIUS = 2;
+declare const CIRCLE_WORDS = 3;
+declare function withinCircle(source: Vec3Array, offset: number, circle: Float64Array, at: number): boolean;
+declare class KeepOut {
+    readonly circles: Float64Array;
+    private readonly fixed;
+    private readonly squares;
+    private readonly scratch;
+    private used;
+    constructor(capacity: number);
+    get count(): number;
+    add(x: number, z: number, radius: number): number;
+    clearFixed(candidate: Int32Array, at: number): boolean;
+    clear(source: Vec3Array, offset: number): boolean;
+}
+declare class Pickups {
+    readonly positions: Float64Array;
+    readonly active: Uint8Array;
+    readonly kinds: Int32Array;
+    readonly radius: number;
+    private live;
+    private readonly closest;
+    private readonly candidate;
+    constructor(capacity: number, radius: number);
+    get capacity(): number;
+    get count(): number;
+    place(slot: number, x: number, y: number, z: number, kind?: number): void;
+    scatter(slot: number, random: SeededRandom, halfExtent: number, y: number, keepOut?: KeepOut | null, kind?: number): void;
+    respawn(slot: number, random: SeededRandom, halfExtent: number, keepOut?: KeepOut | null): void;
+    remove(slot: number): boolean;
+    nearest(source: Vec3Array, offset: number): number;
+    collect(source: Vec3Array, offset: number): number;
+    private activate;
+}
+
+declare const COURIER: {
+    readonly plazaHalf: 18;
+    readonly wallHeight: 1.2;
+    readonly crates: 6;
+    readonly crateHalf: 0.8;
+    readonly pickupRadius: 1.3;
+    readonly dropX: 0;
+    readonly dropZ: 0;
+    readonly dropRadius: 2.2;
+    readonly parcelSpread: 13;
+    readonly parcelLift: 0.35;
+    readonly carryLift: 2.1;
+    readonly parcelSize: 0.5;
+};
+declare class CourierPlaza implements GameScene<Game> {
+    readonly name = "courier";
+    rig: ThirdPersonRig | null;
+    deliveries: number;
+    readonly pickups: Pickups;
+    readonly parcel: Float64Array<ArrayBufferLike>;
+    readonly crates: Float64Array<ArrayBuffer>;
+    private readonly keepOut;
+    private boxes;
+    get carrying(): boolean;
+    enter(game: Game): void;
+    fixedUpdate(game: Game): void;
+    update(game: Game): void;
+    exit(): void;
+    target(out: Float64Array): void;
+    private placeParcel;
+    private draw;
+}
+declare const courierTemplate: GenreTemplate<CourierPlaza>;
+
+declare const courier_COURIER: typeof COURIER;
+type courier_CourierPlaza = CourierPlaza;
+declare const courier_CourierPlaza: typeof CourierPlaza;
+declare const courier_courierTemplate: typeof courierTemplate;
+declare namespace courier {
+  export { courier_COURIER as COURIER, courier_CourierPlaza as CourierPlaza, courier_courierTemplate as courierTemplate };
+}
+
+export { CIRCLE_RADIUS as C, KEEP_OUT_STRIDE as K, MAX_SCATTER_TRIES as M, NO_PICKUP as N, PICKUP_STRIDE as P, type Vec3Array as V, CIRCLE_WORDS as a, CIRCLE_X as b, CIRCLE_Z as c, KeepOut as d, Pickups as e, courier as f, withinRadius as g, writePosition as h, writeScale as i, COURIER as j, CourierPlaza as k, courierTemplate as l, withinCircle as w };

package/dist/crowd-DdHFbqKK.d.ts

@@ -0,0 +1,186 @@
+import { U as UiClock } from './clock-B-UAjkKa.js';
+import { U as UiElement } from './ui-hi7S2YcH.js';
+import { c as UiNumberFormatName } from './vars-Dc_PrhBK.js';
+import { M as Music, S as SoundId } from './audio-m0w8cnxq.js';
+
+type BindValue = number | string | boolean;
+interface ValueSource {
+    read(path: string): BindValue | undefined;
+}
+declare class BindState implements ValueSource {
+    private readonly values;
+    set(path: string, value: BindValue): void;
+    read(path: string): BindValue | undefined;
+    delete(path: string): void;
+}
+type BindShow = "number" | "text" | "vector_number" | "vector_bool" | "vector_trigger";
+type MotionTrigger = "up" | "down" | "change";
+type MotionStep = {
+    readonly kind: "count_up";
+    readonly seconds: number;
+} | {
+    readonly kind: "pop";
+    readonly scale: number;
+    readonly seconds: number;
+} | {
+    readonly kind: "settle";
+    readonly seconds: number;
+} | {
+    readonly kind: "flash";
+    readonly color: number;
+    readonly seconds: number;
+};
+interface BindMotion {
+    readonly on: MotionTrigger;
+    readonly when: string | null;
+    readonly steps: readonly MotionStep[];
+}
+interface UiBinding {
+    readonly shows: string;
+    readonly as: BindShow;
+    readonly format?: UiNumberFormatName;
+    readonly decimals?: number;
+    readonly vectorPath?: string;
+    readonly motions?: readonly BindMotion[];
+}
+declare const SETTLE_DAMPING = 0.6;
+declare const SETTLE_CYCLES = 1.5;
+declare function chooseMotion(motions: readonly BindMotion[], previous: number, next: number, source: ValueSource): number;
+declare class UiBinder {
+    private readonly baseTextColor;
+    private readonly bound;
+    private state;
+    constructor(baseTextColor?: number | null);
+    get size(): number;
+    bind(element: UiElement, binding: UiBinding): number;
+    update(source: ValueSource, clock: UiClock): void;
+    private observe;
+    private enter;
+    private snap;
+    private advance;
+    private write;
+}
+
+interface BedStem {
+    readonly id: string;
+    readonly sound: string;
+    readonly label: string;
+}
+interface MusicMood {
+    readonly id: string;
+    readonly label: string;
+    readonly bpm: number | null;
+    readonly layers: Readonly<Record<string, number>>;
+}
+interface MoodBand {
+    readonly from: number;
+    readonly to: number;
+    readonly mood: string;
+}
+interface MusicCue {
+    readonly moment: string;
+    readonly sound: string;
+    readonly quantize: "now" | "beat" | "bar";
+    readonly gain: number;
+}
+interface MusicBed {
+    readonly bpm: number;
+    readonly beatsPerBar: number;
+    readonly bars: number;
+    readonly stems: readonly BedStem[];
+    readonly moods: readonly MusicMood[];
+    readonly follows: {
+        readonly path: string;
+        readonly wraps: number | null;
+        readonly bands: readonly MoodBand[];
+    };
+    readonly cues: readonly MusicCue[];
+    readonly rampSeconds: number;
+}
+type Conductor = Pick<Music, "available" | "setTempo" | "play" | "setLayer" | "stinger" | "stop">;
+type MusicWait = "no_music_here" | "missing_sound";
+declare const NO_MOOD = -1;
+declare function moodIndex(bed: MusicBed, value: number): number;
+declare class AdaptiveMusic {
+    private readonly conductor;
+    readonly bed: MusicBed;
+    readonly waiting: readonly {
+        readonly what: string;
+        readonly reason: MusicWait;
+    }[];
+    private readonly stems;
+    private readonly gains;
+    private readonly cueSounds;
+    private mood;
+    private bpm;
+    private started;
+    constructor(conductor: Conductor, bed: MusicBed, sounds: ReadonlyMap<string, SoundId>);
+    get playable(): boolean;
+    get currentMood(): string | null;
+    start(value: number): void;
+    follow(value: number): boolean;
+    moment(name: string): number;
+    stop(fadeSeconds?: number): void;
+    private tempoOf;
+    private fillGains;
+}
+
+interface CrowdVote {
+    readonly id: string;
+    readonly question: string;
+    readonly choices: readonly string[];
+    readonly opensOn: string;
+    readonly seconds: number;
+}
+interface CrowdGift {
+    readonly gift: string;
+    readonly moment: string;
+    readonly label: string;
+}
+interface CrowdCheer {
+    readonly on: boolean;
+    readonly perTap: number;
+    readonly drainPerSecond: number;
+}
+interface CrowdDoc {
+    readonly votes: readonly CrowdVote[];
+    readonly gifts: readonly CrowdGift[];
+    readonly cheer: CrowdCheer;
+    readonly maxWatchers: number;
+}
+type CastResult = "counted" | "changed" | "same" | "closed" | "invalid";
+declare const MAX_VOTE_CHOICES = 16;
+declare const MAX_VOTE_INDEX = 255;
+declare const CROWD_VOTE_BYTES = 3;
+declare const CROWD_VOTE_TAG = 86;
+declare const NO_VOTE_WINNER = -1;
+declare class VotePoll {
+    readonly vote: CrowdVote;
+    private readonly stepsPerSecond;
+    readonly tally: Uint32Array;
+    private readonly ballots;
+    private closesAt;
+    private openedAt;
+    constructor(vote: CrowdVote, stepsPerSecond: number);
+    get voters(): number;
+    open(tick: number): void;
+    isOpen(tick: number): boolean;
+    remaining(tick: number): number;
+    cast(watcher: number, choice: number, tick: number): CastResult;
+    winner(): number;
+    share(choice: number): number;
+}
+declare class CheerMeter {
+    readonly cheer: CrowdCheer;
+    private level;
+    constructor(cheer: CrowdCheer);
+    get value(): number;
+    tap(count?: number): number;
+    step(seconds: number): number;
+}
+declare function giftMoments(doc: CrowdDoc, gift: string): readonly string[];
+declare function votesOpenedBy(doc: CrowdDoc, moment: string): readonly number[];
+declare function encodeVote(out: Uint8Array, vote: number, choice: number): number;
+declare function decodeVote(payload: Uint8Array, length: number, out: Int32Array): boolean;
+
+export { AdaptiveMusic as A, type BedStem as B, CROWD_VOTE_BYTES as C, encodeVote as D, giftMoments as E, moodIndex as F, votesOpenedBy as G, MAX_VOTE_CHOICES as M, NO_MOOD as N, SETTLE_CYCLES as S, UiBinder as U, type ValueSource as V, type BindMotion as a, type BindShow as b, BindState as c, type BindValue as d, CROWD_VOTE_TAG as e, type CastResult as f, CheerMeter as g, type Conductor as h, type CrowdCheer as i, type CrowdDoc as j, type CrowdGift as k, type CrowdVote as l, MAX_VOTE_INDEX as m, type MoodBand as n, type MotionStep as o, type MotionTrigger as p, type MusicBed as q, type MusicCue as r, type MusicMood as s, type MusicWait as t, NO_VOTE_WINNER as u, SETTLE_DAMPING as v, type UiBinding as w, VotePoll as x, chooseMotion as y, decodeVote as z };