@its-c10/dis-codec 0.1.0

package/README.md

@@ -0,0 +1,86 @@
+# dis-codec
+
+Spec-accurate **Distributed Interactive Simulation (DIS)** encode/decode library in TypeScript. Wire format follows IEEE 1278.1 (DIS application protocols). PDUs are encoded with correct header length for UDP/DIS feeds.
+
+## Install
+
+```bash
+npm install dis-codec
+```
+
+## Usage
+
+**Encode a PDU and get bytes for UDP:**
+
+```ts
+import { BinaryWriter, dis7 } from "dis-codec";
+
+const writer = new BinaryWriter();
+dis7.encodeCreateEntityPdu(writer, {
+  header: {
+    protocolVersion: dis7.PROTOCOL_VERSION,
+    exerciseId: 1,
+    pduType: dis7.PDU_TYPE_CREATE_ENTITY,
+    protocolFamily: dis7.PROTOCOL_FAMILY_SIMULATION_MANAGEMENT,
+    timestamp: 0,
+    length: 0, // ignored; encoder sets correct length automatically
+    pduStatus: 0,
+    padding: 0,
+  },
+  originatingId: { simulationAddress: { site: 1, application: 2 }, entity: 10 },
+  receivingId: { simulationAddress: { site: 0, application: 0 }, entity: 0 },
+  requestId: 1,
+});
+
+const bytes = new Uint8Array(writer.toArrayBuffer());
+// Send bytes over UDP
+```
+
+**Decode a PDU from received bytes:**
+
+```ts
+import { BinaryReader, dis7 } from "dis-codec";
+
+const reader = new BinaryReader(udpPacketBuffer);
+const pdu = dis7.decodeEntityStatePdu(reader);
+// Use pdu.entityId, pdu.entityLocation, etc.
+```
+
+**Switch on PDU type:**
+
+```ts
+const reader = new BinaryReader(buffer);
+const header = dis7.decodePduHeader(reader);
+reader.setOffset(0); // rewind to decode full PDU
+
+if (header.pduType === dis7.PDU_TYPE_ENTITY_STATE) {
+  const pdu = dis7.decodeEntityStatePdu(reader);
+  // ...
+} else if (header.pduType === dis7.PDU_TYPE_ELECTROMAGNETIC_EMISSION) {
+  const pdu = dis7.decodeElectromagneticEmissionPdu(reader);
+  // ...
+}
+```
+
+## DIS 7 PDUs
+
+| PDU | Encode / Decode | Notes |
+|-----|-----------------|--------|
+| Entity State | `encodeEntityStatePdu` / `decodeEntityStatePdu` | Variable length |
+| Create Entity | `encodeCreateEntityPdu` / `decodeCreateEntityPdu` | 28 bytes |
+| Remove Entity | `encodeRemoveEntityPdu` / `decodeRemoveEntityPdu` | 28 bytes |
+| Start/Resume | `encodeStartResumePdu` / `decodeStartResumePdu` | 44 bytes |
+| Stop/Freeze | `encodeStopFreezePdu` / `decodeStopFreezePdu` | 40 bytes |
+| Electromagnetic Emission | `encodeElectromagneticEmissionPdu` / `decodeElectromagneticEmissionPdu` | Variable length |
+| Transmitter | `encodeTransmitterPdu` / `decodeTransmitterPdu` | Variable length |
+
+Constants for PDU types, protocol families, and fixed lengths are on `dis7` (e.g. `dis7.PDU_TYPE_ENTITY_STATE`, `dis7.CREATE_ENTITY_PDU_LENGTH`).
+
+## Requirements
+
+- ES2020+ (Node or browser)
+- TypeScript types included
+
+## License
+
+MIT

package/dist/binary/BinaryReader.d.ts

@@ -0,0 +1,21 @@
+/** Big-endian binary reader (DIS network byte order). */
+export declare class BinaryReader {
+    private readonly view;
+    private offset;
+    constructor(buffer: ArrayBuffer);
+    getOffset(): number;
+    setOffset(pos: number): void;
+    skip(bytes: number): void;
+    private ensureReadable;
+    readUint8(): number;
+    readUint16(): number;
+    readUint32(): number;
+    readUint64(): bigint;
+    readInt8(): number;
+    readInt16(): number;
+    readInt32(): number;
+    readFloat32(): number;
+    readFloat64(): number;
+    /** Read a fixed number of bytes as a new Uint8Array. */
+    readBytes(byteCount: number): Uint8Array;
+}

package/dist/binary/BinaryReader.js

@@ -0,0 +1,92 @@
+/** Big-endian binary reader (DIS network byte order). */
+export class BinaryReader {
+    constructor(buffer) {
+        this.offset = 0;
+        this.view = new DataView(buffer);
+    }
+    getOffset() {
+        return this.offset;
+    }
+    setOffset(pos) {
+        if (pos < 0 || pos > this.view.byteLength) {
+            throw new RangeError(`BinaryReader.setOffset: offset ${pos} out of range [0, ${this.view.byteLength}]`);
+        }
+        this.offset = pos;
+    }
+    skip(bytes) {
+        if (bytes < 0) {
+            throw new RangeError(`BinaryReader.skip: negative bytes (${bytes})`);
+        }
+        this.ensureReadable(bytes);
+        this.offset += bytes;
+    }
+    ensureReadable(byteCount) {
+        if (this.offset + byteCount > this.view.byteLength) {
+            throw new RangeError(`BinaryReader: read past end (need ${byteCount} bytes at offset ${this.offset}, length ${this.view.byteLength})`);
+        }
+    }
+    readUint8() {
+        this.ensureReadable(1);
+        const v = this.view.getUint8(this.offset);
+        this.offset += 1;
+        return v;
+    }
+    readUint16() {
+        this.ensureReadable(2);
+        const v = this.view.getUint16(this.offset, false);
+        this.offset += 2;
+        return v;
+    }
+    readUint32() {
+        this.ensureReadable(4);
+        const v = this.view.getUint32(this.offset, false);
+        this.offset += 4;
+        return v;
+    }
+    readUint64() {
+        this.ensureReadable(8);
+        const v = this.view.getBigUint64(this.offset, false);
+        this.offset += 8;
+        return v;
+    }
+    readInt8() {
+        this.ensureReadable(1);
+        const v = this.view.getInt8(this.offset);
+        this.offset += 1;
+        return v;
+    }
+    readInt16() {
+        this.ensureReadable(2);
+        const v = this.view.getInt16(this.offset, false);
+        this.offset += 2;
+        return v;
+    }
+    readInt32() {
+        this.ensureReadable(4);
+        const v = this.view.getInt32(this.offset, false);
+        this.offset += 4;
+        return v;
+    }
+    readFloat32() {
+        this.ensureReadable(4);
+        const v = this.view.getFloat32(this.offset, false);
+        this.offset += 4;
+        return v;
+    }
+    readFloat64() {
+        this.ensureReadable(8);
+        const v = this.view.getFloat64(this.offset, false);
+        this.offset += 8;
+        return v;
+    }
+    /** Read a fixed number of bytes as a new Uint8Array. */
+    readBytes(byteCount) {
+        this.ensureReadable(byteCount);
+        const out = new Uint8Array(byteCount);
+        for (let i = 0; i < byteCount; i++) {
+            out[i] = this.view.getUint8(this.offset + i);
+        }
+        this.offset += byteCount;
+        return out;
+    }
+}

package/dist/binary/BinaryWriter.d.ts

@@ -0,0 +1,24 @@
+/** Big-endian binary writer with growable buffer (DIS network byte order). */
+export declare class BinaryWriter {
+    private buf;
+    private view;
+    private offset;
+    constructor(initialCapacity?: number);
+    getOffset(): number;
+    /** Returns a copy of written bytes as ArrayBuffer. */
+    toArrayBuffer(): ArrayBuffer;
+    /** Overwrite a uint16 at the given offset (does not advance write position). Used to patch PDU length. */
+    patchUint16(offset: number, value: number): void;
+    private ensureWritable;
+    writeUint8(value: number): void;
+    writeUint16(value: number): void;
+    writeUint32(value: number): void;
+    writeUint64(value: bigint): void;
+    writeInt8(value: number): void;
+    writeInt16(value: number): void;
+    writeInt32(value: number): void;
+    writeFloat32(value: number): void;
+    writeFloat64(value: number): void;
+    /** Write raw bytes from a Uint8Array or ArrayBuffer. */
+    writeBytes(data: Uint8Array | ArrayBuffer): void;
+}

package/dist/binary/BinaryWriter.js

@@ -0,0 +1,88 @@
+/** Big-endian binary writer with growable buffer (DIS network byte order). */
+export class BinaryWriter {
+    constructor(initialCapacity = 64) {
+        this.offset = 0;
+        this.buf = new Uint8Array(initialCapacity);
+        this.view = new DataView(this.buf.buffer, 0, this.buf.byteLength);
+    }
+    getOffset() {
+        return this.offset;
+    }
+    /** Returns a copy of written bytes as ArrayBuffer. */
+    toArrayBuffer() {
+        const out = new ArrayBuffer(this.offset);
+        new Uint8Array(out).set(this.buf.subarray(0, this.offset));
+        return out;
+    }
+    /** Overwrite a uint16 at the given offset (does not advance write position). Used to patch PDU length. */
+    patchUint16(offset, value) {
+        if (offset < 0 || offset + 2 > this.offset) {
+            throw new RangeError(`BinaryWriter.patchUint16: offset ${offset} out of range [0, ${this.offset - 2}]`);
+        }
+        this.view.setUint16(offset, value, false);
+    }
+    ensureWritable(byteCount) {
+        const need = this.offset + byteCount;
+        if (need <= this.buf.byteLength)
+            return;
+        let cap = this.buf.byteLength;
+        while (cap < need)
+            cap = Math.max(cap * 2, need);
+        const next = new Uint8Array(cap);
+        next.set(this.buf.subarray(0, this.offset));
+        this.buf = next;
+        this.view = new DataView(this.buf.buffer, 0, this.buf.byteLength);
+    }
+    writeUint8(value) {
+        this.ensureWritable(1);
+        this.view.setUint8(this.offset, value);
+        this.offset += 1;
+    }
+    writeUint16(value) {
+        this.ensureWritable(2);
+        this.view.setUint16(this.offset, value, false);
+        this.offset += 2;
+    }
+    writeUint32(value) {
+        this.ensureWritable(4);
+        this.view.setUint32(this.offset, value, false);
+        this.offset += 4;
+    }
+    writeUint64(value) {
+        this.ensureWritable(8);
+        this.view.setBigUint64(this.offset, value, false);
+        this.offset += 8;
+    }
+    writeInt8(value) {
+        this.ensureWritable(1);
+        this.view.setInt8(this.offset, value);
+        this.offset += 1;
+    }
+    writeInt16(value) {
+        this.ensureWritable(2);
+        this.view.setInt16(this.offset, value, false);
+        this.offset += 2;
+    }
+    writeInt32(value) {
+        this.ensureWritable(4);
+        this.view.setInt32(this.offset, value, false);
+        this.offset += 4;
+    }
+    writeFloat32(value) {
+        this.ensureWritable(4);
+        this.view.setFloat32(this.offset, value, false);
+        this.offset += 4;
+    }
+    writeFloat64(value) {
+        this.ensureWritable(8);
+        this.view.setFloat64(this.offset, value, false);
+        this.offset += 8;
+    }
+    /** Write raw bytes from a Uint8Array or ArrayBuffer. */
+    writeBytes(data) {
+        const u8 = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+        this.ensureWritable(u8.byteLength);
+        this.buf.set(u8, this.offset);
+        this.offset += u8.byteLength;
+    }
+}

package/dist/binary.d.ts

@@ -0,0 +1,36 @@
+/** Big-endian binary I/O (DIS network byte order). */
+export declare class BinaryReader {
+    private readonly view;
+    private offset;
+    constructor(buffer: ArrayBuffer);
+    getOffset(): number;
+    setOffset(pos: number): void;
+    skip(bytes: number): void;
+    private ensureReadable;
+    readUint8(): number;
+    readUint16(): number;
+    readUint32(): number;
+    readInt8(): number;
+    readInt16(): number;
+    readInt32(): number;
+    readFloat32(): number;
+    readFloat64(): number;
+}
+export declare class BinaryWriter {
+    private buf;
+    private view;
+    private offset;
+    constructor(initialCapacity?: number);
+    getOffset(): number;
+    /** Returns a copy of written bytes as ArrayBuffer. */
+    toArrayBuffer(): ArrayBuffer;
+    private ensureWritable;
+    writeUint8(value: number): void;
+    writeUint16(value: number): void;
+    writeUint32(value: number): void;
+    writeInt8(value: number): void;
+    writeInt16(value: number): void;
+    writeInt32(value: number): void;
+    writeFloat32(value: number): void;
+    writeFloat64(value: number): void;
+}

package/dist/binary.js

@@ -0,0 +1,144 @@
+/** Big-endian binary I/O (DIS network byte order). */
+export class BinaryReader {
+    constructor(buffer) {
+        this.offset = 0;
+        this.view = new DataView(buffer);
+    }
+    getOffset() {
+        return this.offset;
+    }
+    setOffset(pos) {
+        if (pos < 0 || pos > this.view.byteLength) {
+            throw new RangeError(`BinaryReader.setOffset: offset ${pos} out of range [0, ${this.view.byteLength}]`);
+        }
+        this.offset = pos;
+    }
+    skip(bytes) {
+        if (bytes < 0) {
+            throw new RangeError(`BinaryReader.skip: negative bytes (${bytes})`);
+        }
+        this.ensureReadable(bytes);
+        this.offset += bytes;
+    }
+    ensureReadable(byteCount) {
+        if (this.offset + byteCount > this.view.byteLength) {
+            throw new RangeError(`BinaryReader: read past end (need ${byteCount} bytes at offset ${this.offset}, length ${this.view.byteLength})`);
+        }
+    }
+    readUint8() {
+        this.ensureReadable(1);
+        const v = this.view.getUint8(this.offset);
+        this.offset += 1;
+        return v;
+    }
+    readUint16() {
+        this.ensureReadable(2);
+        const v = this.view.getUint16(this.offset, false);
+        this.offset += 2;
+        return v;
+    }
+    readUint32() {
+        this.ensureReadable(4);
+        const v = this.view.getUint32(this.offset, false);
+        this.offset += 4;
+        return v;
+    }
+    readInt8() {
+        this.ensureReadable(1);
+        const v = this.view.getInt8(this.offset);
+        this.offset += 1;
+        return v;
+    }
+    readInt16() {
+        this.ensureReadable(2);
+        const v = this.view.getInt16(this.offset, false);
+        this.offset += 2;
+        return v;
+    }
+    readInt32() {
+        this.ensureReadable(4);
+        const v = this.view.getInt32(this.offset, false);
+        this.offset += 4;
+        return v;
+    }
+    readFloat32() {
+        this.ensureReadable(4);
+        const v = this.view.getFloat32(this.offset, false);
+        this.offset += 4;
+        return v;
+    }
+    readFloat64() {
+        this.ensureReadable(8);
+        const v = this.view.getFloat64(this.offset, false);
+        this.offset += 8;
+        return v;
+    }
+}
+export class BinaryWriter {
+    constructor(initialCapacity = 64) {
+        this.offset = 0;
+        this.buf = new Uint8Array(initialCapacity);
+        this.view = new DataView(this.buf.buffer, 0, this.buf.byteLength);
+    }
+    getOffset() {
+        return this.offset;
+    }
+    /** Returns a copy of written bytes as ArrayBuffer. */
+    toArrayBuffer() {
+        const out = new ArrayBuffer(this.offset);
+        new Uint8Array(out).set(this.buf.subarray(0, this.offset));
+        return out;
+    }
+    ensureWritable(byteCount) {
+        const need = this.offset + byteCount;
+        if (need <= this.buf.byteLength)
+            return;
+        let cap = this.buf.byteLength;
+        while (cap < need)
+            cap = Math.max(cap * 2, need);
+        const next = new Uint8Array(cap);
+        next.set(this.buf.subarray(0, this.offset));
+        this.buf = next;
+        this.view = new DataView(this.buf.buffer, 0, this.buf.byteLength);
+    }
+    writeUint8(value) {
+        this.ensureWritable(1);
+        this.view.setUint8(this.offset, value);
+        this.offset += 1;
+    }
+    writeUint16(value) {
+        this.ensureWritable(2);
+        this.view.setUint16(this.offset, value, false);
+        this.offset += 2;
+    }
+    writeUint32(value) {
+        this.ensureWritable(4);
+        this.view.setUint32(this.offset, value, false);
+        this.offset += 4;
+    }
+    writeInt8(value) {
+        this.ensureWritable(1);
+        this.view.setInt8(this.offset, value);
+        this.offset += 1;
+    }
+    writeInt16(value) {
+        this.ensureWritable(2);
+        this.view.setInt16(this.offset, value, false);
+        this.offset += 2;
+    }
+    writeInt32(value) {
+        this.ensureWritable(4);
+        this.view.setInt32(this.offset, value, false);
+        this.offset += 4;
+    }
+    writeFloat32(value) {
+        this.ensureWritable(4);
+        this.view.setFloat32(this.offset, value, false);
+        this.offset += 4;
+    }
+    writeFloat64(value) {
+        this.ensureWritable(8);
+        this.view.setFloat64(this.offset, value, false);
+        this.offset += 8;
+    }
+}

package/dist/codecs/common/decodeEntityId.d.ts

@@ -0,0 +1,3 @@
+import type { BinaryReader } from "../../binary/BinaryReader.js";
+import type { EntityId } from "../../types/EntityId.js";
+export declare function decodeEntityId(reader: BinaryReader): EntityId;

package/dist/codecs/common/decodeEntityId.js

@@ -0,0 +1,7 @@
+export function decodeEntityId(reader) {
+    return {
+        site: reader.readUint16(),
+        application: reader.readUint16(),
+        entity: reader.readUint16(),
+    };
+}

package/dist/codecs/common/encodeEntityId.d.ts

@@ -0,0 +1,3 @@
+import type { BinaryWriter } from "../../binary/BinaryWriter.js";
+import type { EntityId } from "../../types/EntityId.js";
+export declare function encodeEntityId(writer: BinaryWriter, value: EntityId): void;

package/dist/codecs/common/encodeEntityId.js

@@ -0,0 +1,5 @@
+export function encodeEntityId(writer, value) {
+    writer.writeUint16(value.site);
+    writer.writeUint16(value.application);
+    writer.writeUint16(value.entity);
+}

package/dist/codecs/entityId.d.ts

@@ -0,0 +1,10 @@
+import type { BinaryReader } from "../binary.js";
+import type { BinaryWriter } from "../binary.js";
+/** DIS Entity ID: site, application, entity — each uint16, 6 bytes on wire. */
+export interface EntityId {
+    site: number;
+    application: number;
+    entity: number;
+}
+export declare function decodeEntityId(reader: BinaryReader): EntityId;
+export declare function encodeEntityId(writer: BinaryWriter, value: EntityId): void;

package/dist/codecs/entityId.js

@@ -0,0 +1,12 @@
+export function decodeEntityId(reader) {
+    return {
+        site: reader.readUint16(),
+        application: reader.readUint16(),
+        entity: reader.readUint16(),
+    };
+}
+export function encodeEntityId(writer, value) {
+    writer.writeUint16(value.site);
+    writer.writeUint16(value.application);
+    writer.writeUint16(value.entity);
+}

package/dist/core/entityId.d.ts

@@ -0,0 +1,14 @@
+import type { BinaryReader } from "../binary/BinaryReader.js";
+import type { BinaryWriter } from "../binary/BinaryWriter.js";
+/** Site + application (uint16 each), 4 bytes on wire before entity number. */
+export interface SimulationAddress {
+    site: number;
+    application: number;
+}
+/** DIS Entity ID: simulation address then entity (uint16), 6 bytes total. */
+export interface EntityId {
+    simulationAddress: SimulationAddress;
+    entity: number;
+}
+export declare function decodeEntityId(reader: BinaryReader): EntityId;
+export declare function encodeEntityId(writer: BinaryWriter, value: EntityId): void;

package/dist/core/entityId.js

@@ -0,0 +1,14 @@
+export function decodeEntityId(reader) {
+    return {
+        simulationAddress: {
+            site: reader.readUint16(),
+            application: reader.readUint16(),
+        },
+        entity: reader.readUint16(),
+    };
+}
+export function encodeEntityId(writer, value) {
+    writer.writeUint16(value.simulationAddress.site);
+    writer.writeUint16(value.simulationAddress.application);
+    writer.writeUint16(value.entity);
+}

package/dist/core/eventId.d.ts

@@ -0,0 +1,12 @@
+import type { BinaryReader } from "../binary/BinaryReader.js";
+import type { BinaryWriter } from "../binary/BinaryWriter.js";
+/** DIS Event ID: simulation address then event number (uint16 each), 6 bytes total. */
+export interface EventId {
+    simulationAddress: {
+        site: number;
+        application: number;
+    };
+    event: number;
+}
+export declare function decodeEventId(reader: BinaryReader): EventId;
+export declare function encodeEventId(writer: BinaryWriter, value: EventId): void;

package/dist/core/eventId.js

@@ -0,0 +1,14 @@
+export function decodeEventId(reader) {
+    return {
+        simulationAddress: {
+            site: reader.readUint16(),
+            application: reader.readUint16(),
+        },
+        event: reader.readUint16(),
+    };
+}
+export function encodeEventId(writer, value) {
+    writer.writeUint16(value.simulationAddress.site);
+    writer.writeUint16(value.simulationAddress.application);
+    writer.writeUint16(value.event);
+}

package/dist/dis/clockTime.d.ts

@@ -0,0 +1,14 @@
+import type { BinaryReader } from "../binary/BinaryReader.js";
+import type { BinaryWriter } from "../binary/BinaryWriter.js";
+/**
+ * DIS Clock Time record (hour + time past the hour).
+ * Wire: int32 hour, uint32 time-past-hour (big-endian). Shared across many PDUs.
+ */
+export interface ClockTime {
+    /** Whole hours since origin (signed). */
+    hour: number;
+    /** Microseconds (or PDU-specific unit) past the hour (unsigned). */
+    timePastHour: number;
+}
+export declare function decodeClockTime(reader: BinaryReader): ClockTime;
+export declare function encodeClockTime(writer: BinaryWriter, value: ClockTime): void;

package/dist/dis/clockTime.js

@@ -0,0 +1,10 @@
+export function decodeClockTime(reader) {
+    return {
+        hour: reader.readInt32(),
+        timePastHour: reader.readUint32(),
+    };
+}
+export function encodeClockTime(writer, value) {
+    writer.writeInt32(value.hour);
+    writer.writeUint32(value.timePastHour);
+}

package/dist/dis7/constants.d.ts

@@ -0,0 +1,41 @@
+/**
+ * DIS protocol version 7 (IEEE 1278.1-2012 application protocols).
+ * Version is implied by module path; add `dis8/constants.ts` etc. for other editions.
+ */
+export declare const PROTOCOL_VERSION = 7;
+/** Entity Information protocol family. */
+export declare const PROTOCOL_FAMILY_ENTITY_INFORMATION = 1;
+/** Simulation Management protocol family. */
+export declare const PROTOCOL_FAMILY_SIMULATION_MANAGEMENT = 5;
+/** PDU type: Entity State. */
+export declare const PDU_TYPE_ENTITY_STATE = 1;
+/** PDU type: Create Entity. */
+export declare const PDU_TYPE_CREATE_ENTITY = 11;
+/** PDU type: Remove Entity. */
+export declare const PDU_TYPE_REMOVE_ENTITY = 12;
+/** PDU type: Start/Resume. */
+export declare const PDU_TYPE_START_RESUME = 13;
+/** PDU type: Stop/Freeze. */
+export declare const PDU_TYPE_STOP_FREEZE = 14;
+/** PDU type: Electromagnetic Emission. */
+export declare const PDU_TYPE_ELECTROMAGNETIC_EMISSION = 23;
+/** PDU type: Transmitter. */
+export declare const PDU_TYPE_TRANSMITTER = 25;
+/** Electromagnetic Emission protocol family. */
+export declare const PROTOCOL_FAMILY_ELECTROMAGNETIC_EMISSION = 6;
+/** Radio Communications protocol family. */
+export declare const PROTOCOL_FAMILY_RADIO_COMMUNICATIONS = 4;
+/** Start/Resume PDU total length on wire (bytes). */
+export declare const START_RESUME_PDU_LENGTH = 44;
+/** Stop/Freeze PDU total length on wire (bytes). */
+export declare const STOP_FREEZE_PDU_LENGTH = 40;
+/** Create Entity PDU total length on wire (bytes). */
+export declare const CREATE_ENTITY_PDU_LENGTH = 28;
+/** Remove Entity PDU total length on wire (bytes). */
+export declare const REMOVE_ENTITY_PDU_LENGTH = 28;
+/** Entity State PDU fixed portion in bytes (144). Total = 144 + 16*N for N variable parameters. */
+export declare const ENTITY_STATE_PDU_FIXED_LENGTH = 144;
+/** Variable parameter record size in bytes. */
+export declare const ENTITY_STATE_VARIABLE_PARAMETER_RECORD_LENGTH = 16;
+/** Transmitter PDU fixed portion in bytes (104). Total = 104 + M + A + sum of variable record sizes. */
+export declare const TRANSMITTER_PDU_FIXED_LENGTH = 104;