@zappar/zappar-cv 3.3.0-beta.2 → 3.4.0-beta.0

package/lib/src/deserializer.d.ts

@@ -0,0 +1,41 @@
+import { barcode_format_t, face_landmark_name_t, instant_world_tracker_transform_orientation_t, transform_orientation_t, log_level_t, plane_orientation_t, anchor_status_t } from "./gen/zappar-native";
+interface Message {
+    int: () => number;
+    float: () => number;
+    bool: () => boolean;
+    string: () => string;
+    dataWithLength: () => ArrayBuffer;
+    type: () => number;
+    matrix4x4: () => Float32Array;
+    matrix3x3: () => Float32Array;
+    ucharArray: () => Uint8Array;
+    floatArray: () => Float32Array;
+    identityCoefficients: () => Float32Array;
+    expressionCoefficients: () => Float32Array;
+    cameraModel: () => Float32Array;
+    timestamp: () => number;
+    barcodeFormat: () => barcode_format_t;
+    faceLandmarkName: () => face_landmark_name_t;
+    instantTrackerTransformOrientation: () => instant_world_tracker_transform_orientation_t;
+    transformOrientation: () => transform_orientation_t;
+    planeOrientation: () => plane_orientation_t;
+    anchorStatus: () => anchor_status_t;
+    logLevel: () => log_level_t;
+}
+export declare class MessageDeserializer {
+    private _buffer;
+    private _i32View;
+    private _f32View;
+    private _f64View;
+    private _u8View;
+    private _u16View;
+    private _u32View;
+    private _offset;
+    private _length;
+    private _startOffset;
+    setData(data: ArrayBuffer): void;
+    hasMessage(): boolean;
+    private _processor;
+    forMessages(cb: (id: number, msg: Message) => void): void;
+}
+export {};

package/lib/src/direct.d.ts

@@ -0,0 +1,3 @@
+import { MsgManager } from "./messages";
+export declare let messageManager: MsgManager;
+export declare function launchWorker(wasm: string): Promise<void>;

package/lib/src/drawaxis.d.ts

@@ -0,0 +1,2 @@
+export declare function disposeDrawPlane(): void;
+export declare function drawAxis(gl: WebGLRenderingContext, projectionMatrix: Float32Array, cameraMatrix: Float32Array, targetMatrix: Float32Array): void;

package/lib/src/drawcamera.d.ts

@@ -0,0 +1,12 @@
+import { CameraFrameInfo } from "./source";
+export declare class CameraDraw {
+    private _gl;
+    private _vbo;
+    private _shader;
+    constructor(_gl: WebGLRenderingContext);
+    dispose(): void;
+    private _generate;
+    drawCameraFrame(screenWidth: number, screenHeight: number, i: CameraFrameInfo, mirror: boolean): void;
+    private _getCameraShader;
+}
+export declare function cameraFrameTextureMatrix(frameWidth: number, frameHeight: number, screenWidth: number, screenHeight: number, uvMatrix: Float32Array, mirror: boolean): Float32Array;

package/lib/src/drawface.d.ts

@@ -0,0 +1,16 @@
+import { FaceMesh } from "./facemesh";
+export declare class FaceDraw {
+    private _gl;
+    private _vbo;
+    private _normalbo;
+    private _ibo;
+    private _lastIndices;
+    private _shader;
+    constructor(_gl: WebGLRenderingContext);
+    dispose(): void;
+    private _generateIBO;
+    private _generateVBO;
+    private _generateNormalBO;
+    drawFace(matrix: Float32Array, o: FaceMesh): void;
+    private _getShader;
+}

package/lib/src/drawfaceproject.d.ts

@@ -0,0 +1,15 @@
+export declare class FaceDrawProject {
+    private _gl;
+    private _vbo;
+    private _uvbo;
+    private _ibo;
+    private _lastIndices;
+    private _shader;
+    constructor(_gl: WebGLRenderingContext);
+    dispose(): void;
+    private _generateIBO;
+    private _generateVBO;
+    private _generateUVBO;
+    drawFace(matrix: Float32Array, vertices: Float32Array, uvMatrix: Float32Array, uvs: Float32Array, indices: Uint16Array, texture: WebGLTexture): void;
+    private _getShader;
+}

package/lib/src/drawgrid.d.ts

@@ -0,0 +1,2 @@
+export declare function disposeDrawGrid(): void;
+export declare function drawGrid(gl: WebGLRenderingContext, projectionMatrix: Float32Array, cameraMatrix: Float32Array, targetMatrix: Float32Array): void;

package/lib/src/drawmesh.d.ts

@@ -0,0 +1,14 @@
+export declare class MeshDraw {
+    private _gl;
+    private _vbo;
+    private _uvbo;
+    private _ibo;
+    private _lastIndices;
+    private _shader;
+    constructor(_gl: WebGLRenderingContext);
+    dispose(): void;
+    private _generateIBO;
+    private _generateVBO;
+    draw(projectionMatrix: Float32Array, cameraMatrix: Float32Array, targetMatrix: Float32Array, vertices: Float32Array, indices: Uint32Array, vertexOffset: number, vertexStride: number, indicesCount: number): void;
+    private _getShader;
+}

package/lib/src/drawplane.d.ts

@@ -0,0 +1,2 @@
+export declare function disposeDrawPlane(): void;
+export declare function drawPlane(gl: WebGLRenderingContext, projectionMatrix: Float32Array, cameraMatrix: Float32Array, targetMatrix: Float32Array, textureUrl: string): void;

package/lib/src/drawpoints.d.ts

@@ -0,0 +1,11 @@
+export declare class PointsDraw {
+    private _gl;
+    private _vbo;
+    private _shader;
+    constructor(_gl: WebGLRenderingContext);
+    dispose(): void;
+    private _generate;
+    drawPoints(screenWidth: number, screenHeight: number, dataWidth: number, dataHeight: number, points: Float32Array, mirror: boolean, color: [number, number, number], pointSize: number): void;
+    private _getCameraShader;
+}
+export declare function getPointsDataMatrix(frameWidth: number, frameHeight: number, screenWidth: number, screenHeight: number, mirror: boolean): Float32Array;

package/lib/src/drawpointswithtype.d.ts

@@ -0,0 +1,13 @@
+export declare class PointsWithTypeDraw {
+    private _gl;
+    private _vbo;
+    private _typebo;
+    private _shader;
+    constructor(_gl: WebGLRenderingContext);
+    dispose(): void;
+    private _generate;
+    private _generateTypes;
+    drawPoints(screenWidth: number, screenHeight: number, dataWidth: number, dataHeight: number, points: Float32Array, mirror: boolean, type: Uint8Array, pointSize: number): void;
+    private _getCameraShader;
+}
+export declare function getPointsDataMatrix(frameWidth: number, frameHeight: number, screenWidth: number, screenHeight: number, mirror: boolean): Float32Array;

package/lib/src/drawpolygon.d.ts

@@ -0,0 +1,5 @@
+export declare class PolygonDraw {
+    private _vbo;
+    private _generate;
+    drawPolygon(gl: WebGLRenderingContext, projectionMatrix: Float32Array, cameraMatrix: Float32Array, targetMatrix: Float32Array, points: Float32Array): void;
+}

package/lib/src/drawpreviewmesh.d.ts

@@ -0,0 +1,16 @@
+import { ImageTracker } from "./imagetracker";
+export declare class PreviewMeshDraw {
+    private _gl;
+    private _vbo;
+    private _uvbo;
+    private _ibo;
+    private _lastIndices;
+    private _shader;
+    constructor(_gl: WebGLRenderingContext);
+    dispose(): void;
+    private _generateIBO;
+    private _generateVBO;
+    private _generateUVBO;
+    draw(matrix: Float32Array, tracker: ImageTracker, indx: number): void;
+    private _getShader;
+}

package/lib/src/drawquad.d.ts

@@ -0,0 +1,2 @@
+export declare function disposeDrawQuad(): void;
+export declare function drawQuad(gl: WebGLRenderingContext, projectionMatrix: Float32Array, modelviewMatrix: Float32Array, color: Float32Array): void;

package/lib/src/event.d.ts

@@ -0,0 +1,30 @@
+export declare class Event {
+    private _funcs;
+    bind(f: () => void): void;
+    unbind(f: () => void): void;
+    emit(): void;
+}
+export declare class Event1<A> {
+    private _funcs;
+    bind(f: (a: A) => void): void;
+    unbind(f: (a: A) => void): void;
+    emit(a: A): void;
+}
+export declare class Event2<A, B> {
+    private _funcs;
+    bind(f: (a: A, b: B) => void): void;
+    unbind(f: (a: A, b: B) => void): void;
+    emit(a: A, b: B): void;
+}
+export declare class Event3<A, B, C> {
+    private _funcs;
+    bind(f: (a: A, b: B, c: C) => void): void;
+    unbind(f: (a: A, b: B, c: C) => void): void;
+    emit(a: A, b: B, c: C): void;
+}
+export declare class Event5<A, B, C, D, E> {
+    private _funcs;
+    bind(f: (a: A, b: B, c: C, d: D, e: E) => void): void;
+    unbind(f: (a: A, b: B, c: C, d: D, e: E) => void): void;
+    emit(a: A, b: B, c: C, d: D, e: E): void;
+}

package/lib/src/facelandmark.d.ts

@@ -0,0 +1,11 @@
+import { zappar_face_landmark_t, face_landmark_name_t } from "./gen/zappar";
+export declare function createFaceLandmark(n: face_landmark_name_t): zappar_face_landmark_t;
+export declare function destroyFaceLandmark(m: zappar_face_landmark_t): void;
+export declare function getFaceLandmark(m: zappar_face_landmark_t): FaceLandmark | undefined;
+export declare class FaceLandmark {
+    private _name;
+    anchor_pose: Float32Array;
+    constructor(_name: face_landmark_name_t);
+    private _getVertex;
+    update(identity: Float32Array, expression: Float32Array, mirrored: boolean): void;
+}

package/lib/src/facelandmarkdata.d.ts

@@ -0,0 +1,4 @@
+import { FaceLandmarkNameData } from './facelandmarkinterface';
+export declare const landmarkData: {
+    [id: string]: FaceLandmarkNameData | FaceLandmarkNameData[];
+};

package/lib/src/facelandmarkinterface.d.ts

@@ -0,0 +1,5 @@
+export interface FaceLandmarkNameData {
+    mean: number[];
+    identity: number[];
+    expression: number[];
+}

package/lib/src/facemesh.d.ts

@@ -0,0 +1,27 @@
+import { zappar_face_mesh_t } from "./gen/zappar";
+import { FaceLandmarkNameData } from "./facelandmarkinterface";
+export declare function createFaceMesh(): zappar_face_mesh_t;
+export declare function destroyFaceMesh(m: zappar_face_mesh_t): void;
+export declare function getFaceMesh(m: zappar_face_mesh_t): FaceMesh | undefined;
+export declare class FaceMesh {
+    private render_mean_;
+    private render_identity_;
+    private render_expression_;
+    private render_uvs_;
+    private render_indices_;
+    private render_indices_reversed;
+    private vertices_;
+    private normals_;
+    private normalsCalculated_;
+    private modelVersion_;
+    private mirrored_;
+    loadFromMemory(ab: ArrayBuffer, fillMouth: boolean, fillEyeL: boolean, fillEyeR: boolean, fillNeck: boolean): void;
+    getVertices(): Float32Array;
+    getUVs(): Float32Array;
+    getIndices(): Uint16Array;
+    getNormals(): Float32Array;
+    getModelVersion(): number;
+    getLandmarkDataForVertex(v: number): FaceLandmarkNameData;
+    update(identity: Float32Array, expression: Float32Array, mirrored: boolean): void;
+    calculateNormals(): void;
+}

package/lib/src/gen/zappar-bridge.d.ts

@@ -0,0 +1,182 @@
+import { barcode_format_t } from "./zappar-native";
+export { barcode_format_t } from "./zappar-native";
+import { face_landmark_name_t } from "./zappar-native";
+export { face_landmark_name_t } from "./zappar-native";
+export { frame_pixel_format_t } from "./zappar-native";
+import { instant_world_tracker_transform_orientation_t } from "./zappar-native";
+export { instant_world_tracker_transform_orientation_t } from "./zappar-native";
+import { transform_orientation_t } from "./zappar-native";
+export { transform_orientation_t } from "./zappar-native";
+import { plane_orientation_t } from "./zappar-native";
+export { plane_orientation_t } from "./zappar-native";
+import { log_level_t } from "./zappar-native";
+export { log_level_t } from "./zappar-native";
+export { image_target_type_t } from "./zappar-native";
+export { world_tracker_quality_t } from "./zappar-native";
+import { anchor_status_t } from "./zappar-native";
+export { anchor_status_t } from "./zappar-native";
+export { camera_profile_t } from "./zappar-native";
+export declare type zappar_pipeline_t = number & {
+    _: 'zappar_pipeline_t';
+};
+export declare type zappar_camera_source_t = number & {
+    _: 'zappar_camera_source_t';
+};
+export declare type zappar_sequence_source_t = number & {
+    _: 'zappar_sequence_source_t';
+};
+export declare type zappar_image_tracker_t = number & {
+    _: 'zappar_image_tracker_t';
+};
+export declare type zappar_face_tracker_t = number & {
+    _: 'zappar_face_tracker_t';
+};
+export declare type zappar_face_mesh_t = number & {
+    _: 'zappar_face_mesh_t';
+};
+export declare type zappar_face_landmark_t = number & {
+    _: 'zappar_face_landmark_t';
+};
+export declare type zappar_barcode_finder_t = number & {
+    _: 'zappar_barcode_finder_t';
+};
+export declare type zappar_instant_world_tracker_t = number & {
+    _: 'zappar_instant_world_tracker_t';
+};
+export declare type zappar_zapcode_tracker_t = number & {
+    _: 'zappar_zapcode_tracker_t';
+};
+export declare type zappar_world_tracker_t = number & {
+    _: 'zappar_world_tracker_t';
+};
+export declare type zappar_custom_anchor_t = number & {
+    _: 'zappar_custom_anchor_t';
+};
+export declare type zappar_d3_tracker_t = number & {
+    _: 'zappar_d3_tracker_t';
+};
+export interface zappar {
+    log_level(): log_level_t;
+    log_level_set(level: log_level_t): void;
+    analytics_project_id_set(id: string, uid: string): void;
+    pipeline_create(): zappar_pipeline_t;
+    pipeline_destroy(o: zappar_pipeline_t): void;
+    pipeline_frame_update(o: zappar_pipeline_t): void;
+    pipeline_frame_number(o: zappar_pipeline_t): number;
+    pipeline_camera_model(o: zappar_pipeline_t): Float32Array;
+    pipeline_camera_data_width(o: zappar_pipeline_t): number;
+    pipeline_camera_data_height(o: zappar_pipeline_t): number;
+    pipeline_camera_frame_user_data(o: zappar_pipeline_t): number;
+    pipeline_camera_frame_submit(o: zappar_pipeline_t, data: ArrayBuffer, width: number, height: number, user_data: number, camera_to_device_transform: Float32Array, camera_model: Float32Array, user_facing: boolean, timestampMicroseconds: number): void;
+    pipeline_camera_frame_camera_attitude(o: zappar_pipeline_t): Float32Array;
+    pipeline_camera_frame_device_attitude(o: zappar_pipeline_t): Float32Array;
+    pipeline_motion_accelerometer_submit(o: zappar_pipeline_t, time: number, x: number, y: number, z: number): void;
+    pipeline_motion_accelerometer_with_gravity_submit_int(o: zappar_pipeline_t, time: number, interval: number, x: number, y: number, z: number): void;
+    pipeline_motion_accelerometer_without_gravity_submit_int(o: zappar_pipeline_t, time: number, interval: number, x: number, y: number, z: number): void;
+    pipeline_motion_rotation_rate_submit(o: zappar_pipeline_t, time: number, x: number, y: number, z: number): void;
+    pipeline_motion_rotation_rate_submit_int(o: zappar_pipeline_t, time: number, interval: number, x: number, y: number, z: number): void;
+    pipeline_motion_attitude_submit(o: zappar_pipeline_t, time: number, x: number, y: number, z: number): void;
+    pipeline_motion_attitude_submit_int(o: zappar_pipeline_t, time: number, interval: number, x: number, y: number, z: number): void;
+    pipeline_motion_relative_orientation_submit_int(o: zappar_pipeline_t, time: number, interval: number, x: number, y: number, z: number, w: number): void;
+    pipeline_motion_attitude_matrix_submit(o: zappar_pipeline_t, mat: Float32Array): void;
+    camera_source_create(pipeline: zappar_pipeline_t, device_id: string): zappar_camera_source_t;
+    camera_source_destroy(o: zappar_camera_source_t): void;
+    sequence_source_create(pipeline: zappar_pipeline_t): zappar_sequence_source_t;
+    sequence_source_destroy(o: zappar_sequence_source_t): void;
+    image_tracker_create(pipeline: zappar_pipeline_t): zappar_image_tracker_t;
+    image_tracker_destroy(o: zappar_image_tracker_t): void;
+    image_tracker_target_load_from_memory(o: zappar_image_tracker_t, data: ArrayBuffer): void;
+    image_tracker_target_loaded_version(o: zappar_image_tracker_t): number;
+    image_tracker_enabled(o: zappar_image_tracker_t): boolean;
+    image_tracker_enabled_set(o: zappar_image_tracker_t, enabled: boolean): void;
+    image_tracker_anchor_count(o: zappar_image_tracker_t): number;
+    image_tracker_anchor_id(o: zappar_image_tracker_t, indx: number): string;
+    image_tracker_anchor_pose_raw(o: zappar_image_tracker_t, indx: number): Float32Array;
+    face_tracker_create(pipeline: zappar_pipeline_t): zappar_face_tracker_t;
+    face_tracker_destroy(o: zappar_face_tracker_t): void;
+    face_tracker_model_load_from_memory(o: zappar_face_tracker_t, data: ArrayBuffer): void;
+    face_tracker_model_loaded_version(o: zappar_face_tracker_t): number;
+    face_tracker_enabled_set(o: zappar_face_tracker_t, enabled: boolean): void;
+    face_tracker_enabled(o: zappar_face_tracker_t): boolean;
+    face_tracker_max_faces_set(o: zappar_face_tracker_t, num: number): void;
+    face_tracker_max_faces(o: zappar_face_tracker_t): number;
+    face_tracker_anchor_count(o: zappar_face_tracker_t): number;
+    face_tracker_anchor_id(o: zappar_face_tracker_t, indx: number): string;
+    face_tracker_anchor_pose_raw(o: zappar_face_tracker_t, indx: number): Float32Array;
+    face_tracker_anchor_identity_coefficients(o: zappar_face_tracker_t, indx: number): Float32Array;
+    face_tracker_anchor_expression_coefficients(o: zappar_face_tracker_t, indx: number): Float32Array;
+    face_mesh_create(): zappar_face_mesh_t;
+    face_mesh_destroy(o: zappar_face_mesh_t): void;
+    face_landmark_create(landmark: face_landmark_name_t): zappar_face_landmark_t;
+    face_landmark_destroy(o: zappar_face_landmark_t): void;
+    barcode_finder_create(pipeline: zappar_pipeline_t): zappar_barcode_finder_t;
+    barcode_finder_destroy(o: zappar_barcode_finder_t): void;
+    barcode_finder_enabled_set(o: zappar_barcode_finder_t, enabled: boolean): void;
+    barcode_finder_enabled(o: zappar_barcode_finder_t): boolean;
+    barcode_finder_found_number(o: zappar_barcode_finder_t): number;
+    barcode_finder_found_text(o: zappar_barcode_finder_t, indx: number): string;
+    barcode_finder_found_format(o: zappar_barcode_finder_t, indx: number): barcode_format_t;
+    barcode_finder_formats(o: zappar_barcode_finder_t): barcode_format_t;
+    barcode_finder_formats_set(o: zappar_barcode_finder_t, f: barcode_format_t): void;
+    instant_world_tracker_create(pipeline: zappar_pipeline_t): zappar_instant_world_tracker_t;
+    instant_world_tracker_destroy(o: zappar_instant_world_tracker_t): void;
+    instant_world_tracker_enabled_set(o: zappar_instant_world_tracker_t, enabled: boolean): void;
+    instant_world_tracker_enabled(o: zappar_instant_world_tracker_t): boolean;
+    instant_world_tracker_anchor_pose_raw(o: zappar_instant_world_tracker_t): Float32Array;
+    instant_world_tracker_anchor_pose_set_from_camera_offset_raw(o: zappar_instant_world_tracker_t, x: number, y: number, z: number, orientation: instant_world_tracker_transform_orientation_t): void;
+    zapcode_tracker_create(pipeline: zappar_pipeline_t): zappar_zapcode_tracker_t;
+    zapcode_tracker_destroy(o: zappar_zapcode_tracker_t): void;
+    zapcode_tracker_target_load_from_memory(o: zappar_zapcode_tracker_t, data: ArrayBuffer): void;
+    zapcode_tracker_target_loaded_version(o: zappar_zapcode_tracker_t): number;
+    zapcode_tracker_enabled(o: zappar_zapcode_tracker_t): boolean;
+    zapcode_tracker_enabled_set(o: zappar_zapcode_tracker_t, enabled: boolean): void;
+    zapcode_tracker_anchor_count(o: zappar_zapcode_tracker_t): number;
+    zapcode_tracker_anchor_id(o: zappar_zapcode_tracker_t, indx: number): string;
+    zapcode_tracker_anchor_pose_raw(o: zappar_zapcode_tracker_t, indx: number): Float32Array;
+    world_tracker_create(pipeline: zappar_pipeline_t): zappar_world_tracker_t;
+    world_tracker_destroy(o: zappar_world_tracker_t): void;
+    world_tracker_enabled(o: zappar_world_tracker_t): boolean;
+    world_tracker_enabled_set(o: zappar_world_tracker_t, enabled: boolean): void;
+    world_tracker_session_number(o: zappar_world_tracker_t): number;
+    world_tracker_quality(o: zappar_world_tracker_t): number;
+    world_tracker_horizontal_plane_detection_enabled(o: zappar_world_tracker_t): boolean;
+    world_tracker_horizontal_plane_detection_enabled_set(o: zappar_world_tracker_t, horizontal_plane_detection_enabled: boolean): void;
+    world_tracker_vertical_plane_detection_enabled(o: zappar_world_tracker_t): boolean;
+    world_tracker_vertical_plane_detection_enabled_set(o: zappar_world_tracker_t, vertical_plane_detection_enabled: boolean): void;
+    world_tracker_plane_anchor_count(o: zappar_world_tracker_t): number;
+    world_tracker_plane_anchor_id(o: zappar_world_tracker_t, indx: number): string;
+    world_tracker_plane_anchor_pose_raw(o: zappar_world_tracker_t, indx: number): Float32Array;
+    world_tracker_plane_anchor_status(o: zappar_world_tracker_t, indx: number): anchor_status_t;
+    world_tracker_plane_anchor_polygon_data_size(o: zappar_world_tracker_t, indx: number): number;
+    world_tracker_plane_anchor_polygon_data(o: zappar_world_tracker_t, indx: number): Float32Array;
+    world_tracker_plane_anchor_polygon_version(o: zappar_world_tracker_t, indx: number): number;
+    world_tracker_plane_anchor_orientation(o: zappar_world_tracker_t, indx: number): plane_orientation_t;
+    world_tracker_world_anchor_status(o: zappar_world_tracker_t): anchor_status_t;
+    world_tracker_world_anchor_id(o: zappar_world_tracker_t): string;
+    world_tracker_world_anchor_pose_raw(o: zappar_world_tracker_t): Float32Array;
+    world_tracker_ground_anchor_id(o: zappar_world_tracker_t): string;
+    world_tracker_ground_anchor_status(o: zappar_world_tracker_t): anchor_status_t;
+    world_tracker_ground_anchor_pose_raw(o: zappar_world_tracker_t): Float32Array;
+    world_tracker_reset(o: zappar_world_tracker_t): void;
+    world_tracker_tracks_data_enabled(o: zappar_world_tracker_t): boolean;
+    world_tracker_tracks_data_enabled_set(o: zappar_world_tracker_t, tracks_data_enabled: boolean): void;
+    world_tracker_tracks_data_size(o: zappar_world_tracker_t): number;
+    world_tracker_tracks_data(o: zappar_world_tracker_t): Float32Array;
+    world_tracker_tracks_type_data_size(o: zappar_world_tracker_t): number;
+    world_tracker_tracks_type_data(o: zappar_world_tracker_t): Uint8Array;
+    world_tracker_projections_data_enabled(o: zappar_world_tracker_t): boolean;
+    world_tracker_projections_data_enabled_set(o: zappar_world_tracker_t, projections_data_enabled: boolean): void;
+    world_tracker_projections_data_size(o: zappar_world_tracker_t): number;
+    world_tracker_projections_data(o: zappar_world_tracker_t): Float32Array;
+    custom_anchor_create(pipeline: zappar_pipeline_t, worldtracker: zappar_world_tracker_t, id: string): zappar_custom_anchor_t;
+    custom_anchor_destroy(o: zappar_custom_anchor_t): void;
+    custom_anchor_status(o: zappar_custom_anchor_t): anchor_status_t;
+    custom_anchor_pose_version(o: zappar_custom_anchor_t): number;
+    custom_anchor_pose_raw(o: zappar_custom_anchor_t): Float32Array;
+    custom_anchor_pose_set_from_camera_offset_raw(o: zappar_custom_anchor_t, x: number, y: number, z: number, orientation: transform_orientation_t): void;
+    custom_anchor_pose_set_from_anchor_offset(o: zappar_custom_anchor_t, anchor_id: string, x: number, y: number, z: number, orientation: transform_orientation_t): void;
+    custom_anchor_pose_set(o: zappar_custom_anchor_t, pose: Float32Array): void;
+    custom_anchor_pose_set_with_parent(o: zappar_custom_anchor_t, pose: Float32Array, anchor_id: string): void;
+    d3_tracker_create(pipeline: zappar_pipeline_t): zappar_d3_tracker_t;
+    d3_tracker_destroy(o: zappar_d3_tracker_t): void;
+}

package/lib/src/gen/zappar-client.d.ts

@@ -0,0 +1,26 @@
+import { MessageSerializer } from "../serializer";
+import { MessageDeserializer } from "../deserializer";
+import { zappar } from "./zappar-bridge";
+export declare class zappar_client {
+    private _messageSender;
+    constructor(_messageSender: (ab: ArrayBuffer) => void);
+    private _globalState;
+    serializer: MessageSerializer;
+    deserializer: MessageDeserializer;
+    private _latestId;
+    private _pipeline_state_by_instance;
+    private _camera_source_state_by_instance;
+    private _sequence_source_state_by_instance;
+    private _image_tracker_state_by_instance;
+    private _face_tracker_state_by_instance;
+    private _face_mesh_state_by_instance;
+    private _face_landmark_state_by_instance;
+    private _barcode_finder_state_by_instance;
+    private _instant_world_tracker_state_by_instance;
+    private _zapcode_tracker_state_by_instance;
+    private _world_tracker_state_by_instance;
+    private _custom_anchor_state_by_instance;
+    private _d3_tracker_state_by_instance;
+    impl: zappar;
+    processMessages(a: ArrayBuffer): void;
+}

package/lib/src/gen/zappar-cwrap.d.ts

@@ -0,0 +1,12 @@
+import { zappar_cwrap } from "./zappar-native";
+export interface Module {
+    cwrap: (func: string, retType: "number" | "string" | null, args: ("number" | "string")[]) => ((...args: any[]) => any);
+    _malloc: (size: number) => number;
+    _free: (data: number) => void;
+    setValue: (offset: number, val: number, type: "i8") => void;
+    getValue: (offset: number, type: "float") => number;
+    UTF8ToString: (offset: number) => string;
+    HEAPU8: Uint8Array;
+    HEAPF32: Float32Array;
+}
+export declare function getRuntimeObject(mod: Module): zappar_cwrap;