@pose-tracker/pose-estimation-web 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1325 @@
+import * as _tensorflow_tfjs from '@tensorflow/tfjs';
+
+/** Bumped with package.json version (keep in sync). */
+declare const SDK_VERSION = "0.1.0";
+declare const SDK_NAME: "posetracker-web";
+
+/**
+ * Types for the `POST /api/sdk/configure` handshake response ("manifest").
+ *
+ * The manifest is the single source of truth for server-driven behavior:
+ * exercise definitions (angle thresholds, rep state machines), reference
+ * movements, engine bundle distribution and model profiles. Updating the
+ * manifest server-side changes SDK behavior without republishing the app.
+ */
+/**
+ * Model profiles (Sency-style). In v1 every profile maps to the bundled
+ * MoveNet SinglePose Lightning model; the fields below exist so the backend
+ * can later distribute per-profile models (e.g. Thunder for Prime, custom
+ * TFLite for native backends) without breaking older SDKs.
+ */
+type PoseModelProfile = 'UltraLite' | 'Lite' | 'Pro' | 'Prime' | 'AdaptiveChoice';
+type ModelFormat = 'tfjs-graph-model' | 'tflite' | 'coreml';
+interface ModelDescriptor {
+    /** Stable identifier, e.g. "movenet-singlepose-lightning". */
+    modelId: string;
+    format: ModelFormat;
+    /** Square input resolution in pixels (192 for MoveNet Lightning). */
+    inputSize: number;
+    /**
+     * Signed (token-gated) download URL for a standalone model archive, or
+     * null/absent when the model is delivered by another channel (stub-loader
+     * architecture: MoveNet ships inside the `pose-runtime` payload).
+     */
+    signedUrl?: string | null;
+    /** SHA-256 hex digest of the downloadable archive (null when signedUrl is null). */
+    sha256?: string | null;
+    /** Delivery channel; 'pose-runtime' = part of the public runtime payload. */
+    deliveredBy?: 'pose-runtime';
+    version: string;
+}
+/** Maps each profile to a model. v1: all profiles point to the same MoveNet entry. */
+type ModelsByProfile = Record<Exclude<PoseModelProfile, 'AdaptiveChoice'>, ModelDescriptor>;
+/**
+ * Full movement definition, mirroring the Strapi content-types
+ * (`api::movement.movement` + steps/parameters/recommendations/initial
+ * posture) that already drive the WebView engine. The remote engine bundle
+ * consumes this structure as-is, so movements/exercises created or tuned in
+ * the dashboard update SDK behavior without any republish.
+ */
+interface MovementStepParameter {
+    /** Keypoint/angle selector; `a||b` accepts either side (front convention). */
+    name: string;
+    type: 'angle' | 'upper_y' | 'matching_y' | 'same_y' | 'matching_x' | 'same_x' | 'distance_y';
+    /** Weight of this parameter within the step (0–100). */
+    percentage: number;
+    operator?: string;
+    value?: number;
+    reference?: string;
+    /** When true, the parameter is included in `step_completion` payloads. */
+    public?: boolean;
+    /** Per-difficulty acceptance values (e.g. { easy: 90, medium: 100 }). */
+    scale_acceptance?: Record<string, number>;
+    /** Acceptance values when the camera point of view is elevated. */
+    upper_scale_acceptance?: Record<string, number>;
+}
+interface MovementRecommendation {
+    name: string;
+    type: 'angle' | 'body_axe_without_arms' | 'upper_y' | 'matching_x';
+    operator: string;
+    value?: number;
+    reference?: string;
+    recommendation_text: string;
+    scale_acceptance?: Record<string, number>;
+    upper_scale_acceptance?: Record<string, number>;
+}
+interface MovementStep {
+    name: string;
+    /** Order of the step within the movement (0-based). */
+    position: number;
+    /** Contribution of this step to the overall 0–100 progression. */
+    percentage: number;
+    /** Per-difficulty completion threshold to validate the step. */
+    scale_acceptance: Record<string, number>;
+    movement_parameters: MovementStepParameter[];
+    movement_recommendations: MovementRecommendation[];
+}
+interface InitialPosture {
+    /** Expected orientation: 'face' or 'profile'. */
+    type: string;
+    /** Keypoints that must be visible inside the placement box. */
+    required_points: string[];
+    /** Placement box paddings, in % of the frame. */
+    padding_horizontal?: number | string;
+    padding_vertical?: number | string;
+}
+interface MovementDefinition {
+    name: string;
+    type: 'dynamic' | 'static';
+    scale_acceptance: Record<string, number>;
+    movement_steps: MovementStep[];
+    movement_initial_posture: InitialPosture | null;
+    custom_skeleton?: string | null;
+    silhouette_image_url?: string | null;
+}
+interface ExerciseConfig {
+    /** Stable identifier, e.g. "squat". */
+    id: string;
+    name: string;
+    type: 'dynamic' | 'static';
+    /**
+     * Full server-driven definition, consumed by the remote engine bundle.
+     * Exercise configs only ever exist behind a validated handshake (live or
+     * encrypted session cache) — the npm package ships zero movement
+     * intelligence (commercial boundary, see ARCHITECTURE.md §Modes).
+     */
+    movement: MovementDefinition;
+}
+interface ReferenceMovementDescriptor {
+    uuid: string;
+    name: string;
+    /** Signed URL to the movement signature JSON (angles/ratios/deltas over time). */
+    signedSignatureUrl: string;
+    sha256: string;
+}
+interface EngineBundleDescriptor {
+    version: string;
+    /** Signed, token-gated URL of the JS engine bundle. */
+    signedUrl: string;
+    /** SHA-256 hex digest used for integrity validation after download. */
+    sha256: string;
+    /** Minimum SDK version able to run this bundle (semver). */
+    minSdkVersion: string;
+    /** True when the version sent in `localVersions.engine` is already current. */
+    upToDate?: boolean;
+}
+interface PoseRuntimePartDescriptor {
+    /** Download URL of this part (`GET /api/sdk/pose-runtime?part=...&v=...`). */
+    url: string;
+    /** SHA-256 hex digest, verified BEFORE the part is committed to the cache. */
+    sha256: string;
+    bytes: number;
+}
+/**
+ * Descriptor of the public pose estimation payload (TF.js + MoveNet +
+ * proprietary pipeline wasm + page runtime). No API key required: pose
+ * estimation is the free tier; the movement engine stays key-gated.
+ */
+interface PoseRuntimeDescriptor {
+    version: string;
+    /** True when the version sent in `localVersions.poseRuntime` is current. */
+    upToDate?: boolean;
+    baseUrl?: string;
+    /** Parts by name: tfjs, tfjs-wasm, model, weights, pipeline, runtime. */
+    parts: Record<string, PoseRuntimePartDescriptor>;
+}
+interface ConfigureRequest {
+    /** Optional: keyless handshakes get the public manifest (pose-runtime only). */
+    apiToken?: string;
+    sdkName: 'posetracker-rn' | 'posetracker-rn-light' | 'posetracker-web';
+    sdkVersion: string;
+    targetPlatform: 'ios' | 'android' | 'web';
+    /** Requested profile; the backend may downgrade it based on plan. */
+    poseModelProfile: PoseModelProfile;
+    /** Locale for localized strings in configs (hints, recommendations). */
+    locale?: string;
+    /**
+     * Versions currently committed to the local caches; the backend answers
+     * with `upToDate` flags per module so unchanged payloads are not
+     * re-downloaded.
+     */
+    localVersions?: {
+        poseRuntime?: string | null;
+        engine?: string | null;
+    };
+}
+interface PlanInfo {
+    plan: string;
+    /** Remaining API calls for the current period; null = unlimited. */
+    remainingCalls: number | null;
+    commercialUse: boolean;
+}
+interface SdkManifest {
+    /**
+     * Short-lived session token for follow-up SDK requests (downloads, usage
+     * pings). Null on keyless handshakes (public manifest).
+     */
+    sessionToken: string | null;
+    /** Null on keyless handshakes. */
+    plan: PlanInfo | null;
+    models: ModelsByProfile;
+    /** Profile the backend resolved for this device/plan. */
+    resolvedProfile: Exclude<PoseModelProfile, 'AdaptiveChoice'>;
+    /** Public pose estimation payload (always present, key or not). */
+    poseRuntime: PoseRuntimeDescriptor | null;
+    /** Null on keyless handshakes or when no engine bundle is deployed. */
+    engine: EngineBundleDescriptor | null;
+    exercises: ExerciseConfig[];
+    referenceMovements: ReferenceMovementDescriptor[];
+    /** Revocation signal: when true the SDK purges its sealed engine cache. */
+    revoked?: boolean;
+    /** Unix epoch ms after which the SDK should re-run the handshake. */
+    expiresAt: number;
+}
+
+/**
+ * Handshake client: `configure(apiToken)` → Strapi `SdkManifest`.
+ * Same endpoint as RN light; `targetPlatform: 'web'`, `sdkName: posetracker-web`.
+ */
+
+declare const DEFAULT_BASE_URL = "https://movelytics-strapi-c78a339b7070.herokuapp.com";
+interface ConfigureOptions {
+    baseUrl?: string;
+    poseModelProfile?: PoseModelProfile;
+    locale?: string;
+    localVersions?: ConfigureRequest['localVersions'];
+}
+declare class ConfigureError extends Error {
+    readonly code: 'invalid_token' | 'quota_exceeded' | 'network' | 'internal';
+    constructor(code: 'invalid_token' | 'quota_exceeded' | 'network' | 'internal', message: string);
+}
+declare function configure(apiToken: string | null, options?: ConfigureOptions): Promise<SdkManifest>;
+
+/**
+ * Backend-agnostic pose types (COCO-17 MoveNet topology).
+ * Same contract as the React Native light SDK.
+ */
+type CocoKeypointName = 'nose' | 'left_eye' | 'right_eye' | 'left_ear' | 'right_ear' | 'left_shoulder' | 'right_shoulder' | 'left_elbow' | 'right_elbow' | 'left_wrist' | 'right_wrist' | 'left_hip' | 'right_hip' | 'left_knee' | 'right_knee' | 'left_ankle' | 'right_ankle';
+type KeypointName = CocoKeypointName;
+declare const COCO_KEYPOINT_NAMES: readonly CocoKeypointName[];
+interface Keypoint {
+    name: KeypointName;
+    /** Normalized [0, 1] relative to display width (mirrored for user-facing camera). */
+    x: number;
+    /** Normalized [0, 1] relative to display height. */
+    y: number;
+    z?: number;
+    /** Confidence in [0, 1]. */
+    score: number;
+}
+interface Pose {
+    keypoints: Keypoint[];
+    score: number;
+    timestampMs: number;
+}
+
+/**
+ * Classic PoseTracker WebView → native message parity.
+ *
+ * Host apps that already parse `sendDataToNative` JSON
+ * (`PoseTrackerFront/lib/v3/sendDataToNativeContract.js`) can subscribe via
+ * `addMessageListener` / `usePoseTracker({ onMessage })` and keep the same
+ * `type` + payload field names (`data`, `current_count`, `message`, …).
+ *
+ * Typed {@link PoseTrackerEvent} remains the preferred API for new apps.
+ */
+
+/** Loose JSON envelope matching the frozen WebView → native contract. */
+type ClassicNativeMessage = {
+    type: string;
+    [key: string]: unknown;
+};
+type ClassicMessageListener = (message: ClassicNativeMessage) => void;
+/**
+ * Map a typed SDK event to a classic PoseTracker `sendDataToNative` payload.
+ * Returns null for SDK-only events that have no classic equivalent and should
+ * not be mirrored (none today — quality/performance map to error/warning).
+ */
+declare function toClassicNativeMessage(event: PoseTrackerEvent): ClassicNativeMessage;
+
+/**
+ * Acceleration diagnostics — web stub (browser TF.js WebGL vs WASM).
+ * Full AdaptiveChoice / Vision reports live in the RN light SDK.
+ */
+type AccelerationState = 'unknown' | 'gpu' | 'cpu-fallback' | 'unavailable';
+type InferenceRuntime = 'tfjs-webgl' | 'tfjs-wasm' | 'tfjs-cpu' | 'unknown';
+interface AccelerationDiagnostics {
+    state: AccelerationState;
+    runtime: InferenceRuntime;
+    backend: string | null;
+    glRenderer: string | null;
+    medianInferenceMs: number | null;
+    detail?: string;
+}
+type DiagnosticListener = (message: string) => void;
+
+/**
+ * Minimal quality profile types for event parity with RN light.
+ * Full AdaptiveChoice ladder is RN/WebView-oriented; web uses getUserMedia
+ * idealWidth/idealHeight from host options instead.
+ */
+type QualityProfileId = 'ultra' | 'high' | 'balanced' | 'performance' | 'low' | 'minimal';
+interface QualityProfile {
+    id: QualityProfileId;
+    idealWidth: number;
+    idealHeight: number;
+    idealFrameRate: number;
+}
+
+type PoseTrackerStatus = 'idle' | 'configuring' | 'downloading' | 'warming' | 'ready' | 'error';
+/**
+ * Operating mode (commercial boundary):
+ * - 'keypoints-only': no validated API key/session — the SDK provides its
+ *   core value only (bundled MoveNet, warm-up, camera pipeline) and streams
+ *   raw `keypoints` events. No business events (counter, angles, posture,
+ *   progression, recommendations, form_score, exercise_summary).
+ * - 'full-engine': a handshake succeeded (live or from the encrypted local
+ *   session cache) and the engine bundle is loaded — all events available.
+ *
+ * The mode can upgrade at runtime (keypoints-only → full-engine) without
+ * restarting the camera pipeline, via `configure()` or a preload retry.
+ */
+type PoseTrackerMode = 'keypoints-only' | 'full-engine';
+type InitializationStep = 'configuring' | 'downloading' | 'warming' | 'accessing_webcam' | 'loading_pose_model' | 'ready';
+interface InitializationEvent {
+    type: 'initialization';
+    /**
+     * Machine step. Classic PoseTracker used free-form `message` strings
+     * ("accessing webcam", "loading pose model", "running"); both are set.
+     */
+    step: InitializationStep;
+    /** Human-readable status (PoseTracker WebView parity). */
+    message: string;
+    ready: boolean;
+    /** Present on the `ready` step. */
+    mode?: PoseTrackerMode;
+    /**
+     * Present on the `ready` step: GPU-acceleration verdict from the warm-up
+     * health check ('gpu' | 'cpu-fallback' | 'unavailable'). See
+     * docs/ANDROID_GL_ACCELERATION.md.
+     */
+    acceleration?: AccelerationState;
+}
+interface ErrorEvent {
+    type: 'error';
+    code: 'invalid_token' | 'quota_exceeded' | 'network'
+    /**
+     * First launch, no network, empty runtime cache: the pose runtime cannot
+     * be initialized without downloading the payload once. Fatal.
+     */
+     | 'network_required'
+    /**
+     * Offline with an API key: metered features (engine/exercises) are
+     * refused because PoseTracker cannot count their usage. Non-fatal —
+     * keypoints-only keeps running from the cache.
+     */
+     | 'offline_metered'
+    /**
+     * The `free` plan requested developer features (angles, recommendations,
+     * progression, or keypoints combined with an exercise). Same message as
+     * the PoseTracker WebView (`TrackingAppV3`). Non-fatal: keypoints-only
+     * pose estimation keeps running.
+     */
+     | 'free_plan_feature_blocked'
+    /**
+     * A WebView-only option was requested (blazepose, poseEngine,
+     * mediapipeModel, …): this SDK ships MoveNet Lightning only.
+     */
+     | 'feature_not_supported'
+    /** Unknown exercise id (WebView parity: `invalid_exercise`). */
+     | 'invalid_exercise'
+    /** jump_analysis requires `userHeightCm` (WebView parity). */
+     | 'jump_analysis_missing_height' | 'model_load_failed' | 'engine_load_failed' | 'integrity_check_failed' | 'webview_error' | 'device_too_slow' | 'backend_fallback_wasm' | 'camera_denied' | 'camera_unavailable' | 'internal';
+    message: string;
+}
+/**
+ * Non-fatal warning the host can surface (telemetry / soft UX).
+ * Classic WebView sometimes used `type: "warning"`; V3 degradations often
+ * reuse `type: "error"` with a code — see {@link PerformanceWarningEvent}.
+ */
+interface WarningEvent {
+    type: 'warning';
+    code: 'quality_downgraded' | 'backend_fallback_wasm' | 'webview' | 'internal';
+    message: string;
+    timestampMs: number;
+}
+interface KeypointsEvent {
+    type: 'keypoints';
+    keypoints: Keypoint[];
+    /** Mean confidence of the pose. */
+    score: number;
+    timestampMs: number;
+}
+/** ~1 Hz telemetry pulse (web debug HUD / host metrics). */
+interface StatsEvent {
+    type: 'stats';
+    fps: number;
+    medianInferenceMs: number | null;
+    backend: string | null;
+    keypointsAbove03: number;
+    meanScore: number;
+    videoSize: string;
+    timestampMs: number;
+}
+interface AngleValue {
+    /** Angle id from the exercise config, e.g. "left_knee". */
+    id: string;
+    side: 'left' | 'right' | 'center';
+    degrees: number;
+    /** Min confidence of the three keypoints defining the angle. */
+    score: number;
+}
+interface AnglesEvent {
+    type: 'angles';
+    angles: AngleValue[];
+    timestampMs: number;
+}
+/**
+ * Letter grade for a 0–100 form score (GitBook / Front BaseExercise):
+ * A ≥ 90, B ≥ 80, C ≥ 70, D ≥ 60, F &lt; 60.
+ */
+type FormGrade = 'A' | 'B' | 'C' | 'D' | 'F';
+/** Valid `minGrade` filter values (F is not a valid minGrade config). */
+type MinGrade = 'A' | 'B' | 'C' | 'D';
+/**
+ * Nested form score on a counted rep — GitBook / WebView V3
+ * `counter.form_score` (authoritative grade for that rep).
+ */
+interface CounterFormScore {
+    /** Score of the rep that was just counted, 0–100. */
+    score: number;
+    /** Running average across counted reps, 0–100. */
+    average: number;
+    grade: FormGrade;
+}
+interface CounterEvent {
+    type: 'counter';
+    count: number;
+    /**
+     * Authoritative form score for the counted rep (WebView
+     * `counter.form_score`). Prefer this over a standalone `form_score` event
+     * when mirroring the tracking endpoint.
+     */
+    formScore?: CounterFormScore;
+    /** Similarity score vs. reference movement for the last rep, when a reference is active. */
+    referenceScore?: number;
+    timestampMs: number;
+}
+interface PostureEvent {
+    type: 'posture';
+    /** True when the user placement satisfies the exercise posture requirements. */
+    ready: boolean;
+    /** Localized human hint ("Face the camera", "Get ready…"). */
+    hint: string;
+    /** WebView parity: placement direction hint ("in-frame", "face-camera", "profile-camera"). */
+    direction?: string;
+    missingKeypoints: string[];
+    timestampMs: number;
+}
+interface ProgressionEvent {
+    type: 'progression';
+    /** Movement progression within the current rep, 0–100. */
+    value: number;
+    timestampMs: number;
+}
+interface RecommendationsEvent {
+    type: 'recommendations';
+    /** Localized form advice strings. */
+    recommendations: string[];
+    timestampMs: number;
+}
+interface FormScoreEvent {
+    type: 'form_score';
+    /** Score of the last completed rep, 0–100. */
+    score: number;
+    /** Running average across the session, 0–100. */
+    average: number;
+    grade: FormGrade;
+    timestampMs: number;
+}
+interface RepSummary {
+    index: number;
+    formScore: number;
+    durationMs: number;
+    referenceScore?: number;
+}
+interface ExerciseSummaryEvent {
+    type: 'exercise_summary';
+    exercise: string;
+    counter: number;
+    averageFormScore: number;
+    averageSimilarity?: number;
+    grade: FormGrade;
+    history: RepSummary[];
+    durationMs: number;
+    timestampMs: number;
+}
+interface VisibleHipsInfo {
+    left: boolean;
+    right: boolean;
+}
+/** jump_analysis only: cm/pixel calibration established from userHeightCm. */
+interface JumpCalibrationEvent {
+    type: 'jump_calibration';
+    calibrated: true;
+    cmPerPixel: number;
+    baselineY: number | null;
+    visibleHips: VisibleHipsInfo;
+    /** WebView literal: "Calibration complete - ready to jump". */
+    message: string;
+    timestampMs: number;
+}
+/** Push-off detected — measurement in progress. */
+interface JumpStartedEvent {
+    type: 'jump_started';
+    /** WebView literal: "Jump detected - measuring height". */
+    message: string;
+    timestampMs: number;
+}
+/** Live/final jump height. `final: true` closes the jump (see JumpResultEvent). */
+interface JumpHeightEvent {
+    type: 'jump_height';
+    jumpHeightCm: number;
+    baselineY?: number | null;
+    minY?: number | null;
+    measuring: boolean;
+    landed: boolean;
+    final?: boolean;
+    deltaPixels?: number;
+    sideUsed?: string | null;
+    airTimeMs?: number;
+    airTimeSeconds?: number;
+    visibleHips?: VisibleHipsInfo;
+    timestampMs: number;
+}
+/** Detection aborted (approach toward camera, timeout, tracking lost…). */
+interface JumpDiscardedEvent {
+    type: 'jump_discarded';
+    reason: string;
+    userMessage: string;
+    timestampMs: number;
+}
+/** One completed jump (final height for jump N). */
+interface JumpResultEvent {
+    type: 'jump_result';
+    jumpNumber: number;
+    jumpHeightCm: number;
+    airTimeMs?: number;
+    airTimeSeconds?: number;
+    baselineY?: number | null;
+    minY?: number | null;
+    deltaPixels?: number;
+    sideUsed?: string | null;
+    visibleHips?: VisibleHipsInfo;
+    timestampMs: number;
+}
+interface JumpSummaryEntry {
+    jumpNumber: number;
+    jumpHeightCm: number;
+    airTimeMs?: number;
+    airTimeSeconds?: number;
+}
+/** Running summary of all completed jumps (emitted after each jump_result). */
+interface JumpSummaryEvent {
+    type: 'jump_summary';
+    totalJumps: number;
+    avgJumpHeight: number;
+    maxJumpHeight: number;
+    minJumpHeight: number;
+    avgAirTimeSeconds?: number;
+    jumps: JumpSummaryEntry[];
+    timestampMs: number;
+}
+/**
+ * Camera / preprocess quality tier changed (AdaptiveChoice auto-downgrade,
+ * crash-guard recovery, or GL capability hint). English, for app developers.
+ */
+interface QualityChangedEvent {
+    type: 'quality_changed';
+    previousProfile: QualityProfileId;
+    activeProfile: QualityProfileId;
+    reason: 'low_fps' | 'device_capability' | 'crash_guard' | 'warmup_estimate' | 'manual';
+    detail: string;
+    profile: QualityProfile;
+    /** Present when reason is warmup_estimate / low_fps. */
+    estimatedFps?: number | null;
+    medianInferenceMs?: number | null;
+    timestampMs: number;
+}
+/**
+ * Fired when mean inference FPS stays critically low. English developer alert —
+ * surface in your own telemetry / support tooling; do not show raw to end users
+ * unless you localize it.
+ */
+interface PerformanceWarningEvent {
+    type: 'performance_warning';
+    code: 'device_too_slow';
+    message: string;
+    meanFps: number;
+    thresholdFps: number;
+    activeProfile: QualityProfileId;
+    medianInferenceMs: number | null;
+    videoSize?: string;
+    timestampMs: number;
+}
+/**
+ * Download progress of the pose-runtime payload (first preload, or version
+ * update). Lets the host app show a loader/progress bar during the initial
+ * ~9 MB download; never fired when the cache is already up-to-date.
+ */
+interface RuntimeDownloadProgressEvent {
+    type: 'runtime_download_progress';
+    /** Part being downloaded (tfjs, tfjs-wasm, model, weights, pipeline, runtime). */
+    part: string;
+    completedParts: number;
+    totalParts: number;
+    /** Size of the current part, from the signed manifest. */
+    partBytes: number;
+    timestampMs: number;
+}
+type PoseTrackerEvent = InitializationEvent | ErrorEvent | WarningEvent | RuntimeDownloadProgressEvent | KeypointsEvent | StatsEvent | AnglesEvent | CounterEvent | PostureEvent | ProgressionEvent | RecommendationsEvent | FormScoreEvent | ExerciseSummaryEvent | JumpCalibrationEvent | JumpStartedEvent | JumpHeightEvent | JumpDiscardedEvent | JumpResultEvent | JumpSummaryEvent | QualityChangedEvent | PerformanceWarningEvent;
+type PoseTrackerEventType = PoseTrackerEvent['type'];
+type PoseTrackerEventListener = (event: PoseTrackerEvent) => void;
+/**
+ * Typed per-event callbacks, convenient for `usePoseTracker({ onCounter, ... })`.
+ * Also accepts {@link onMessage} for classic PoseTracker WebView JSON parity.
+ */
+interface PoseTrackerCallbacks {
+    onInitialization?: (event: InitializationEvent) => void;
+    onError?: (event: ErrorEvent) => void;
+    onWarning?: (event: WarningEvent) => void;
+    onKeypoints?: (event: KeypointsEvent) => void;
+    onStats?: (event: StatsEvent) => void;
+    onAngles?: (event: AnglesEvent) => void;
+    onCounter?: (event: CounterEvent) => void;
+    onPosture?: (event: PostureEvent) => void;
+    onProgression?: (event: ProgressionEvent) => void;
+    onRecommendations?: (event: RecommendationsEvent) => void;
+    onFormScore?: (event: FormScoreEvent) => void;
+    onExerciseSummary?: (event: ExerciseSummaryEvent) => void;
+    onJumpCalibration?: (event: JumpCalibrationEvent) => void;
+    onJumpStarted?: (event: JumpStartedEvent) => void;
+    onJumpHeight?: (event: JumpHeightEvent) => void;
+    onJumpDiscarded?: (event: JumpDiscardedEvent) => void;
+    onJumpResult?: (event: JumpResultEvent) => void;
+    onJumpSummary?: (event: JumpSummaryEvent) => void;
+    onQualityChanged?: (event: QualityChangedEvent) => void;
+    onPerformanceWarning?: (event: PerformanceWarningEvent) => void;
+    onRuntimeDownloadProgress?: (event: RuntimeDownloadProgressEvent) => void;
+    /**
+     * Classic PoseTracker `sendDataToNative` JSON stream (same `type` / field
+     * names as the WebView product). Fires for every typed event.
+     */
+    onMessage?: (message: ClassicNativeMessage) => void;
+}
+
+/**
+ * Contract between the SDK shell and the engine (business logic: angles,
+ * rep counting, form scoring, posture, progression, recommendations).
+ *
+ * The engine is EXCLUSIVELY distributed remotely as a versioned JS bundle
+ * (signed URL in the handshake manifest, SHA-256 integrity check, sealed
+ * local cache) — the npm package ships zero business logic. Without a
+ * loaded engine the SDK runs in keypoints-only mode.
+ */
+
+/**
+ * Feature flags forwarded to the engine session (WebView query-param
+ * parity). The client already filters emissions by plan/flags; passing
+ * them to the engine is a second gate AND lets the engine skip work.
+ */
+interface EngineSessionFeatures {
+    angles?: boolean;
+    recommendations?: boolean;
+    progression?: boolean;
+}
+interface EngineSessionOptions {
+    exercise: ExerciseConfig;
+    /** Locale used to resolve localized hints/recommendations. */
+    locale: string;
+    /** Difficulty key into the movement `scale_acceptance` maps. Default: 'medium'. */
+    difficulty?: string;
+    /** Parsed reference-movement signature, when comparing against a reference. */
+    referenceSignature?: unknown;
+    /**
+     * Only count reps whose form grade is at or above this letter (`A` best).
+     * WebView `minGrade` parity: reps below the bar emit neither `counter`
+     * nor `form_score` and are excluded from the summary.
+     */
+    minGrade?: MinGrade;
+    /** Emission flags — engines older than 1.1.0 ignore them (client re-filters). */
+    features?: EngineSessionFeatures;
+}
+interface EngineSession {
+    /** Feed one estimated pose; the session emits events through the sink. */
+    processPose(pose: Pose): void;
+    /** Finish the session; emits a final `exercise_summary` event. */
+    end(): void;
+}
+/**
+ * Custom (non-FSM) exercise shipped inside the engine bundle, e.g. the jump
+ * analysis handlers (WebView `customHandlers.js` parity). Not present in the
+ * Strapi movement manifest — discovered via `listCustomExercises()`.
+ */
+interface CustomExerciseDescriptor {
+    /** Exercise id used with `startExercise()` (e.g. 'jump_analysis'). */
+    id: string;
+    displayName: string;
+    type: 'custom';
+    description?: string;
+    /** Option keys that MUST be passed to `startExercise` (e.g. 'userHeightCm'). */
+    requiredParams: string[];
+    optionalParams: string[];
+}
+/** Options for engine custom sessions (jump_analysis / air_time_jump). */
+interface CustomSessionOptions {
+    exerciseId: string;
+    locale: string;
+    /** Athlete height in cm — required by jump_analysis (cm/pixel calibration). */
+    userHeightCm?: number;
+    /** Device pitch in degrees, used to compensate camera tilt. */
+    devicePitchDeg?: number;
+}
+type EventSink = (event: PoseTrackerEvent) => void;
+interface PoseTrackerEngine {
+    readonly version: string;
+    createSession(options: EngineSessionOptions, emit: EventSink): EngineSession;
+    /** Engine >= 1.2.0: custom exercises shipped in the bundle (jump analysis…). */
+    listCustomExercises?(): CustomExerciseDescriptor[];
+    /** Engine >= 1.2.0: start a custom exercise session (placement + jump_* events). */
+    createCustomSession?(options: CustomSessionOptions, emit: EventSink): EngineSession;
+}
+
+/**
+ * Remote engine distribution for the browser (same contract as RN light):
+ * signed URL → SHA-256 → evaluate via `new Function` → sealed localStorage cache.
+ */
+
+interface FileStore {
+    read(key: string): Promise<string | null>;
+    write(key: string, contents: string): Promise<void>;
+    remove(key: string): Promise<void>;
+}
+interface KeyValueStore {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+/** localStorage-backed KV (guard + track queue). */
+declare function createLocalKeyValueStore(): KeyValueStore | null;
+/**
+ * localStorage file store for sealed engine bundles.
+ * Large engines may exceed ~5 MB quota — download still works; cache is best-effort.
+ */
+declare function createLocalFileStore(): FileStore | null;
+declare function createMemoryFileStore(): FileStore;
+/** Best available browser store: localStorage → memory. */
+declare function createWebFileStore(): FileStore;
+interface EngineLoadResult {
+    engine: PoseTrackerEngine;
+    source: 'remote-cache' | 'remote-download';
+}
+interface EngineLoaderOptions {
+    fileStore?: FileStore | null;
+    keyValueStore?: KeyValueStore | null;
+    fetchFn?: typeof fetch;
+    onDiagnostic?: (message: string) => void;
+}
+declare class EngineLoader {
+    private readonly files;
+    private readonly kv;
+    private readonly fetchFn;
+    private readonly onDiagnostic;
+    lastError: string | null;
+    constructor(options?: EngineLoaderOptions);
+    clearGuard(descriptor: EngineBundleDescriptor | null): Promise<void>;
+    load(descriptor: EngineBundleDescriptor | null, cacheSecret: string, options?: {
+        forceRetry?: boolean;
+    }): Promise<EngineLoadResult | null>;
+    private evaluate;
+}
+
+/**
+ * Usage tracking — `POST /api/sdk/track` (same contract as RN light).
+ * Browser: platform = 'web'; anonymous queue → localStorage.
+ */
+
+declare class TrackError extends Error {
+    readonly code: 'invalid_token' | 'quota_exceeded' | 'network' | 'internal';
+    constructor(code: 'invalid_token' | 'quota_exceeded' | 'network' | 'internal', message: string);
+}
+interface TrackRequest {
+    event?: string;
+    apiToken?: string | null;
+    params?: Record<string, unknown>;
+}
+interface TrackResponse {
+    tracked: boolean;
+    anonymous?: boolean;
+    monthly_usage_counter?: number;
+    remainingCalls?: number;
+    type?: string;
+}
+interface UsageTrackerOptions {
+    baseUrl?: string;
+    keyValueStore?: KeyValueStore | null;
+    fetchFn?: typeof fetch;
+}
+declare class UsageTracker {
+    private readonly baseUrl;
+    private readonly kv;
+    private readonly fetchFn;
+    constructor(options?: UsageTrackerOptions);
+    trackMetered(request: TrackRequest & {
+        apiToken: string;
+    }): Promise<TrackResponse>;
+    trackAnonymous(request?: TrackRequest): Promise<void>;
+    flushQueue(): Promise<void>;
+    private post;
+    private readQueue;
+    private writeQueue;
+    private enqueue;
+}
+
+/**
+ * Online pose-model catalog (web) — mirrors RN light `poseModels.ts`.
+ *
+ * Default: MoveNet SinglePose Lightning at app.posetracker.com.
+ * BlazePose: handled by the pose-detection adapter (no graph modelUrl).
+ */
+/** Production MoveNet SinglePose Lightning topology (Front / RN light default). */
+declare const DEFAULT_MOVENET_LIGHTNING_URL = "https://app.posetracker.com/scripts/tmp_model_to_remove.json";
+type PoseModelAlias = 'movenet' | 'movenet-singlepose-lightning' | 'lightning' | 'blazepose' | (string & {});
+interface ResolvePoseModelOptions {
+    model?: PoseModelAlias;
+    /** Explicit TF.js graph-model topology URL (weights resolve as siblings). */
+    modelUrl?: string;
+}
+type PoseModelKind = 'movenet-graph' | 'blazepose' | 'custom-graph' | 'unsupported';
+interface ResolvedPoseModel {
+    modelId: string;
+    kind: PoseModelKind;
+    /** TF.js `loadGraphModel` URL when kind is movenet-graph or custom-graph. */
+    modelUrl: string | null;
+    unsupportedReason?: string;
+}
+declare function resolvePoseModel(options?: ResolvePoseModelOptions): ResolvedPoseModel;
+
+/**
+ * Host-selectable tracking features — same plan gating / messages as RN light
+ * and PoseTracker WebView `TrackingAppV3`.
+ *
+ * Web delta: `model: 'blazepose'` is a first-class model option (separate from
+ * the unsupported WebView `features.blazepose` query-param key).
+ */
+
+interface PoseTrackerFeatures {
+    angles?: boolean;
+    recommendations?: boolean;
+    progression?: boolean;
+    keypoints?: boolean;
+    minGrade?: MinGrade;
+}
+interface ResolvedFeatures {
+    angles: boolean;
+    recommendations: boolean;
+    progression: boolean;
+    keypoints: boolean;
+    minGrade: MinGrade | null;
+}
+declare const DEFAULT_FEATURES: ResolvedFeatures;
+declare const FREE_PLAN_FEATURES_MESSAGE = "You cannot use developer features. (visit: https://posetracker.gitbook.io/posetracker-api/tracking-endpoint)";
+declare const INVALID_TOKEN_MESSAGE = "Invalid params. Please refer to the documentation and set token=YOUR API_KEY et exercise=A correct exercise. (visit: https://posetracker.gitbook.io/posetracker-api/tracking-endpoint)";
+declare const COMBINED_REFERENCE_EXERCISE_MESSAGE = "You cannot combine reference & exercise. Please check the documentation.";
+declare function featureNotSupportedMessage(key: string): string;
+declare function resolveFeatures(input: PoseTrackerFeatures | undefined): {
+    features: ResolvedFeatures;
+    unsupportedKeys: string[];
+};
+declare function freeBlockedFeatures(features: ResolvedFeatures, options: {
+    withExercise: boolean;
+}): string[];
+declare function isPaidPlan(planType: string | null | undefined): boolean;
+declare function shouldShowWatermark(planType: string | null | undefined): boolean;
+
+/**
+ * Cold-start / preload modes for {@link PoseTrackerClient.preload}.
+ *
+ * - `basic` (default): load MoveNet + warm TF.js/WebGL with zero tensors.
+ *   Does **not** call `getUserMedia` — no unexpected camera permission prompt.
+ * - `full`: also open the camera during warm-up (legacy behaviour). Only use
+ *   when the host UI is already in a camera context the user expects.
+ */
+type ColdStartMode = 'basic' | 'full';
+interface PreloadOptions {
+    /**
+     * Cold-start depth. Default `basic`.
+     * Pass `full` only when you intentionally want getUserMedia during preload
+     * (e.g. a visible camera screen that also warms the model).
+     */
+    coldStart?: ColdStartMode;
+}
+
+/**
+ * Skeleton overlay definition — same JSON shape as Strapi `api::skeleton.skeleton`
+ * / PoseTrackerFront `DEFAULT_SKELETON` (WebView `?skeleton=<api_uuid>`).
+ */
+interface SkeletonCirclesStyle {
+    circleFillColor: string;
+    circleStrokeColor: string;
+    strokeWidth: string | number;
+    radius: string | number;
+}
+interface SkeletonLinesStyle {
+    lineStrokeColor: string;
+    strokeWidth: string | number;
+}
+interface SkeletonAnglesStyle {
+    fontColor?: string;
+    strokeColor?: string;
+}
+interface SkeletonDefinition {
+    keypoints: string[];
+    /** Named pairs `"left_hip||left_knee"`. */
+    keypoint_lines: string[];
+    keypoint_angles?: string[];
+    circles: SkeletonCirclesStyle;
+    lines: SkeletonLinesStyle;
+    angles?: SkeletonAnglesStyle;
+}
+/** PoseTracker API default (navy `#010A73` + gold `#FFC300`). */
+declare const DEFAULT_SKELETON_DEFINITION: SkeletonDefinition;
+
+/**
+ * Browser PoseTracker client — DOM camera + TF.js keypoints + remote engine.
+ * Public surface mirrors RN light `PoseTrackerClient` where the browser allows.
+ */
+
+interface StartExerciseOptions {
+    difficulty?: string;
+    userHeightCm?: number;
+    devicePitchDeg?: number;
+}
+interface PoseTrackerClientOptions extends ConfigureOptions {
+    model?: PoseModelAlias;
+    modelUrl?: string;
+    apiToken?: string;
+    facingMode?: 'user' | 'environment';
+    /** RN `position` alias: front → user, back → environment. */
+    position?: 'front' | 'back';
+    drawSkeleton?: boolean;
+    drawPlacementBox?: boolean;
+    placementPaddingPercent?: number;
+    loadingText?: string;
+    showWatermark?: boolean;
+    debugHud?: boolean;
+    features?: PoseTrackerFeatures;
+    idealWidth?: number;
+    idealHeight?: number;
+    skeletonDef?: SkeletonDefinition | null;
+    skeletonUuid?: string | null;
+    engineLoader?: EngineLoader;
+    fileStore?: FileStore | null;
+    usageTracker?: UsageTracker;
+    onDiagnostic?: (message: string) => void;
+    /** Alias of preload coldStart when using start(). Default full on camera screens. */
+    coldStart?: ColdStartMode;
+}
+/** @deprecated Prefer PoseTrackerClientOptions — kept for vanilla DX. */
+type PoseTrackerOptions = PoseTrackerClientOptions;
+type PoseTracker = PoseTrackerClient;
+declare class PoseTrackerClient {
+    private status;
+    private mode;
+    private lastError;
+    private manifest;
+    private engine;
+    private engineSource;
+    private session;
+    private currentExerciseId;
+    private apiToken;
+    private readonly engineLoader;
+    private readonly files;
+    private readonly tracker;
+    private readonly listeners;
+    private readonly typedListeners;
+    private readonly messageListeners;
+    private readonly stateListeners;
+    private preloadPromise;
+    private coldStartMode;
+    private configurePromise;
+    private handshakePromise;
+    private meteredSessionState;
+    private lastCameraStartInfo;
+    private sessionErrorStreak;
+    private readonly features;
+    private readonly unsupportedFeatureKeys;
+    private featureGateReported;
+    private keypointsSuppressionLogged;
+    private opts;
+    private shell;
+    private stream;
+    private adapter;
+    private resolved;
+    private running;
+    private busy;
+    private loopToken;
+    private cameraRevealed;
+    private disposed;
+    private skeletonDef;
+    private acceleration;
+    private inferMs;
+    private fpsWindow;
+    private fpsTimer;
+    constructor(apiToken?: string, options?: PoseTrackerClientOptions);
+    getStatus(): PoseTrackerStatus;
+    getMode(): PoseTrackerMode;
+    getError(): ErrorEvent | null;
+    getManifest(): SdkManifest | null;
+    getPlanType(): string | null;
+    getFeatures(): ResolvedFeatures;
+    getEngineSource(): EngineLoadResult['source'] | null;
+    getAcceleration(): AccelerationState;
+    getAccelerationDiagnostics(): AccelerationDiagnostics;
+    getResolvedModel(): ResolvedPoseModel;
+    getColdStartMode(): ColdStartMode;
+    addEventListener(listener: PoseTrackerEventListener): () => void;
+    on(type: PoseTrackerEvent['type'] | '*', listener: PoseTrackerEventListener): () => void;
+    addMessageListener(listener: ClassicMessageListener): () => void;
+    onStateChange(listener: () => void): () => void;
+    mount(target: string | HTMLElement): void;
+    /**
+     * Warm model (and optionally camera). Default coldStart = basic (no gUM).
+     * Alias: {@link warmup}.
+     */
+    preload(options?: PreloadOptions): Promise<void>;
+    warmup(options?: PreloadOptions): Promise<void>;
+    /** Mount + load model + open camera + start loop (camera-screen convenience). */
+    start(): Promise<void>;
+    stop(): void;
+    dispose(): Promise<void>;
+    configure(apiToken?: string): Promise<boolean>;
+    getAvailableExercises(): ExerciseConfig[];
+    getAvailableCustomExercises(): CustomExerciseDescriptor[];
+    startExercise(exerciseId: string, options?: StartExerciseOptions): void;
+    private startCustomExercise;
+    stopExercise(): void;
+    getCurrentExerciseId(): string | null;
+    fetchSkeleton(uuid: string): Promise<SkeletonDefinition>;
+    setModel(model?: PoseModelAlias, modelUrl?: string): Promise<void>;
+    updateOptions(partial: Partial<PoseTrackerClientOptions>): void;
+    ingestPose(pose: Pose): void;
+    private doPreload;
+    private ensureColdStartMode;
+    private ensureAdapter;
+    private ensureCamera;
+    private beginLoop;
+    private loop;
+    private resolveSkeletonFromOptions;
+    private resolveManifestOnce;
+    private doResolveManifestOnce;
+    private handleRevocation;
+    private handleCameraStart;
+    private retryMeteredSessionIfRefused;
+    private tryConfigure;
+    private resolveManifest;
+    private validateRequestedFeatures;
+    private emitFromSession;
+    private watermarkOn;
+    private applyWatermark;
+    private revealCamera;
+    private setStatus;
+    private setMode;
+    private reportError;
+    private notifyState;
+    private emit;
+}
+/** Factory — `createPoseTracker({ model: 'movenet' })`. */
+declare function createPoseTracker(options?: PoseTrackerClientOptions): PoseTrackerClient;
+declare function PoseCamera_mount(target: string | HTMLElement, options?: PoseTrackerClientOptions): PoseTrackerClient;
+declare const PoseCamera: {
+    mount: typeof PoseCamera_mount;
+};
+
+interface Letterbox {
+    offsetX: number;
+    offsetY: number;
+    drawW: number;
+    drawH: number;
+    vw: number;
+    vh: number;
+}
+interface DetectorFrameResult {
+    /** Raw model output used for skeleton mapping (MoveNet: Float32Array length 51). */
+    raw?: Float32Array | Float32ArrayLike;
+    keypoints: Keypoint[];
+    score: number;
+    inferenceMs: number;
+    /** Video-space keypoints for overlay (before object-fit:cover). */
+    videoKeypoints: Array<{
+        name: string;
+        xPx: number;
+        yPx: number;
+        score: number;
+    }>;
+    letterbox: Letterbox;
+}
+type Float32ArrayLike = ArrayLike<number>;
+interface PoseDetectorAdapter {
+    readonly modelId: string;
+    load(): Promise<void>;
+    /**
+     * Run one frame. `video` must have non-zero dimensions.
+     * Returns null when the frame should be skipped.
+     */
+    estimate(video: HTMLVideoElement, options: {
+        facingMode: 'user' | 'environment';
+        displayWidth: number;
+        displayHeight: number;
+    }): Promise<DetectorFrameResult | null>;
+    dispose(): void;
+}
+interface CreateAdapterContext {
+    resolved: ResolvedPoseModel;
+    /** Optional override when host already loaded tf. */
+    getTf?: () => typeof _tensorflow_tfjs;
+}
+
+declare function createPoseAdapter(ctx: CreateAdapterContext): PoseDetectorAdapter;
+
+declare class MoveNetGraphAdapter implements PoseDetectorAdapter {
+    readonly modelId: string;
+    private readonly modelUrl;
+    private tf;
+    private model;
+    private backend;
+    private offscreen;
+    private offCtx;
+    private smoothed;
+    private letterbox;
+    constructor(ctx: CreateAdapterContext);
+    getBackend(): string | null;
+    load(): Promise<void>;
+    private poseCanvasCtx;
+    private prepareInput;
+    private smooth;
+    estimate(video: HTMLVideoElement, options: {
+        facingMode: 'user' | 'environment';
+        displayWidth: number;
+        displayHeight: number;
+    }): Promise<DetectorFrameResult | null>;
+    dispose(): void;
+}
+/** Map video keypoints → object-fit:cover display pixels for drawing. */
+declare function mapVideoKeypointsToDisplay(videoKeypoints: Array<{
+    name: string;
+    xPx: number;
+    yPx: number;
+    score: number;
+}>, letterbox: Letterbox, dispW: number, dispH: number): Array<{
+    name: string;
+    dx: number;
+    dy: number;
+    score: number;
+}>;
+
+type BlazePoseModelType = 'lite' | 'full' | 'heavy';
+declare class BlazePoseAdapter implements PoseDetectorAdapter {
+    readonly modelId = "blazepose";
+    private detector;
+    private backend;
+    private readonly modelType;
+    constructor(_ctx: CreateAdapterContext);
+    getBackend(): string | null;
+    load(): Promise<void>;
+    estimate(video: HTMLVideoElement, options: {
+        facingMode: 'user' | 'environment';
+        displayWidth: number;
+        displayHeight: number;
+    }): Promise<DetectorFrameResult | null>;
+    dispose(): void;
+}
+
+/**
+ * Resolve TensorFlow.js: peer dependency (bundlers) or global `tf` (CDN script tags).
+ */
+declare const ONLINE_TFJS_VERSION = "4.22.0";
+interface TfjsCdnUrls {
+    scriptUrls: string[];
+    wasmPath: string;
+}
+declare function defaultTfjsCdnUrls(cdnBase?: string, tfjsVersion?: string): TfjsCdnUrls;
+type TfModule = typeof _tensorflow_tfjs;
+declare global {
+    interface Window {
+        tf?: TfModule;
+    }
+}
+/**
+ * Load TF.js from `window.tf` (CDN) or npm peer import.
+ */
+declare function resolveTf(): Promise<TfModule>;
+declare function initWebGlBackend(tf: TfModule): Promise<'webgl' | 'cpu'>;
+
+/**
+ * Resolve `@tensorflow-models/pose-detection` for BlazePose:
+ * 1. Global `window.poseDetection` (CDN / IIFE)
+ * 2. Optional npm peer (bundlers)
+ * 3. Dynamic jsDelivr script inject in the browser when peer is missing
+ */
+declare const ONLINE_POSE_DETECTION_VERSION = "2.1.3";
+type PoseDetectionModule = {
+    SupportedModels: {
+        BlazePose: string;
+    };
+    createDetector: (model: string, config?: Record<string, unknown>) => Promise<{
+        estimatePoses: (input: HTMLVideoElement, opts?: Record<string, unknown>) => Promise<Array<{
+            keypoints: Array<{
+                name?: string;
+                x: number;
+                y: number;
+                score?: number;
+            }>;
+        }>>;
+        dispose?: () => void;
+    }>;
+};
+declare global {
+    interface Window {
+        poseDetection?: PoseDetectionModule;
+    }
+}
+declare function defaultPoseDetectionCdnUrl(cdnBase?: string, version?: string): string;
+/**
+ * Load pose-detection from `window.poseDetection`, npm peer, or CDN inject.
+ */
+declare function resolvePoseDetection(options?: {
+    cdnBase?: string;
+    version?: string;
+    /** Skip CDN inject (tests / Node). Default false. */
+    allowCdn?: boolean;
+}): Promise<PoseDetectionModule>;
+
+interface CameraOptions {
+    facingMode?: 'user' | 'environment';
+    idealWidth?: number;
+    idealHeight?: number;
+    idealFrameRate?: number;
+}
+declare function openCameraStream(options?: CameraOptions): Promise<MediaStream>;
+declare function stopMediaStream(stream: MediaStream | null | undefined): void;
+
+/**
+ * Brand assets for boot overlay / watermark.
+ * Remote logo keeps the npm package small (light philosophy).
+ */
+declare const DEFAULT_LOADING_TEXT = "AI Loading";
+/** Public PoseTracker logo (docs site). Falls back to text if offline. */
+declare const POSETRACKER_LOGO_URL = "https://docs.posetracker.com/logo/light.png";
+declare const BRAND_COLORS: {
+    readonly navy: "#010A73";
+    readonly gold: "#FFC300";
+    readonly bootBg: "#0a0a0a";
+    readonly logoPad: "#3a3a3a";
+};
+
+/** @deprecated Prefer DEFAULT_SKELETON_DEFINITION */
+declare const DEFAULT_SKELETON: SkeletonDefinition;
+interface DrawKeypoint {
+    name: string;
+    dx: number;
+    dy: number;
+    score: number;
+}
+declare function drawSkeleton(ctx: CanvasRenderingContext2D, kps: DrawKeypoint[], dispW: number, dispH: number, enabled?: boolean, def?: SkeletonDefinition | null): void;
+
+interface DomShell {
+    root: HTMLElement;
+    video: HTMLVideoElement;
+    canvas: HTMLCanvasElement;
+    boot: HTMLElement;
+    bootMsg: HTMLElement;
+    watermark: HTMLElement;
+    hud: HTMLElement;
+    placement: HTMLElement;
+    setBootMessage(text: string, isError?: boolean): void;
+    setCameraVisible(visible: boolean): void;
+    setWatermarkVisible(visible: boolean): void;
+    setHud(text: string, debug: boolean): void;
+    setPlacementVisible(visible: boolean, paddingPercent?: number): void;
+    applyMirror(facingMode: 'user' | 'environment'): void;
+    destroy(): void;
+}
+declare function mountDomShell(host: HTMLElement, options?: {
+    loadingText?: string;
+    logoUrl?: string;
+}): DomShell;
+
+/**
+ * Fetch a custom skeleton overlay by Strapi `api_uuid`
+ * (WebView `?skeleton=<uuid>` parity).
+ */
+
+interface FetchSkeletonOptions {
+    baseUrl?: string;
+}
+declare class SkeletonFetchError extends Error {
+    readonly code: 'not_found' | 'network' | 'invalid';
+    constructor(code: 'not_found' | 'network' | 'invalid', message: string);
+}
+/**
+ * GET /api/sdk/skeleton?uuid=…
+ * Returns the overlay definition or throws {@link SkeletonFetchError}.
+ */
+declare function fetchSkeletonDefinition(uuid: string, options?: FetchSkeletonOptions): Promise<SkeletonDefinition>;
+
+/**
+ * V2 Strapi movement names → canonical V3 exercise keys.
+ * Mirrors PoseTrackerFront/lib/v3/exercises/index.js `EXERCISE_ALIASES`.
+ *
+ * The RN SDK manifest still often ships legacy `face_*` ids from Strapi while
+ * host apps / demos call V3 keys (`squat`, `push_up`, …).
+ */
+declare const EXERCISE_ALIASES: Readonly<Record<string, string>>;
+/** Resolve a legacy or V3 id to the canonical V3 key. */
+declare function resolveExerciseName(name: string): string;
+/**
+ * Pick the best matching exercise config for a requested id.
+ * Tries exact id, then any legacy alias that maps to the same V3 key,
+ * then any config whose id resolves to the same V3 key.
+ */
+declare function findExerciseByIdOrAlias<T extends {
+    id: string;
+}>(exerciseId: string, exercises: readonly T[]): T | undefined;
+
+export { type AccelerationDiagnostics, type AccelerationState, type AngleValue, type AnglesEvent, BRAND_COLORS, BlazePoseAdapter, type BlazePoseModelType, COCO_KEYPOINT_NAMES, COMBINED_REFERENCE_EXERCISE_MESSAGE, type CameraOptions, type ClassicMessageListener, type ClassicNativeMessage, type CocoKeypointName, type ColdStartMode, ConfigureError, type ConfigureOptions, type ConfigureRequest, type CounterEvent, type CounterFormScore, type CustomExerciseDescriptor, type CustomSessionOptions, DEFAULT_BASE_URL, DEFAULT_FEATURES, DEFAULT_LOADING_TEXT, DEFAULT_MOVENET_LIGHTNING_URL, DEFAULT_SKELETON, DEFAULT_SKELETON_DEFINITION, type DetectorFrameResult, type DiagnosticListener, EXERCISE_ALIASES, type EngineBundleDescriptor, type EngineLoadResult, EngineLoader, type EngineLoaderOptions, type EngineSession, type EngineSessionFeatures, type EngineSessionOptions, type ErrorEvent, type EventSink, type ExerciseConfig, type ExerciseSummaryEvent, FREE_PLAN_FEATURES_MESSAGE, type FetchSkeletonOptions, type FileStore, type FormGrade, type FormScoreEvent, INVALID_TOKEN_MESSAGE, type InferenceRuntime, type InitialPosture, type InitializationEvent, type InitializationStep, type JumpCalibrationEvent, type JumpDiscardedEvent, type JumpHeightEvent, type JumpResultEvent, type JumpStartedEvent, type JumpSummaryEntry, type JumpSummaryEvent, type KeyValueStore, type Keypoint, type KeypointName, type KeypointsEvent, type MinGrade, type ModelDescriptor, type ModelFormat, type ModelsByProfile, MoveNetGraphAdapter, type MovementDefinition, type MovementRecommendation, type MovementStep, type MovementStepParameter, ONLINE_POSE_DETECTION_VERSION, ONLINE_TFJS_VERSION, POSETRACKER_LOGO_URL, type PerformanceWarningEvent, type PlanInfo, type Pose, PoseCamera, PoseCamera_mount, type PoseDetectionModule, type PoseDetectorAdapter, type PoseModelAlias, type PoseModelKind, type PoseModelProfile, type PoseRuntimeDescriptor, type PoseRuntimePartDescriptor, type PoseTracker, type PoseTrackerCallbacks, PoseTrackerClient, type PoseTrackerClientOptions, type PoseTrackerEngine, type PoseTrackerEvent, type PoseTrackerEventListener, type PoseTrackerEventType, type PoseTrackerFeatures, type PoseTrackerMode, type PoseTrackerOptions, type PoseTrackerStatus, type PostureEvent, type PreloadOptions, type ProgressionEvent, type QualityChangedEvent, type RecommendationsEvent, type ReferenceMovementDescriptor, type RepSummary, type ResolvePoseModelOptions, type ResolvedFeatures, type ResolvedPoseModel, type RuntimeDownloadProgressEvent, SDK_NAME, SDK_VERSION, type SdkManifest, type SkeletonAnglesStyle, type SkeletonCirclesStyle, type SkeletonDefinition, SkeletonFetchError, type SkeletonLinesStyle, type StartExerciseOptions, type StatsEvent, type TfModule, type TfjsCdnUrls, TrackError, type TrackRequest, type TrackResponse, UsageTracker, type UsageTrackerOptions, type VisibleHipsInfo, type WarningEvent, configure, createLocalFileStore, createLocalKeyValueStore, createMemoryFileStore, createPoseAdapter, createPoseTracker, createWebFileStore, defaultPoseDetectionCdnUrl, defaultTfjsCdnUrls, drawSkeleton, featureNotSupportedMessage, fetchSkeletonDefinition, findExerciseByIdOrAlias, freeBlockedFeatures, initWebGlBackend, isPaidPlan, mapVideoKeypointsToDisplay, mountDomShell, openCameraStream, resolveExerciseName, resolveFeatures, resolvePoseDetection, resolvePoseModel, resolveTf, shouldShowWatermark, stopMediaStream, toClassicNativeMessage };