@aircast-one/mavlink 3.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Aircast MAVLink
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,371 @@
+# @aircast-one/mavlink
+
+Type-safe MAVLink library for TypeScript. Parses and serializes MAVLink v1/v2 messages with full type narrowing — no manual casts needed. Works in browsers, Web Workers, and Node.js.
+
+Generated from official [MAVLink XML definitions](https://github.com/mavlink/mavlink/tree/master/message_definitions/v1.0).
+
+## Features
+
+- **Type-safe parsing** — discriminated unions narrow `payload` when you switch on `message_name`
+- **Type-safe serialization** — per-message `serialize` functions with typed payloads
+- **Tree-shakeable** — import only the constants and messages you need
+- **MAVLink v1 & v2** — automatic protocol detection, CRC validation, extension field handling
+- **Browser-first** — designed for Web Workers, no Node.js dependencies at runtime
+- **4 built-in dialects** — Common, ArduPilotMega, Minimal, Standard
+
+## Installation
+
+```bash
+npm install @aircast-one/mavlink
+```
+
+Requires Node.js >= 18.0.0 (uses native `fetch` for code generation).
+
+## Quick Start
+
+### Parsing
+
+```typescript
+import { ArdupilotmegaParser } from '@aircast-one/mavlink/dialects/ardupilotmega/full'
+import type { ArdupilotmegaMessage } from '@aircast-one/mavlink/dialects/ardupilotmega/messages'
+
+const parser = new ArdupilotmegaParser()
+
+// parseBytes handles buffering, frame sync, CRC validation
+const messages = parser.parseBytes(rawBytes) as ArdupilotmegaMessage[]
+
+for (const msg of messages) {
+  switch (msg.message_name) {
+    case 'HEARTBEAT':
+      // payload is auto-narrowed to MessageHeartbeat
+      console.log('Type:', msg.payload.type)
+      console.log('Autopilot:', msg.payload.autopilot)
+      break
+
+    case 'GPS_RAW_INT':
+      // payload is auto-narrowed to MessageGpsRawInt
+      console.log('Lat:', msg.payload.lat / 1e7)
+      console.log('Lon:', msg.payload.lon / 1e7)
+      break
+
+    case 'ATTITUDE':
+      console.log('Roll:', msg.payload.roll)
+      break
+  }
+}
+```
+
+### Serializing (type-safe per-message functions)
+
+Each message has a generated `serialize` function with a fully typed payload:
+
+```typescript
+import { serializeCommandLong } from '@aircast-one/mavlink/dialects/ardupilotmega/messages'
+
+const bytes = serializeCommandLong(
+  {
+    target_system: 1,
+    target_component: 1,
+    command: 400, // MAV_CMD_COMPONENT_ARM_DISARM
+    confirmation: 0,
+    param1: 1, // arm
+    param2: 0,
+    param3: 0,
+    param4: 0,
+    param5: 0,
+    param6: 0,
+    param7: 0,
+  },
+  { system_id: 255, component_id: 190, sequence: 0 }
+)
+```
+
+### Serializing (generic serializer)
+
+For dynamic message names, use the dialect serializer:
+
+```typescript
+import { ArdupilotmegaSerializer } from '@aircast-one/mavlink/dialects/ardupilotmega/full'
+
+const serializer = new ArdupilotmegaSerializer()
+
+const bytes = serializer.serialize(
+  'HEARTBEAT',
+  {
+    type: 6,
+    autopilot: 8,
+    base_mode: 81,
+    custom_mode: 0,
+    system_status: 4,
+    mavlink_version: 3,
+  },
+  { system_id: 255, component_id: 190, sequence: 0 }
+)
+```
+
+### Selective serializer (tree-shakeable)
+
+Register only the messages you send — skip the full dialect bundle:
+
+```typescript
+import { ArdupilotmegaSerializer } from '@aircast-one/mavlink/dialects/ardupilotmega/parser'
+import { CommandLongDefinition } from '@aircast-one/mavlink/dialects/ardupilotmega/messages/command-long'
+import { HeartbeatDefinition } from '@aircast-one/mavlink/dialects/ardupilotmega/messages/heartbeat'
+
+const serializer = new ArdupilotmegaSerializer([CommandLongDefinition, HeartbeatDefinition])
+```
+
+### Constants
+
+Constants are tree-shakeable — import only what you need:
+
+```typescript
+import {
+  MAV_CMD_COMPONENT_ARM_DISARM,
+  MAV_CMD_NAV_TAKEOFF,
+} from '@aircast-one/mavlink/dialects/ardupilotmega/constants/mav-cmd'
+
+import type { MAV_CMD } from '@aircast-one/mavlink/dialects/ardupilotmega/constants/mav-cmd'
+```
+
+### Web Worker
+
+```typescript
+// worker.ts
+import { ArdupilotmegaParser } from '@aircast-one/mavlink/dialects/ardupilotmega/full'
+import type { ArdupilotmegaMessage } from '@aircast-one/mavlink/dialects/ardupilotmega/messages'
+
+const parser = new ArdupilotmegaParser()
+
+self.onmessage = (event) => {
+  const messages = parser.parseBytes(event.data) as ArdupilotmegaMessage[]
+
+  for (const msg of messages) {
+    self.postMessage(msg)
+  }
+}
+```
+
+## Available Dialects
+
+| Dialect       | Parser                | Serializer                | Messages               |
+| ------------- | --------------------- | ------------------------- | ---------------------- |
+| Common        | `CommonParser`        | `CommonSerializer`        | `CommonMessage`        |
+| ArduPilotMega | `ArdupilotmegaParser` | `ArdupilotmegaSerializer` | `ArdupilotmegaMessage` |
+| Minimal       | `MinimalParser`       | `MinimalSerializer`       | `MinimalMessage`       |
+| Standard      | `StandardParser`      | `StandardSerializer`      | `StandardMessage`      |
+
+All are imported from `@aircast-one/mavlink/dialects/<dialect>/full`.
+
+## API Reference
+
+### Parser
+
+```typescript
+class DialectParser {
+  parseBytes(data: Uint8Array): ParsedMAVLinkMessage[]
+  decode(frame: MAVLinkFrame): ParsedMAVLinkMessage
+  resetBuffer(): void
+  getDialectName(): string
+}
+```
+
+`parseBytes` handles buffering, frame synchronization, protocol detection (v1/v2), CRC validation, and payload decoding. Feed it raw bytes from any transport — WebSocket, WebRTC data channel, TCP, serial — and get back fully decoded messages.
+
+### Serializer
+
+```typescript
+class DialectSerializer {
+  constructor(definitions?: MessageDefinition[])
+  serialize(
+    messageName: string,
+    payload: Record<string, unknown>,
+    options: SerializeOptions
+  ): Uint8Array
+}
+
+interface SerializeOptions {
+  system_id: number
+  component_id: number
+  sequence: number
+  protocol_version?: 1 | 2 // auto-detected from message ID if omitted
+}
+```
+
+Pass specific `MessageDefinition` arrays to the constructor for selective registration (smaller bundles). Omit to use all definitions registered by the `/full` import.
+
+### Per-Message Serialize Functions
+
+Each message module exports a type-safe serialize function:
+
+```typescript
+function serializeHeartbeat(payload: MessageHeartbeat, options: SerializeOptions): Uint8Array
+function serializeCommandLong(payload: MessageCommandLong, options: SerializeOptions): Uint8Array
+// ... one per message in the dialect
+```
+
+Import from `@aircast-one/mavlink/dialects/<dialect>/messages`.
+
+### Generated Types
+
+```typescript
+// Discriminated union — TypeScript narrows payload via message_name
+type ArdupilotmegaMessage =
+  | { message_name: 'HEARTBEAT'; payload: MessageHeartbeat; /* ...base fields */ }
+  | { message_name: 'GPS_RAW_INT'; payload: MessageGpsRawInt; /* ...base fields */ }
+  | { message_name: 'ATTITUDE'; payload: MessageAttitude; /* ...base fields */ }
+  // ... all messages in dialect
+
+// Message name literal union — for autocomplete and exhaustive checks
+type ArdupilotmegaMessageName = 'HEARTBEAT' | 'GPS_RAW_INT' | 'ATTITUDE' | ...;
+
+// Lookup map — get payload type from message name
+interface MessageTypeMap {
+  HEARTBEAT: MessageHeartbeat;
+  GPS_RAW_INT: MessageGpsRawInt;
+  // ...
+}
+```
+
+### ParsedMAVLinkMessage (base type)
+
+```typescript
+interface ParsedMAVLinkMessage {
+  timestamp: number
+  system_id: number
+  component_id: number
+  message_id: number
+  message_name: string
+  sequence: number
+  payload: Record<string, unknown>
+  protocol_version: 1 | 2
+  checksum: number
+  crc_ok: boolean
+  signature?: Uint8Array
+  dialect?: string
+}
+```
+
+Cast to the dialect's message type for full type narrowing:
+
+```typescript
+const messages = parser.parseBytes(data) as ArdupilotmegaMessage[]
+```
+
+## Import Patterns
+
+```
+@aircast-one/mavlink/
+├── core/types                           # ParsedMAVLinkMessage, SerializeOptions, etc.
+├── dialects/<dialect>/full              # Parser + Serializer (all messages registered)
+├── dialects/<dialect>/parser            # Parser + Serializer classes (register manually)
+├── dialects/<dialect>/messages          # All message types + serialize functions + unions
+└── dialects/<dialect>/constants/<enum>  # Individual enum constants (tree-shakeable)
+```
+
+## Code Generation
+
+Generate TypeScript types from any MAVLink XML dialect:
+
+```bash
+# From URL
+bun src/cli.ts generate \
+  -i https://raw.githubusercontent.com/mavlink/mavlink/master/message_definitions/v1.0/common.xml \
+  -o ./src/generated/dialects/common
+
+# From local file
+bun src/cli.ts generate -i ./my-dialect.xml -o ./types
+
+# Batch generate multiple dialects
+bun src/cli.ts batch -d "common,minimal,ardupilotmega" -o ./mavlink-types
+
+# List available upstream dialects
+bun src/cli.ts list
+```
+
+### CLI Options
+
+| Command    | Flag               | Description                                   |
+| ---------- | ------------------ | --------------------------------------------- |
+| `generate` | `-i <path>`        | Input XML file or URL (required)              |
+|            | `-o <path>`        | Output directory (default: `./types`)         |
+|            | `-n <name>`        | Dialect name (auto-detected from filename)    |
+|            | `-f <format>`      | `single` or `separate` (default: `separate`)  |
+|            | `--no-enums`       | Skip enum generation                          |
+|            | `--no-type-guards` | Skip type guard generation                    |
+| `batch`    | `-o <path>`        | Output directory (default: `./mavlink-types`) |
+|            | `-d <dialects>`    | Comma-separated dialect names                 |
+|            | `--package`        | Generate `package.json` and `tsconfig.json`   |
+
+### Programmatic Usage
+
+```typescript
+import { generateTypesFromXML } from '@aircast-one/mavlink'
+
+const files = await generateTypesFromXML(xmlContent, {
+  dialectName: 'my-dialect',
+  outputFormat: 'separate',
+  includeEnums: true,
+  includeTypeGuards: true,
+})
+// files: { 'types.ts': '...', 'parser.ts': '...', ... }
+```
+
+## Architecture
+
+```
+XML Dialect Definition
+        │
+        ▼
+   Code Generator ──► Per-message modules (definition + interface + serialize fn)
+        │              Per-constant modules (type union + const values)
+        │              Parser class (extends DialectParser)
+        │              Serializer class (standalone, lazy registration)
+        │              Discriminated union type
+        │              Message name literal union
+        ▼
+  Runtime (browser/Node.js)
+        │
+   ┌────┴────┐
+   │ Parser  │  Raw bytes → ParsedMAVLinkMessage[]
+   │         │  - StreamBuffer handles partial frames
+   │         │  - Frame parser detects v1/v2 magic bytes
+   │         │  - CRC validation with computed CRC_EXTRA
+   │         │  - Payload decoding with wire-order field sorting
+   └─────────┘
+   ┌─────────┐
+   │Serializer│  Message name + payload + options → Uint8Array
+   │         │  - Encodes payload with field defaults
+   │         │  - Creates v1/v2 frame with CRC
+   │         │  - Protocol version auto-detected from message ID
+   └─────────┘
+```
+
+## Limitations
+
+- **MAVLink v2 signing** — the parser reads v2 signatures but does not validate them. The serializer does not create signed frames. Use transport-layer encryption (DTLS/TLS) for security.
+- **CRC_EXTRA** — computed from XML definitions at generation time. Custom dialects must be generated with the CLI to get correct CRC values.
+- **Pinned MAVLink version** — built-in dialects are generated from a pinned upstream commit (`mavlinkCommit` in package.json). Update the commit SHA and regenerate to pick up new messages.
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Generate dialects from MAVLink XML
+npm run generate
+
+# Build the package
+npm run build
+
+# Run tests
+npm test
+
+# Type-check
+npm run typecheck
+```
+
+## License
+
+MIT

package/dist/core/codec.d.ts

@@ -0,0 +1,55 @@
+import { FieldDefinition, FieldValue, DecodedValue, PayloadObject } from './types';
+/**
+ * Get the size of a single MAVLink type in bytes
+ */
+export declare function getTypeSize(type: string): number;
+/**
+ * Get the base type from a field type (strips array notation)
+ */
+export declare function getBaseType(type: string): string;
+/**
+ * Get the total size of a field in bytes
+ */
+export declare function getFieldSize(field: FieldDefinition): number;
+/**
+ * Get the element type size for wire order sorting
+ * Arrays are sorted by element type, not total array size
+ */
+export declare function getFieldTypeSize(field: FieldDefinition): number;
+/**
+ * Sort fields by MAVLink v2 wire order
+ * Core fields sorted by type size (largest first), extension fields last in XML order
+ */
+export declare function sortFieldsByWireOrder(fields: FieldDefinition[]): FieldDefinition[];
+/**
+ * Get default value for a MAVLink type
+ */
+export declare function getDefaultValue(type: string): number | bigint;
+/**
+ * Get default value for a field
+ */
+export declare function getFieldDefaultValue(field: FieldDefinition): FieldValue;
+/**
+ * Decode a single value from a DataView
+ */
+export declare function decodeSingleValue(view: DataView, offset: number, type: string): DecodedValue;
+/**
+ * Decode a field from a DataView
+ */
+export declare function decodeField(view: DataView, offset: number, field: FieldDefinition): DecodedValue;
+/**
+ * Decode a payload buffer into an object
+ */
+export declare function decodePayload(payload: Uint8Array, fields: FieldDefinition[]): PayloadObject;
+/**
+ * Encode a single value to a DataView
+ */
+export declare function encodeSingleValue(view: DataView, offset: number, type: string, value: unknown): number;
+/**
+ * Encode a field to a DataView
+ */
+export declare function encodeField(view: DataView, offset: number, field: FieldDefinition, value: unknown): number;
+/**
+ * Encode a payload object to bytes with MAVLink payload trimming
+ */
+export declare function encodePayload(message: Record<string, unknown>, fields: FieldDefinition[]): Uint8Array;

package/dist/core/crc.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Initial CRC value for X.25 algorithm
+ */
+export declare const X25_INIT_CRC = 65535;
+/**
+ * MAVLink CRC calculator using X.25 (MCRF4XX) algorithm
+ */
+export declare class MAVLinkCRC {
+    /**
+     * Calculate CRC for MAVLink message data with CRC_EXTRA seed
+     * @param data Message bytes (header + payload, excluding magic and checksum)
+     * @param crcExtra CRC_EXTRA byte for the message type
+     * @returns 16-bit CRC checksum
+     */
+    static calculate(data: Uint8Array, crcExtra: number): number;
+    /**
+     * Validate a received MAVLink checksum
+     * @param data Message bytes (header + payload, excluding magic and checksum)
+     * @param crcExtra CRC_EXTRA byte for the message type
+     * @param receivedChecksum The checksum from the received message
+     * @returns true if checksum matches
+     */
+    static validate(data: Uint8Array, crcExtra: number, receivedChecksum: number): boolean;
+    /**
+     * Validate using CRC_EXTRA lookup table
+     * @param data Message bytes
+     * @param messageId Message ID to look up CRC_EXTRA
+     * @param receivedChecksum The received checksum
+     * @param crcExtraTable CRC_EXTRA lookup table for the dialect
+     * @returns true if checksum matches, false if invalid or unknown message
+     */
+    static validateWithTable(data: Uint8Array, messageId: number, receivedChecksum: number, crcExtraTable: Record<number, number>): boolean;
+}

package/dist/core/frame.d.ts

@@ -0,0 +1,39 @@
+import { MAVLinkFrame } from './types';
+/**
+ * MAVLink protocol magic bytes
+ */
+export declare const MAVLINK_V1_MAGIC = 254;
+export declare const MAVLINK_V2_MAGIC = 253;
+/**
+ * Minimum frame sizes
+ */
+export declare const MAVLINK_V1_HEADER_SIZE = 6;
+export declare const MAVLINK_V2_HEADER_SIZE = 10;
+export declare const MAVLINK_CHECKSUM_SIZE = 2;
+export declare const MAVLINK_SIGNATURE_SIZE = 13;
+/**
+ * Result of attempting to parse a frame
+ */
+export interface FrameParseResult {
+    frame?: MAVLinkFrame;
+    bytesConsumed: number;
+}
+/**
+ * Parse a single MAVLink frame from a byte buffer
+ * @param data Raw bytes to parse
+ * @param crcExtraTable CRC_EXTRA lookup table for checksum validation
+ * @returns Frame if found, plus number of bytes consumed
+ */
+export declare function parseFrame(data: Uint8Array, crcExtraTable: Record<number, number>): FrameParseResult;
+/**
+ * Create a MAVLink v1 or v2 frame from message data
+ * @param messageId Message ID
+ * @param payload Serialized payload bytes
+ * @param systemId System ID (default: 1)
+ * @param componentId Component ID (default: 1)
+ * @param sequence Sequence number (default: 0)
+ * @param crcExtra CRC_EXTRA for this message type
+ * @param protocolVersion Protocol version (1 or 2, auto-detected if not specified)
+ * @returns Complete MAVLink frame as bytes
+ */
+export declare function createFrame(messageId: number, payload: Uint8Array, systemId: number, componentId: number, sequence: number, crcExtra: number, protocolVersion?: 1 | 2): Uint8Array;

package/dist/core/index.d.ts

@@ -0,0 +1,8 @@
+export * from './types';
+export * from './crc';
+export * from './codec';
+export * from './frame';
+export * from './parser';
+export * from './stream-buffer';
+export * from './message-registry';
+export * from './message-serializer';

package/dist/core/message-registry.d.ts

@@ -0,0 +1,15 @@
+import { MessageDefinition } from './types';
+/**
+ * Registry for MAVLink message definitions.
+ * Provides O(1) lookup by both ID and name.
+ */
+export declare class MessageRegistry {
+    private definitionsById;
+    private definitionsByName;
+    register(def: MessageDefinition): void;
+    getCrcExtraTable(): Record<number, number>;
+    getMessageDefinition(id: number): MessageDefinition | undefined;
+    getMessageDefinitionByName(name: string): MessageDefinition | undefined;
+    supportsMessage(messageId: number): boolean;
+    getSupportedMessageIds(): number[];
+}

package/dist/core/message-serializer.d.ts

@@ -0,0 +1,12 @@
+import { MessageDefinition, SerializeOptions } from './types';
+/**
+ * Serializes MAVLink messages to bytes.
+ * Standalone — does not require a parser instance.
+ */
+export declare class MessageSerializer {
+    private readonly registry;
+    constructor();
+    registerDefinition(def: MessageDefinition): void;
+    serialize(messageName: string, payload: Record<string, unknown>, options: SerializeOptions): Uint8Array;
+    private completeWithDefaults;
+}

package/dist/core/parser.d.ts

@@ -0,0 +1,17 @@
+import { ParsedMAVLinkMessage, MAVLinkFrame, MessageDefinition } from './types';
+import { MessageRegistry } from './message-registry';
+/**
+ * Base class for dialect-specific parsers.
+ * Handles frame parsing, buffering, and payload decoding.
+ */
+export declare class DialectParser {
+    protected readonly registry: MessageRegistry;
+    protected readonly dialectName: string;
+    private readonly streamBuffer;
+    constructor(dialectName: string);
+    protected registerMessageDefinition(def: MessageDefinition): void;
+    parseBytes(data: Uint8Array): ParsedMAVLinkMessage[];
+    decode(frame: MAVLinkFrame): ParsedMAVLinkMessage;
+    resetBuffer(): void;
+    getDialectName(): string;
+}

package/dist/core/stream-buffer.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Ring buffer implementation for efficient byte stream processing.
+ * Avoids repeated array allocations by reusing a fixed buffer.
+ */
+export declare class StreamBuffer {
+    private buffer;
+    private bufferStart;
+    private bufferEnd;
+    constructor(initialSize?: number);
+    /**
+     * Append data to the buffer, growing if necessary
+     */
+    append(data: Uint8Array): void;
+    /**
+     * Get current buffer contents as a view
+     */
+    getContents(): Uint8Array;
+    /**
+     * Consume bytes from the start of the buffer
+     */
+    consume(bytes: number): void;
+    /**
+     * Clear the buffer
+     */
+    reset(): void;
+    /**
+     * Get current buffer length
+     */
+    get length(): number;
+}

package/dist/core/types.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Base fields present on all parsed MAVLink messages.
+ * Dialect-specific parsers extend this with a discriminated union
+ * that narrows message_name and payload together.
+ */
+export interface ParsedMAVLinkMessage {
+    timestamp: number;
+    system_id: number;
+    component_id: number;
+    message_id: number;
+    message_name: string;
+    sequence: number;
+    payload: Record<string, unknown>;
+    protocol_version: 1 | 2;
+    checksum: number;
+    crc_ok: boolean;
+    signature?: Uint8Array;
+    dialect?: string;
+}
+/**
+ * A raw MAVLink frame before payload decoding
+ */
+export interface MAVLinkFrame {
+    magic: number;
+    length: number;
+    incompatible_flags?: number;
+    compatible_flags?: number;
+    sequence: number;
+    system_id: number;
+    component_id: number;
+    message_id: number;
+    payload: Uint8Array;
+    checksum: number;
+    signature?: Uint8Array;
+    crc_ok?: boolean;
+    protocol_version?: 1 | 2;
+}
+/**
+ * Definition of a single field within a message
+ */
+export interface FieldDefinition {
+    name: string;
+    type: string;
+    arrayLength?: number;
+    extension?: boolean;
+}
+/**
+ * Definition of a complete MAVLink message
+ */
+export interface MessageDefinition {
+    id: number;
+    name: string;
+    crcExtra: number;
+    fields: FieldDefinition[];
+}
+/**
+ * Value types that can be encoded/decoded in MAVLink fields
+ */
+export type FieldValue = string | number | bigint | boolean | Array<string | number | bigint | boolean>;
+/**
+ * A decoded payload object
+ */
+export type PayloadObject = Record<string, FieldValue>;
+/**
+ * Result of decoding a single field value
+ */
+export type DecodedValue = {
+    value: FieldValue;
+    bytesRead: number;
+};
+/**
+ * Options for serializing a MAVLink message
+ */
+export interface SerializeOptions {
+    system_id: number;
+    component_id: number;
+    sequence: number;
+    protocol_version?: 1 | 2;
+}