@zerodds/wire 0.0.0-stage → 1.0.0-rc.7

package/dist/reader.d.ts

@@ -0,0 +1,605 @@
+/**
+ * The read half of XCDR, implemented from DDS-XTypes 1.3 §7.4.
+ *
+ * The mirror of `writer.ts` clause for clause and not by inversion of
+ * it: a reader written as "whatever undoes the writer" agrees with the
+ * writer about a misreading of the clause, and agreement between two
+ * halves of one column is the one thing that proves nothing.
+ *
+ * ## Two kinds of failure, and why they are not one
+ *
+ * A malformed *stream* throws. A length that runs past the end of the
+ * buffer is not a state a caller can carry on from, and
+ * {@link Truncated} against {@link ImpossibleLength} is the distinction
+ * that matters: the first says the stream is short, the second says the
+ * stream is lying. Allocating for a claimed length before checking it
+ * is how a reader turns a bad message into an out-of-memory.
+ *
+ * A refusal about the *type* sets {@link Status} and does not throw.
+ * The runtime owns the wire and the generated decoder owns the type,
+ * and this reader cannot see an integer that names no enumerator, a
+ * bitmask bit the declaration does not have, or a member that did not
+ * arrive. §7.2.2.7's DISCARD is a sample the receiver drops and carries
+ * on from, which is not a failure of the peer.
+ *
+ * ## What TypeScript decides differently from the other columns
+ *
+ * - `readChar` and `readWchar` answer with a one-character **string**,
+ *   not with a code point. TypeScript has no character type, the
+ *   materialiser declares a `char` member as `string`, and
+ *   `Writer.writeChar` takes one; a reader answering with a `number`
+ *   would be the only one of the three that did not.
+ * - `readU32` answers with a `number`, because 4294967295 is far below
+ *   `Number.MAX_SAFE_INTEGER`. `readI64` and `readU64` answer with a
+ *   `bigint`, because 2^63 is not.
+ * - `readEnum`, `readBitmask` and `readBitset` answer with a `bigint`
+ *   whatever their bound. The generated decoder compares the answer
+ *   against 64-bit patterns, and one comparison that mixed a `number`
+ *   with a `bigint` is a `tsc` error rather than a wrong arm — which
+ *   is the outcome this column wants.
+ * - `readF128` answers with the sixteen octets. A binary64 would drop
+ *   sixty bits of the significand at the assignment.
+ */
+import { Endianness } from "./endianness.js";
+import { FixedDigitCount, ParameterRole, Status, WcharFraming, WcharWidth, WstringLengthPolicy, WstringUnitOrder } from "./policy.js";
+import { Float128, PlCdr1Framing } from "./writer.js";
+/**
+ * The low fourteen bits of a short parameter id, which are the id.
+ *
+ * §7.4.1.2.2 puts `FLAG_IMPL_EXTENSION` at bit 15 and the
+ * must-understand flag at bit 14; everything below them is the
+ * identifier.
+ */
+export declare const PID_ID_MASK = 16383;
+/**
+ * `PID_IGNORE`. §7.4.1.2.2: "All consumers of this Data Representation
+ * shall ignore this parameter" — with no exception for the
+ * must-understand bit above it.
+ *
+ * Declared here and not in `writer.ts` because no writer in this tree
+ * emits one. It is a parameter a *peer* sends, so only the reader has
+ * anything to do with it.
+ */
+export declare const PID_IGNORE = 16131;
+/**
+ * Everything a two-pass read has to put back.
+ *
+ * One caller: a `map` under `rule-15-omits`, where a delimited map
+ * states no entry count and the entries are read once to count them and
+ * again into storage sized from that count. TypeScript allocates its own
+ * values, so there is no heap mark to carry — the cursor, the stream
+ * origin and the status are the whole of it.
+ *
+ * The status is part of it deliberately. A refusal made during the
+ * counting pass is a refusal about bytes that are about to be read
+ * again, and carrying it forward would refuse the sample twice.
+ */
+export interface ReaderMark {
+    readonly at: number;
+    readonly origin: number;
+    readonly status: Status;
+}
+/** An EMHEADER as read. §7.4.3.4.2. */
+export interface EmHeaderRead {
+    /** The 28-bit member id. */
+    readonly memberId: number;
+    /** The length code, 0 to 7. */
+    readonly lengthCode: number;
+    /** Whether the writer set the member's must-understand flag. */
+    readonly mustUnderstand: boolean;
+    /** The NEXTINT, for the codes that carry one. */
+    readonly nextInt: number;
+    /** Whether there was a NEXTINT at all. */
+    readonly hasNextInt: boolean;
+    /**
+     * How many octets the member occupies after the header word, NEXTINT
+     * included where there is one.
+     *
+     * What a reader skipping an unknown member advances by, and what a
+     * reader of a known one checks itself against. §7.4.3.4.2: codes 0 to
+     * 3 state a size of one, two, four or eight octets outright; code 4 is
+     * followed by a NEXTINT holding the member's length; and codes 5, 6
+     * and 7 have a NEXTINT that is *also* the member's own leading word,
+     * so the member spans that word plus the length it states, times one,
+     * four or eight.
+     */
+    readonly extent: number;
+}
+/** A PL_CDR1 parameter header as read. §7.4.1.2. */
+export interface PidRead {
+    /** The member id, with the flag bits taken off. */
+    readonly pid: number;
+    /** The declared length. */
+    readonly length: number;
+    /** Whether this is the `PID_LIST_END` sentinel. */
+    readonly end: boolean;
+    /** Whether the writer set the member's must-understand flag. */
+    readonly mustUnderstand: boolean;
+    /**
+     * Whether the writer set `FLAG_IMPL_EXTENSION`.
+     *
+     * §7.4.1.2.2: the parameter is the writing implementation's own, and a
+     * user-defined member "will never set the FLAG_IMPL_EXTENSION bit".
+     * Masking it off with the rest would make a vendor-private parameter
+     * indistinguishable from the member with the same low fourteen bits.
+     */
+    readonly implExtension: boolean;
+    /**
+     * Whether the short-form id is inside §7.4.1.2.2's reserved range,
+     * which no member id occupies.
+     */
+    readonly reserved: boolean;
+    /** `PID_IGNORE`, which every consumer shall ignore. */
+    readonly ignore: boolean;
+    /** Which of §7.4.1.2's two roles the caller read it in. */
+    readonly role: ParameterRole;
+    /** The stream origin the parameter's value block replaced. */
+    readonly savedOrigin: number;
+    /**
+     * Where the parameter's value starts — the first octet after the
+     * header.
+     *
+     * Carried on the header rather than worked out again at the finish,
+     * because working it out again needs two things at once that are not
+     * both still there: the enclosing origin has been put back by then,
+     * and the header's own width is four octets or twelve depending on a
+     * form the finish can only guess at from the values it reads.
+     *
+     * `runtime/java` reconstructs it as `savedOrigin + headerOctets` and
+     * that is only the value start for the *first* parameter of a list:
+     * the enclosing origin does not move between parameters, so the
+     * second parameter's used length comes out as its offset from the
+     * start of the whole list. Measured on
+     * `tests/interop-results/struct-mutable/zerodds-rust/pl-cdr1.le.bin`,
+     * where the second member's 8 octets are computed as 16 and the
+     * sample is refused OUT_OF_RANGE.
+     */
+    readonly valueAt: number;
+}
+/**
+ * Whether a parameter can be one of the reading type's members.
+ *
+ * False for a vendor-private parameter, for a reserved id and for
+ * `PID_IGNORE`. All three are legal for a peer to send and none of them
+ * is a member, so all three take the unknown-parameter path — skipped,
+ * or the sample discarded when the writer set must-understand.
+ * §7.4.1.2.2, §7.2.2.4.4.4.6.
+ *
+ * A free function and not a method, because the generated decoder calls
+ * it without a receiver.
+ */
+export declare function pidIsUserMember(header: PidRead): boolean;
+/**
+ * How many octets `text` is as UTF-8, which is what a `string<N>` bound
+ * counts: `string<5>` is `char[6]` in the C mapping of every measured
+ * DDS implementation, so a five-scalar value of ten octets is one no
+ * peer can hold.
+ */
+export declare function utf8Octets(text: string): number;
+/**
+ * How many UTF-16 code units `text` is, which is what a `wstring<N>`
+ * bound counts. A surrogate pair is two, which is what `String.length`
+ * already answers.
+ */
+export declare function utf16Units(text: string): number;
+/**
+ * The same value in a `number`, whatever holder it arrived in.
+ *
+ * The generated decoder's narrowings are `as` in every other column and
+ * `as` is *erased* here: `zd_bits as number` on a `bigint` is a `tsc`
+ * error, and where it is not — `x as unknown as number` — it would put
+ * a `bigint` in a `number` field and every later comparison would be
+ * false. So the three coercions below are real conversions, and the
+ * TypeScript backend emits a call to one where the other columns emit a
+ * cast.
+ *
+ * A one-character string answers with its code point, which is what the
+ * narrowing means where the source is a `char`.
+ */
+export declare function zdNumber(value: number | bigint | string | boolean): number;
+/** The same value in a `bigint`. See {@link zdNumber}. */
+export declare function zdBigInt(value: number | bigint | string | boolean): bigint;
+/**
+ * The same value as a one-character `string`, which is what an IDL
+ * `char` and `wchar` are here.
+ *
+ * A value that is already a string is itself; a number or a `bigint` is
+ * the character its code point names. `String(65)` would be `"65"`,
+ * which is two characters and a different value.
+ */
+export declare function zdChar(value: number | bigint | string): string;
+export declare class Reader {
+    readonly order: Endianness;
+    readonly plCdr1: PlCdr1Framing;
+    private readonly bytes;
+    private at;
+    private origin;
+    private readonly maxAlignment;
+    private state;
+    /**
+     * A reader over `data` in `order`, capped at `maxAlign`.
+     *
+     * Four for XCDR2, eight for XCDR1 — {@link Writer}'s counterpart.
+     * §7.4.1: `ALIGN(N)` aligns to `MIN(N, XCDR.maxalign)`. A reader that
+     * skipped padding the writer never wrote reads the wrong octets from
+     * the second member on.
+     *
+     * `plCdr1` is the writer's framing, and the reader needs two things
+     * out of it. Under a framing that puts `FLAG_IMPL_EXTENSION` on every
+     * member id — OpenDDS writes `c0010004` for `@id(1) long a` — the flag
+     * no longer tells a vendor-private parameter from a user member. And
+     * §7.4.1.2.2 stops the short form's ids at `0x3F00` inclusive while
+     * one measured implementation carries the whole low fourteen bits, so
+     * a reader holding the clause's threshold as a constant reports
+     * `@id(16383)` as a reserved parameter and drops the member.
+     */
+    constructor(data: Uint8Array, order: Endianness, maxAlign?: number, plCdr1?: PlCdr1Framing);
+    /** The alignment cap in force. */
+    get maxAlign(): number;
+    /**
+     * Whether a refusal has been made, so every later read does nothing.
+     *
+     * The generated decoder carries on to the end of the type rather than
+     * returning early — that is what lets one `if` at the top of the
+     * caller decide what to do with the sample — and a read that consumed
+     * octets after a refusal would leave the cursor somewhere no writer
+     * put it, which the trailing-octet check at the top would then report
+     * as a second, invented, fault.
+     */
+    private stopped;
+    /** How the read is going. */
+    readerStatus(): Status;
+    /** Refuse the stream from outside the runtime. The first refusal sticks. */
+    readerRefuse(refusal: Status): void;
+    /**
+     * Take back a {@link Status.Discarded}, and only that one.
+     *
+     * A member whose own `@try_construct` is `USE_DEFAULT` but which also
+     * carries an explicit `@default` cannot be answered inside the type's
+     * decoder: the decoder knows Table 9's value for the type and not the
+     * literal the member's declaration gave it, and §7.2.2.4.4.4.9 puts
+     * the literal first. So the call site asks for DISCARD, and where it
+     * gets one it clears it and assigns the literal.
+     *
+     * Every other status stays: a truncated stream is not a narrowing.
+     */
+    readerClearDiscard(): boolean;
+    /** Where it is. The generated decoder's name for {@link position}. */
+    readerPosition(): number;
+    /** How many octets are left. */
+    readerRemaining(): number;
+    /**
+     * Move the alignment origin to the current position.
+     *
+     * The read-side pair of the writer's `beginPackedElement`, for
+     * `ElementPadding::Packed`. Returns the origin displaced.
+     */
+    readerBeginPackedElement(): number;
+    /** Restore the origin {@link readerBeginPackedElement} displaced. */
+    readerFinishPackedElement(saved: number): void;
+    /**
+     * Move the cursor forward to `target`, which is never backwards.
+     *
+     * A framing word pointing behind the cursor means the reader has
+     * already read past what it framed, and seeking back would paper over
+     * it: the member would be read twice and the sample would come back
+     * plausible.
+     */
+    readerSkipTo(target: number): void;
+    /** The cursor, the origin and the status, to be put back later. */
+    readerSave(): ReaderMark;
+    /** Put back what {@link readerSave} took. */
+    readerRestore(mark: ReaderMark): void;
+    /** Where it is. */
+    position(): number;
+    /** How many octets are left. */
+    remaining(): number;
+    /** Skip padding to `align`, counted from the stream's origin. */
+    alignTo(align: number): void;
+    /** Step over `count` octets, refusing to step past the end. */
+    skip(count: number): void;
+    /** Move to an absolute offset inside the buffer. */
+    seek(target: number): void;
+    /**
+     * Advance over `count` octets and answer where they started.
+     *
+     * A negative count is refused rather than treated as zero: it can only
+     * come from a length field this reader computed wrongly, and a zero
+     * there would carry on reading at an offset nothing wrote.
+     */
+    private take;
+    /**
+     * An integer of `width` octets in the stream's order, as a `bigint`.
+     *
+     * A `bigint` throughout and narrowed by the caller, because the eight-
+     * octet case does not fit a `number` and a second code path for it
+     * would be the one place the two widths could disagree about a sign.
+     */
+    private readInt;
+    /** {@link readInt} in a stated order rather than the stream's. */
+    private rawInt;
+    /**
+     * `boolean`.
+     *
+     * An octet that is neither 0 nor 1 is a stream that disagrees with its
+     * own type, and is refused rather than coerced: `!!octet` would turn
+     * every one of the 254 impossible values into `true` and say nothing.
+     */
+    readBool(): boolean;
+    /** `octet` and `uint8`. */
+    readU8(): number;
+    /** `int8`. */
+    readI8(): number;
+    /**
+     * `char`, one octet, as the one-character string it is here.
+     *
+     * The octet is a code point in `[0, 255]` and not a UTF-8 lead: an IDL
+     * `char` is one octet and §7.4.1.1.1 gives it no encoding of its own,
+     * so `0xE4` is U+00E4 and not the first half of anything.
+     */
+    readChar(): string;
+    /**
+     * `wchar`, at `width` octets and in `framing`'s shape.
+     *
+     * The four-octet form is RTI Connext's under XCDR1, where the high
+     * sixteen bits are padding around one UTF-16 code unit. A value that
+     * uses them is refused rather than narrowed: narrowing would return a
+     * character the peer never sent.
+     *
+     * {@link WcharFraming.GiopLengthPrefixed} is CORBA 3.3 part 2
+     * §9.3.1.6's GIOP 1.2 form, which all three ORBs write. The octet
+     * count is checked against the configured code-set width rather than
+     * believed: a stream whose first octet says `0xE4` — which is what a
+     * bare two-octet `wchar` looks like read this way — would otherwise
+     * consume 228 octets of whatever followed and return a character
+     * assembled out of the next four members.
+     */
+    readWchar(width?: WcharWidth, framing?: WcharFraming, order?: WstringUnitOrder): string;
+    /** `short`. */
+    readI16(): number;
+    /** `unsigned short`. */
+    readU16(): number;
+    /** `long`. */
+    readI32(): number;
+    /**
+     * `unsigned long`, as a `number`.
+     *
+     * 4294967295 is far below `Number.MAX_SAFE_INTEGER`, so unlike the
+     * Java column nothing has to widen and unlike the C column nothing
+     * comes back negative.
+     */
+    readU32(): number;
+    /** `long long`, which is a `bigint` because a binary64 is not one. */
+    readI64(): bigint;
+    /**
+     * `unsigned long long`, as the value and not as a pattern.
+     *
+     * Where the Java column has to hand back `-1L` for
+     * `0xFFFFFFFFFFFFFFFF` because it has nothing wider than a `long`, a
+     * `bigint` holds 18446744073709551615 as itself.
+     */
+    readU64(): bigint;
+    /** `float`, a binary32. */
+    readF32(): number;
+    /** `double`, a binary64. */
+    readF64(): number;
+    /**
+     * `long double`: all sixteen octets, as the writer's counterpart holds
+     * them.
+     *
+     * The octets come back in the order a little-endian stream carries
+     * them, which is what {@link Writer.writeF128} takes; a big-endian
+     * stream's are reversed on the way in. Reading the first eight as a
+     * `double` and skipping the rest would decode every value a binary64
+     * cannot hold as a different number and say nothing.
+     */
+    readF128(): Float128;
+    /** A 16-bit value little-endian whatever the stream's order is. */
+    readU16Little(): number;
+    /** A 16-bit value big-endian whatever the stream's order is. */
+    readU16Big(): number;
+    /** A 32-bit value little-endian whatever the stream's order is. */
+    readU32Little(): number;
+    /** A 32-bit value big-endian whatever the stream's order is. */
+    readU32Big(): number;
+    /**
+     * `string`: a four-octet length that includes the terminator, then the
+     * octets, then a NUL. §7.4.1.1.1.
+     *
+     * A declared length of zero is impossible rather than empty: the count
+     * includes the terminator, so the shortest honest frame states one.
+     * A length past the end is {@link ImpossibleLength} and not
+     * {@link Truncated} — the stream is not short, the field is lying, and
+     * a reader that allocated for it first would be the vector.
+     */
+    readString(): string;
+    /**
+     * A `string` the reader materialises itself.
+     *
+     * `runtime/c` takes it out of a heap the caller set, because an
+     * embedded target decides where memory comes from. TypeScript has one
+     * answer to that question and this is it; the name is kept so that one
+     * walk names one operation in both columns.
+     */
+    readStringAlloc(): string;
+    /**
+     * A `wstring`, in whichever length convention the policy names.
+     *
+     * `runtime/c` converts to UTF-8 because that is what its
+     * `const char *` holds, and its name carries it. A TypeScript `string`
+     * is UTF-16 already and {@link readWstring} is the whole of the
+     * operation.
+     */
+    readWstringUtf8(policy: WstringLengthPolicy, order: WstringUnitOrder): string;
+    /**
+     * The inverse of `Writer.writeWstringUtf8Octets`.
+     *
+     * `WstringCodeUnits::Utf8`: the declared length is the UTF-8 octet count,
+     * and the terminator `policy` asks for is the last of those octets. A count
+     * the stream cannot hold, a missing or an interior NUL, or an ill-formed
+     * UTF-8 sequence is refused, never a replacement character or a truncated
+     * value.
+     */
+    readWstringUtf8Octets(policy: WstringLengthPolicy): string;
+    /**
+     * A `wstring`, in the form `policy` and `order` name.
+     *
+     * Under {@link WstringLengthPolicy.Specification} the count is octets
+     * and not characters — §7.4.1.1.2 — so a count the code-unit width
+     * does not divide is a stream no encoder produced and is refused
+     * rather than rounded down: rounding would leave the remainder in the
+     * stream and put every later member at the wrong offset.
+     *
+     * The form is never inferred from the stream. The cells are not
+     * separable: a Fast DDS `"ab"` followed by a `long` is byte-identical
+     * to a specification `"a"` followed by the same `long`, differing only
+     * in padding no clause fixes. Choosing between them would mean letting
+     * the length field — the one field a hostile peer controls — decide
+     * how much is read.
+     */
+    readWstring(policy: WstringLengthPolicy, order: WstringUnitOrder): string;
+    /**
+     * `count` `wstring` characters of `width` octets, as UTF-16 units.
+     *
+     * The whole run is checked against what is left **before** the first
+     * unit is read, because a count is what a hostile peer controls: the
+     * check is the difference between refusing a frame and reading 4·2^32
+     * octets of whatever follows.
+     *
+     * The four-octet width is RTI's XCDR1 form, where a character is a
+     * code unit zero-extended. A value above `0xFFFF` there is not a form
+     * this reader knows how to narrow, so it is refused rather than
+     * truncated — truncating is the defect this whole policy exists
+     * because of.
+     */
+    private readWstringUnits;
+    /**
+     * `text` cut to at most `octets` UTF-8 octets, never inside a
+     * character.
+     *
+     * Table 11: "The order of the characters in the string ... is
+     * preserved", so this is a prefix. A character that would straddle the
+     * bound is left out whole: a peer holding `char[octets + 1]` cannot
+     * store half of one either, and half a UTF-8 sequence is not text.
+     */
+    trimUtf8(text: string, octets: number): string;
+    /**
+     * `text` cut to at most `units` UTF-16 code units, never between the
+     * halves of a surrogate pair.
+     */
+    trimUtf16(text: string, units: number): string;
+    /**
+     * `fixed<digits, scale>`, as the decimal string the writer took.
+     *
+     * The mirror of `Writer.writeFixed`: `ceil((digits + 1) / 2)` octets
+     * of BCD, digits most-significant first, sign nibble last.
+     *
+     * The leading zeros go, because the BCD field is `digits` wide
+     * whatever the value: the nibbles for `0.01` in a `fixed<5, 2>` spell
+     * `00001`, and returning `"000.01"` would put a decimal on the read
+     * side that the write side would never produce from the same value.
+     * A negative zero loses its sign for the same reason: `-0.00` and
+     * `0.00` are one value, and the sign nibble is the only place they
+     * differ.
+     *
+     * Under {@link FixedDigitCount.ValuePrecision} the field's end is read
+     * out of the octets: [CDR] §9.3.2.8 makes a digit `0` to `9` and a
+     * sign `0xa` upwards, and the nibble count is even by construction, so
+     * the field ends at the first octet whose **low** nibble is a sign. A
+     * field that never presents one within the sixteen octets of the
+     * widest `fixed` IDL admits is refused.
+     */
+    readFixed(digits: number, scale: number, count: FixedDigitCount): string;
+    /**
+     * An enumerator's holder, **sign-extended from its holder's width**.
+     *
+     * §7.4.3.5.3 rule (5) makes the holder signed: `@value(200)` under a
+     * bound of eight goes out as `c8`, and that octet read as the type
+     * says is `-56`. `@value(-1)` and `@value(255)` are the same octet and
+     * nothing in the stream separates them — which one was meant is a
+     * question about the *type*, and the generated decoder answers it by
+     * comparing this against each declared enumerator's own pattern, taken
+     * the same way.
+     *
+     * The Java column had this unsigned while its walk compared against
+     * the signed pattern, and every `@bit_bound(8)` enumerator above 127
+     * matched no arm at all — the sample came back discarded rather than
+     * wrong, which is why it took a corpus run to find. The sign extension
+     * is from the *holder's* width and not from the bound: `@bit_bound(5)`
+     * still occupies an octet, and rule (5) makes the octet signed.
+     */
+    readEnum(bitBound: number): bigint;
+    /** A bitmask's holder. Table 33 of §7.4.1.1.3.2. */
+    readBitmask(bitBound: number): bigint;
+    /** A bitset's anchor integer, of the width the planner sized. */
+    readBitset(anchorOctets: number): bigint;
+    /**
+     * A sequence's element count, refusing one the stream cannot hold.
+     *
+     * An element is one octet or more, so a stream with fewer octets left
+     * than elements claimed cannot be honest about it. Allocating for it
+     * is how a reader turns a bad message into an out-of-memory — and in
+     * this column `new Array(n)` for a claimed 4294967295 is exactly that.
+     */
+    readSequenceLength(): number;
+    /** A DHEADER: the length the members that follow occupy. §7.4.3.5.3. */
+    readDheader(): number;
+    /**
+     * An EMHEADER, unpacked into its parts and the NEXTINT it carries.
+     *
+     * Codes 5 to 7 report the NEXTINT they read, but the reader is put
+     * back before it: §7.4.3.4.2 says that word "shall be reused also as
+     * part of the serialized member", so it is the member's own leading
+     * length and the member's decoder has to see it.
+     */
+    readEmheader(): EmHeaderRead;
+    /** A PL_CDR1 parameter header in the {@link ParameterRole.Member} role. */
+    readPid(): PidRead;
+    /**
+     * A PL_CDR1 parameter header, in whichever form it was written.
+     *
+     * `role` is the caller's, not the stream's: the octets are the same
+     * octets and only what the declared length means differs. §7.4.1.2.
+     */
+    readPidAs(role: ParameterRole): PidRead;
+    /**
+     * End a parameter's value and step to the next header.
+     *
+     * The padding to four follows the value and is outside the declared
+     * length, so the next parameter is found by alignment and not by
+     * adding the length — which is what lets one reader take RTI's
+     * rounded-up length and Fast DDS's exact one.
+     *
+     * The declared length is checked against the configured framing rather
+     * than believed: a length belonging to the other convention is a
+     * stream this reader was pointed at with the wrong framing, and
+     * reading on would put every later member at an offset no writer
+     * produced. Both readings are accepted where they coincide, which is
+     * every value already a multiple of four.
+     */
+    finishPidRead(header: PidRead): void;
+    /**
+     * Step over a member this reader does not know.
+     *
+     * The whole point of the length code, and the reason §7.4.3.4.2 gives
+     * one to every mutable member: a reader of an older type has to be
+     * able to walk past what it does not have a field for.
+     */
+    skipMember(header: EmHeaderRead): void;
+    /**
+     * Start reading a parameter's value, answering with the origin it
+     * replaces. The reader's half of the writer's parameter block.
+     */
+    beginParameterValue(): number;
+    /** End a parameter's value and step over its trailing padding. */
+    finishParameterValue(savedOrigin: number): void;
+    /**
+     * `length` octets from `from` as UTF-8, refusing anything that is not.
+     *
+     * `fatal: true` is the whole of it: without it `TextDecoder` replaces
+     * every malformed sequence with U+FFFD and answers a string that is
+     * the right length and the wrong text, which is precisely the silent
+     * substitution {@link NotUtf8} exists to prevent.
+     */
+    private decodeUtf8;
+}