ping-openmls-sdk 0.1.1 → 0.2.0

package/wasm/ping_wasm.d.ts

@@ -0,0 +1,259 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class PingClient {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Add members ([CR-2]). `entries` is an array of `{ deviceId: Uint8Array,
+     * keyPackage: Uint8Array }`. Bundling the device_id with the KeyPackage lets us
+     * persist a per-conversation device→leaf map for [`revokeDevice`].
+     */
+    addMembers(conv_id: Uint8Array, entries: any, now_ms: number): Promise<void>;
+    /**
+     * Build a `LinkingTicket` ([CR-13] populates `catchup_snapshot` from `last_app_events`).
+     *
+     * `last_app_events` is an array of `{ conversationId: Uint8Array, appEventBytes:
+     * Uint8Array }`. Pass `[]` to suppress catchup data.
+     */
+    buildLinkingTicket(new_device_id: Uint8Array, new_device_kp: Uint8Array, last_app_events: any, now_ms: number): Promise<any>;
+    consumeLinkingTicket(ticket: any, now_ms: number): Promise<void>;
+    createConversation(name: string | null | undefined, now_ms: number): Promise<Uint8Array>;
+    deviceId(): Uint8Array;
+    /**
+     * Export a derived secret from a conversation's MLS exporter ([CR-8]).
+     *
+     * The core wraps the bytes in `Zeroizing<Vec<u8>>`; once they cross the WASM/JS
+     * boundary they live in a regular JS `Uint8Array` and JS GC controls the lifetime.
+     * Callers in JS MUST treat the buffer as a secret — never log, persist only
+     * encrypted, and clear the typed array when done (`u8.fill(0)`).
+     */
+    exportConversationSecret(conv_id: Uint8Array, label: string, context: Uint8Array, length: number): Uint8Array;
+    /**
+     * [CR-7] Export the MLS state snapshot for one conversation.
+     */
+    exportConversationStateSnapshot(conv_id: Uint8Array, now_ms: number): Uint8Array;
+    freshKeyPackage(): Uint8Array;
+    /**
+     * Generate a fresh identity. Returns the export bytes — store them under the user's account.
+     */
+    static generateIdentity(): Uint8Array;
+    /**
+     * [CR-7] Import an MLS state snapshot produced by another device of the same
+     * user identity. Returns the conversation id the snapshot describes.
+     */
+    importStateSnapshot(snapshot_bytes: Uint8Array, now_ms: number): Promise<Uint8Array>;
+    /**
+     * Initialise the client. Pass an exported identity (use `generateIdentity()` for a fresh one).
+     */
+    static init(identity_export: Uint8Array, device_label: string, storage: JsStorage, transport: JsTransport, now_ms: number): Promise<PingClient>;
+    joinConversation(welcome: any, now_ms: number): Promise<Uint8Array>;
+    listConversations(): any;
+    onMessage(cb: Function): void;
+    processEnvelope(env: any, now_ms: number): Promise<any>;
+    removeMembers(conv_id: Uint8Array, leaves: Uint32Array, now_ms: number): Promise<void>;
+    /**
+     * Revoke a device ([CR-2]). Returns an array of Commit envelopes — one per
+     * conversation the device was a locally-known leaf in. Each envelope has already
+     * been handed to the transport; the host's hand-back is for any additional
+     * receipt-of-revocation handling.
+     */
+    revokeDevice(device_id: Uint8Array, now_ms: number): Promise<any>;
+    send(conv_id: Uint8Array, plaintext: Uint8Array, now_ms: number): Promise<any>;
+    syncConversations(now_ms: number): Promise<any>;
+    userId(): Uint8Array;
+}
+
+/**
+ * Runtime test harness support instantiated in JS.
+ *
+ * The node.js entry script instantiates a `Context` here which is used to
+ * drive test execution.
+ */
+export class WasmBindgenTestContext {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Handle filter argument.
+     */
+    filtered_count(filtered: number): void;
+    /**
+     * Handle `--include-ignored` flag.
+     */
+    include_ignored(include_ignored: boolean): void;
+    /**
+     * Creates a new context ready to run tests.
+     *
+     * A `Context` is the main structure through which test execution is
+     * coordinated, and this will collect output and results for all executed
+     * tests.
+     */
+    constructor(is_bench: boolean);
+    /**
+     * Executes a list of tests, returning a promise representing their
+     * eventual completion.
+     *
+     * This is the main entry point for executing tests. All the tests passed
+     * in are the JS `Function` object that was plucked off the
+     * `WebAssembly.Instance` exports list.
+     *
+     * The promise returned resolves to either `true` if all tests passed or
+     * `false` if at least one test failed.
+     */
+    run(tests: any[]): Promise<any>;
+}
+
+/**
+ * Used to read benchmark data, and then the runner stores it on the local disk.
+ */
+export function __wbgbench_dump(): Uint8Array | undefined;
+
+/**
+ * Used to write previous benchmark data before the benchmark, for later comparison.
+ */
+export function __wbgbench_import(baseline: Uint8Array): void;
+
+/**
+ * Handler for `console.debug` invocations. See above.
+ */
+export function __wbgtest_console_debug(args: Array<any>): void;
+
+/**
+ * Handler for `console.error` invocations. See above.
+ */
+export function __wbgtest_console_error(args: Array<any>): void;
+
+/**
+ * Handler for `console.info` invocations. See above.
+ */
+export function __wbgtest_console_info(args: Array<any>): void;
+
+/**
+ * Handler for `console.log` invocations.
+ *
+ * If a test is currently running it takes the `args` array and stringifies
+ * it and appends it to the current output of the test. Otherwise it passes
+ * the arguments to the original `console.log` function, psased as
+ * `original`.
+ */
+export function __wbgtest_console_log(args: Array<any>): void;
+
+/**
+ * Handler for `console.warn` invocations. See above.
+ */
+export function __wbgtest_console_warn(args: Array<any>): void;
+
+export function __wbgtest_cov_dump(): Uint8Array | undefined;
+
+/**
+ * Path to use for coverage data.
+ */
+export function __wbgtest_coverage_path(env: string | null | undefined, pid: number, temp_dir: string, module_signature: bigint): string;
+
+export function __wbgtest_module_signature(): bigint | undefined;
+
+export function _start(): void;
+
+/**
+ * HPKE-open a sealed `LinkingTicket` ([CR-3]). Pure function — usable without an
+ * initialized `PingClient`, which is exactly the situation the receiving device is in
+ * (pre-bootstrap; no identity yet).
+ *
+ * `new_device_priv` must be 32 bytes (X25519 private key). Errors are returned with a
+ * generic message — the new device shouldn't get to discriminate "wrong key" from
+ * "tampered ciphertext".
+ * [CR-13] Decode a `LinkingTicket.catchup_snapshot` blob. Pure function; no client
+ * required. The new device calls this after `consumeLinkingTicket` to populate its
+ * initial UI.
+ */
+export function decodeCatchupSnapshot(snapshot_bytes: Uint8Array): any;
+
+export function openLinkingTicket(sealed: Uint8Array, new_device_priv: Uint8Array): any;
+
+/**
+ * HPKE-seal a `LinkingTicket` ([CR-3]). Pure function — does not need an initialized
+ * `PingClient`, so it's exported at module scope and the JS facade can call it from an
+ * ephemeral worker (no full client init needed on the sender side).
+ *
+ * `new_device_pub` must be 32 bytes. Returns CBOR-encoded sealed bytes.
+ */
+export function sealLinkingTicket(ticket: any, new_device_pub: Uint8Array): Uint8Array;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_pingclient_free: (a: number, b: number) => void;
+    readonly decodeCatchupSnapshot: (a: number, b: number, c: number) => void;
+    readonly openLinkingTicket: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly pingclient_addMembers: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly pingclient_buildLinkingTicket: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly pingclient_consumeLinkingTicket: (a: number, b: number, c: number) => number;
+    readonly pingclient_createConversation: (a: number, b: number, c: number, d: number) => number;
+    readonly pingclient_deviceId: (a: number, b: number) => void;
+    readonly pingclient_exportConversationSecret: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+    readonly pingclient_exportConversationStateSnapshot: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly pingclient_freshKeyPackage: (a: number, b: number) => void;
+    readonly pingclient_generateIdentity: (a: number) => void;
+    readonly pingclient_importStateSnapshot: (a: number, b: number, c: number, d: number) => number;
+    readonly pingclient_init: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+    readonly pingclient_joinConversation: (a: number, b: number, c: number) => number;
+    readonly pingclient_listConversations: (a: number, b: number) => void;
+    readonly pingclient_onMessage: (a: number, b: number) => void;
+    readonly pingclient_processEnvelope: (a: number, b: number, c: number) => number;
+    readonly pingclient_removeMembers: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly pingclient_revokeDevice: (a: number, b: number, c: number, d: number) => number;
+    readonly pingclient_send: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly pingclient_syncConversations: (a: number, b: number) => number;
+    readonly pingclient_userId: (a: number, b: number) => void;
+    readonly sealLinkingTicket: (a: number, b: number, c: number, d: number) => void;
+    readonly _start: () => void;
+    readonly __wbg_wasmbindgentestcontext_free: (a: number, b: number) => void;
+    readonly __wbgbench_dump: (a: number) => void;
+    readonly __wbgbench_import: (a: number, b: number) => void;
+    readonly __wbgtest_console_debug: (a: number) => void;
+    readonly __wbgtest_console_error: (a: number) => void;
+    readonly __wbgtest_console_info: (a: number) => void;
+    readonly __wbgtest_console_log: (a: number) => void;
+    readonly __wbgtest_console_warn: (a: number) => void;
+    readonly __wbgtest_cov_dump: (a: number) => void;
+    readonly __wbgtest_coverage_path: (a: number, b: number, c: number, d: number, e: number, f: number, g: bigint) => void;
+    readonly __wbgtest_module_signature: (a: number) => void;
+    readonly wasmbindgentestcontext_filtered_count: (a: number, b: number) => void;
+    readonly wasmbindgentestcontext_include_ignored: (a: number, b: number) => void;
+    readonly wasmbindgentestcontext_new: (a: number) => number;
+    readonly wasmbindgentestcontext_run: (a: number, b: number, c: number) => number;
+    readonly __wasm_bindgen_func_elem_2609: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly __wasm_bindgen_func_elem_2599: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_2608: (a: number, b: number, c: number, d: number) => void;
+    readonly __wbindgen_export: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_export3: (a: number) => void;
+    readonly __wbindgen_export4: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_export5: (a: number, b: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;