@derec-alliance/react-native 0.0.1

package/lib/primitives.d.ts

@@ -0,0 +1,137 @@
+import type { CommittedDeRecShare, CommunicationInfo, ContactMessage, ContactMode, CreateContactResult, DiscoveryProcessResult, GetSecretIdsVersionsRequestMessage, GetSecretIdsVersionsResponseMessage, GetShareRequestMessage, GetShareResponseMessage, PairRequestMessage, PairResponseMessage, PairingProcessResult, PairingRequestProduceResult, PairingResponseProduceResult, ParameterRange, PrePairRequestExtractResult, PrePairRequestMessage, PrePairResponseExtractResult, PrePairResponseMessage, ProcessPrePairResult, ProducePrePairResult, ProduceResult, RecoverResult, SecretVersionEntry, SenderKind, SharingResponseProduceResult, SplitResult, StoreShareRequestMessage, StoreShareResponseMessage, TransportProtocol, UnpairRequestMessage, UnpairResponseMessage, UnpairingProcessResult, VerifyShareRequestMessage, VerifyShareResponseMessage } from './types';
+/**
+ * `ContactMessage` keeps its own dedicated codec rather than going through
+ * the generic message codec: `encode_contact_message` /
+ * `decode_contact_message` also enforce the mode/field invariant — an
+ * `InlineKeys` contact must carry keys, a `HashedKeys` one must carry only
+ * the commitment — so a malformed contact is rejected here rather than
+ * travelling.
+ */
+declare function encodeContact(contact_message: ContactMessage): Uint8Array;
+declare function decodeContact(wire: Uint8Array | ArrayBuffer): ContactMessage;
+export declare const primitives: {
+    discovery: {
+        request: {
+            produce(channel_id: bigint, shared_key: Uint8Array, reply_to?: TransportProtocol | null): ProduceResult;
+            extract(envelope_bytes: Uint8Array, shared_key: Uint8Array): {
+                request: GetSecretIdsVersionsRequestMessage;
+            };
+        };
+        response: {
+            produce(channel_id: bigint, secret_list: SecretVersionEntry[], shared_key: Uint8Array): ProduceResult;
+            extract(envelope_bytes: Uint8Array, shared_key: Uint8Array): {
+                response: GetSecretIdsVersionsResponseMessage;
+            };
+            process(response: GetSecretIdsVersionsResponseMessage): DiscoveryProcessResult;
+        };
+    };
+    pairing: {
+        request: {
+            create_contact(channel_id: bigint, contact_mode: ContactMode | number, transport_protocol: TransportProtocol): CreateContactResult;
+            /** Proto-encodes a `ContactMessage`. Rejects a contact that violates the
+             *  mode/field invariant rather than serializing it. */
+            encode_contact: typeof encodeContact;
+            /** Decodes proto `ContactMessage` bytes. Rejects a contact that violates
+             *  the mode/field invariant rather than returning it. */
+            decode_contact: typeof decodeContact;
+            produce(kind: SenderKind, transport_protocol: TransportProtocol, contact_message: ContactMessage, communication_info: CommunicationInfo | null, parameter_range: ParameterRange | null): PairingRequestProduceResult;
+            extract(envelope_bytes: Uint8Array, secret_key: Uint8Array): {
+                request: PairRequestMessage;
+            };
+            produce_pre_pair(transport_protocol: TransportProtocol, contact_message: ContactMessage): ProducePrePairResult;
+            extract_pre_pair(envelope_bytes: Uint8Array): PrePairRequestExtractResult;
+        };
+        response: {
+            produce(channel_id: bigint, request: PairRequestMessage, secret_key: Uint8Array, communication_info: CommunicationInfo | null, parameter_range: ParameterRange | null): PairingResponseProduceResult;
+            extract(envelope_bytes: Uint8Array, secret_key: Uint8Array): {
+                response: PairResponseMessage;
+            };
+            process(contact_message: ContactMessage, response: PairResponseMessage, secret_key: Uint8Array): PairingProcessResult;
+            produce_pre_pair(channel_id: bigint, request: PrePairRequestMessage, secret_key: Uint8Array): ProducePrePairResult;
+            extract_pre_pair(envelope_bytes: Uint8Array): PrePairResponseExtractResult;
+            process_pre_pair(contact_message: ContactMessage, response: PrePairResponseMessage): ProcessPrePairResult;
+        };
+    };
+    recovery: {
+        request: {
+            produce(channel_id: bigint, secret_id: bigint, version: number, shared_key: Uint8Array, reply_to?: TransportProtocol | null): ProduceResult;
+            extract(envelope_bytes: Uint8Array, shared_key: Uint8Array): {
+                request: GetShareRequestMessage;
+            };
+        };
+        response: {
+            produce(channel_id: bigint, request: GetShareRequestMessage, stored_share_request: StoreShareRequestMessage, shared_key: Uint8Array): ProduceResult;
+            extract(envelope_bytes: Uint8Array, shared_key: Uint8Array): {
+                response: GetShareResponseMessage;
+            };
+            recover(secret_id: bigint, version: number, responses: GetShareResponseMessage[]): RecoverResult;
+        };
+    };
+    sharing: {
+        request: {
+            split(channels: bigint[], secret_id: bigint, version: number, secret_data: Uint8Array, threshold: number): SplitResult;
+            produce(channel_id: bigint, version: number, secret_id: bigint, committed_share: CommittedDeRecShare, keep_list: number[], description: string, shared_key: Uint8Array, reply_to?: TransportProtocol | null): ProduceResult;
+            extract(envelope_bytes: Uint8Array, shared_key: Uint8Array): {
+                request: StoreShareRequestMessage;
+            };
+        };
+        response: {
+            produce(channel_id: bigint, request: StoreShareRequestMessage, shared_key: Uint8Array): SharingResponseProduceResult;
+            extract(envelope_bytes: Uint8Array, shared_key: Uint8Array): {
+                response: StoreShareResponseMessage;
+            };
+            process(version: number, response: StoreShareResponseMessage): void;
+        };
+    };
+    unpairing: {
+        request: {
+            produce(channel_id: bigint, memo: string, shared_key: Uint8Array, reply_to?: TransportProtocol | null): ProduceResult;
+            extract(envelope_bytes: Uint8Array, shared_key: Uint8Array): {
+                request: UnpairRequestMessage;
+            };
+        };
+        response: {
+            produce(channel_id: bigint, shared_key: Uint8Array): ProduceResult;
+            extract(envelope_bytes: Uint8Array, shared_key: Uint8Array): {
+                response: UnpairResponseMessage;
+            };
+            /**
+             * `acknowledged` is `true` for every value this can return. The library's
+             * `unpairing::response::process` yields `ProcessResult { acknowledged:
+             * true }` on success and an error on a non-Ok peer status, and the C ABI
+             * carries only the error — so a refusal arrives as a thrown `DeRecError`,
+             * never as `acknowledged: false`. The field exists because
+             * `@derec-alliance/nodejs` surfaces it, where serde serializes the same
+             * constant.
+             */
+            process(response: UnpairResponseMessage): UnpairingProcessResult;
+        };
+    };
+    verification: {
+        request: {
+            produce(channel_id: bigint, secret_id: bigint, version: number, shared_key: Uint8Array, reply_to?: TransportProtocol | null): ProduceResult;
+            extract(envelope_bytes: Uint8Array, shared_key: Uint8Array): {
+                request: VerifyShareRequestMessage;
+            };
+        };
+        response: {
+            produce(channel_id: bigint, request: VerifyShareRequestMessage, shared_key: Uint8Array, share_content: Uint8Array): ProduceResult;
+            extract(envelope_bytes: Uint8Array, shared_key: Uint8Array): {
+                response: VerifyShareResponseMessage;
+            };
+            /** `request` must be the request the owner previously produced for this
+             *  challenge. Responses whose `(nonce, secret_id, version)` triple does
+             *  not match are rejected — that is the anti-replay gate. */
+            process(request: VerifyShareRequestMessage, response: VerifyShareResponseMessage, share_content: Uint8Array): boolean;
+        };
+    };
+};
+/**
+ * Envelope-level helpers that operate on raw `DeRecMessage` bytes without
+ * touching the encrypted inner payload.
+ */
+export declare const envelope: {
+    apply_trace_id(envelope_bytes: Uint8Array, trace_id: bigint): Uint8Array;
+    read_trace_id(envelope_bytes: Uint8Array): bigint;
+};
+export {};

package/lib/primitives.js

@@ -0,0 +1,329 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (c) 2026 DeRec Alliance. All rights reserved.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envelope = exports.primitives = void 0;
+/**
+ * The stateless primitive surface, shaped identically to
+ * `@derec-alliance/nodejs`.
+ *
+ * Primitives are synchronous: they are pure byte transforms with no store or
+ * transport callbacks, so they run on the JavaScript thread. `sharing.request.
+ * split` does real cryptographic work, which is why an application that needs
+ * it off-thread should drive it through `DeRecProtocol` instead.
+ *
+ * Each function marshals between the typed surface and the C ABI's own shapes
+ * — protobuf wire bytes for messages, hand-packed little-endian containers for
+ * the three set-valued arguments. See `./messages` and `./binary`. Nothing
+ * here interprets a protocol value: no defaulting, no clamping, no branching
+ * on what a field contains.
+ */
+const binary_1 = require("./binary");
+const codec_1 = require("./codec");
+const messages_1 = require("./messages");
+const native_1 = require("./native");
+function call(name, ...args) {
+    return (0, native_1.getNative)()[name](...args);
+}
+function bytes(value) {
+    return new Uint8Array(value);
+}
+/** `null` and `undefined` both mean "no override" for every optional
+ *  `TransportProtocol` argument; the C ABI reads a zero-length buffer as
+ *  absent. */
+function replyTo(value) {
+    return (0, messages_1.encodeOptionalMessage)(messages_1.MessageKind.TransportProtocol, value);
+}
+/**
+ * `ContactMessage` keeps its own dedicated codec rather than going through
+ * the generic message codec: `encode_contact_message` /
+ * `decode_contact_message` also enforce the mode/field invariant — an
+ * `InlineKeys` contact must carry keys, a `HashedKeys` one must carry only
+ * the commitment — so a malformed contact is rejected here rather than
+ * travelling.
+ */
+function encodeContact(contact_message) {
+    return bytes(call('encode_contact_message', (0, codec_1.jsonToBytes)((0, messages_1.plainMessage)(contact_message))));
+}
+function decodeContact(wire) {
+    const json = call('decode_contact_message', wire);
+    return (0, messages_1.reviveMessage)((0, codec_1.jsonFromBytes)(json));
+}
+const discovery = {
+    request: {
+        produce(channel_id, shared_key, reply_to) {
+            const envelope = call('produce_get_secret_ids_versions_request_message', channel_id, shared_key, replyTo(reply_to));
+            return { envelope: bytes(envelope) };
+        },
+        extract(envelope_bytes, shared_key) {
+            const result = call('extract_get_secret_ids_versions_request', envelope_bytes, shared_key);
+            return {
+                request: (0, messages_1.decodeMessage)(messages_1.MessageKind.GetSecretIdsVersionsRequest, result.request_proto_bytes),
+            };
+        },
+    },
+    response: {
+        produce(channel_id, secret_list, shared_key) {
+            const envelope = call('produce_get_secret_ids_versions_response_message', channel_id, (0, binary_1.encodeSecretList)(secret_list), shared_key);
+            return { envelope: bytes(envelope) };
+        },
+        extract(envelope_bytes, shared_key) {
+            const result = call('extract_get_secret_ids_versions_response', envelope_bytes, shared_key);
+            return {
+                response: (0, messages_1.decodeMessage)(messages_1.MessageKind.GetSecretIdsVersionsResponse, result.response_proto_bytes),
+            };
+        },
+        process(response) {
+            const packed = call('process_get_secret_ids_versions_response_message', (0, messages_1.encodeMessage)(messages_1.MessageKind.GetSecretIdsVersionsResponse, response));
+            return { secret_list: (0, binary_1.decodeSecretList)(packed) };
+        },
+    },
+};
+const pairing = {
+    request: {
+        create_contact(channel_id, contact_mode, transport_protocol) {
+            // The C entry point also accepts a caller-supplied nonce behind a
+            // presence flag. `@derec-alliance/nodejs` has no such parameter, so the
+            // flag is 0 and the library generates one — the same behaviour, not a
+            // default invented here.
+            const result = call('create_contact_message', channel_id, contact_mode, (0, messages_1.encodeMessage)(messages_1.MessageKind.TransportProtocol, transport_protocol), 0, 0n);
+            return {
+                contact_message: decodeContact(result.contact_wire_bytes),
+                secret_key: bytes(result.secret_key_material),
+            };
+        },
+        /** Proto-encodes a `ContactMessage`. Rejects a contact that violates the
+         *  mode/field invariant rather than serializing it. */
+        encode_contact: encodeContact,
+        /** Decodes proto `ContactMessage` bytes. Rejects a contact that violates
+         *  the mode/field invariant rather than returning it. */
+        decode_contact: decodeContact,
+        produce(kind, transport_protocol, contact_message, communication_info, parameter_range) {
+            const result = call('produce_pair_request_message', kind, (0, messages_1.encodeMessage)(messages_1.MessageKind.TransportProtocol, transport_protocol), encodeContact(contact_message), (0, messages_1.encodeOptionalMessage)(messages_1.MessageKind.CommunicationInfo, communication_info), (0, messages_1.encodeOptionalMessage)(messages_1.MessageKind.ParameterRange, parameter_range));
+            return {
+                envelope: bytes(result.request_wire_bytes),
+                initiator_contact_message: decodeContact(result.initiator_contact_message_wire_bytes),
+                secret_key: bytes(result.secret_key_material),
+            };
+        },
+        extract(envelope_bytes, secret_key) {
+            const result = call('extract_pair_request', envelope_bytes, secret_key);
+            return {
+                request: (0, messages_1.decodeMessage)(messages_1.MessageKind.PairRequest, result.request_proto_bytes),
+            };
+        },
+        produce_pre_pair(transport_protocol, contact_message) {
+            const envelope = call('produce_pre_pair_request_message', (0, messages_1.encodeMessage)(messages_1.MessageKind.TransportProtocol, transport_protocol), encodeContact(contact_message));
+            return { envelope: bytes(envelope) };
+        },
+        extract_pre_pair(envelope_bytes) {
+            const result = call('extract_pre_pair_request', envelope_bytes);
+            return {
+                request: (0, messages_1.decodeMessage)(messages_1.MessageKind.PrePairRequest, result.request_proto_bytes),
+            };
+        },
+    },
+    response: {
+        produce(channel_id, request, secret_key, communication_info, parameter_range) {
+            const result = call('produce_pair_response_message', channel_id, (0, messages_1.encodeMessage)(messages_1.MessageKind.PairRequest, request), secret_key, (0, messages_1.encodeOptionalMessage)(messages_1.MessageKind.CommunicationInfo, communication_info), (0, messages_1.encodeOptionalMessage)(messages_1.MessageKind.ParameterRange, parameter_range));
+            return {
+                envelope: bytes(result.response_wire_bytes),
+                peer_transport_protocol: (0, messages_1.decodeMessage)(messages_1.MessageKind.TransportProtocol, result.peer_transport_protocol),
+                shared_key: bytes(result.shared_key),
+                channel_id: result.channel_id,
+            };
+        },
+        extract(envelope_bytes, secret_key) {
+            const result = call('extract_pair_response', envelope_bytes, secret_key);
+            return {
+                response: (0, messages_1.decodeMessage)(messages_1.MessageKind.PairResponse, result.response_proto_bytes),
+            };
+        },
+        process(contact_message, response, secret_key) {
+            const result = call('process_pair_response_message', encodeContact(contact_message), (0, messages_1.encodeMessage)(messages_1.MessageKind.PairResponse, response), secret_key);
+            return { shared_key: bytes(result.shared_key), channel_id: result.channel_id };
+        },
+        produce_pre_pair(channel_id, request, secret_key) {
+            const envelope = call('produce_pre_pair_response_message', channel_id, (0, messages_1.encodeMessage)(messages_1.MessageKind.PrePairRequest, request), secret_key);
+            return { envelope: bytes(envelope) };
+        },
+        extract_pre_pair(envelope_bytes) {
+            const result = call('extract_pre_pair_response', envelope_bytes);
+            return {
+                response: (0, messages_1.decodeMessage)(messages_1.MessageKind.PrePairResponse, result.response_proto_bytes),
+            };
+        },
+        process_pre_pair(contact_message, response) {
+            const result = call('process_pre_pair_response_message', encodeContact(contact_message), (0, messages_1.encodeMessage)(messages_1.MessageKind.PrePairResponse, response));
+            return {
+                mlkem_encapsulation_key: bytes(result.mlkem_encapsulation_key),
+                ecies_public_key: bytes(result.ecies_public_key),
+                nonce: result.nonce,
+            };
+        },
+    },
+};
+const recovery = {
+    request: {
+        produce(channel_id, secret_id, version, shared_key, reply_to) {
+            const envelope = call('produce_get_share_request_message', channel_id, secret_id, version, shared_key, replyTo(reply_to));
+            return { envelope: bytes(envelope) };
+        },
+        extract(envelope_bytes, shared_key) {
+            const result = call('extract_get_share_request', envelope_bytes, shared_key);
+            return {
+                request: (0, messages_1.decodeMessage)(messages_1.MessageKind.GetShareRequest, result.request_proto_bytes),
+            };
+        },
+    },
+    response: {
+        produce(channel_id, request, stored_share_request, shared_key) {
+            const envelope = call('produce_get_share_response_message', channel_id, (0, messages_1.encodeMessage)(messages_1.MessageKind.GetShareRequest, request), (0, messages_1.encodeMessage)(messages_1.MessageKind.StoreShareRequest, stored_share_request), shared_key);
+            return { envelope: bytes(envelope) };
+        },
+        extract(envelope_bytes, shared_key) {
+            const result = call('extract_get_share_response', envelope_bytes, shared_key);
+            return {
+                response: (0, messages_1.decodeMessage)(messages_1.MessageKind.GetShareResponse, result.response_proto_bytes),
+            };
+        },
+        recover(secret_id, version, responses) {
+            const packed = (0, binary_1.encodeShareResponses)(responses.map((response) => (0, messages_1.encodeMessage)(messages_1.MessageKind.GetShareResponse, response)));
+            const secret = call('recover_from_share_responses', packed, secret_id, version);
+            return { secret_data: bytes(secret) };
+        },
+    },
+};
+const sharing = {
+    request: {
+        split(channels, secret_id, version, secret_data, threshold) {
+            const packed = call('protect_secret', secret_id, secret_data, channels, threshold, version);
+            const shares = new Map();
+            for (const entry of (0, binary_1.decodeCommittedShareEntries)(packed)) {
+                shares.set(entry.channelId, (0, messages_1.decodeMessage)(messages_1.MessageKind.CommittedDeRecShare, entry.shareProto));
+            }
+            return { shares };
+        },
+        produce(channel_id, version, secret_id, committed_share, keep_list, description, shared_key, reply_to) {
+            const envelope = call('produce_store_share_request_message', channel_id, version, secret_id, (0, messages_1.encodeMessage)(messages_1.MessageKind.CommittedDeRecShare, committed_share), keep_list, (0, codec_1.utf8Encode)(description), shared_key, replyTo(reply_to));
+            return { envelope: bytes(envelope) };
+        },
+        extract(envelope_bytes, shared_key) {
+            const result = call('extract_store_share_request', envelope_bytes, shared_key);
+            return {
+                request: (0, messages_1.decodeMessage)(messages_1.MessageKind.StoreShareRequest, result.request_proto_bytes),
+            };
+        },
+    },
+    response: {
+        produce(channel_id, request, shared_key) {
+            const result = call('produce_store_share_response_message', channel_id, (0, messages_1.encodeMessage)(messages_1.MessageKind.StoreShareRequest, request), shared_key);
+            return {
+                envelope: bytes(result.wire_bytes),
+                committed_share: (0, messages_1.decodeMessage)(messages_1.MessageKind.CommittedDeRecShare, result.committed_share_bytes),
+                secret_id: result.secret_id,
+                version: result.version,
+            };
+        },
+        extract(envelope_bytes, shared_key) {
+            const result = call('extract_store_share_response', envelope_bytes, shared_key);
+            return {
+                response: (0, messages_1.decodeMessage)(messages_1.MessageKind.StoreShareResponse, result.response_proto_bytes),
+            };
+        },
+        process(version, response) {
+            call('process_store_share_response_message', version, (0, messages_1.encodeMessage)(messages_1.MessageKind.StoreShareResponse, response));
+        },
+    },
+};
+const unpairing = {
+    request: {
+        produce(channel_id, memo, shared_key, reply_to) {
+            const envelope = call('produce_unpair_request_message', channel_id, (0, codec_1.utf8Encode)(memo), shared_key, replyTo(reply_to));
+            return { envelope: bytes(envelope) };
+        },
+        extract(envelope_bytes, shared_key) {
+            const result = call('extract_unpair_request', envelope_bytes, shared_key);
+            return {
+                request: (0, messages_1.decodeMessage)(messages_1.MessageKind.UnpairRequest, result.request_proto_bytes),
+            };
+        },
+    },
+    response: {
+        produce(channel_id, shared_key) {
+            const envelope = call('produce_unpair_response_message', channel_id, shared_key);
+            return { envelope: bytes(envelope) };
+        },
+        extract(envelope_bytes, shared_key) {
+            const result = call('extract_unpair_response', envelope_bytes, shared_key);
+            return {
+                response: (0, messages_1.decodeMessage)(messages_1.MessageKind.UnpairResponse, result.response_proto_bytes),
+            };
+        },
+        /**
+         * `acknowledged` is `true` for every value this can return. The library's
+         * `unpairing::response::process` yields `ProcessResult { acknowledged:
+         * true }` on success and an error on a non-Ok peer status, and the C ABI
+         * carries only the error — so a refusal arrives as a thrown `DeRecError`,
+         * never as `acknowledged: false`. The field exists because
+         * `@derec-alliance/nodejs` surfaces it, where serde serializes the same
+         * constant.
+         */
+        process(response) {
+            call('process_unpair_response_message', (0, messages_1.encodeMessage)(messages_1.MessageKind.UnpairResponse, response));
+            return { acknowledged: true };
+        },
+    },
+};
+const verification = {
+    request: {
+        produce(channel_id, secret_id, version, shared_key, reply_to) {
+            const envelope = call('produce_verify_share_request_message', channel_id, secret_id, version, shared_key, replyTo(reply_to));
+            return { envelope: bytes(envelope) };
+        },
+        extract(envelope_bytes, shared_key) {
+            const result = call('extract_verify_share_request', envelope_bytes, shared_key);
+            return {
+                request: (0, messages_1.decodeMessage)(messages_1.MessageKind.VerifyShareRequest, result.request_proto_bytes),
+            };
+        },
+    },
+    response: {
+        produce(channel_id, request, shared_key, share_content) {
+            const envelope = call('produce_verify_share_response_message', channel_id, (0, messages_1.encodeMessage)(messages_1.MessageKind.VerifyShareRequest, request), shared_key, share_content);
+            return { envelope: bytes(envelope) };
+        },
+        extract(envelope_bytes, shared_key) {
+            const result = call('extract_verify_share_response', envelope_bytes, shared_key);
+            return {
+                response: (0, messages_1.decodeMessage)(messages_1.MessageKind.VerifyShareResponse, result.response_proto_bytes),
+            };
+        },
+        /** `request` must be the request the owner previously produced for this
+         *  challenge. Responses whose `(nonce, secret_id, version)` triple does
+         *  not match are rejected — that is the anti-replay gate. */
+        process(request, response, share_content) {
+            return call('process_verify_share_response_message', (0, messages_1.encodeMessage)(messages_1.MessageKind.VerifyShareRequest, request), (0, messages_1.encodeMessage)(messages_1.MessageKind.VerifyShareResponse, response), share_content);
+        },
+    },
+};
+exports.primitives = {
+    discovery,
+    pairing,
+    recovery,
+    sharing,
+    unpairing,
+    verification,
+};
+/**
+ * Envelope-level helpers that operate on raw `DeRecMessage` bytes without
+ * touching the encrypted inner payload.
+ */
+exports.envelope = {
+    apply_trace_id(envelope_bytes, trace_id) {
+        return bytes(call('apply_trace_id_to_envelope', envelope_bytes, trace_id));
+    },
+    read_trace_id(envelope_bytes) {
+        return call('read_trace_id_from_envelope', envelope_bytes);
+    },
+};

package/lib/protocol.d.ts

@@ -0,0 +1,188 @@
+import { FlowKind } from './types';
+import type { AutoAcceptPolicy, ChannelStore, ContactMessage, ContactMode, DeRecEvent, DiscoveryParams, PairingParams, ProtectSecretParams, RecoverSecretParams, RemoveReplicaParams, SecretStore, ShareStore, StateStore, SyncCheckParams, Timeouts, Transport, UnpairAck, UnpairParams, UpdateChannelInfoParams, UserSecretStore, VerifySharesParams } from './types';
+/** Shape of the `__DeRec` host object as seen from this file: every member is
+ *  a plain callable, since the JSI layer exposes host functions this way and
+ *  TypeScript has no static knowledge of them (see `primitives.ts`'s `call`
+ *  helper, which uses the same escape hatch). */
+type NativeHost = Record<string, (...args: any[]) => any>;
+/**
+ * Maps a transport protocol name to the `derec_proto::Protocol` discriminant.
+ * `bindings/test_fixture/enums.json` — the shared enum fixture every other
+ * numeric mapping in this SDK is read from — does not carry this enum (it
+ * only covers the Rust-internal serde enums listed under its `"enums"` key);
+ * the transport `Protocol` enum lives in `protobufs/transportprotocol.proto`
+ * instead, where only `HTTPS = 0` is currently defined.
+ */
+export declare function protocolDiscriminant(protocol: string): number;
+/**
+ * `ProtectSecretParamsJson` (`library/src/interop/ffi/protocol/flow.rs`): every
+ * `UserSecret.id`/`.data` byte array travels as a bare JSON array of decimal
+ * byte values, matching `UserSecretJson`'s plain `Vec<u8>` fields — no
+ * base64, no wrapping.
+ *
+ * Exported so it can be golden-tested against
+ * `bindings/test_fixture/wire_golden.json` without a native module.
+ */
+export declare function buildProtectSecretParams(params: ProtectSecretParams): Record<string, unknown>;
+/**
+ * `RestoreParamsJson` (`library/src/interop/ffi/protocol/handle/flow.rs`). Mirrors
+ * `SecretWire`'s own shape: `channel_id`/`replica_id` are the decimal `u64`
+ * strings the `SecretRecovered` event already carries, forwarded verbatim;
+ * `communication_info` is omitted per-entry (not sent as `{}`) whenever a
+ * helper or replica member has none, matching the Go SDK's `omitempty` and
+ * the shared golden fixture byte-for-byte; `replicas` is omitted entirely
+ * when the recovered secret has no replica group.
+ *
+ * Exported so it can be golden-tested against
+ * `bindings/test_fixture/wire_golden.json` without a native module.
+ */
+export declare function buildRestoreParams(recoveredSecret: Extract<DeRecEvent, {
+    type: 'SecretRecovered';
+}>['secret'], version: number): Record<string, unknown>;
+/**
+ * Builder for {@link DeRecProtocol}, mirroring `@derec-alliance/nodejs`'s
+ * `DeRecProtocolBuilder` method-for-method. The config JSON shape is dictated
+ * by the Rust `ProtocolConfig` struct (`library/src/interop/ffi/protocol/handle/mod.rs`);
+ * every field here writes exactly the `snake_case` key that struct expects.
+ *
+ * Every value the caller supplies is forwarded verbatim — defaults, clamping
+ * and the meaning of a disabled cleanup policy are library decisions.
+ * `threshold`, `keep_versions_count`, `auto_respond_on_failure`,
+ * `unpair_ack`, `auto_reply_to` and `auto_accept` are omitted entirely from
+ * the emitted config unless their setter was called: `ProtocolConfig` has a
+ * `#[serde(default = "...")]` on each of them, reading the same constants
+ * `DeRecProtocolBuilder::new` uses, so an absent key resolves to the
+ * library's own default rather than one frozen into this shim.
+ */
+export declare class DeRecProtocolBuilder {
+    private readonly secretIdValue;
+    private config;
+    private stores;
+    private communicationInfo;
+    constructor(secretId: bigint | number);
+    withChannelStore(store: ChannelStore): this;
+    withShareStore(store: ShareStore): this;
+    withSecretStore(store: SecretStore): this;
+    withUserSecretStore(store: UserSecretStore): this;
+    withStateStore(store: StateStore): this;
+    withTransport(transport: Transport): this;
+    withOwnTransport(endpoint: {
+        uri: string;
+        protocol: string;
+    }): this;
+    /** Default: 3. */
+    withThreshold(threshold: number): this;
+    /** Default: 3. */
+    withKeepVersionsCount(count: number): this;
+    /**
+     * Every field is optional; not calling this at all leaves all four at the
+     * library's defaults — `timeouts` is genuinely absent from the JSON in
+     * that case, not filled in with a synthesized object. Values are forwarded
+     * verbatim; `Timeouts`'s field names already match `TimeoutsConfig`'s
+     * `snake_case` keys one for one.
+     */
+    withTimeouts(timeouts: Timeouts): this;
+    /** Default: false. */
+    withUnsafeHttp(allow: boolean): this;
+    /**
+     * Default: empty. `derec_protocol_new`'s own `communication_info` argument
+     * is a pre-encoded `CommunicationInfo` protobuf message, and this SDK has
+     * no encoder for that message — the C ABI exposes one only for
+     * `ContactMessage`. Hand-rolling one here would be SDK-side protocol logic
+     * with no test coverage — exactly what this codebase's "Rust decides, the
+     * SDK only marshals" rule forbids. Instead,
+     * `build()` constructs the protocol with an empty `communication_info`
+     * (a legitimate, always-accepted value — see `decode_communication_info`
+     * in `library/src/interop/ffi/protocol/handle/mod.rs`, which treats a zero-length
+     * buffer as "no entries") and then calls the already-bound
+     * {@link DeRecProtocol.setCommunicationInfo}, which takes the same map as
+     * plain JSON (`derec_protocol_set_communication_info` in
+     * `library/src/interop/ffi/protocol/handle/config.rs`). That setter is queued on
+     * the protocol's serial worker before `build()` returns, so it is ordered
+     * ahead of every call the caller can subsequently make.
+     */
+    withCommunicationInfo(info: Record<string, string>): this;
+    /** Default: false. */
+    withAutoRespondOnFailure(enabled: boolean): this;
+    /** Default: "required". */
+    withUnpairAck(ack: UnpairAck): this;
+    /** Default: false. */
+    withAutoReplyTo(enabled: boolean): this;
+    /** Default: empty policy (every flow off). */
+    withAutoAccept(policy: AutoAcceptPolicy): this;
+    /** Default: unset. */
+    withReplicaId(replicaId: bigint | number): this;
+    build(): DeRecProtocol;
+}
+/**
+ * Thin wrapper around the `ProtocolHost` JSI host object, mirroring
+ * `@derec-alliance/nodejs`'s `DeRecProtocol` — same methods, and the same
+ * sync/async split except for `setCommunicationInfo` and `setOwnTransport`,
+ * which return a `Promise` here (see their own doc comments for why);
+ * `secretId` is synchronous and everything else returns a `Promise`. Every method encodes its
+ * arguments into the wire shape the host function expects and decodes its
+ * result back into the typed value declared here; no protocol decision is
+ * made in this class.
+ */
+export declare class DeRecProtocol {
+    private readonly host;
+    /** Use {@link DeRecProtocolBuilder} to construct instances. */
+    private constructor();
+    /**
+     * @internal Constructs an instance from a native `ProtocolHost`. Not part
+     * of the public surface — {@link DeRecProtocolBuilder.build} is the only
+     * caller. Exists because the constructor is `private` (matching
+     * `@derec-alliance/nodejs`'s `index.d.ts`), and a private constructor is
+     * only callable from within this class's own body, not from
+     * `DeRecProtocolBuilder`.
+     */
+    static fromHost(host: NativeHost): DeRecProtocol;
+    secretId(): bigint;
+    /**
+     * Returns a `Promise`, where `@derec-alliance/nodejs` declares this
+     * `void`. The native setter takes the same handle mutex a running flow
+     * holds across its store callbacks, so calling it on the JavaScript thread
+     * would block that thread until the flow released the mutex — which it
+     * cannot do while it is waiting on the JavaScript thread. The binding
+     * therefore queues the setter onto the same serial worker every flow runs
+     * on, which orders it after any call already in flight. The nodejs SDK is
+     * WASM and single-threaded, so it has no such hazard.
+     *
+     * Callers that ignore the result behave exactly as before, so this stays
+     * source-compatible with nodejs-shaped code; awaiting it additionally
+     * surfaces a failure that would otherwise be swallowed.
+     */
+    setCommunicationInfo(info: Record<string, string>): Promise<void>;
+    /** Returns a `Promise` for the same reason {@link setCommunicationInfo} does. */
+    setOwnTransport(uri: string, protocol: string): Promise<void>;
+    /**
+     * Decodes the `contact_wire_bytes` `derec_protocol_create_contact`
+     * produces into a typed `ContactMessage`, so an application can read the
+     * contact's `nonce`, `transport_protocol` and mode without a protobuf
+     * codec of its own. Feed the returned object straight back into
+     * `start(FlowKind.Pairing, { contact })`, which re-encodes it.
+     */
+    createContact(channelId: bigint | number | null | undefined, contactMode: ContactMode, nonce?: bigint | number | null): Promise<ContactMessage>;
+    start(flowKind: FlowKind.Pairing, params: PairingParams): Promise<DeRecEvent[]>;
+    start(flowKind: FlowKind.Discovery, params?: DiscoveryParams): Promise<DeRecEvent[]>;
+    start(flowKind: FlowKind.ProtectSecret, params: ProtectSecretParams): Promise<DeRecEvent[]>;
+    start(flowKind: FlowKind.VerifyShares, params: VerifySharesParams): Promise<DeRecEvent[]>;
+    start(flowKind: FlowKind.RecoverSecret, params: RecoverSecretParams): Promise<DeRecEvent[]>;
+    start(flowKind: FlowKind.Unpair, params: UnpairParams): Promise<DeRecEvent[]>;
+    start(flowKind: FlowKind.UpdateChannelInfo, params: UpdateChannelInfoParams): Promise<DeRecEvent[]>;
+    start(flowKind: FlowKind.SyncCheck, params?: SyncCheckParams): Promise<DeRecEvent[]>;
+    start(flowKind: FlowKind.RemoveReplica, params: RemoveReplicaParams): Promise<DeRecEvent[]>;
+    process(message: Uint8Array): Promise<DeRecEvent[]>;
+    tick(): Promise<DeRecEvent[]>;
+    accept(actionBytes: Uint8Array): Promise<DeRecEvent[]>;
+    reject(actionBytes: Uint8Array, status: number, memo: string): Promise<void>;
+    getFingerprint(channelId: bigint | number): Promise<string>;
+    verifyFingerprint(channelId: bigint | number, fingerprint: string): Promise<boolean>;
+    removeExpiredChannels(olderThanSecs: number): Promise<string[]>;
+    restore(recoveredSecret: Extract<DeRecEvent, {
+        type: 'SecretRecovered';
+    }>['secret'], version: number): Promise<DeRecEvent[]>;
+    /** Release the native handle. Safe to call more than once. */
+    free(): void;
+}
+export {};