fixparser 9.1.7-def37df3 → 9.1.7-edd9ee17

package/types/IFIXParser.d.ts

@@ -0,0 +1,182 @@
+import type { KeyObject } from 'node:tls';
+import type { ProxyAgent } from 'proxy-agent';
+import type { IMessageStore } from 'fixparser-common';
+import type { FIXParser } from './FIXParser';
+import type { ConnectionType, FIXParserBase, Options as FIXParserOptions, Protocol } from './FIXParserBase';
+import type { Options as FIXParserBrowserOptions } from './FIXParserBrowser';
+import type { Field } from './fields/Field';
+import type { Logger } from './logger/Logger';
+import type { Message } from './message/Message';
+import type { Parser } from './util/util';
+/**
+ * Interface defining the core functionality for FIX protocol communication.
+ * This interface is implemented by various FIX parser classes to provide consistent
+ * FIX protocol handling across different environments (browser, server, etc.).
+ */
+export interface IFIXParser {
+    host: string | undefined;
+    port: number | undefined;
+    protocol: Protocol | undefined;
+    sender: string | undefined;
+    target: string | undefined;
+    heartBeatInterval: number;
+    fixVersion: string;
+    connectionType: ConnectionType;
+    parserName: Parser;
+    fixParserBase?: FIXParserBase;
+    messageCounter?: number;
+    heartBeatIntervalId: ReturnType<typeof setInterval> | undefined;
+    connected: boolean;
+    messageStoreIn: IMessageStore<Message>;
+    messageStoreOut: IMessageStore<Message>;
+    fixParser?: FIXParser;
+    isLoggedIn?: boolean;
+    requestedLogout?: boolean;
+    logger: Logger;
+    logging: boolean;
+    proxy?: ProxyAgent;
+    tlsKey?: string | Buffer | Array<string | Buffer | KeyObject>;
+    tlsCert?: string | Buffer | Array<string | Buffer>;
+    tlsUseSNI?: boolean;
+    tlsSkipStdInPipe?: boolean;
+    skipValidation?: boolean;
+    /**
+     * Registers a callback function to be invoked when a FIX message is received.
+     * Multiple callbacks can be registered and all will be triggered.
+     *
+     * @param {FIXParserOptions['onMessage']} callback - The callback function to handle incoming FIX messages.
+     */
+    addOnMessageCallback(callback: FIXParserOptions['onMessage']): void;
+    /**
+     * Registers a callback function to be invoked when the FIX connection is successfully established.
+     * Multiple callbacks can be registered and all will be triggered.
+     *
+     * @param {FIXParserOptions['onOpen']} callback - The callback function to handle connection opening.
+     */
+    addOnOpenCallback(callback: FIXParserOptions['onOpen']): void;
+    /**
+     * Registers a callback function to be invoked when a FIX connection error occurs.
+     * Multiple callbacks can be registered and all will be triggered.
+     *
+     * @param {FIXParserOptions['onError']} callback - The callback function to handle connection errors.
+     */
+    addOnErrorCallback(callback: FIXParserOptions['onError']): void;
+    /**
+     * Registers a callback function to be invoked when the FIX connection is closed.
+     * Multiple callbacks can be registered and all will be triggered.
+     *
+     * @param {FIXParserOptions['onClose']} callback - The callback function to handle connection closure.
+     */
+    addOnCloseCallback(callback: FIXParserOptions['onClose']): void;
+    /**
+     * Registers a callback function to be invoked when the FIX connection is ready for use.
+     * Multiple callbacks can be registered and all will be triggered.
+     *
+     * @param {FIXParserOptions['onReady']} callback - The callback function to handle connection readiness.
+     */
+    addOnReadyCallback(callback: FIXParserOptions['onReady']): void;
+    /**
+     * Callback function that is invoked when a FIX message is received.
+     *
+     * @param {Message} message - The received FIX message.
+     */
+    onMessageCallback?: FIXParserOptions['onMessage'];
+    /**
+     * Callback function that is invoked when the FIX connection is established.
+     */
+    onOpenCallback?: FIXParserOptions['onOpen'];
+    /**
+     * Callback function that is invoked when a FIX connection error occurs.
+     *
+     * @param {Error} error - The error that occurred.
+     */
+    onErrorCallback?: FIXParserOptions['onError'];
+    /**
+     * Callback function that is invoked when the FIX connection is closed.
+     */
+    onCloseCallback?: FIXParserOptions['onClose'];
+    /**
+     * Callback function that is invoked when the FIX connection is ready for use.
+     */
+    onReadyCallback?: FIXParserOptions['onReady'];
+    /**
+     * Connect to a remote FIX server/gateway.
+     *
+     * @param {FIXParserOptions | FIXParserBrowserOptions} options - Connection options.
+     * @returns {void}
+     */
+    connect?(options: FIXParserOptions | FIXParserBrowserOptions): void;
+    /**
+     * Get the next outgoing message sequence number.
+     *
+     * @returns {number} The next outgoing message sequence number.
+     */
+    getNextTargetMsgSeqNum(): number;
+    /**
+     * Set the next outgoing message sequence number.
+     *
+     * @param {number} nextMsgSeqNum - The next message sequence number.
+     * @returns {number} The next outgoing message sequence number.
+     */
+    setNextTargetMsgSeqNum(nextMsgSeqNum: number): number;
+    /**
+     * Get current timestamp.
+     *
+     * @param {Date} dateObject - An instance of a Date class.
+     * @returns {string} The current timestamp.
+     */
+    getTimestamp(dateObject?: Date): string;
+    /**
+     * Create an instance of a FIX Message.
+     *
+     * @param {...Field} fields - An array of Fields.
+     * @returns {Message} A FIX Message class instance.
+     */
+    createMessage(...fields: Field[]): Message;
+    /**
+     * Parse a FIX message string into Message instance(s).
+     *
+     * @param {string} data - FIX message string.
+     * @returns {Message[]} FIX Message class instance(s).
+     */
+    parse(data: string): Message[];
+    /**
+     * Send a FIX message.
+     *
+     * @param {Message} message - FIX Message class instance.
+     * @returns {void}
+     */
+    send(message: Message): void;
+    /**
+     * Get connection status.
+     *
+     * @returns {boolean} Current connection status.
+     */
+    isConnected(): boolean;
+    /**
+     * Close current connection.
+     *
+     * @returns {void}
+     */
+    close(): void;
+    /**
+     * Stop heartbeat interval.
+     *
+     * @returns {void}
+     */
+    stopHeartbeat(): void;
+    /**
+     * Restart heartbeat interval.
+     *
+     * @returns {void}
+     */
+    restartHeartbeat(): void;
+    /**
+     * Start heartbeat interval.
+     *
+     * @param {number} heartBeatInterval - Heartbeat interval in seconds.
+     * @param {boolean} [disableLog] - Whether to disable heartbeat logs.
+     * @returns {void}
+     */
+    startHeartbeat(heartBeatInterval: number, disableLog?: boolean): void;
+}

package/types/components/Components.d.ts

@@ -0,0 +1,41 @@
+import { type ISpecComponents } from '../spec/SpecComponents';
+/**
+ * Class for managing FIX protocol components.
+ * Provides functionality to find and process FIX components,
+ * including looking up components by ID or name and retrieving
+ * associated field tags.
+ */
+export declare class Components {
+    /** Array of all available component specifications */
+    components: ISpecComponents[];
+    /** Cache map for looking up components by ID */
+    cacheMap: Map<number, ISpecComponents>;
+    /** Cache map for looking up components by name */
+    cacheMapByName: Map<string, ISpecComponents>;
+    /**
+     * Creates a new Components instance and initializes the cache maps
+     * with all available component specifications.
+     */
+    constructor();
+    /**
+     * Finds a component by its ID.
+     *
+     * @param {number} componentId - The ID of the component to find
+     * @returns {ISpecComponents | undefined} The found component, or undefined if not found
+     */
+    find(componentId: number): ISpecComponents | undefined;
+    /**
+     * Finds a component by its name.
+     *
+     * @param {string} name - The name of the component to find
+     * @returns {ISpecComponents | undefined} The found component, or undefined if not found
+     */
+    findByName(name: string): ISpecComponents | undefined;
+    /**
+     * Gets all field tags associated with a component by its name.
+     *
+     * @param {string} name - The name of the component
+     * @returns {number[]} An array of field tag numbers associated with the component
+     */
+    getTagsByComponentName(name: string): number[];
+}

package/types/enums/EnumType.d.ts

@@ -0,0 +1,44 @@
+import type { ISpecEnums } from '../spec/SpecEnums';
+/**
+ * Class representing a FIX enumeration type.
+ * Stores and manages enumeration-specific information for FIX fields,
+ * including version history and deprecation status.
+ */
+export declare class EnumType {
+    /** The name of the enumeration */
+    name: string | undefined;
+    /** The unique identifier for the enumeration */
+    id: string | undefined;
+    /** The tag number associated with this enumeration */
+    tag: number | undefined;
+    /** The data type of the enumeration */
+    type: string | undefined;
+    /** The code set this enumeration belongs to */
+    codeSet: string | undefined;
+    /** The value of the enumeration */
+    value: string | undefined;
+    /** The sort order of the enumeration */
+    sort?: number;
+    /** The group this enumeration belongs to */
+    group?: string;
+    /** The version when this enumeration was added */
+    added?: string;
+    /** The EP version when this enumeration was added */
+    addedEP?: string;
+    /** The version when this enumeration was last updated */
+    updated?: string;
+    /** The EP version when this enumeration was last updated */
+    updatedEP?: string;
+    /** The version when this enumeration was deprecated */
+    deprecated?: string;
+    /** The EP version when this enumeration was deprecated */
+    deprecatedEP?: string;
+    /** A description of the enumeration */
+    description?: string;
+    /**
+     * Sets the enumeration properties based on the provided enumeration specification.
+     *
+     * @param {ISpecEnums} enumType - The enumeration specification to set
+     */
+    setEnumeration(enumType: ISpecEnums): void;
+}

package/types/enums/Enums.d.ts

@@ -0,0 +1,43 @@
+import type { Field } from '../fields/Field';
+import { type ISpecEnums } from '../spec/SpecEnums';
+import type { FIXValue } from '../util/util';
+/**
+ * Class for managing FIX enumerations.
+ * Provides functionality to process and look up FIX field enumerations
+ * using both tag-value pairs and tag-only lookups.
+ */
+export declare class Enums {
+    /** Array of all available enumeration specifications */
+    enums: ISpecEnums[];
+    /** Cache map for looking up enumerations by tag and value */
+    cacheMap: Map<string, ISpecEnums>;
+    /** Cache map for looking up enumerations by tag only */
+    cacheMapTag: Map<string, ISpecEnums>;
+    /**
+     * Creates a new Enums instance and initializes the cache maps
+     * with all available enumeration specifications.
+     */
+    constructor();
+    /**
+     * Gets an enumeration by its tag and value.
+     *
+     * @param {string} tag - The tag number
+     * @param {FIXValue} value - The enumeration value
+     * @returns {ISpecEnums | undefined} The found enumeration, or undefined if not found
+     */
+    getEnum(tag: string, value: FIXValue): ISpecEnums | undefined;
+    /**
+     * Gets an enumeration by its tag only.
+     *
+     * @param {string} tag - The tag number
+     * @returns {ISpecEnums | undefined} The found enumeration, or undefined if not found
+     */
+    getEnumByTag(tag: string): ISpecEnums | undefined;
+    /**
+     * Processes a field's enumeration, setting the appropriate enumeration type
+     * if a matching enumeration is found.
+     *
+     * @param {Field} field - The field to process
+     */
+    processEnum(field: Field): void;
+}

package/types/fields/Field.d.ts

@@ -0,0 +1,91 @@
+import type { EnumType } from '../enums/EnumType';
+import type { ISpecDatatypes } from '../spec/SpecDatatypes';
+import type { FIXValue } from '../util/util';
+import type { CategoryType } from './categories/CategoryType';
+import type { SectionType } from './sections/SectionType';
+/**
+ * Field is a predefined data element, identified by a unique tag number,
+ * that represents a specific piece of information within a message
+ * (such as price, quantity, or order ID).
+ *
+ * @public
+ */
+export declare class Field {
+    /** The unique tag number identifying this field */
+    tag: number;
+    /** The value of the field */
+    value: FIXValue;
+    /** The name of the field */
+    name: string | undefined;
+    /** A description of what the field represents */
+    description: string | undefined;
+    /** The data type of the field */
+    type: ISpecDatatypes | undefined;
+    /** The category this field belongs to */
+    category: CategoryType | undefined;
+    /** The section this field belongs to */
+    section: SectionType | undefined;
+    /** The enumeration type if this field is an enumerated value */
+    enumeration: EnumType | undefined;
+    /**
+     * Creates a new Field instance with the specified tag and value.
+     *
+     * @param {number} tag - The unique tag number identifying this field
+     * @param {FIXValue} value - The value to be stored in this field
+     */
+    constructor(tag: number, value: FIXValue);
+    /**
+     * Sets the tag number for this field.
+     *
+     * @param {number} tag - The new tag number
+     */
+    setTag(tag: number): void;
+    /**
+     * Sets the value for this field.
+     *
+     * @param {FIXValue} value - The new value
+     */
+    setValue(value: FIXValue): void;
+    /**
+     * Sets the name for this field.
+     *
+     * @param {string} name - The new name
+     */
+    setName(name: string): void;
+    /**
+     * Sets the description for this field.
+     *
+     * @param {string} description - The new description
+     */
+    setDescription(description: string): void;
+    /**
+     * Sets the data type for this field.
+     *
+     * @param {ISpecDatatypes | undefined} type - The new data type
+     */
+    setType(type: ISpecDatatypes | undefined): void;
+    /**
+     * Sets the category for this field.
+     *
+     * @param {CategoryType} category - The new category
+     */
+    setCategory(category: CategoryType): void;
+    /**
+     * Sets the section for this field.
+     *
+     * @param {SectionType} section - The new section
+     */
+    setSection(section: SectionType): void;
+    /**
+     * Sets the enumeration type for this field.
+     *
+     * @param {EnumType} enumeration - The new enumeration type
+     */
+    setEnumeration(enumeration: EnumType): void;
+    /**
+     * Returns a string representation of the field in FIX format (tag=value).
+     *
+     * @returns {string} The string representation of the field
+     */
+    toString(): string;
+}

package/types/fields/Fields.d.ts

@@ -0,0 +1,42 @@
+import type { Message } from '../message/Message';
+import { MessageType } from '../messagetype/MessageType';
+import { type ISpecFields } from '../spec/SpecFields';
+import type { Field } from './Field';
+import { Categories } from './categories/Categories';
+import { DataTypes } from './datatypes/Datatypes';
+import { Sections } from './sections/Sections';
+/**
+ * Fields class manages the collection of FIX fields and their processing.
+ * It maintains a cache of field definitions and provides methods to process
+ * fields within FIX messages.
+ *
+ * @public
+ */
+export declare class Fields {
+    /** Array of all FIX field specifications */
+    fields: ISpecFields[];
+    /** Cache map for quick field lookup by tag number */
+    cacheMap: Map<number, ISpecFields>;
+    /** Message type processor */
+    messageType: MessageType;
+    /** Categories processor */
+    categories: Categories;
+    /** Sections processor */
+    sections: Sections;
+    /** Data types processor */
+    dataTypes: DataTypes;
+    /**
+     * Creates a new Fields instance and initializes the cache map
+     * with all available field specifications.
+     */
+    constructor();
+    /**
+     * Processes a field within a message, setting its properties based on
+     * the field specification. This includes setting the name, description,
+     * category, section, and data type of the field.
+     *
+     * @param {Message} message - The FIX message containing the field
+     * @param {Field} field - The field to process
+     */
+    processField(message: Message, field: Field): void;
+}

package/types/fields/categories/Categories.d.ts

@@ -0,0 +1,28 @@
+import { type ISpecCategories } from '../../spec/SpecCategories';
+import type { Field } from '../Field';
+import { CategoryType } from './CategoryType';
+/**
+ * Class for managing FIX field categories.
+ * Provides functionality to process and categorize FIX fields based on their specifications.
+ */
+export declare class Categories {
+    /** Array of all available category specifications */
+    categories: ISpecCategories[];
+    /** Cache map for looking up categories by name */
+    cacheMap: Map<string, ISpecCategories>;
+    /** Instance of CategoryType for managing category data */
+    categoryType: CategoryType;
+    /**
+     * Creates a new Categories instance and initializes the cache map
+     * with all available category specifications.
+     */
+    constructor();
+    /**
+     * Processes a field's category based on its base category name.
+     * Sets the appropriate category type for the field if found.
+     *
+     * @param {Field} field - The field to process
+     * @param {string} baseCategory - The base category name to look up
+     */
+    processCategory(field: Field, baseCategory: string): void;
+}

package/types/fields/categories/CategoryType.d.ts

@@ -0,0 +1,27 @@
+import type { ISpecCategories } from '../../spec/SpecCategories';
+/**
+ * Class representing a FIX field category type.
+ * Stores and manages category-specific information for FIX fields.
+ */
+export declare class CategoryType {
+    /** The unique identifier for the category */
+    categoryID: string | undefined;
+    /** The FIXML file name associated with this category */
+    fixmlFileName: string | undefined;
+    /** The type of component this category represents */
+    componentType: string | undefined;
+    /** The section ID this category belongs to */
+    sectionID: string | undefined;
+    /** The include file associated with this category */
+    includeFile: string | undefined;
+    /**
+     * Sets the category properties based on the provided category specification.
+     *
+     * @param {ISpecCategories} category - The category specification to set
+     */
+    setCategory(category: ISpecCategories): void;
+    /**
+     * Resets all category properties to undefined.
+     */
+    reset(): void;
+}

package/types/fields/datatypes/Datatypes.d.ts

@@ -0,0 +1,44 @@
+import { type ISpecDatatypes } from '../../spec/SpecDatatypes';
+import type { FIXValue } from '../../util/util';
+import type { Field } from '../Field';
+/**
+ * Class for managing FIX data types.
+ * Provides functionality to validate and process different FIX data types,
+ * including numeric types (int, float) and string types.
+ */
+export declare class DataTypes {
+    /** Array of all available data type specifications */
+    dataTypes: ISpecDatatypes[];
+    /** Cache map for looking up data types by name */
+    cacheMap: Map<string, ISpecDatatypes>;
+    /** Cache map for type-specific formatters and validators */
+    cacheTypeMap: Map<
+        string,
+        {
+            formatter: typeof parseInt | typeof parseFloat | StringConstructor;
+            validator: any;
+        }
+    >;
+    /**
+     * Creates a new DataTypes instance and initializes the cache maps
+     * with all available data type specifications and their corresponding
+     * formatters and validators.
+     */
+    constructor();
+    /**
+     * Validates a value against its expected data type.
+     *
+     * @param {FIXValue} value - The value to validate
+     * @param {string | undefined} type - The expected data type
+     * @returns {boolean} True if the value is valid for the type, false otherwise
+     */
+    validateDatatype(value: FIXValue, type: string | undefined): boolean;
+    /**
+     * Processes a field's data type, setting appropriate type information
+     * and converting values to their proper format if necessary.
+     *
+     * @param {Field} field - The field to process
+     * @param {string} type - The data type to set
+     */
+    processDatatype(field: Field, type: string): void;
+}

package/types/fields/sections/SectionType.d.ts

@@ -0,0 +1,31 @@
+import type { ISpecSections } from '../../spec/SpecSections';
+/**
+ * Class representing a FIX field section type.
+ * Stores and manages section-specific information for FIX fields.
+ */
+export declare class SectionType {
+    /** The unique identifier for the section */
+    sectionID: string | undefined;
+    /** The name of the section */
+    name: string | undefined;
+    /** The order in which the section should be displayed */
+    displayOrder: number | undefined;
+    /** The volume this section belongs to */
+    volume: string | undefined;
+    /** Whether this section is not required in XML */
+    notReqXML: boolean | undefined;
+    /** The FIXML file name associated with this section */
+    fixmlFileName: string | undefined;
+    /** A description of the section */
+    description: string | undefined;
+    /**
+     * Sets the section properties based on the provided section specification.
+     *
+     * @param {ISpecSections} section - The section specification to set
+     */
+    setSection(section: ISpecSections): void;
+    /**
+     * Resets all section properties to undefined.
+     */
+    reset(): void;
+}

package/types/fields/sections/Sections.d.ts

@@ -0,0 +1,28 @@
+import { type ISpecSections } from '../../spec/SpecSections';
+import type { Field } from '../Field';
+import { SectionType } from './SectionType';
+/**
+ * Class for managing FIX field sections.
+ * Provides functionality to process and organize FIX fields into their respective sections.
+ */
+export declare class Sections {
+    /** Array of all available section specifications */
+    sections: ISpecSections[];
+    /** Cache map for looking up sections by ID */
+    cacheMap: Map<string, ISpecSections>;
+    /** Instance of SectionType for managing section data */
+    sectionType: SectionType;
+    /**
+     * Creates a new Sections instance and initializes the cache map
+     * with all available section specifications.
+     */
+    constructor();
+    /**
+     * Processes a field's section based on its section ID.
+     * Sets the appropriate section type for the field if found.
+     *
+     * @param {Field} item - The field to process
+     * @param {string} sectionId - The section ID to look up
+     */
+    processSection(item: Field, sectionId: string): void;
+}

package/types/fieldtypes/AccountType.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Type of account associated with an order
+ * - Tag: 581
+ * - FIX Specification type: int
+ * - Mapped type: number
+ * @readonly
+ * @public
+ */
+export declare const AccountType: Readonly<{
+    /** Account is carried on customer side of the books */
+    readonly CarriedCustomerSide: 1;
+    /** Account is carried on non-customer side of books */
+    readonly CarriedNonCustomerSide: 2;
+    /** House Trader */
+    readonly HouseTrader: 3;
+    /** Floor Trader */
+    readonly FloorTrader: 4;
+    /** Account is carried on non-customer side of books and is cross margined */
+    readonly CarriedNonCustomerSideCrossMargined: 6;
+    /** Account is house trader and is cross margined */
+    readonly HouseTraderCrossMargined: 7;
+    /** Joint back office account (JBO) */
+    readonly JointBackOfficeAccount: 8;
+    /** Equities specialist */
+    readonly EquitiesSpecialist: 9;
+    /** Options market maker */
+    readonly OptionsMarketMaker: 10;
+    /** Options firm account */
+    readonly OptionsFirmAccount: 11;
+    readonly AccountCustomerNonCustomerOrders: 12;
+    readonly AccountOrdersMultipleCustomers: 13;
+}>;
+export type AccountType = (typeof AccountType)[keyof typeof AccountType];

package/types/fieldtypes/AcctIDSource.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Used to identify the source of the Account (1) code. This is especially useful if the account is a new account that the Respondent may not have setup yet in their system.
+ * - Tag: 660
+ * - FIX Specification type: int
+ * - Mapped type: number
+ * @readonly
+ * @public
+ */
+export declare const AcctIDSource: Readonly<{
+    /** BIC */
+    readonly BIC: 1;
+    /** SID Code */
+    readonly SIDCode: 2;
+    /** TFM (GSPTA) */
+    readonly TFM: 3;
+    /** OMGEO (Alert ID) */
+    readonly OMGEO: 4;
+    /** DTCC Code */
+    readonly DTCCCode: 5;
+    readonly SPSAID: 6;
+    /** Other (custom or proprietary) */
+    readonly Other: 99;
+}>;
+export type AcctIDSource = (typeof AcctIDSource)[keyof typeof AcctIDSource];