@oxidezap/whatsapp-rust-bridge 0.7.2 → 0.8.1

package/dist/proto-reader.d.ts

@@ -1,20 +1,108 @@
-import { BinaryReader as BaseBinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
-export { BinaryWriter };
-/** BinaryReader specialized for ts-proto's safe-number output contract. */
+import { BinaryReader as BaseBinaryReader, BinaryWriter as BaseBinaryWriter } from "@bufbuild/protobuf/wire";
+import { Buffer } from "node:buffer";
+/** Index of the first UTF-16 code unit with no partner, or -1 when well-formed. */
+export declare function unpairedSurrogateIndex(value: string): number;
+/**
+ * A `string` field is UTF-8 on the wire and an unpaired UTF-16 surrogate has no
+ * UTF-8 form, so there is nothing faithful to write. `path` is filled in by
+ * `encodeProto`, which is the only layer that knows the field names.
+ */
+export declare class UnpairedSurrogateError extends RangeError {
+    readonly index: number;
+    readonly codeUnit: number;
+    readonly path?: string | undefined;
+    constructor(index: number, codeUnit: number, path?: string | undefined);
+}
+/**
+ * protobufjs-style 64-bit value, `high * 2^32 + low`, with `low` unsigned and
+ * `high` the signed 32-bit field protobufjs uses. Same shape `camel_serializer.rs`
+ * emits on the event path, and `JSON.stringify`-safe where a BigInt is not.
+ */
+export interface Long {
+    low: number;
+    high: number;
+    unsigned: boolean;
+}
+/**
+ * What a 64-bit field crosses as: a plain `number` while the value is exact as
+ * a double, a `Long` beyond that. Rejecting the wide value instead — which is
+ * what ts-proto's generated `longToNumber()` does — fails the whole message
+ * over one field, and truncating it to a double would lose the value silently.
+ */
+export type Int64 = number | Long;
+/** Everything a numeric field accepts. `Int64` is the decode-side subset. */
+export type NumericInput = number | bigint | string | Long;
+export declare const longToBigInt: (value: Long) => bigint;
+/**
+ * `unsigned` (a boolean) is the discriminant: it short-circuits virtually every
+ * non-Long object in one comparison, and matches the guard in
+ * `camel_serializer.rs`. A plain `{ low, high }` data object is NOT a Long, and
+ * neither is one whose words are not words — `longToBigInt` would truncate
+ * `low: 1.5` to `1` and write a value nobody sent.
+ */
+export declare const isLong: (value: unknown) => value is Long;
+/**
+ * BinaryWriter that accepts back what the reader below produces — Buf's own
+ * 64-bit setters take `number | bigint | string`, so a decoded `Long` would
+ * reach `BigInt(object)` and throw — and that holds every numeric field to the
+ * input contract above.
+ *
+ * It also refuses an unpaired surrogate rather than letting `TextEncoder`
+ * substitute U+FFFD for it, which would send the server text the caller never
+ * wrote. The value came from the caller, so the caller is the one who can fix it.
+ */
+export declare class BinaryWriter extends BaseBinaryWriter {
+    string(value: string): this;
+    uint32(value: NumericInput): this;
+    int32(value: NumericInput): this;
+    sint32(value: NumericInput): this;
+    fixed32(value: NumericInput): this;
+    sfixed32(value: NumericInput): this;
+    float(value: NumericInput): this;
+    double(value: NumericInput): this;
+    int64(value: NumericInput): this;
+    uint64(value: NumericInput): this;
+    sint64(value: NumericInput): this;
+    fixed64(value: NumericInput): this;
+    sfixed64(value: NumericInput): this;
+}
+/**
+ * BinaryReader specialized for ts-proto's 64-bit output contract. Buf's own
+ * 64-bit methods materialize a BigInt and then a decimal string; the `*Value()`
+ * methods below avoid both intermediates, while the inherited methods retain
+ * Buf's public BigInt/string behavior for direct users.
+ */
 export declare class BinaryReader extends BaseBinaryReader {
-    private readonly utf8Buffer;
+    protected readonly utf8Buffer: Buffer;
     constructor(buf: Uint8Array);
+    /**
+     * Bytes come from a peer this side does not control, so a malformed one
+     * substitutes U+FFFD rather than costing the whole message. `strict` reaches
+     * Buf's throwing decoder; the generated codecs never pass it.
+     */
     string(strict?: boolean): string;
     bool(): boolean;
     /**
      * Decode the overwhelmingly common positive/safe varint without allocating
      * Buf's `[low, high]` tuple. Returning `undefined` rewinds for the full signed
-     * two-word path (negative int64 values always use ten wire bytes).
+     * two-word path (negative int64 values always use ten wire bytes, and eight
+     * data bytes can carry more than a double holds exactly).
      */
     private positiveSafeVarint;
-    uint64Number(): number;
-    int64Number(): number;
-    sint64Number(): number;
-    fixed64Number(): number;
-    sfixed64Number(): number;
+    uint64Value(): Int64;
+    int64Value(): Int64;
+    sint64Value(): Int64;
+    fixed64Value(): Int64;
+    sfixed64Value(): Int64;
+}
+/**
+ * Counts the substitutions `BinaryReader` makes silently. It is a separate
+ * class so the ordinary decode path carries neither the flag nor the branch:
+ * a consumer who never asks for the count pays nothing for it existing.
+ */
+export declare class InvalidUtf8CountingReader extends BinaryReader {
+    invalidUtf8Fields: number;
+    string(strict?: boolean): string;
+    /** A U+FFFD the peer actually sent re-encodes to the bytes it arrived as; a substituted one does not. */
+    private decodedExactly;
 }