/* tslint:disable */
/* eslint-disable */

export class WasmCiphertext {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    readonly body: Uint8Array;
    readonly message_type: number;
}

/**
 * Result of `decryptMessage`: the plaintext plus the one-time pre-key ids the
 * engine consumed while establishing a new session.
 *
 * The engine learns these ids internally (`pre_key_used` in
 * `rust/protocol/src/session_management.rs`) but upstream surfaces only the
 * plaintext. Signal's own clients don't need them returned — their store
 * callbacks are app code and delete/mark durably at call time. Our stores sit
 * behind the wasm boundary, so the ids are reported here for the TS layer to
 * tombstone in its durable store; without that, a consumed one-time kyber
 * record is re-imported on next hydration and its KEM private key is reused
 * across restarts. All id fields are `undefined` for Whisper
 * (non-prekey) decrypts and for prekey messages that decrypted against an
 * existing session. Under concurrent decrypts sharing one store set a caller
 * may see a superset of its own consumed ids — every reported id was
 * genuinely consumed, so tombstoning it is always safe.
 */
export class WasmDecryptResult {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    /**
     * The kyber pre-key consumed by this decrypt (one-time or last-resort),
     * if any — the caller knows which ids are one-time. Tombstone it in the
     * durable store. libsignal's `mark_kyber_pre_key_used` makes no
     * one-time/last-resort distinction
     * (rust/protocol/src/storage/traits.rs:129-133 @ b5121d0).
     */
    readonly kyberPreKeyId: number | undefined;
    /**
     * The one-time X25519 pre-key consumed (already removed from the engine
     * store by the decrypt itself), if any. Tombstone it in the durable
     * store.
     */
    readonly oneTimePreKeyId: number | undefined;
    readonly plaintext: Uint8Array;
    /**
     * The signed pre-key paired with the consumed kyber key in the
     * anti-replay record. Correlation only — signed pre-keys are not
     * consumed.
     */
    readonly signedPreKeyId: number | undefined;
}

export class WasmGroupIdentifier {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    readonly serialize: Uint8Array;
}

export class WasmGroupMasterKey {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    derive_identifier(): WasmGroupIdentifier;
    derive_secret_params(): WasmGroupSecretParams;
    static from_bytes(bytes: Uint8Array): WasmGroupMasterKey;
    static generate(): WasmGroupMasterKey;
    readonly serialize: Uint8Array;
}

export class WasmGroupSecretParams {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    get_identifier(): WasmGroupIdentifier;
    /**
     * Returns the 32-byte **master key**, not the (289-byte) group secret
     * params. Named explicitly so no future caller mistakes it for the full
     * params encoding (see the 0.5.0 CHANGELOG entry).
     */
    readonly serialize_master_key: Uint8Array;
}

/**
 * IdentityKeyPair — wraps a (PublicKey, PrivateKey) pair used as the long-term identity.
 */
export class WasmIdentityKeyPair {
    free(): void;
    [Symbol.dispose](): void;
    /**
     * Deserialize from standard protobuf format.
     */
    static deserialize(data: Uint8Array): WasmIdentityKeyPair;
    constructor(public_key: WasmPublicKey, private_key: WasmPrivateKey);
    /**
     * Serialize to the standard protobuf format used by libsignal.
     */
    serialize(): Uint8Array;
    readonly private_key: WasmPrivateKey;
    readonly public_key: WasmPublicKey;
}

export class WasmInMemIdentityKeyStore {
    free(): void;
    [Symbol.dispose](): void;
    constructor(identity_key_pair: WasmIdentityKeyPair, registration_id: number);
}

export class WasmInMemKyberPreKeyStore {
    free(): void;
    [Symbol.dispose](): void;
    export_kyber_pre_key(id: number): Promise<Uint8Array | undefined>;
    /**
     * Export the anti-replay memory — the set of `(kyberId, signedPreKeyId,
     * baseKey)` triples already seen — for durable storage. Persist it
     * alongside the kyber records and re-import at hydration; without it the
     * replay guard resets on every reload. Format: version byte (1),
     * u32 BE record count, then per record `kyberId u32 BE || signedPreKeyId
     * u32 BE || 33-byte compressed base key`.
     */
    export_kyber_usage(): Uint8Array;
    import_kyber_pre_key(id: number, record_bytes: Uint8Array): Promise<void>;
    /**
     * Merge a previously exported usage set back in. Union semantics with
     * dedup, so re-importing the same export is a no-op. Unknown version,
     * malformed length, or an invalid base key is a hard error.
     */
    import_kyber_usage(bytes: Uint8Array): void;
    constructor();
    /**
     * Evict a Kyber pre-key record from the store. Canonical clients delete a
     * consumed ONE-TIME Kyber pre-key and record NO anti-replay triple for it
     * (Signal-iOS removes the row when `preKey.isOneTime`,
     * `SignalServiceKit/Axolotl/PreKeyStore.swift:199-225` @ 58cc49ec1;
     * Signal-Desktop writes `kyberPreKey_triples` only for last-resort keys,
     * `ts/SignalProtocolStore.preload.ts:536-570` @ de8fe1e70; libsignal trait
     * contract `rust/protocol/src/storage/traits.rs:116-138` @ b5121d0 leaves
     * one-time deletion to the caller). Removing the record also prunes the
     * `(kyber_id, signed_prekey_id, base_key)` triples held for that id,
     * because a replay against an evicted key fails earlier at
     * `get_kyber_pre_key` (`InvalidKyberPreKeyId`) before the base-key check
     * is ever reached. Last-resort records must NOT be evicted here; their
     * triples must persist so a replay against the live last-resort key is
     * still rejected.
     * Idempotent: returns whether a record was present.
     */
    remove_kyber_pre_key(id: number): boolean;
}

export class WasmInMemPreKeyStore {
    free(): void;
    [Symbol.dispose](): void;
    export_pre_key(id: number): Promise<Uint8Array | undefined>;
    import_pre_key(id: number, record_bytes: Uint8Array): Promise<void>;
    constructor();
}

export class WasmInMemSenderKeyStore {
    free(): void;
    [Symbol.dispose](): void;
    export_sender_key(address: WasmProtocolAddress, distribution_id: string): Promise<Uint8Array | undefined>;
    import_sender_key(address: WasmProtocolAddress, distribution_id: string, record_bytes: Uint8Array): Promise<void>;
    constructor();
    /**
     * Delete the sender-key record for `(address, distribution_id)`.
     *
     * Rotation must delete the record before re-creating it, otherwise
     * `createSenderKeyDistribution` reuses the existing chain and removed
     * group members keep deriving future message keys. Returns `true` if a
     * record was actually removed.
     */
    remove_sender_key(address: WasmProtocolAddress, distribution_id: string): Promise<boolean>;
}

export class WasmInMemSessionStore {
    free(): void;
    [Symbol.dispose](): void;
    archive_session(address: WasmProtocolAddress): Promise<void>;
    /**
     * Delete the session record for `address` entirely.
     *
     * Canonical libsignal's `SessionStore` trait has no `delete_session`
     * (`rust/protocol/src/storage/traits.rs:150-160` @ b5121d0); this removes
     * the wrapper-owned in-memory record. Intended for no-prior-session
     * rollback after a durable-save failure: a first-contact decrypt/encrypt
     * may create a session in the engine while the durable save fails, leaving
     * the engine state out of step with storage. Removing the record lets the
     * retry reprocess the PreKey ciphertext as a first-contact message.
     *
     * This is NOT `archive_session` — archive rotates the live ratchet state
     * into the record's previous-states list so straggler messages still
     * decrypt; delete removes the record completely.
     *
     * Returns `true` if a record was actually removed. A missing address
     * returns `false`.
     */
    delete_session(address: WasmProtocolAddress): Promise<boolean>;
    export_session(address: WasmProtocolAddress): Promise<Uint8Array | undefined>;
    has_session(address: WasmProtocolAddress): Promise<boolean>;
    import_session(address: WasmProtocolAddress, session_bytes: Uint8Array): Promise<void>;
    constructor();
    /**
     * Whether the live session for `address` is still on ratchet key
     * `key_bytes` — the match half of the sender-side retry-request handler
     * (monorepo `docs/signal-retry-request-design.md` R10).
     *
     * Thin wrap over `SessionRecord::current_ratchet_key_matches`
     * (`rust/protocol/src/state/session.rs:950` @ b056faa6d), which compares
     * against the current session state's `sender_ratchet_key()` — exactly
     * the load → match → archive flow libsignal's own harnesses run before
     * re-sending (`rust/protocol/src/session_management.rs:2266-2286`,
     * `rust/protocol/test-support/src/lib.rs:368-385` @ b056faa6d). A
     * missing record, or a record with no current state, yields `Ok(false)`
     * (the upstream method already maps no-current-state to false), so a
     * healed or never-established session never matches. Malformed key
     * bytes surface as an error rather than a false negative.
     */
    session_current_ratchet_key_matches(address: WasmProtocolAddress, key_bytes: Uint8Array): Promise<boolean>;
    /**
     * Return the remote registration id stored in the current session state
     * for `address`, or `None` when no record exists or the record has no
     * current state.
     *
     * This mirrors the value canonical Signal-Desktop sends in fan-out
     * metadata: `OutgoingMessage.preload.ts:537` @ `de8fe1e70` reads
     * `sessionCache.getSession(device.id).remoteRegistrationId()` so the
     * server's stale-registration check can force a session refresh when the
     * recipient re-registers. That check lives in Signal-Server's
     * `MessageSender.java:402-417` @ `5eb1a76e9`.
     *
     * `archive_session` rotates the live ratchet into the record's previous
     * states and leaves no current state; libsignal's
     * `SessionRecord::session_state()` returns `None` there
     * (`rust/protocol/src/state/session.rs:775-780` @ `b5121d0`), and
     * `SessionRecord::remote_registration_id()` returns `SessionNotFound`
     * (`rust/protocol/src/state/session.rs:847-856` @ `b5121d0`). This
     * wrapper maps both "no record" and "no current state" to `Ok(None)` so
     * callers can treat an archived record the same as a missing one.
     */
    session_remote_registration_id(address: WasmProtocolAddress): Promise<number | undefined>;
}

export class WasmInMemSignedPreKeyStore {
    free(): void;
    [Symbol.dispose](): void;
    export_signed_pre_key(id: number): Promise<Uint8Array | undefined>;
    import_signed_pre_key(id: number, record_bytes: Uint8Array): Promise<void>;
    constructor();
}

export class WasmKyberPreKey {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    readonly id: number;
    readonly public_key: Uint8Array;
    readonly record: Uint8Array;
    readonly signature: Uint8Array;
    readonly timestamp: bigint;
}

export class WasmPreKey {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    readonly id: number;
    readonly public_key: Uint8Array;
    readonly record: Uint8Array;
}

/**
 * PrivateKey — standalone asymmetric secret key.
 *
 * Zeroization note: the inner libsignal `PrivateKey` is a `Copy` type over a
 * `[u8; 32]` that upstream does not zero on drop, so this wrapper cannot
 * guarantee erasure of the scalar itself. The wrapper does zeroise every
 * secret-bearing buffer it owns (serialized prekey records, group master-key
 * bytes). Bytes exported to JS (`serialize()`) are copies in JS memory,
 * subject to the browser's GC — they cannot be erased from Rust.
 */
export class WasmPrivateKey {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    static deserialize(data: Uint8Array): WasmPrivateKey;
    static generate(): WasmPrivateKey;
    getPublicKey(): WasmPublicKey;
    serialize(): Uint8Array;
}

export class WasmProtocolAddress {
    free(): void;
    [Symbol.dispose](): void;
    constructor(name: string, device_id: number);
    readonly deviceId: number;
    readonly name: string;
}

/**
 * PublicKey — standalone asymmetric public key.
 */
export class WasmPublicKey {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    static deserialize(data: Uint8Array): WasmPublicKey;
    serialize(): Uint8Array;
}

export class WasmSafetyNumber {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    readonly displayable: string;
    readonly scannable: Uint8Array;
}

export class WasmSignedPreKey {
    private constructor();
    free(): void;
    [Symbol.dispose](): void;
    readonly id: number;
    readonly public_key: Uint8Array;
    readonly record: Uint8Array;
    readonly signature: Uint8Array;
    readonly timestamp: bigint;
}

/**
 * Create a sender key distribution message.
 *
 * `distribution_id` must be a caller-minted UUID string; since 0.4.0 the
 * wrapper no longer derives an id from arbitrary group strings.
 */
export function createSenderKeyDistribution(local_address: WasmProtocolAddress, distribution_id: string, sender_key_store: WasmInMemSenderKeyStore): Promise<Uint8Array>;

/**
 * Decrypt a group message.
 *
 * The distribution id is embedded in the ciphertext, so the record lookup is
 * keyed automatically; an unknown id surfaces as a `NoSenderKeyState` error.
 */
export function decryptGroupMessage(sender_address: WasmProtocolAddress, ciphertext: Uint8Array, sender_key_store: WasmInMemSenderKeyStore): Promise<Uint8Array>;

/**
 * Decrypt a Signal message.
 *
 * Returns the plaintext plus any one-time pre-key ids consumed while
 * establishing a new session (see `WasmDecryptResult`). The ids are captured
 * by the wrapper-owned stores' trait callbacks during the engine call —
 * exactly where Signal's own clients persist them — so they reflect genuine
 * consumption, never a guess from the message header.
 */
export function decryptMessage(ciphertext: Uint8Array, message_type: number, sender: WasmProtocolAddress, local_address: WasmProtocolAddress, session_store: WasmInMemSessionStore, identity_store: WasmInMemIdentityKeyStore, prekey_store: WasmInMemPreKeyStore, signed_prekey_store: WasmInMemSignedPreKeyStore, kyber_prekey_store: WasmInMemKyberPreKeyStore): Promise<WasmDecryptResult>;

/**
 * Encrypt a group message.
 *
 * `distribution_id` must be the same caller-minted UUID string used for
 * `createSenderKeyDistribution`.
 */
export function encryptGroupMessage(local_address: WasmProtocolAddress, distribution_id: string, plaintext: Uint8Array, sender_key_store: WasmInMemSenderKeyStore): Promise<Uint8Array>;

/**
 * Encrypt a Signal message.
 */
export function encryptMessage(plaintext: Uint8Array, recipient: WasmProtocolAddress, local_address: WasmProtocolAddress, session_store: WasmInMemSessionStore, identity_store: WasmInMemIdentityKeyStore): Promise<WasmCiphertext>;

/**
 * Generate a Kyber PreKey for post-quantum security.
 */
export function generateKyberPreKey(key_id: number, identity_key_pair: WasmIdentityKeyPair, kyber_prekey_store: WasmInMemKyberPreKeyStore): Promise<WasmKyberPreKey>;

/**
 * Generate a batch of one-time PreKeys.
 */
export function generatePreKeys(start_id: number, count: number, prekey_store: WasmInMemPreKeyStore): Promise<WasmPreKey[]>;

/**
 * Generate a registration ID using unbiased rejection sampling over the
 * canonical inclusive range 1..=16383.
 */
export function generateRegistrationId(): number;

/**
 * Generate a safety number.
 */
export function generateSafetyNumber(local_uuid: string, local_identity_key: WasmPublicKey, contact_uuid: string, contact_identity_key: WasmPublicKey): WasmSafetyNumber;

/**
 * Generate a signed PreKey.
 */
export function generateSignedPreKey(key_id: number, identity_key_pair: WasmIdentityKeyPair, signed_prekey_store: WasmInMemSignedPreKeyStore): Promise<WasmSignedPreKey>;

export function generate_attachment_key(): Uint8Array;

export function generate_random_bytes(length: number): Uint8Array;

export function generate_uuid(): Uint8Array;

export function init(): void;

export function message_type_pre_key(): number;

export function message_type_sender_key(): number;

export function message_type_signal(): number;

/**
 * Process a PreKeyBundle to establish a session.
 */
export function processPreKeyBundle(recipient: WasmProtocolAddress, local_address: WasmProtocolAddress, registration_id: number, identity_key: WasmPublicKey, signed_prekey_id: number, signed_prekey: WasmPublicKey, signed_prekey_signature: Uint8Array, prekey_id: number | null | undefined, prekey: Uint8Array | null | undefined, kyber_prekey_id: number, kyber_prekey: Uint8Array, kyber_prekey_signature: Uint8Array, session_store: WasmInMemSessionStore, identity_store: WasmInMemIdentityKeyStore): Promise<void>;

/**
 * Process a sender key distribution message.
 *
 * The distribution id is read from the message itself, so no id parameter is
 * required here.
 */
export function processSenderKeyDistribution(sender_address: WasmProtocolAddress, distribution_message: Uint8Array, sender_key_store: WasmInMemSenderKeyStore): Promise<void>;

/**
 * Extract the sender's ratchet key from a ciphertext, for the receiver
 * side of the retry-request protocol (monorepo
 * `docs/signal-retry-request-design.md` R10).
 *
 * Mirrors the arm logic of `DecryptionErrorMessage::for_original`
 * (`rust/protocol/src/protocol.rs:888-905` @ b056faa6d): Whisper takes
 * `SignalMessage::sender_ratchet_key` (protocol.rs:136), PreKey takes the
 * embedded SignalMessage's ratchet key, SenderKey yields `Ok(None)` (group
 * messages carry no Double-Ratchet key; group heal is SKDM re-serve, not
 * archive-on-match), and Plaintext is an error. The key is returned as
 * `PublicKey::serialize()` bytes (`rust/protocol/src/curve.rs:122` @
 * b056faa6d); the receiver embeds them in the retry-request control
 * envelope and the sender matches them with
 * `WasmInMemSessionStore.session_current_ratchet_key_matches`.
 *
 * Works on undecryptable ciphertexts by construction: the ratchet key sits
 * in the unauthenticated header of a SignalMessage, which is why canonical
 * clients can build a DecryptionErrorMessage for messages that failed
 * decryption.
 */
export function ratchet_key_of_ciphertext(bytes: Uint8Array, message_type: number): Uint8Array | undefined;

/**
 * Sign `message` with an identity private key (XEdDSA over the X25519
 * identity key, canonical `PrivateKey::calculate_signature`).
 *
 * Intended for server-verifiable proof-of-possession of an identity key,
 * e.g. authorising a re-key. Returns the 64-byte signature.
 */
export function signWithIdentityKey(identity_private_key: WasmPrivateKey, message: Uint8Array): Uint8Array;

export function uuid_from_string(s: string): Uint8Array;

export function uuid_to_string(bytes: Uint8Array): string;

/**
 * Verify an identity-key signature produced by `signWithIdentityKey`
 * (canonical `PublicKey::verify_signature`, constant-time).
 *
 * Returns `false` for a wrong key, wrong message, or malformed signature —
 * verification failure is data, not an error.
 */
export function verifyIdentitySignature(identity_public_key: WasmPublicKey, message: Uint8Array, signature: Uint8Array): boolean;

/**
 * Verify a scanned safety number.
 *
 * **Deprecated**: this recomputes OUR OWN fingerprint and byte-compares it
 * with the scanned payload, which can never validate a cross-perspective
 * scan (the scanned QR encodes the OTHER party's CombinedFingerprints with
 * local/remote swapped). Use `verifyScannableFingerprint`, which implements
 * the canonical `ScannableFingerprint::compare` semantics. Kept for API
 * compatibility only.
 */
export function verifySafetyNumber(scanned: Uint8Array, local_uuid: string, local_identity_key: WasmPublicKey, contact_uuid: string, contact_identity_key: WasmPublicKey): boolean;

/**
 * Verify a scanned QR-code fingerprint against OUR view of the session.
 *
 * This is the canonical cross-perspective check
 * (`ScannableFingerprint::compare`, libsignal
 * `rust/protocol/src/fingerprint.rs`): the scanned payload encodes the OTHER
 * party's CombinedFingerprints, so verification requires their.local ==
 * our.remote AND their.remote == our.local, enforced in constant time, with
 * version equality. A version mismatch throws with code
 * `FingerprintVersionMismatch`; an undecodable payload throws with code
 * `FingerprintParsingError`.
 */
export function verifyScannableFingerprint(scanned: Uint8Array, local_uuid: string, local_identity_key: WasmPublicKey, contact_uuid: string, contact_identity_key: WasmPublicKey): boolean;

export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;

export interface InitOutput {
    readonly memory: WebAssembly.Memory;
    readonly __wbg_wasmciphertext_free: (a: number, b: number) => void;
    readonly __wbg_wasmdecryptresult_free: (a: number, b: number) => void;
    readonly __wbg_wasmgroupidentifier_free: (a: number, b: number) => void;
    readonly __wbg_wasmgroupmasterkey_free: (a: number, b: number) => void;
    readonly __wbg_wasmgroupsecretparams_free: (a: number, b: number) => void;
    readonly __wbg_wasmidentitykeypair_free: (a: number, b: number) => void;
    readonly __wbg_wasminmemidentitykeystore_free: (a: number, b: number) => void;
    readonly __wbg_wasminmemkyberprekeystore_free: (a: number, b: number) => void;
    readonly __wbg_wasminmemprekeystore_free: (a: number, b: number) => void;
    readonly __wbg_wasminmemsenderkeystore_free: (a: number, b: number) => void;
    readonly __wbg_wasminmemsessionstore_free: (a: number, b: number) => void;
    readonly __wbg_wasminmemsignedprekeystore_free: (a: number, b: number) => void;
    readonly __wbg_wasmkyberprekey_free: (a: number, b: number) => void;
    readonly __wbg_wasmprekey_free: (a: number, b: number) => void;
    readonly __wbg_wasmprivatekey_free: (a: number, b: number) => void;
    readonly __wbg_wasmprotocoladdress_free: (a: number, b: number) => void;
    readonly __wbg_wasmpublickey_free: (a: number, b: number) => void;
    readonly __wbg_wasmsafetynumber_free: (a: number, b: number) => void;
    readonly __wbg_wasmsignedprekey_free: (a: number, b: number) => void;
    readonly createSenderKeyDistribution: (a: number, b: number, c: number, d: number) => any;
    readonly decryptGroupMessage: (a: number, b: number, c: number, d: number) => any;
    readonly decryptMessage: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => any;
    readonly encryptGroupMessage: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
    readonly encryptMessage: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
    readonly generateKyberPreKey: (a: number, b: number, c: number) => any;
    readonly generatePreKeys: (a: number, b: number, c: number) => any;
    readonly generateRegistrationId: () => number;
    readonly generateSafetyNumber: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
    readonly generateSignedPreKey: (a: number, b: number, c: number) => any;
    readonly generate_attachment_key: () => [number, number, number, number];
    readonly generate_random_bytes: (a: number) => [number, number, number, number];
    readonly generate_uuid: () => [number, number];
    readonly init: () => void;
    readonly message_type_pre_key: () => number;
    readonly message_type_sender_key: () => number;
    readonly message_type_signal: () => number;
    readonly processPreKeyBundle: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number) => any;
    readonly processSenderKeyDistribution: (a: number, b: number, c: number, d: number) => any;
    readonly ratchet_key_of_ciphertext: (a: number, b: number, c: number) => [number, number, number, number];
    readonly signWithIdentityKey: (a: number, b: number, c: number) => [number, number, number, number];
    readonly uuid_from_string: (a: number, b: number) => [number, number, number, number];
    readonly uuid_to_string: (a: number, b: number) => [number, number, number, number];
    readonly verifyIdentitySignature: (a: number, b: number, c: number, d: number, e: number) => number;
    readonly verifySafetyNumber: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number];
    readonly verifyScannableFingerprint: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number];
    readonly wasmciphertext_body: (a: number) => [number, number];
    readonly wasmciphertext_message_type: (a: number) => number;
    readonly wasmdecryptresult_kyberPreKeyId: (a: number) => number;
    readonly wasmdecryptresult_oneTimePreKeyId: (a: number) => number;
    readonly wasmdecryptresult_plaintext: (a: number) => [number, number];
    readonly wasmdecryptresult_signedPreKeyId: (a: number) => number;
    readonly wasmgroupidentifier_serialize: (a: number) => [number, number];
    readonly wasmgroupmasterkey_derive_identifier: (a: number) => number;
    readonly wasmgroupmasterkey_derive_secret_params: (a: number) => number;
    readonly wasmgroupmasterkey_from_bytes: (a: number, b: number) => [number, number, number];
    readonly wasmgroupmasterkey_generate: () => number;
    readonly wasmgroupmasterkey_serialize: (a: number) => [number, number];
    readonly wasmgroupsecretparams_get_identifier: (a: number) => number;
    readonly wasmgroupsecretparams_serialize_master_key: (a: number) => [number, number];
    readonly wasmidentitykeypair_deserialize: (a: number, b: number) => [number, number, number];
    readonly wasmidentitykeypair_new: (a: number, b: number) => number;
    readonly wasmidentitykeypair_private_key: (a: number) => number;
    readonly wasmidentitykeypair_public_key: (a: number) => number;
    readonly wasmidentitykeypair_serialize: (a: number) => [number, number];
    readonly wasminmemidentitykeystore_new: (a: number, b: number) => number;
    readonly wasminmemkyberprekeystore_export_kyber_pre_key: (a: number, b: number) => any;
    readonly wasminmemkyberprekeystore_export_kyber_usage: (a: number) => [number, number];
    readonly wasminmemkyberprekeystore_import_kyber_pre_key: (a: number, b: number, c: number, d: number) => any;
    readonly wasminmemkyberprekeystore_import_kyber_usage: (a: number, b: number, c: number) => [number, number];
    readonly wasminmemkyberprekeystore_new: () => number;
    readonly wasminmemkyberprekeystore_remove_kyber_pre_key: (a: number, b: number) => number;
    readonly wasminmemprekeystore_export_pre_key: (a: number, b: number) => any;
    readonly wasminmemprekeystore_import_pre_key: (a: number, b: number, c: number, d: number) => any;
    readonly wasminmemprekeystore_new: () => number;
    readonly wasminmemsenderkeystore_export_sender_key: (a: number, b: number, c: number, d: number) => any;
    readonly wasminmemsenderkeystore_import_sender_key: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
    readonly wasminmemsenderkeystore_new: () => number;
    readonly wasminmemsenderkeystore_remove_sender_key: (a: number, b: number, c: number, d: number) => any;
    readonly wasminmemsessionstore_archive_session: (a: number, b: number) => any;
    readonly wasminmemsessionstore_delete_session: (a: number, b: number) => any;
    readonly wasminmemsessionstore_export_session: (a: number, b: number) => any;
    readonly wasminmemsessionstore_has_session: (a: number, b: number) => any;
    readonly wasminmemsessionstore_import_session: (a: number, b: number, c: number, d: number) => any;
    readonly wasminmemsessionstore_new: () => number;
    readonly wasminmemsessionstore_session_current_ratchet_key_matches: (a: number, b: number, c: number, d: number) => any;
    readonly wasminmemsessionstore_session_remote_registration_id: (a: number, b: number) => any;
    readonly wasminmemsignedprekeystore_export_signed_pre_key: (a: number, b: number) => any;
    readonly wasminmemsignedprekeystore_import_signed_pre_key: (a: number, b: number, c: number, d: number) => any;
    readonly wasminmemsignedprekeystore_new: () => number;
    readonly wasmkyberprekey_id: (a: number) => number;
    readonly wasmkyberprekey_public_key: (a: number) => [number, number];
    readonly wasmkyberprekey_record: (a: number) => [number, number];
    readonly wasmkyberprekey_signature: (a: number) => [number, number];
    readonly wasmkyberprekey_timestamp: (a: number) => bigint;
    readonly wasmprekey_id: (a: number) => number;
    readonly wasmprekey_public_key: (a: number) => [number, number];
    readonly wasmprekey_record: (a: number) => [number, number];
    readonly wasmprivatekey_deserialize: (a: number, b: number) => [number, number, number];
    readonly wasmprivatekey_generate: () => number;
    readonly wasmprivatekey_getPublicKey: (a: number) => [number, number, number];
    readonly wasmprivatekey_serialize: (a: number) => [number, number];
    readonly wasmprotocoladdress_deviceId: (a: number) => number;
    readonly wasmprotocoladdress_name: (a: number) => [number, number];
    readonly wasmprotocoladdress_new: (a: number, b: number, c: number) => [number, number, number];
    readonly wasmpublickey_deserialize: (a: number, b: number) => [number, number, number];
    readonly wasmpublickey_serialize: (a: number) => [number, number];
    readonly wasmsafetynumber_displayable: (a: number) => [number, number];
    readonly wasmsafetynumber_scannable: (a: number) => [number, number];
    readonly wasmsignedprekey_id: (a: number) => number;
    readonly wasmsignedprekey_public_key: (a: number) => [number, number];
    readonly wasmsignedprekey_record: (a: number) => [number, number];
    readonly wasmsignedprekey_signature: (a: number) => [number, number];
    readonly wasmsignedprekey_timestamp: (a: number) => bigint;
    readonly wasm_bindgen__convert__closures_____invoke__hc68c8c729deff463: (a: number, b: number, c: any) => [number, number];
    readonly wasm_bindgen__convert__closures_____invoke__h2f2506a8f2f9cf3a: (a: number, b: number, c: any, d: any) => void;
    readonly __wbindgen_exn_store: (a: number) => void;
    readonly __externref_table_alloc: () => number;
    readonly __wbindgen_externrefs: WebAssembly.Table;
    readonly __wbindgen_destroy_closure: (a: number, b: number) => void;
    readonly __externref_drop_slice: (a: number, b: number) => void;
    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
    readonly __wbindgen_malloc: (a: number, b: number) => number;
    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
    readonly __externref_table_dealloc: (a: number) => void;
    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>;