@homaiohq/napi-quickfix 0.0.0-stage → 0.2.0

package/dist/esm/native.d.ts

@@ -0,0 +1,325 @@
+/**
+ * The field and repeating-group operations every `FIX::FieldMap` exposes.
+ * Shared by the message body and by group entries. Group indices are 1-based,
+ * as in QuickFIX; `getGroup` returns a snapshot copy.
+ */
+export interface NativeFieldMap {
+    getField(tag: number): string;
+    setField(tag: number, value: string): void;
+    isSetField(tag: number): boolean;
+    removeField(tag: number): void;
+    getFieldIfSet(tag: number): string | undefined;
+    /** Own fields plus every field of every nested group entry. */
+    totalFields(): number;
+    isEmpty(): boolean;
+    clear(): void;
+    /** Own fields, in wire order, as `[tag, value]` pairs. */
+    fields(): [number, string][];
+    addGroup(group: NativeGroup): void;
+    /** @throws A {@link QuickFixError} (`FieldNotFound`) when absent / out of range. */
+    getGroup(index: number, tag: number): NativeGroup;
+    /** @throws A {@link QuickFixError} (`FieldNotFound`) when the slot does not exist. */
+    replaceGroup(index: number, group: NativeGroup): void;
+    removeGroup(tag: number): void;
+    removeGroup(index: number, tag: number): void;
+    hasGroup(tag: number): boolean;
+    hasGroup(index: number, tag: number): boolean;
+    groupCount(tag: number): number;
+}
+/**
+ * Native `FIX::Message` wrapper. FIX is string-on-the-wire, so every field
+ * value crosses the boundary as a string. The {@link NativeFieldMap} methods
+ * auto-route well-known header/trailer tags to the right section; `fields()`,
+ * `isEmpty()` and `totalFields()` read the body, `clear()` empties everything.
+ */
+export interface NativeMessage extends NativeFieldMap {
+    getHeaderField(tag: number): string;
+    setHeaderField(tag: number, value: string): void;
+    getTrailerField(tag: number): string;
+    setTrailerField(tag: number, value: string): void;
+    headerFields(): [number, string][];
+    trailerFields(): [number, string][];
+    getMsgType(): string;
+    toString(): string;
+    toPretty(): string;
+}
+/** Constructor shape for the native `MessageWrap` class. */
+export interface NativeMessageConstructor {
+    new (): NativeMessage;
+    /**
+     * Parse `raw`. With a dictionary the parse is structural (repeating groups
+     * become nested groups); without one it is flat. Admin messages always use
+     * the session dictionary; application messages use the application one.
+     */
+    new (raw: string, validate?: boolean, sessionDictionary?: NativeDataDictionary | null, applicationDictionary?: NativeDataDictionary | null): NativeMessage;
+}
+/** Native `FIX::Group` wrapper: one entry of a repeating group. */
+export interface NativeGroup extends NativeFieldMap {
+    /** The group's count tag (e.g. 453 NoPartyIDs). */
+    field(): number;
+    /** The first tag of every entry (e.g. 448 PartyID). */
+    delim(): number;
+    /** The entry's fields (and nested groups) as a SOH-delimited string, in wire order. */
+    toString(): string;
+}
+/** Constructor shape for the native `GroupWrap` class. */
+export interface NativeGroupConstructor {
+    /**
+     * @param order Optional full field order of an entry, delimiter first, no
+     *   zeros. Without it, fields sort delimiter-first then by tag number.
+     */
+    new (field: number, delim: number, order?: readonly number[] | null): NativeGroup;
+}
+/** Native `FIX::SessionID` wrapper. */
+export interface NativeSessionID {
+    getBeginString(): string;
+    getSenderCompID(): string;
+    getTargetCompID(): string;
+    getSessionQualifier(): string;
+    toString(): string;
+}
+/** Constructor shape for the native `SessionIDWrap` class. */
+export interface NativeSessionIDConstructor {
+    new (beginString: string, senderCompID: string, targetCompID: string, qualifier?: string): NativeSessionID;
+}
+/** Native `FIX::SessionSettings` wrapper. */
+export interface NativeSessionSettings {
+    getSessions(): NativeSessionID[];
+}
+/**
+ * Constructor shape for the native `SessionSettingsWrap` class. `fromString` /
+ * `fromFile` MAY appear here as statics (see the module-level equivalents on
+ * {@link NativeModule}); we resolve defensively at runtime.
+ */
+export interface NativeSessionSettingsConstructor {
+    new (): NativeSessionSettings;
+    fromString?(cfg: string): NativeSessionSettings;
+    fromFile?(path: string): NativeSessionSettings;
+}
+/**
+ * Error shape thrown across the native bridge (e.g. from
+ * {@link NativeDataDictionary.validate}, message getters, or engine ops).
+ *
+ * Carries TWO error identifiers:
+ * - {@link QuickFixError.fixError} — the QuickFIX runtime exception type as
+ *   reported by the C++ engine. This is a human-facing string that MAY contain
+ *   spaces (e.g. `'Session Not Found'`, `'Field not found'`).
+ * - {@link QuickFixError.fixErrorName} — a stable, space-free discriminator
+ *   suitable for `switch`/equality checks (e.g. `'SessionNotFound'`,
+ *   `'FieldNotFound'`). Prefer this for programmatic branching.
+ */
+export interface QuickFixError extends Error {
+    /** Always `'QuickFixError'` for errors originating in the native bridge. */
+    name: string;
+    /** Human-readable message. */
+    message: string;
+    /**
+     * QuickFIX runtime exception type string (may contain spaces), e.g.
+     * `'Session Not Found'`. This is the value the native bridge reads when
+     * mapping a thrown rejection back to a FIX exception.
+     */
+    fixError?: string;
+    /**
+     * Stable, space-free discriminator, e.g. `'SessionNotFound'`. Use this for
+     * programmatic checks; it is not subject to QuickFIX's human-facing wording.
+     */
+    fixErrorName?: string;
+    /** Optional extra detail forwarded from the engine where available. */
+    detail?: string;
+}
+/** Native `FIX::DataDictionary` wrapper. */
+export interface NativeDataDictionary {
+    /**
+     * Throws a {@link QuickFixError} if the message is invalid. With `bodyOnly`
+     * the BeginString version check and the tag/value validation of the
+     * header/trailer fields are skipped; required header/trailer fields are
+     * still checked.
+     */
+    validate(message: NativeMessage, bodyOnly?: boolean): void;
+    /** The BeginString the spec declares (e.g. `'FIX.4.4'`), `''` if none. */
+    getVersion(): string;
+    getFieldName(tag: number): string | undefined;
+    getFieldTag(name: string): number | undefined;
+    isField(tag: number): boolean;
+    isMsgType(msgType: string): boolean;
+}
+/**
+ * Constructor shape for the native `DataDictionaryWrap` class. `fromString` /
+ * `fromFile` MAY appear here as statics (see module-level equivalents on
+ * {@link NativeModule}); we resolve defensively at runtime.
+ */
+export interface NativeDataDictionaryConstructor {
+    new (): NativeDataDictionary;
+    fromString?(xml: string): NativeDataDictionary;
+    fromFile?(path: string): NativeDataDictionary;
+}
+/**
+ * The handlers object handed to the native engine constructor. Each callback
+ * receives raw native handles (the TS layer re-wraps them). Mutation happens by
+ * mutating the passed {@link NativeMessage}; rejection happens by throwing.
+ */
+export interface NativeApplicationHandlers {
+    onCreate?(sessionID: NativeSessionID): void;
+    onLogon?(sessionID: NativeSessionID): void;
+    onLogout?(sessionID: NativeSessionID): void;
+    toAdmin?(message: NativeMessage, sessionID: NativeSessionID): void;
+    toApp?(message: NativeMessage, sessionID: NativeSessionID): void;
+    fromAdmin?(message: NativeMessage, sessionID: NativeSessionID): void;
+    fromApp?(message: NativeMessage, sessionID: NativeSessionID): void;
+}
+/** Options passed to the native `InitiatorWrap` / `AcceptorWrap` constructors. */
+export interface NativeEngineOptions {
+    settings: NativeSessionSettings;
+    handlers?: NativeApplicationHandlers;
+    store?: 'file' | 'memory';
+    log?: 'screen' | 'file' | 'none';
+}
+/**
+ * Native handle on a live `FIX::Session`.
+ *
+ * The handle stores only the `FIX::SessionID`; every method re-resolves the
+ * engine-owned session via `FIX::Session::lookupSession` and throws a
+ * {@link QuickFixError} with `fixErrorName: 'SessionNotFound'` once the owning
+ * engine has been stopped.
+ *
+ * Every member is synchronous: none takes the session mutex QuickFIX holds
+ * across application callbacks, so they cannot deadlock the main thread
+ * (`logon()`/`logout()` write a plain flag the network thread reads without a
+ * lock, as QuickFIX's own `Initiator::stop()` does).
+ * `FIX::Session::disconnect()`/`reset()` are not exposed; they are only safe
+ * on the engine's own network thread (see `cpp/session_wrap.cpp`).
+ */
+export interface NativeSession {
+    getSessionID(): NativeSessionID;
+    isLoggedOn(): boolean;
+    isEnabled(): boolean;
+    sentLogon(): boolean;
+    sentLogout(): boolean;
+    receivedLogon(): boolean;
+    isInitiator(): boolean;
+    isAcceptor(): boolean;
+    /** `nowMs` is an epoch-millisecond timestamp; omitted means "now". */
+    isSessionTime(nowMs?: number): boolean;
+    isLogonTime(nowMs?: number): boolean;
+    getExpectedSenderNum(): number;
+    getExpectedTargetNum(): number;
+    setNextSenderMsgSeqNum(seqNum: number): void;
+    setNextTargetMsgSeqNum(seqNum: number): void;
+    getResetOnLogon(): boolean;
+    setResetOnLogon(value: boolean): void;
+    getResetOnLogout(): boolean;
+    setResetOnLogout(value: boolean): void;
+    getResetOnDisconnect(): boolean;
+    setResetOnDisconnect(value: boolean): void;
+    getRefreshOnLogon(): boolean;
+    setRefreshOnLogon(value: boolean): void;
+    getCheckCompId(): boolean;
+    setCheckCompId(value: boolean): void;
+    getCheckLatency(): boolean;
+    setCheckLatency(value: boolean): void;
+    getPersistMessages(): boolean;
+    setPersistMessages(value: boolean): void;
+    getSendRedundantResendRequests(): boolean;
+    setSendRedundantResendRequests(value: boolean): void;
+    getValidateLengthAndChecksum(): boolean;
+    setValidateLengthAndChecksum(value: boolean): void;
+    getSendNextExpectedMsgSeqNum(): boolean;
+    setSendNextExpectedMsgSeqNum(value: boolean): void;
+    getIsNonStopSession(): boolean;
+    setIsNonStopSession(value: boolean): void;
+    getLogonTimeout(): number;
+    setLogonTimeout(seconds: number): void;
+    getLogoutTimeout(): number;
+    setLogoutTimeout(seconds: number): void;
+    getMaxLatency(): number;
+    setMaxLatency(seconds: number): void;
+    getTimestampPrecision(): number;
+    /** Throws a `RangeError` unless `precision` is an integer in `0..9`. */
+    setTimestampPrecision(precision: number): void;
+    logon(): void;
+    logout(reason?: string): void;
+    /** May throw a `QuickFixError` (`IOException`) from the message store. */
+    refresh(): void;
+}
+/**
+ * Constructor shape for the native `SessionWrap` class. Internal: JS obtains a
+ * session through {@link NativeModule.lookupSession} or
+ * {@link NativeEngine.getSession}, never by constructing one.
+ */
+export interface NativeSessionConstructor {
+    new (sessionID: NativeSessionID): NativeSession;
+}
+/**
+ * Native engine (SocketInitiator / SocketAcceptor) wrapper.
+ *
+ * `start`/`stop` run OFF the main thread and resolve a Promise when the engine
+ * has finished (re)configuring its sockets, so the Node.js event loop stays free
+ * to service the application callbacks the engine fires. `isLoggedOn`/`ref`/
+ * `unref`/`getSessions`/`getSession` remain synchronous.
+ *
+ * Once `stop()` settles the engine is destroyed, which also destroys its
+ * `FIX::Session` objects: `getSession` then returns `undefined` and any
+ * previously obtained {@link NativeSession} throws `SessionNotFound`.
+ */
+export interface NativeEngine {
+    start(): Promise<void>;
+    stop(force?: boolean): Promise<void>;
+    /**
+     * No argument: whether ANY of this engine's sessions is logged on. With a
+     * SessionID: whether THAT session belongs to this engine and is logged on.
+     */
+    isLoggedOn(sessionID?: NativeSessionID): boolean;
+    /** The SessionIDs this engine was configured with (stable across stop()). */
+    getSessions(): NativeSessionID[];
+    /** `undefined` if the id is not one of this engine's sessions or stop() has settled. */
+    getSession(sessionID: NativeSessionID): NativeSession | undefined;
+    ref(): void;
+    unref(): void;
+}
+/** Constructor shape for the native `InitiatorWrap` / `AcceptorWrap` classes. */
+export interface NativeEngineConstructor {
+    new (options: NativeEngineOptions): NativeEngine;
+}
+/**
+ * The full surface of the native addon exported by `load-native.cjs`.
+ *
+ * FIX constants are not exported by the addon: field tags (`FIELD`) and value
+ * groups (`MsgType`, `Side`, ...) are generated on the TS side from the
+ * QuickFIX headers (`src/generated/fields.ts`, `src/generated/values.ts`).
+ */
+export interface NativeModule {
+    version(): string;
+    quickfixParseMsgType(raw: string): string;
+    /**
+     * Runs off the main thread; resolves `true` if accepted for sending.
+     *
+     * Second argument: an explicit SessionID, or a session qualifier (possibly
+     * omitted/empty), in which case QuickFIX resolves the session from the
+     * message's own header (BeginString / SenderCompID / TargetCompID).
+     */
+    sendToTarget(message: NativeMessage, sessionIDOrQualifier?: NativeSessionID | string): Promise<boolean>;
+    /** `undefined` if no session with that id exists in this process. */
+    lookupSession(sessionID: NativeSessionID): NativeSession | undefined;
+    doesSessionExist(sessionID: NativeSessionID): boolean;
+    /** Every session registered in this process (all engines). */
+    getSessions(): NativeSessionID[];
+    numSessions(): number;
+    MessageWrap: NativeMessageConstructor;
+    GroupWrap: NativeGroupConstructor;
+    SessionIDWrap: NativeSessionIDConstructor;
+    SessionSettingsWrap: NativeSessionSettingsConstructor;
+    DataDictionaryWrap: NativeDataDictionaryConstructor;
+    SessionWrap: NativeSessionConstructor;
+    InitiatorWrap: NativeEngineConstructor;
+    AcceptorWrap: NativeEngineConstructor;
+    sessionSettingsFromString?(cfg: string): NativeSessionSettings;
+    sessionSettingsFromFile?(path: string): NativeSessionSettings;
+    dataDictionaryFromString?(xml: string): NativeDataDictionary;
+    dataDictionaryFromFile?(path: string): NativeDataDictionary;
+}
+/**
+ * The loaded native addon, typed against the {@link NativeModule} contract.
+ * The default import is an `unknown` (per node-gyp-build's declaration); we
+ * assert it to the contract here — the single localized cast in the codebase.
+ */
+export declare const native: NativeModule;

package/dist/esm/native.js

@@ -0,0 +1,16 @@
+// Loads the compiled native addon. The actual `require('node-gyp-build')(root)`
+// lives in the authored load-native.cjs, which build:ts:copy places next to the
+// compiled output in both dist/esm and dist/cjs. We import it here; the ESM and
+// CJS TS builds each emit the correct interop for pulling in a CommonJS module,
+// so this single source works for both output formats.
+//
+// A plain default import compiles under BOTH tsconfigs (NodeNext ESM and
+// CommonJS/Bundler). We intentionally avoid `import.meta` / `createRequire`
+// here because `import.meta` is not permitted under the CommonJS tsconfig.
+import nativeModule from './load-native.cjs';
+/**
+ * The loaded native addon, typed against the {@link NativeModule} contract.
+ * The default import is an `unknown` (per node-gyp-build's declaration); we
+ * assert it to the contract here — the single localized cast in the codebase.
+ */
+export const native = nativeModule;

package/dist/esm/session-id.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Ergonomic wrapper around the native `FIX::SessionID`.
+ */
+import { type NativeSessionID } from './native.js';
+/**
+ * Identifies a FIX session by its `BeginString`, `SenderCompID`,
+ * `TargetCompID`, and an optional qualifier.
+ *
+ * @example
+ * ```ts
+ * const id = new SessionID('FIX.4.4', 'CLIENT', 'BROKER');
+ * console.log(id.toString()); // FIX.4.4:CLIENT->BROKER
+ * ```
+ */
+export declare class SessionID {
+    #private;
+    /**
+     * @param beginString FIX version, e.g. `'FIX.4.4'`, or an existing native
+     *   handle to adopt (bridge path).
+     * @param senderCompID The sender's CompID.
+     * @param targetCompID The target's CompID.
+     * @param qualifier Optional session qualifier.
+     */
+    constructor(beginString: string | NativeSessionID, senderCompID?: string, targetCompID?: string, qualifier?: string);
+    /** @internal Wrap an existing native session-id handle (used by the engine bridge). */
+    static fromNative(handle: NativeSessionID): SessionID;
+    /** @internal The native handle backing this session id. */
+    get nativeHandle(): NativeSessionID;
+    /** FIX version, e.g. `'FIX.4.4'`. */
+    get beginString(): string;
+    /** The sender's CompID. */
+    get senderCompID(): string;
+    /** The target's CompID. */
+    get targetCompID(): string;
+    /** The session qualifier (empty string if none). */
+    get sessionQualifier(): string;
+    /** The canonical string form, e.g. `FIX.4.4:CLIENT->BROKER`. */
+    toString(): string;
+}
+/**
+ * @internal The native handle behind a {@link SessionID} argument.
+ *
+ * Duck-typed rather than `instanceof SessionID`: this package ships ESM and
+ * CJS builds, and a `SessionID` created by the other build is a different class
+ * with the same shape. Both builds load the same native addon, so its
+ * `SessionIDWrap` class is the one thing they share, and that is what the
+ * handle is checked against. Anything else -- `null`, `{}`, a `Session` -- is
+ * a `TypeError` naming the argument, rather than silently degrading to an
+ * `undefined` handle that the callee would read as "no session id given".
+ */
+export declare function toNativeSessionID(value: unknown, name: string): NativeSessionID;

package/dist/esm/session-id.js

@@ -0,0 +1,82 @@
+/**
+ * Ergonomic wrapper around the native `FIX::SessionID`.
+ */
+import { native } from './native.js';
+/**
+ * Identifies a FIX session by its `BeginString`, `SenderCompID`,
+ * `TargetCompID`, and an optional qualifier.
+ *
+ * @example
+ * ```ts
+ * const id = new SessionID('FIX.4.4', 'CLIENT', 'BROKER');
+ * console.log(id.toString()); // FIX.4.4:CLIENT->BROKER
+ * ```
+ */
+export class SessionID {
+    /** @internal Underlying native handle. */
+    #native;
+    /**
+     * @param beginString FIX version, e.g. `'FIX.4.4'`, or an existing native
+     *   handle to adopt (bridge path).
+     * @param senderCompID The sender's CompID.
+     * @param targetCompID The target's CompID.
+     * @param qualifier Optional session qualifier.
+     */
+    constructor(beginString, senderCompID, targetCompID, qualifier) {
+        if (typeof beginString !== 'string') {
+            // Adopt an existing native handle (bridge path).
+            this.#native = beginString;
+        }
+        else {
+            this.#native = new native.SessionIDWrap(beginString, senderCompID ?? '', targetCompID ?? '', qualifier);
+        }
+    }
+    /** @internal Wrap an existing native session-id handle (used by the engine bridge). */
+    static fromNative(handle) {
+        return new SessionID(handle);
+    }
+    /** @internal The native handle backing this session id. */
+    get nativeHandle() {
+        return this.#native;
+    }
+    /** FIX version, e.g. `'FIX.4.4'`. */
+    get beginString() {
+        return this.#native.getBeginString();
+    }
+    /** The sender's CompID. */
+    get senderCompID() {
+        return this.#native.getSenderCompID();
+    }
+    /** The target's CompID. */
+    get targetCompID() {
+        return this.#native.getTargetCompID();
+    }
+    /** The session qualifier (empty string if none). */
+    get sessionQualifier() {
+        return this.#native.getSessionQualifier();
+    }
+    /** The canonical string form, e.g. `FIX.4.4:CLIENT->BROKER`. */
+    toString() {
+        return this.#native.toString();
+    }
+}
+/**
+ * @internal The native handle behind a {@link SessionID} argument.
+ *
+ * Duck-typed rather than `instanceof SessionID`: this package ships ESM and
+ * CJS builds, and a `SessionID` created by the other build is a different class
+ * with the same shape. Both builds load the same native addon, so its
+ * `SessionIDWrap` class is the one thing they share, and that is what the
+ * handle is checked against. Anything else -- `null`, `{}`, a `Session` -- is
+ * a `TypeError` naming the argument, rather than silently degrading to an
+ * `undefined` handle that the callee would read as "no session id given".
+ */
+export function toNativeSessionID(value, name) {
+    const handle = typeof value === 'object' && value !== null
+        ? value.nativeHandle
+        : undefined;
+    if (!(handle instanceof native.SessionIDWrap)) {
+        throw new TypeError(`${name} must be a SessionID`);
+    }
+    return handle;
+}

package/dist/esm/session-settings.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Ergonomic wrapper around the native `FIX::SessionSettings`.
+ */
+import { type NativeSessionSettings } from './native.js';
+import { SessionID } from './session-id.js';
+/**
+ * Parsed QuickFIX session settings (the `.cfg` configuration).
+ *
+ * Construct via {@link SessionSettings.fromString} or
+ * {@link SessionSettings.fromFile}; direct construction is not supported.
+ *
+ * @example
+ * ```ts
+ * const settings = SessionSettings.fromString(`
+ * [DEFAULT]
+ * ConnectionType=initiator
+ * ...
+ * `);
+ * for (const id of settings.getSessions()) console.log(id.toString());
+ * ```
+ */
+export declare class SessionSettings {
+    #private;
+    /** @internal Use {@link SessionSettings.fromString} / {@link SessionSettings.fromFile}. */
+    private constructor();
+    /**
+     * Parse settings from an in-memory config string.
+     *
+     * @param cfg The QuickFIX `.cfg` contents.
+     * @throws A `QuickFixError` (`fixError: 'ConfigError'`) on invalid config.
+     */
+    static fromString(cfg: string): SessionSettings;
+    /**
+     * Load settings from a `.cfg` file on disk.
+     *
+     * @param path Path to the QuickFIX `.cfg` file.
+     * @throws A `QuickFixError` (`fixError: 'ConfigError'`) on invalid config.
+     */
+    static fromFile(path: string): SessionSettings;
+    /** @internal Wrap an existing native handle. */
+    static fromNative(handle: NativeSessionSettings): SessionSettings;
+    /** @internal The native handle backing these settings. */
+    get nativeHandle(): NativeSessionSettings;
+    /** The sessions declared by this configuration. */
+    getSessions(): SessionID[];
+}

package/dist/esm/session-settings.js

@@ -0,0 +1,71 @@
+/**
+ * Ergonomic wrapper around the native `FIX::SessionSettings`.
+ */
+import { native } from './native.js';
+import { SessionID } from './session-id.js';
+/**
+ * Parsed QuickFIX session settings (the `.cfg` configuration).
+ *
+ * Construct via {@link SessionSettings.fromString} or
+ * {@link SessionSettings.fromFile}; direct construction is not supported.
+ *
+ * @example
+ * ```ts
+ * const settings = SessionSettings.fromString(`
+ * [DEFAULT]
+ * ConnectionType=initiator
+ * ...
+ * `);
+ * for (const id of settings.getSessions()) console.log(id.toString());
+ * ```
+ */
+export class SessionSettings {
+    /** @internal Underlying native handle. */
+    #native;
+    /** @internal Use {@link SessionSettings.fromString} / {@link SessionSettings.fromFile}. */
+    constructor(handle) {
+        this.#native = handle;
+    }
+    /**
+     * Parse settings from an in-memory config string.
+     *
+     * @param cfg The QuickFIX `.cfg` contents.
+     * @throws A `QuickFixError` (`fixError: 'ConfigError'`) on invalid config.
+     */
+    static fromString(cfg) {
+        // The native `fromString` may be a module-level fn or a class static;
+        // prefer the module-level fn, fall back to the static.
+        const handle = native.sessionSettingsFromString?.(cfg) ??
+            native.SessionSettingsWrap.fromString?.(cfg);
+        if (!handle) {
+            throw new Error('native SessionSettings.fromString is unavailable');
+        }
+        return new SessionSettings(handle);
+    }
+    /**
+     * Load settings from a `.cfg` file on disk.
+     *
+     * @param path Path to the QuickFIX `.cfg` file.
+     * @throws A `QuickFixError` (`fixError: 'ConfigError'`) on invalid config.
+     */
+    static fromFile(path) {
+        const handle = native.sessionSettingsFromFile?.(path) ??
+            native.SessionSettingsWrap.fromFile?.(path);
+        if (!handle) {
+            throw new Error('native SessionSettings.fromFile is unavailable');
+        }
+        return new SessionSettings(handle);
+    }
+    /** @internal Wrap an existing native handle. */
+    static fromNative(handle) {
+        return new SessionSettings(handle);
+    }
+    /** @internal The native handle backing these settings. */
+    get nativeHandle() {
+        return this.#native;
+    }
+    /** The sessions declared by this configuration. */
+    getSessions() {
+        return this.#native.getSessions().map((h) => SessionID.fromNative(h));
+    }
+}