Typed messages API

Create a MutableMessage for a MsgType, optionally seeded with a complete MessageInit (omit it to build incrementally). The body type B defaults to the loose UntypedBody; pass a generated per-message body type (or use the dict package's typed message factory / a createFixEngine<Bodies> engine) for field-level type safety.

Create an ImmutableMessage for a MsgType. See createMessage.

Build a dictionary-bound MessageFactory typed by a Bodies registry (the generated MessageBodies map of MsgType value → body type). The dict packages call this and re-export the result as message:

export const message = messageFactory<MessageBodies>(dictionary);message('W').set('MDReqID', 'r1');        // typed to MarketDataSnapshotFullRefreshmessage.immutable(MsgType.Logon).with(...);

A dictionary-bound, typed message factory — the strongly-typed entry point the dict packages re-export (message). Call it with a MsgType value keyed into Bodies (e.g. MsgType.MarketDataSnapshotFullRefresh, the literal "W") to get a builder typed to exactly that message's body. Build one with messageFactory.

The read surface shared by the mutable and immutable Message — enough to drive log metadata (msgType, Symbol, SecurityID, per-entry prices) and to render to wire.

A mutable, fluent Message builder — the fast path for hot loops (per-tick market-data snapshots): set/assign mutate in place and return this for chaining, then MessageView.render converts the body once. Bodies are plain objects (no JS accessor properties), so writes are ordinary property assignments.

An immutable Message — every edit returns a NEW instance (copy-on-write of the top-level body), leaving the original untouched. Preferred when a message is shared, cached, or treated as a value; use MutableMessage for the hot path. Copy-on-write is shallow: to change a repeating group, pass a fresh array to with/merge.

The init shape for a message body B — what MessageFactory, createMessage, and the engine's create accept. Key modifiers are preserved from B: a dictionary-required field must be named (pass undefined to deliberately omit it — the escape hatch for dialects that skip a "required" tag), an optional field may be left out entirely. Every value additionally accepts null | undefined, and all absent values — undefined, null, and '' — are skipped at render and reported absent by MessageView.has, so possibly-empty values pass straight through without guards:

message(MsgType.Logon, {  EncryptMethod: EncryptMethod.NONE,  HeartBtInt: 30,  Username: username,   // string | null | undefined — no `if (username)` needed  Password: password,});

Repeating-group entry arrays are widened deep via FieldInit: entry keys keep their requiredness, entry values accept the same absent forms. | undefined is spelled explicitly so the shape stays correct for consumers compiling with exactOptionalPropertyTypes.

A single field/group value in init position: a group-counter value (an array of entry bodies) is accepted as a readonly array of MessageInit-widened entries; scalar values pass through unchanged, so enum unions and dialect casts are preserved. Entries themselves may NOT be null/undefined — the renderer recurses into each entry object.

Envelope (header/trailer/session) fields supplied to MessageView.render at call time — the fields a Message deliberately does NOT model in its typed body: MsgSeqNum (34), SenderCompID (49), SendingTime (52), TargetCompID (56), and any other standard-header/trailer field. Keys may be field names (SenderCompID) or numeric tags (49); framing tags 8/9/10 and MsgType (35) are computed by the encoder and ignored if supplied here. Absent values (undefined, null, '') are skipped, so conditional session fields (SenderSubID, …) can be passed straight through.

The loose body type for the untyped path: any field name maps to any scalar value or, for a group counter name, an array of entry bodies. Used as the default body type of createMessage/createFixEngine when no generated MessageBodies is supplied, so engine.create(someMsgType) still works — without the field-level type safety a concrete body type provides.

Build a dictionary-agnostic MessageTypeGuard bound to a Bodies registry (the generated MessageBodies map of MsgType value → body type). The dict packages call this and re-export the result as isMessageType:

const isMessageType = messageTypeGuard<MessageBodies>();if (isMessageType(message, 'W')) {  message.get('SecurityID');      // string | undefined — typed to MarketDataSnapshotFullRefresh  message.get('NoMDEntries');     // the typed entry array}

Pure and side-effect-free: the only runtime work is message.msgType === msgType, so it holds no dictionary, session, or transport state.

A Bodies-bound message-narrowing type guard — the read-side counterpart of MessageFactory. Given a message of unknown body (a MessageView<any>, e.g. at a generic send(message) boundary where the concrete msgType is erased) and a MsgType value keyed into Bodies, it narrows the message to that message's body so subsequent MessageView.get/MessageView.has reads are typed — no any, no casts. The runtime is a plain msgType string compare; the narrowing comes entirely from Bodies[M].

It narrows to the read surface MessageView (the interface both MutableMessage and ImmutableMessage extend), not to the mutable/immutable kind: the guard's job is typed reads at an inbound/outbound boundary, and a call site that already holds a concrete builder rarely needs to re-narrow it. Preserving the kind would take a second overload keyed on the input type for no read-side benefit. Build one with messageTypeGuard.

The read surface of the message whose MsgType value is M in a Bodies registry — a convenience alias for annotating a narrowed message (a function parameter, a variable). Equal to MessageView<Bodies[M] & object>; the dict packages emit a pre-bound one-argument MessageOf<M> over their generated MessageBodies.