fixparser 9.1.7-9d6b5ca3 → 9.1.7-a0927339

package/types/groups/Groups.d.ts

@@ -0,0 +1,43 @@
+import { type ISpecGroups } from '../spec/SpecGroups';
+/**
+ * Class for managing FIX protocol groups.
+ * Provides functionality to find and filter groups based on various criteria.
+ * Uses caching to improve performance when looking up groups.
+ */
+export declare class Groups {
+    /** Array of all available groups from the FIX specification */
+    groups: ISpecGroups[];
+    /** Cache map for looking up groups by their ID */
+    cacheMap: Map<number, ISpecGroups>;
+    /** Cache map for looking up groups by their name */
+    cacheMapByName: Map<string, ISpecGroups>;
+    /**
+     * Creates a new Groups instance and initializes the cache maps.
+     * Populates both the ID-based and name-based cache maps for efficient lookups.
+     */
+    constructor();
+    /**
+     * Finds a group by its component ID.
+     *
+     * @param {number} componentId - The ID of the group to find
+     * @returns {ISpecGroups | undefined} The found group, or undefined if not found
+     */
+    find(componentId: number): ISpecGroups | undefined;
+    /**
+     * Finds a group by its name.
+     *
+     * @param {string} name - The name of the group to find
+     * @returns {ISpecGroups | undefined} The found group, or undefined if not found
+     */
+    findByName(name: string): ISpecGroups | undefined;
+    /**
+     * Filters and finds a group based on the NoMDEntries tag and message type.
+     * Handles special cases for MarketDataSnapshotFullRefresh and MarketDataIncrementalRefresh messages.
+     * Falls back to searching by numInGroup ID if no special case matches.
+     *
+     * @param {number} tag - The tag number to filter by (typically NoMDEntries)
+     * @param {string} messageType - The type of the message being processed
+     * @returns {ISpecGroups | undefined} The found group, or undefined if not found
+     */
+    filterMapByNumInGroupId(tag: number, messageType: string): ISpecGroups | undefined;
+}

package/types/licensemanager/LicenseManager.d.ts

@@ -0,0 +1,104 @@
+import type { Logger } from '../logger/Logger';
+declare global {
+    const __RELEASE_INFORMATION__: string;
+    const __DISTRIBUTED_CACHING_MECHANISM__: string;
+    const __MULTI_THREAD_SYNC_MUTEX__: string;
+    const __INTERFACE_COMPOSITION_PATTERN__: string;
+}
+/**
+ * The LicenseManager class is responsible for validating license keys,
+ * ensuring that only users with valid licenses can access the
+ * Pro version features of the FIXParsers.
+ *
+ * @public
+ */
+declare class LicenseManager {
+    #private;
+    /** Error message for missing free license */
+    static readonly ERROR_MESSAGE_NO_FREE_LICENSE = 'Requires FIXParser Free license';
+    /** Error message for missing pro license */
+    static readonly ERROR_MESSAGE_NO_LICENSE = 'Requires FIXParser Pro license';
+    /**
+     * Private constructor to prevent instantiation.
+     * This is a static class.
+     */
+    private constructor();
+    /**
+     * Validates if a free license is present and valid.
+     * Checks for free, pro, or trial license types.
+     *
+     * @returns {boolean} True if a valid free license is present
+     */
+    static readonly validateFreeLicense: () => boolean;
+    /**
+     * Validates if a pro license is present and valid.
+     * Checks for pro or trial license types.
+     *
+     * @returns {boolean} True if a valid pro license is present
+     */
+    static readonly validateLicense: () => boolean;
+    /**
+     * Sets the logger instance for license validation messages.
+     *
+     * @param {Logger} loggerInstance - The logger instance to use
+     */
+    static setLogger(loggerInstance: Logger): void;
+    /**
+     * Sets and validates a license key.
+     * Processes the key, verifies its signature, and extracts license information.
+     *
+     * @param {string} rawLicenseKey - The raw license key to validate
+     * @returns {Promise<void>} A promise that resolves when the license is validated
+     */
+    static setLicenseKey(rawLicenseKey: string): Promise<void>;
+    /**
+     * Gets the release date from the release information.
+     *
+     * @returns {Date} The release date
+     */
+    private static getReleaseDate;
+    /**
+     * Formats a date into a human-readable string.
+     *
+     * @param {Date} date - The date to format
+     * @returns {string} The formatted date string
+     */
+    private static formatDate;
+    /**
+     * Validates a license key by checking its ID, expiry date, and type.
+     *
+     * @param {string} keyId - The license key ID
+     * @param {number} expiryTimestamp - The license expiry timestamp
+     * @param {LicenseType} type - The license type
+     * @returns {boolean} True if the license is valid
+     */
+    private static validateKey;
+    /**
+     * Outputs a message indicating a valid free license.
+     */
+    private static outputValidFreeLicense;
+    /**
+     * Outputs a message indicating a valid pro license.
+     */
+    private static outputValidLicense;
+    /**
+     * Outputs a message indicating an invalid free license.
+     */
+    private static outputInvalidFreeLicenseKey;
+    /**
+     * Outputs a message indicating an invalid pro license.
+     */
+    private static outputInvalidLicenseKey;
+    /**
+     * Outputs a message indicating a missing license key.
+     */
+    private static outputMissingLicenseKey;
+    /**
+     * Outputs a message indicating an incompatible version.
+     *
+     * @param {string} formattedExpiryDate - The formatted expiry date
+     * @param {string} formattedReleaseDate - The formatted release date
+     */
+    private static outputIncompatibleVersion;
+}
+export { LicenseManager };

package/types/licensemanager/LicenseManagerUtils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Decodes a Base64 encoded string to its original form.
+ * This is a polyfill for the atob function, which may not be available in all environments.
+ *
+ * @param {string} input - The Base64 encoded string to decode
+ * @returns {string | undefined} The decoded string, or undefined if the input is invalid
+ */
+export declare const atob: (input: string) => string | undefined;

package/types/logger/Logger.d.ts

@@ -0,0 +1,93 @@
+import type { ILogTransporter, Level, LogMessage } from 'fixparser-common';
+import { type ConsoleFormat as Format } from 'fixparser-plugin-log-console';
+/**
+ * Configuration options for logging output.
+ *
+ * @public
+ */
+export type LogOptions = {
+    name?: string;
+    id?: string;
+    level?: Level;
+    format?: Format;
+    transport?: ILogTransporter;
+};
+/**
+ * Logger class for handling FIX protocol logging.
+ * Provides methods for logging messages at different severity levels
+ * and supports custom log transports and formats.
+ */
+export declare class Logger {
+    #private;
+    /** Name of the logger instance */
+    name: string;
+    /** Unique identifier for the logger instance */
+    id: string;
+    /**
+     * Creates a new Logger instance with the specified options.
+     *
+     * @param {LogOptions} [options] - Configuration options for the logger
+     * @param {string} [options.name=''] - Name of the logger
+     * @param {string} [options.id] - Unique identifier for the logger (auto-generated if not provided)
+     * @param {Level} [options.level='info'] - Initial log level
+     * @param {Format} [options.format='json'] - Log message format
+     * @param {ILogTransporter} [options.transport] - Custom log transport (defaults to console)
+     */
+    constructor(options?: LogOptions);
+    /**
+     * Processes a log message, adding metadata and sending it through the transport.
+     * Only processes messages if logging is enabled and the message level meets the current level.
+     *
+     * @param {LogMessage} msg - The message to process
+     * @returns {this} The logger instance for chaining
+     */
+    private processMessage;
+    /**
+     * Logs a message at the specified level.
+     * If no level is specified, defaults to 'info'.
+     *
+     * @param {LogMessage} msg - The message to log
+     * @returns {this} The logger instance for chaining
+     */
+    log(msg: LogMessage): this;
+    /**
+     * Logs a warning message.
+     *
+     * @param {Omit<LogMessage, 'level'>} msg - The message to log (level will be set to 'warn')
+     * @returns {this} The logger instance for chaining
+     */
+    logWarning(msg: Omit<LogMessage, 'level'>): this;
+    /**
+     * Logs an error message.
+     *
+     * @param {Omit<LogMessage, 'level'>} msg - The message to log (level will be set to 'error')
+     * @returns {this} The logger instance for chaining
+     */
+    logError(msg: Omit<LogMessage, 'level'>): this;
+    /**
+     * Sets whether the logger should be silent.
+     * When silent, no messages will be logged regardless of their level.
+     *
+     * @param {boolean} silent - Whether to silence the logger
+     */
+    set silent(silent: boolean);
+    /**
+     * Gets whether the logger is currently silent.
+     *
+     * @returns {boolean} True if the logger is silent, false otherwise
+     */
+    get silent(): boolean;
+    /**
+     * Gets the current log level.
+     *
+     * @returns {Level} The current log level
+     */
+    get level(): Level;
+    /**
+     * Gets the current log format.
+     *
+     * @returns {Format} The current log format
+     */
+    get format(): Format;
+}
+export type { Format };

package/types/message/Message.d.ts

@@ -0,0 +1,408 @@
+import { Field } from '../fields/Field';
+import type { RefType, Structure } from '../messagetype/MessageType';
+import type { ISpecEnums } from '../spec/SpecEnums';
+import type { ISpecFields } from '../spec/SpecFields';
+import { type FIXValue } from '../util/util';
+type FieldValues = {
+    [tag: string]: any;
+};
+/**
+ * The MessageError object is used by FIXParser validation to
+ * represent detailed error information when validation fails,
+ * including the field, tag, value, expected value, and a
+ * descriptive error message.
+ *
+ * @public
+ */
+export type MessageError = {
+    field: RefType | ISpecFields | undefined;
+    name: string | undefined;
+    tag: number;
+    value: FIXValue;
+    expectedValue?: FIXValue;
+    error: string;
+};
+/**
+ * Represents a complete FIX (Financial Information eXchange) message structure.
+ * The message is divided into three main parts: Header, Body, and Trailer.
+ *
+ * @typedef {Object} FIXJSON
+ * @property {Record<string, FIXValue | FIXValue[]>} Header - The header section of the FIX message, which includes metadata such as the sender, target, and timestamp.
+ * @property {Record<string, FIXValue | FIXValue[] | Record<string, FIXValue | FIXValue[]>[]}> Body - The body section of the FIX message, which contains the actual transaction or data being conveyed. It can contain nested groups.
+ * @property {Record<string, FIXValue | FIXValue[]>} Trailer - The trailer section of the FIX message, which typically contains checksum or other closing information.
+ */
+type FIXJSON = {
+    Header: Record<string, FIXValue | FIXValue[]>;
+    Body: Record<string, FIXValue | FIXValue[] | Record<string, FIXValue | FIXValue[]>[]>;
+    Trailer: Record<string, FIXValue | FIXValue[]>;
+};
+/**
+ * A FIX message is a standardized electronic communication used in
+ * financial markets to exchange information such as orders,
+ * executions, and market data between trading participants,
+ * following the FIX protocol's predefined structure and rules.
+ *
+ * @public
+ */
+export declare class Message {
+    #private;
+    /** The fix version associated with the message. */
+    fixVersion: string;
+    /** The data fields associated with the message. */
+    data: Field[];
+    /** The FIX string representation of the message. */
+    messageString: string;
+    /** The description of the message. */
+    description: string;
+    /** The type of the message. */
+    messageType: string;
+    /** A description of the message type. */
+    messageTypeDescription: string;
+    /** The sequence number of the message. */
+    messageSequence: number;
+    /** The structure of the message, can be null if not defined. */
+    structure: Structure[] | undefined;
+    /** Flag indicating whether the body length is valid. */
+    bodyLengthValid: boolean;
+    /** Flag indicating whether the checksum is valid. */
+    checksumValid: boolean;
+    /** The specified checksum value of the message, can be null if not available. */
+    checksumValue: string | undefined;
+    /** The actual checksum value of the message, can be null if not provided. */
+    checksumExpected: string | undefined;
+    /** The specified body length of the message, can be null if not available. */
+    bodyLengthValue: number | undefined;
+    /** The actual body length of the message, can be null if not provided. */
+    bodyLengthExpected: number | undefined;
+    /**
+     * Creates a new FIX Message instance.
+     *
+     * The constructor initializes the FIX Message with the specified FIX version and optional
+     * custom fields. It processes the fields to set specific FIX tags such as `BeginString`,
+     * `MsgSeqNum`, and `MsgType`, and updates the message accordingly.
+     *
+     * @param {string} [fixVersion=DEFAULT_FIX_VERSION] - The FIX protocol version. Defaults to `DEFAULT_FIX_VERSION`.
+     * @param {...Field} fields - A variable number of `Field` objects that represent individual tags in the FIX message.
+     * Each field object must contain a `tag` and a `value`, where `tag` indicates the field type (e.g., `BeginString`, `MsgSeqNum`, etc.).
+     *
+     * @throws {Error} If the field contains an invalid tag or value type.
+     *
+     * @example
+     * const message = new Message('FIXT.1.1', new Field(FieldType.MsgType, Messages.NewOrderSingle), new Field(Fields.OrderQty, 10000));
+     *
+     */
+    constructor(fixVersion?: string, ...fields: Field[]);
+    /**
+     * Adds a single `Field` object to the message data.
+     *
+     * @param {Field} field - The `Field` object to be added.
+     */
+    addField(field: Field): void;
+    /**
+     * Adds multiple `Field` objects to the message data.
+     * If the field's tag is `MsgType`, it will be added at the beginning of the `data` array.
+     * Otherwise, it will be appended to the end.
+     *
+     * @param {...Field} fields - One or more `Field` objects to be added.
+     */
+    addFields(...fields: Field[]): void;
+    /**
+     * Removes a field from the message data by its `tag`.
+     *
+     * @param {number} tag - The tag of the field to be removed.
+     */
+    removeFieldByTag(tag: number): void;
+    /**
+     * Retrieves a single field from the message data by its `tag`.
+     *
+     * @param {number} tag - The tag of the field to be retrieved.
+     * @returns {Field | undefined} The `Field` object if found, otherwise `undefined`.
+     */
+    getField(tag: number): Field | undefined;
+    /**
+     * Retrieves all fields from the message data that have the specified `tag`.
+     *
+     * @param {number} tag - The tag of the fields to be retrieved.
+     * @returns {Field[]} An array of `Field` objects that match the specified `tag`, or an empty array if no fields match.
+     */
+    getFields(tag: number): Field[] | undefined;
+    /**
+     * Returns an object containing the name-explain pairs of all fields in the message.
+     * The `name` of each field is used as the key, and the enumeration of the (`value`) is assigned to it.
+     * For example, `MsgType: 'D'` gets assigned `MsgType: 'NewOrderSingle'`,
+     *
+     * @returns {FieldValues} An object where the keys are field names and the values are the explained field values.
+     * @example
+     * console.log(message.getFieldExplains());
+     * {
+     *   '47': 'A',
+     *   BeginString: 'FIX42',
+     *   BodyLength: 146,
+     *   MsgType: 'NewOrderSingle',
+     *   MsgSeqNum: 4,
+     *   SenderCompID: 'ABC_DEFG01',
+     *   SendingTime: '20090323-15:40:29',
+     *   TargetCompID: 'CCG',
+     *   OnBehalfOfCompID: 'XYZ',
+     *   ClOrdID: 'NF 0542/03232009',
+     *   Side: 'Buy',
+     *   OrderQty: 100,
+     *   Symbol: 'CVS',
+     *   OrdType: 'Market',
+     *   TimeInForce: 'Day',
+     *   TransactTime: '20090323-15:40:29',
+     *   HandlInst: 'AutomatedExecutionNoIntervention',
+     *   SecurityExchange: 'N',
+     *   CheckSum: '195'
+     * }
+     */
+    getFieldExplains(): FieldValues;
+    /**
+     * Returns an object containing the name-value pairs of all fields in the message.
+     * The `name` of each field is used as the key, and the `value` is assigned to it.
+     *
+     * @returns {FieldValues} An object where the keys are field names and the values are field values.
+     * @example
+     * console.log(message.getFieldNameValues());
+     * {
+     *   '47': 'A',
+     *   BeginString: 'FIX.4.2',
+     *   BodyLength: 146,
+     *   MsgType: 'D',
+     *   MsgSeqNum: 4,
+     *   SenderCompID: 'ABC_DEFG01',
+     *   SendingTime: '20090323-15:40:29',
+     *   TargetCompID: 'CCG',
+     *   OnBehalfOfCompID: 'XYZ',
+     *   ClOrdID: 'NF 0542/03232009',
+     *   Side: '1',
+     *   OrderQty: 100,
+     *   Symbol: 'CVS',
+     *   OrdType: '1',
+     *   TimeInForce: '0',
+     *   TransactTime: '20090323-15:40:29',
+     *   HandlInst: '1',
+     *   SecurityExchange: 'N',
+     *   CheckSum: '195'
+     * }
+     */
+    getFieldNameValues(): FieldValues;
+    /**
+     * Returns an object containing the values of all fields in the message, indexed by their `tag`.
+     * If a tag has multiple fields, the values will be stored in an array.
+     *
+     * @returns {FieldValues} An object where the keys are field tags and the values are field values (or arrays of values).
+     * @example
+     * console.log(message.getFieldValues());
+     * {
+     *   '8': 'FIX.4.2',
+     *   '9': 146,
+     *   '10': '195',
+     *   '11': 'NF 0542/03232009',
+     *   '21': '1',
+     *   '34': 4,
+     *   '35': 'D',
+     *   '38': 100,
+     *   '40': '1',
+     *   '47': 'A',
+     *   '49': 'ABC_DEFG01',
+     *   '52': '20090323-15:40:29',
+     *   '54': '1',
+     *   '55': 'CVS',
+     *   '56': 'CCG',
+     *   '59': '0',
+     *   '60': '20090323-15:40:29',
+     *   '115': 'XYZ',
+     *   '207': 'N'
+     * }
+     */
+    getFieldValues(): FieldValues;
+    /**
+     * Updates a field in the message data based on its `tag`.
+     * If a field with the same tag exists, it will be replaced with the new `Field` object.
+     *
+     * @param {Field} field - The `Field` object to update in the data.
+     */
+    setField(field: Field): void;
+    /**
+     * Retrieves the enumeration for a given `tag` and `value` based on the message's `MsgType`.
+     * This method ensures that the `MsgType` field is present and has a value before attempting
+     * to retrieve the corresponding enumeration.
+     *
+     * @param {number} tag - The tag of the field for which the enum is to be retrieved.
+     * @param {FIXValue} value - The value of the field for which the enum is to be retrieved.
+     * @returns {ISpecEnums | undefined} The corresponding enumeration if found, or `undefined` if the `MsgType` field is missing
+     * or has no value, or if no matching enum is found.
+     *
+     * @example
+     * const enumValue = message.getEnum(35, 'D');
+     * console.log(`Enum: ${enumValue}`);
+     */
+    getEnum(tag: number, value: FIXValue): ISpecEnums | undefined;
+    /**
+     * Generates a brief Bloomberg-style description of the current message based on its fields, such as `Side`, `OrderQty`, `Symbol`, `Price`, etc.
+     * The description is typically used for a quick summary of an order or trade message, formatted with key field values.
+     *
+     * Depending on the available fields, the method formats and returns a string summarizing the message's main details,
+     * such as quantity, price, symbol, and order type. If certain fields (like `LeavesQty`, `OrderQty`, `Price`, etc.) are not present,
+     * it adjusts the description accordingly.
+     *
+     * @returns {string | null} A brief string description summarizing the message. If no description can be formed, `null` is returned.
+     *
+     * @example
+     * const description = message.getBriefDescription();
+     * console.log(description); // "100 AAPL LMT @123.45 GTC"
+     */
+    getBriefDescription(): string | undefined;
+    /**
+     * Validates the body length of the FIX message by comparing the provided value to the actual body length.
+     * The body length is calculated as the difference between the positions of the `MsgType` tag and the `Checksum` tag.
+     *
+     * @param {string} value - The body length value to validate against the calculated body length.
+     * @returns {boolean} `true` if the provided body length matches the calculated body length, otherwise `false`.
+     *
+     * @example
+     * const isValid = message.validateBodyLength('123');
+     * console.log(isValid); // true if the body length is correct, false otherwise
+     */
+    validateBodyLength(value: string): boolean;
+    /**
+     * Validates the checksum of the FIX message by comparing the provided checksum value to the calculated checksum.
+     * The checksum is calculated based on the substring of the message string before the `Checksum` tag.
+     *
+     * @param {string} value - The checksum value to validate against the calculated checksum.
+     * @returns {boolean} `true` if the provided checksum matches the calculated checksum, otherwise `false`.
+     *
+     * @example
+     * const isValid = message.validateChecksum('123456');
+     * console.log(isValid); // true if the checksum is valid, false otherwise
+     */
+    validateChecksum(value: string): boolean;
+    /**
+     * Recalculates and updates the body length and checksum of the FIX message.
+     * This method is useful when message fields have been modified and the message
+     * needs to be updated with correct length and checksum values.
+     *
+     * The method will:
+     * 1. Calculate the new body length based on the message content
+     * 2. Calculate the new checksum based on the entire message
+     * 3. Update the message's internal state with the new values
+     *
+     * @returns {Object} An object containing the new body length and checksum values
+     * @property {number} bodyLength - The newly calculated body length
+     * @property {string} checksum - The newly calculated checksum
+     *
+     * @example
+     * const message = new Message('FIX.4.4');
+     * message.addField(new Field(FieldType.OrderQty, 100));
+     * const { bodyLength, checksum } = message.recalculateMessageLengths();
+     * console.log(`New body length: ${bodyLength}, New checksum: ${checksum}`);
+     */
+    recalculateMessageLengths(): {
+        bodyLength: number;
+        checksum: string;
+    };
+    /**
+     * Validates the structure and content of a given FIX message.
+     *
+     * This method checks the fields in the provided `message` for correct data format, required fields,
+     * and field references (such as `fieldRef`, `groupRef`, `componentRef`). It also validates specific fields
+     * like `BodyLength` and `CheckSum` against expected values.
+     *
+     * The validation process can be constrained to only required fields, based on the `requiredFieldsOnly` flag.
+     *
+     * @param {boolean} [requiredFieldsOnly=true] - If `true`, only required fields (as specified in the message structure) are validated.
+     * Defaults to `true`.
+     *
+     * @returns {MessageError[]} - An array of validation errors. Each error includes details about the field that caused the error,
+     * such as the field's `tag`, `name`, `value`, the error message, and any expected value (if applicable).
+     *
+     * @throws {Error} If any internal validation process fails or an invalid message is encountered.
+     *
+     * @example
+     * const validationErrors = message.validate();
+     *
+     * if (validationErrors.length > 0) {
+     *   validationErrors.forEach(error => {
+     *     console.error(`Field ${error.name} (Tag ${error.tag}) has error: ${error.error}`);
+     *   });
+     * }
+     */
+    validate(requiredFieldsOnly?: boolean): MessageError[];
+    /**
+     * Encodes the FIX message into a string format based on the current message data, including its header, body, and trailer.
+     * This method first validates the license, then constructs the message by adding fields such as `BeginString`, `BodyLength`,
+     * and `CheckSum`. It also calculates the body length and checksum dynamically, ensuring the message is correctly formatted
+     * according to the FIX protocol.
+     *
+     * @param {string} [separator=SOH] - The separator used to separate fields in the encoded FIX message. Defaults to `SOH` (Start of Header).
+     * @returns {string} The encoded FIX message string, including calculated body length and checksum.
+     * @throws {Error} If the license is invalid, it throws an error with a message indicating no valid license.
+     *
+     * @example
+     * const fixMessage = message.encode();
+     * console.log(fixMessage); // "8=FIX.4.4|35=D|49=SenderCompID|56=TargetCompID|34=1|10=123"
+     */
+    encode(separator?: string): string;
+    /**
+     * Converts the current FIX message to a JSON-like structure (FIX JSON), representing the message in a format that mirrors the FIX protocol.
+     * The structure includes three main sections: `Header`, `Body`, and `Trailer`. Each section contains fields and, where applicable,
+     * groups of repeating fields. The method processes the fields in the `data` array and organizes them into these sections, handling
+     * groups, references, and field types appropriately.
+     *
+     * @returns {FIXJSON} The FIX message converted into a structured JSON-like format with `Header`, `Body`, and `Trailer` sections.
+     *
+     * @throws {Error} If the license is invalid, an error is thrown with a message indicating that no valid license is available.
+     *
+     * @example
+     * const fixJson = message.toFIXJSON();
+     * console.log(fixJson);
+     * // {
+     * //   "Header": {
+     * //     "BeginString": "FIXT.1.1",
+     * //     "MsgType": "NewOrderSingle",
+     * //     "SenderCompID": "ABC",
+     * //     "TargetCompID": "XYZ"
+     * //   },
+     * //   "Body": {
+     * //     "OrderQty": 1000,
+     * //     "Price": 50.25,
+     * //     "Symbol": "AAPL",
+     * //     "Side": "Buy"
+     * //   },
+     * //   "Trailer": {
+     * //     "CheckSum": "123"
+     * //   }
+     * // }
+     */
+    toFIXJSON(): FIXJSON;
+    /**
+     * Creates and returns a new instance of the `Message` class, which is a deep clone of the current `Message` instance.
+     * The cloned instance has the same `fixVersion`, `messageSequence`, and `messageType`, but the `data` array is also cloned to avoid references to the original fields.
+     *
+     * @returns {Message} A new `Message` instance that is a clone of the current one.
+     *
+     * @example
+     * const originalMessage = new Message('FIXT.1.1', field1, field2, field3);
+     * const clonedMessage = originalMessage.clone();
+     * console.log(clonedMessage); // A new Message instance with the same data as the original
+     */
+    clone(): Message;
+    /**
+     * Resets the internal state of the `Message` instance to its initial, empty state.
+     * This includes clearing all data fields, resetting various properties to their default values,
+     * and ensuring the message is in a clean state ready for processing.
+     *
+     * This method is typically used when you want to clear the state of the current `Message` object
+     * and prepare it for new data, e.g., when parsing or constructing a new FIX message.
+     *
+     * @private
+     * @returns {void} This method does not return any value.
+     *
+     * @example
+     * const message = new Message('FIX.4.4', field1, field2);
+     * message.reset(); // Clears all properties and prepares the message for a new state
+     */
+    private reset;
+}
+export {};