@netkitty/codec 1.0.0

package/dist/headers/RTPS.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RTPS = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const HexToBuffer_1 = require("../helper/HexToBuffer");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+/**
+ * RTPS — the OMG DDSI-RTPS wire protocol (Real-Time Publish-Subscribe) that carries DDS traffic for
+ * industrial IoT / robotics. It rides UDP on dynamically negotiated ports (the well-known 7400-range
+ * discovery ports are only defaults), so selection is by content signature, not port: every RTPS
+ * message opens with a 20-byte header — the 4-byte magic 'RTPS' (0x52545053), a 2-byte protocol
+ * version, a 2-byte vendorId, and a 12-byte guidPrefix — followed by a sequence of submessages.
+ *
+ * Each submessage is a 4-byte submessage header — submessageId(1), flags(1), submessageLength(2) —
+ * then `submessageLength` body octets. The single most important quirk: the low bit of the flags octet
+ * is the EndiannessFlag, and it governs the byte order of THAT submessage's submessageLength field
+ * (little-endian when set, big-endian when clear). A submessageLength of 0 is legal for the final
+ * submessage and means "the rest of the message"; it is honored verbatim so the frame round-trips.
+ *
+ * The submessage bodies (DATA's serialized payload, ACKNACK bitmaps, INFO_TS timestamps, …) are cross-
+ * message, QoS- and type-dependent state, so they are kept verbatim as hex (byte-perfect) rather than
+ * sub-decoded. The whole message is bounded by the UDP payload (the parent UDP Length when present),
+ * and every submessageLength is honored on encode (a crafted message may lie), else derived from the
+ * body. A well-formed message round-trips byte-for-byte.
+ */
+class RTPS extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'rtps';
+        this.name = 'Real-Time Publish-Subscribe Wire Protocol';
+        this.nickname = 'RTPS';
+        //No demux keys: RTPS uses dynamically negotiated UDP ports, so it is a content-heuristic child
+        //recognized by its 'RTPS' magic rather than a well-known port.
+        this.matchKeys = [];
+        this.heuristicFallback = true;
+        //A leaf header — submessage bodies are QoS/type-dependent and kept verbatim, decoded later.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (RTPS.#schemaCache ??= RTPS.#buildSchema());
+    }
+    /** The EndiannessFlag is the low bit of the flags octet: set → little-endian submessage header. */
+    static #isLittleEndian(flags) {
+        return (flags & 0x01) === 0x01;
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'RTPS v${protocolVersion} vendor=${vendorId}',
+            properties: {
+                //The 4-byte magic 'RTPS' (0x52545053). Kept verbatim so any variant round-trips; it is
+                //also the content signature match() gates on.
+                magic: this.fieldHex('magic', 0, 4, 'Magic'),
+                //Protocol version (major.minor), e.g. 0x0201 = RTPS 2.1. Two opaque octets.
+                protocolVersion: this.fieldHex('protocolVersion', 4, 2, 'Protocol Version'),
+                //Vendor ID (OMG-assigned), e.g. 0x0101 = RTI Connext. Two opaque octets.
+                vendorId: this.fieldHex('vendorId', 6, 2, 'Vendor ID'),
+                //The 12-byte GUID prefix identifying the participant that sent this message.
+                guidPrefix: this.fieldHex('guidPrefix', 8, 12, 'GUID Prefix'),
+                //The submessage sequence after the 20-byte header. Each is a 4-byte submessage header
+                //(id/flags/length) plus a verbatim body. Bounded by BOTH the declared submessageLength
+                //AND the bytes actually present (the UDP payload), so a lying length cannot spawn phantom
+                //submessages past the end of the buffer, and the loop always advances by at least 4.
+                submessages: {
+                    type: 'array',
+                    label: 'Submessages',
+                    items: {
+                        type: 'object',
+                        label: 'Submessage',
+                        properties: {
+                            submessageId: {
+                                type: 'integer',
+                                label: 'Submessage ID',
+                                minimum: 0,
+                                maximum: 255
+                            },
+                            flags: {
+                                type: 'integer',
+                                label: 'Flags',
+                                minimum: 0,
+                                maximum: 255
+                            },
+                            submessageLength: {
+                                type: 'integer',
+                                label: 'Submessage Length',
+                                minimum: 0,
+                                maximum: 65535
+                            },
+                            body: {
+                                type: 'string',
+                                label: 'Body',
+                                contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX
+                            }
+                        }
+                    },
+                    decode: function () {
+                        //Cap the submessage walk at the UDP payload end so trailing frame padding / a
+                        //pipelined datagram is never absorbed. The parent UDP Length spans the 8-byte UDP
+                        //header + payload, so the RTPS payload is (Length − 8) bytes; else fall back to the
+                        //captured bytes.
+                        let cap = this.packet.length - this.startPos;
+                        if (this.prevCodecModule && this.prevCodecModule.id === 'udp') {
+                            const payload = this.prevCodecModule.instance.length.getValue(0) - 8;
+                            if (payload >= 0 && payload < cap)
+                                cap = payload;
+                        }
+                        const submessages = [];
+                        let offset = 20;
+                        while (offset + 4 <= cap) {
+                            const submessageId = this.readBytes(offset, 1)[0];
+                            const flags = this.readBytes(offset + 1, 1)[0];
+                            const lengthBytes = this.readBytes(offset + 2, 2);
+                            const submessageLength = RTPS.#isLittleEndian(flags)
+                                ? (lengthBytes[0] | (lengthBytes[1] << 8))
+                                : ((lengthBytes[0] << 8) | lengthBytes[1]);
+                            offset += 4;
+                            //A submessageLength of 0 means "the rest of the message" (only legal on the
+                            //last submessage). Otherwise the body is `submessageLength` bytes, clamped to
+                            //the bytes actually present so a lying length cannot read past the buffer.
+                            let bodyLength = submessageLength === 0 ? cap - offset : submessageLength;
+                            if (bodyLength > cap - offset)
+                                bodyLength = cap - offset;
+                            if (bodyLength < 0)
+                                bodyLength = 0;
+                            const body = bodyLength ? this.readBytes(offset, bodyLength) : Buffer.alloc(0);
+                            offset += bodyLength;
+                            submessages.push({
+                                submessageId: submessageId,
+                                flags: flags,
+                                submessageLength: submessageLength,
+                                body: (0, BufferToHex_1.BufferToHex)(body)
+                            });
+                        }
+                        this.instance.submessages.setValue(submessages);
+                    },
+                    encode: function () {
+                        const submessages = this.instance.submessages.getValue();
+                        if (!submessages)
+                            return;
+                        let offset = 20;
+                        submessages.forEach((submessage) => {
+                            const submessageId = submessage.submessageId ? submessage.submessageId : 0;
+                            const flags = submessage.flags ? submessage.flags : 0;
+                            const body = (0, HexToBuffer_1.HexToBuffer)(submessage.body ? submessage.body : '');
+                            //Honor an explicitly supplied submessageLength verbatim (a number, including a
+                            //legal 0 = "rest of message"); derive from the body length only when absent.
+                            const provided = submessage.submessageLength;
+                            let submessageLength = (provided !== undefined && provided !== null) ? provided : body.length;
+                            if (submessageLength > 65535)
+                                submessageLength = 65535;
+                            if (submessageLength < 0)
+                                submessageLength = 0;
+                            this.writeBytes(offset, Buffer.from([submessageId & 0xff, flags & 0xff]));
+                            //submessageLength byte order follows this submessage's EndiannessFlag (flags bit 0).
+                            const lengthBytes = RTPS.#isLittleEndian(flags)
+                                ? Buffer.from([submessageLength & 0xff, (submessageLength >> 8) & 0xff])
+                                : Buffer.from([(submessageLength >> 8) & 0xff, submessageLength & 0xff]);
+                            this.writeBytes(offset + 2, lengthBytes);
+                            offset += 4;
+                            if (body.length) {
+                                this.writeBytes(offset, body);
+                                offset += body.length;
+                            }
+                        });
+                    }
+                }
+            }
+        };
+    }
+    match() {
+        //RTPS rides UDP on dynamic ports; require the parent to be UDP, the full 20-byte header to be
+        //present, and the 4-byte magic 'RTPS' (0x52545053) — a strong, distinctive content signature.
+        if (!this.prevCodecModule || this.prevCodecModule.id !== 'udp')
+            return false;
+        if (this.packet.length - this.startPos < 20)
+            return false;
+        return (0, BufferToHex_1.BufferToHex)(this.readBytes(0, 4, true)) === '52545053';
+    }
+}
+exports.RTPS = RTPS;

package/dist/headers/RTSP.d.ts

@@ -0,0 +1,36 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * RTSP — the Real Time Streaming Protocol (RFC 2326, obsoleted by RFC 7826), the control channel for
+ * streaming media ("network remote control" for A/V servers) carried as US-ASCII text over TCP port
+ * 554. RTSP borrows HTTP's syntax almost verbatim: a message is a start-line, then header lines, a
+ * CRLF, and an optional body (e.g. an SDP description for a DESCRIBE response). The start-line is either
+ * a Request-Line (`METHOD SP Request-URI SP RTSP-Version CRLF`) or a Status-Line (`RTSP-Version SP
+ * Status-Code SP Reason-Phrase CRLF`). The only visible difference from HTTP is the version token
+ * (`RTSP/1.0` instead of `HTTP/1.1`) and RTSP's own method set (DESCRIBE, SETUP, PLAY, …).
+ *
+ * Like HTTP and SIP, the message body is text whose full internal structure (arbitrary header fields, a
+ * body of any content-type, significant whitespace/header ordering/casing) is far richer than a form
+ * needs. So the ENTIRE raw message is kept verbatim as the authoritative `message` field (hex) and
+ * re-emitted untouched; only the start-line (plus the RTSP-specific CSeq sequence number) is parsed on
+ * decode into display-only metadata (method/uri/version or status-code/reason, and cseq). Encode never
+ * reconstructs the message from the parsed fields — it writes `message` back byte-for-byte — so any
+ * conformant (or even malformed) RTSP message round-trips exactly.
+ *
+ * Note: RTSP bodies (SDP, etc.) can span multiple TCP segments and RTSP can also interleave binary RTP
+ * over the same TCP connection ($-framed); reassembly/interleaving across segments is out of scope.
+ * This single-segment codec keeps whatever bytes are present in the current segment verbatim, which is
+ * byte-perfect for the single-packet case.
+ */
+export declare class RTSP extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    readonly heuristicFallback: boolean;
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}

package/dist/headers/RTSP.js

@@ -0,0 +1,184 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RTSP = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const BufferToHex_1 = require("../helper/BufferToHex");
+const HexToBuffer_1 = require("../helper/HexToBuffer");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+/** RTSP request methods (RFC 2326 / RFC 7826) used only to recognize a request start-line. */
+const RTSP_METHODS = ['DESCRIBE', 'ANNOUNCE', 'GET_PARAMETER', 'OPTIONS', 'PAUSE', 'PLAY', 'RECORD', 'REDIRECT', 'SETUP', 'SET_PARAMETER', 'TEARDOWN'];
+/**
+ * RTSP — the Real Time Streaming Protocol (RFC 2326, obsoleted by RFC 7826), the control channel for
+ * streaming media ("network remote control" for A/V servers) carried as US-ASCII text over TCP port
+ * 554. RTSP borrows HTTP's syntax almost verbatim: a message is a start-line, then header lines, a
+ * CRLF, and an optional body (e.g. an SDP description for a DESCRIBE response). The start-line is either
+ * a Request-Line (`METHOD SP Request-URI SP RTSP-Version CRLF`) or a Status-Line (`RTSP-Version SP
+ * Status-Code SP Reason-Phrase CRLF`). The only visible difference from HTTP is the version token
+ * (`RTSP/1.0` instead of `HTTP/1.1`) and RTSP's own method set (DESCRIBE, SETUP, PLAY, …).
+ *
+ * Like HTTP and SIP, the message body is text whose full internal structure (arbitrary header fields, a
+ * body of any content-type, significant whitespace/header ordering/casing) is far richer than a form
+ * needs. So the ENTIRE raw message is kept verbatim as the authoritative `message` field (hex) and
+ * re-emitted untouched; only the start-line (plus the RTSP-specific CSeq sequence number) is parsed on
+ * decode into display-only metadata (method/uri/version or status-code/reason, and cseq). Encode never
+ * reconstructs the message from the parsed fields — it writes `message` back byte-for-byte — so any
+ * conformant (or even malformed) RTSP message round-trips exactly.
+ *
+ * Note: RTSP bodies (SDP, etc.) can span multiple TCP segments and RTSP can also interleave binary RTP
+ * over the same TCP connection ($-framed); reassembly/interleaving across segments is out of scope.
+ * This single-segment codec keeps whatever bytes are present in the current segment verbatim, which is
+ * byte-perfect for the single-packet case.
+ */
+class RTSP extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.id = 'rtsp';
+        this.name = 'Real Time Streaming Protocol';
+        this.nickname = 'RTSP';
+        //The well-known port gives O(1) bucket dispatch, but RTSP (like HTTP) can run on arbitrary ports
+        //(8554 is common for test servers). heuristicFallback lets a non-listed port still be recognized by
+        //the start-line signature in match() below — the port is a fast path, not a whitelist. The signature
+        //is specific enough (a known method + space, or "RTSP/") that this does not claim arbitrary TCP
+        //traffic. See the HTTP header for the same rationale.
+        this.matchKeys = ['tcpport:554'];
+        this.heuristicFallback = true;
+        //A leaf header — the RTSP body (SDP, etc.) and the media session it controls are a higher-layer concern.
+        this.demuxProducers = [];
+    }
+    static #schemaCache;
+    get SCHEMA() {
+        return (_a.#schemaCache ??= _a.#buildSchema());
+    }
+    /**
+     * Bytes of this header: RTSP rides on TCP, which has no per-message length, so take the rest of the
+     * segment. Body reassembly across segments is out of scope (see class doc).
+     */
+    #payloadLength() {
+        const available = this.packet.length - this.startPos;
+        return available < 0 ? 0 : available;
+    }
+    /** The first line of the message (up to the first CRLF, or the whole payload if none). */
+    static #firstLine(text) {
+        const idx = text.indexOf('\r\n');
+        return idx >= 0 ? text.slice(0, idx) : text;
+    }
+    /**
+     * The RTSP CSeq (sequence number): every RTSP request/response carries exactly one `CSeq:` header
+     * pairing a response to its request. Scan the header lines for it (case-insensitive) and return the
+     * first integer found, or 0 when absent/non-numeric. Display-only, like SIP's CSeq.
+     */
+    static #parseCSeq(text) {
+        for (const line of text.split('\r\n')) {
+            const match = line.match(/^CSeq\s*:\s*(\d+)/i);
+            if (match)
+                return Number(match[1]);
+        }
+        return 0;
+    }
+    /**
+     * Parse the start-line into the display-only metadata fields. A Status-Line begins with the
+     * RTSP-Version ("RTSP/1.0"); anything else is treated as a Request-Line. Populated on decode only —
+     * these fields have no encode, so they never affect the re-emitted bytes and never mutate `message`.
+     * Never throws: a non-numeric status yields 0, missing tokens yield empty strings.
+     */
+    #parseStartLine(text) {
+        this.instance.cseq.setValue(_a.#parseCSeq(text));
+        const line = _a.#firstLine(text);
+        if (line.startsWith('RTSP/')) {
+            //Status-Line: RTSP-Version SP Status-Code SP Reason-Phrase
+            const match = line.match(/^(\S+)\s+(\d{3})\s*(.*)$/);
+            this.instance.isRequest.setValue(false);
+            this.instance.method.setValue('');
+            this.instance.requestUri.setValue('');
+            this.instance.version.setValue(match ? match[1] : (line.split(' ')[0] || ''));
+            this.instance.statusCode.setValue(match ? Number(match[2]) : 0);
+            this.instance.reasonPhrase.setValue(match ? match[3] : '');
+            return;
+        }
+        //Request-Line: METHOD SP Request-URI SP RTSP-Version
+        const parts = line.split(' ');
+        this.instance.isRequest.setValue(true);
+        this.instance.method.setValue(parts[0] ? parts[0] : '');
+        this.instance.requestUri.setValue(parts.length > 1 ? parts[1] : '');
+        //The RTSP-Version is the last whitespace-delimited token; the Request-URI itself has no spaces.
+        this.instance.version.setValue(parts.length > 2 ? parts[parts.length - 1] : '');
+        this.instance.statusCode.setValue(0);
+        this.instance.reasonPhrase.setValue('');
+    }
+    static #buildSchema() {
+        return {
+            type: 'object',
+            summary: 'RTSP ${method}${statusCode}',
+            properties: {
+                //The whole raw message is the single source of truth: decoded verbatim to hex and
+                //re-emitted untouched (byte-perfect for any RTSP message). The start-line + CSeq are
+                //parsed into the display-only metadata below, which carry no codec of their own.
+                message: {
+                    type: 'string',
+                    label: 'Message',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: function () {
+                        const available = this.#payloadLength();
+                        if (available <= 0) {
+                            this.instance.message.setValue('');
+                            this.#parseStartLine('');
+                            return;
+                        }
+                        const raw = this.readBytes(0, available);
+                        this.instance.message.setValue((0, BufferToHex_1.BufferToHex)(raw));
+                        this.#parseStartLine(raw.toString('latin1'));
+                    },
+                    encode: function () {
+                        //Re-emit the authoritative message verbatim — never reconstruct from metadata.
+                        this.writeBytes(0, (0, HexToBuffer_1.HexToBuffer)(this.instance.message.getValue('')));
+                    }
+                },
+                //Display-only metadata parsed from the start-line on decode (no encode — populated by the
+                //message field above, never read back). isRequest distinguishes a Request-Line from a
+                //Status-Line; method/requestUri are for requests, statusCode/reasonPhrase for responses;
+                //cseq is RTSP's request/response sequence number (one per message).
+                isRequest: { type: 'boolean', label: 'Is Request' },
+                method: { type: 'string', label: 'Method' },
+                requestUri: { type: 'string', label: 'Request URI' },
+                version: { type: 'string', label: 'Version' },
+                statusCode: { type: 'integer', label: 'Status Code', minimum: 0, maximum: 999 },
+                reasonPhrase: { type: 'string', label: 'Reason Phrase' },
+                cseq: { type: 'integer', label: 'CSeq', minimum: 0 }
+            }
+        };
+    }
+    match() {
+        //RTSP rides on TCP as US-ASCII text. Recognize it by the start-line signature: a known request
+        //method followed by a space (the trailing space rejects e.g. "PLAYX"), or the "RTSP/" response
+        //version — so non-RTSP traffic on this port falls through to raw rather than claiming an
+        //un-decodable text layer.
+        //
+        //RTSP and HTTP both set heuristicFallback and both are text start-line protocols, so their
+        //signatures must stay disjoint: RTSP checks "RTSP/" and the RTSP method set, HTTP checks "HTTP/1."
+        //and the HTTP method set. DESCRIBE/SETUP/PLAY/… are not HTTP methods and "RTSP/" is not "HTTP/1.",
+        //so neither claims the other's traffic. The one overlap is OPTIONS, which is a method in BOTH
+        //sets: an "OPTIONS <uri> ..." line could be claimed by either at match() time. This is resolved by
+        //port bucket on the well-known port (554 → RTSP, 80 → HTTP wins its own bucket) and, on an
+        //arbitrary port reached via the heuristic chain, by registration order (first-registered wins).
+        //The ambiguity is cosmetic only: both headers keep the message verbatim byte-perfect regardless of
+        //which claims the OPTIONS line, so the round-trip bytes are identical either way; only the
+        //displayed protocol nickname differs.
+        if (!this.prevCodecModule)
+            return false;
+        if (this.prevCodecModule.id !== 'tcp')
+            return false;
+        if (this.#payloadLength() < 4)
+            return false;
+        const lead = this.readBytes(0, 16, true).toString('latin1');
+        if (lead.startsWith('RTSP/'))
+            return true;
+        for (const method of RTSP_METHODS) {
+            if (lead.startsWith(method + ' '))
+                return true;
+        }
+        return false;
+    }
+}
+exports.RTSP = RTSP;
+_a = RTSP;

package/dist/headers/RawData.d.ts

@@ -0,0 +1,17 @@
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { BaseHeader } from '../abstracts/BaseHeader';
+/**
+ * The forced catch-all header. The codec selects it as the final fallback when no
+ * demux-table or content-heuristic codec matches, so decode never fails: any bytes
+ * left unparsed at the current offset are captured verbatim into a single lower-case
+ * hex `data` field and re-emitted byte-for-byte on encode. Not a protocol
+ * (`isProtocol = false`); matches whenever there is a previous layer to trail.
+ */
+export declare class RawData extends BaseHeader {
+    readonly SCHEMA: ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly isProtocol: boolean;
+    match(): boolean;
+}

package/dist/headers/RawData.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawData = void 0;
+const BaseHeader_1 = require("../abstracts/BaseHeader");
+const StringContentEncodingEnum_1 = require("../lib/StringContentEncodingEnum");
+const BufferToHex_1 = require("../helper/BufferToHex");
+/**
+ * The forced catch-all header. The codec selects it as the final fallback when no
+ * demux-table or content-heuristic codec matches, so decode never fails: any bytes
+ * left unparsed at the current offset are captured verbatim into a single lower-case
+ * hex `data` field and re-emitted byte-for-byte on encode. Not a protocol
+ * (`isProtocol = false`); matches whenever there is a previous layer to trail.
+ */
+class RawData extends BaseHeader_1.BaseHeader {
+    constructor() {
+        super(...arguments);
+        this.SCHEMA = {
+            type: 'object',
+            properties: {
+                data: {
+                    type: 'string',
+                    label: 'Raw',
+                    contentEncoding: StringContentEncodingEnum_1.StringContentEncodingEnum.HEX,
+                    decode: () => {
+                        const dataLength = this.packet.length - this.startPos;
+                        this.instance.data.setValue((0, BufferToHex_1.BufferToHex)(this.readBytes(0, dataLength)));
+                    },
+                    encode: () => {
+                        this.writeBytes(0, Buffer.from(this.instance.data.getValue().toString(), 'hex'));
+                    }
+                }
+            }
+        };
+        this.id = 'raw';
+        this.name = 'Raw Data';
+        this.nickname = 'Raw';
+        this.isProtocol = false;
+    }
+    match() {
+        return !!this.prevCodecModule;
+    }
+}
+exports.RawData = RawData;

package/dist/headers/Redis.d.ts

@@ -0,0 +1,32 @@
+import { BaseHeader } from '../abstracts/BaseHeader';
+import { ProtocolJSONSchema } from '../schema/ProtocolJSONSchema';
+import { DemuxProducer } from '../types/DemuxProducer';
+/**
+ * Redis RESP — the REdis Serialization Protocol (RESP2/RESP3), carried over TCP well-known port 6379. RESP
+ * is a text-ish line protocol whose FIRST byte names the message type: `+` simple string (`+OK\r\n`), `-`
+ * error (`-ERR msg\r\n`), `:` integer (`:1000\r\n`), `$` bulk string (`$6\r\nfoobar\r\n`, or `$-1\r\n` null),
+ * `*` array (`*3\r\n$3\r\nSET\r\n$3\r\nfoo\r\n$3\r\nbar\r\n`). RESP3 adds `_` null, `#` boolean, `,` double,
+ * `(` big number, `!` blob error, `=` verbatim string, `%` map, `~` set, `>` push. Client commands are
+ * almost always arrays of bulk strings (`*` framing), so the first bulk-string element is the command verb.
+ *
+ * Like FTP, SMTP, POP3, IMAP, Syslog, SIP and HTTP, the message is text whose full internal structure
+ * (nested aggregates, binary-safe bulk strings, inline commands) is richer than a form needs. So the ENTIRE
+ * raw segment is kept verbatim as the authoritative `message` field (hex) and re-emitted untouched; only a
+ * little first-byte/first-line metadata is parsed on decode for display (respType/isRequest/command/preview).
+ * Encode never reconstructs the message from the parsed fields — it writes `message` back byte-for-byte — so
+ * any conformant (or even malformed) RESP frame round-trips exactly.
+ *
+ * Note: a single TCP segment may carry more than one RESP message (pipelined commands) or only part of a
+ * large bulk string; reassembly across segments is out of scope. This single-segment codec keeps whatever
+ * bytes are present verbatim, which is byte-perfect for the single-packet case.
+ */
+export declare class Redis extends BaseHeader {
+    #private;
+    get SCHEMA(): ProtocolJSONSchema;
+    readonly id: string;
+    readonly name: string;
+    readonly nickname: string;
+    readonly matchKeys: string[];
+    match(): boolean;
+    readonly demuxProducers: DemuxProducer[];
+}