/**
 * Represents a base data type, as defined in ETG.1020 Protocol Enhancements (24 Base Data Types).
 */
export interface BaseDataType {
    /** The unique index identifying the data type. */
    index: number;
    /** The name of the data type. */
    name: string;
    /** The base data type category (e.g., "BIT", "SINT"). */
    baseDataType: string;
    /** The size of the data type in bits. */
    bitSize: number;
    /** An optional description providing additional details about the data type. */
    description?: string;
    /** An optional range specifying the minimum and maximum allowable values. */
    range?: [number, number];
}
/**
 * List of base data types as defined in ETG.1020 Protocol Enhancements, Table 98.
 */
export declare const baseDataTypes: BaseDataType[];
/**
 * List of base data types with variable length, as specified in ETG.1020 Protocol Enhancements, Table 99.
 */
export declare const baseDataTypesWithVariableLength: BaseDataType[];
export declare const preDefinedRecords: BaseDataType[];
/**
 * Combines all base data types, including those from Table 98 and Table 99.
 */
export declare const allBaseDataTypes: BaseDataType[];
/**
 * Finds a base data type that matches the specified index.
 * @param index - The index to search for.
 * @returns The matching base data type, or undefined if not found.
 */
export declare function findBaseDataTypeByIndex(index: number): BaseDataType | undefined;
/**
 * Enum for object code definitions, based on ETG.1000.6 EtherCAT Specification - Part 6, Table 62.
 */
export declare enum ObjectCodeDefinition {
    DOMAIN = 2,
    DEFTYPE = 5,
    DEFSTRUCT = 6,
    VAR = 7,
    ARRAY = 8,
    RECORD = 9
}
/**
 * Flags used to describe object access rights, mapping, and startup behavior.
 * These can be combined using bitwise OR to form compound flags.
 */
/**
 * Flags used to describe object access rights, mapping, and startup behavior.
 * These can be combined using bitwise OR to form compound flags.
 */
export declare enum ObjectFlags {
    /**
     * No flags set.
     */
    NONE = 0,
    /**
     * Pre-operational read access.
     */
    PO_RD = 1,
    /**
     * Safe-operational read access.
     */
    SO_RD = 2,
    /**
     * Operational read access.
     */
    OP_RD = 4,
    /**
     * All read access (pre-op, safe-op, operational).
     */
    ALL_RD = 7,
    /**
     * Pre-operational write access.
     */
    PO_WR = 8,
    /**
     * Safe-operational write access.
     */
    SO_WR = 16,
    /**
     * Operational write access.
     */
    OP_WR = 32,
    /**
     * All write access (pre-op, safe-op, operational).
     */
    ALL_WR = 56,
    /**
     * Pre-operational read/write access.
     */
    PO_RDWR = 9,
    /**
     * Safe-operational read/write access.
     */
    SO_RDWR = 18,
    /**
     * Operational read/write access.
     */
    OP_RDWR = 36,
    /**
     * All read/write access (pre-op, safe-op, operational).
     */
    ALL_RDWR = 63,
    /**
     * Mapped to Receive PDO.
     */
    RXPDO_MAP = 64,
    /**
     * Mapped to Transmit PDO.
     */
    TXPDO_MAP = 128,
    /**
     * Mapped to both Receive and Transmit PDO.
     */
    RXTXPDO_MAP = 192,
    /**
     * Include in device backup.
     */
    BACKUP = 256,
    /**
     * Set on device startup.
     */
    STARTUP = 512,
    /**
     * All list flags (mapping, backup, and startup).
     */
    ALL_LIST_FLAGS = 960
}
/**
 * Returns the names of individual base flags that are set in a given bitmask.
 *
 * This function filters out composite flags (e.g., `ALL_RD`, `PO_RDWR`)
 * and returns only the names of "base" flags — flags that represent a single bit.
 *
 * @param flagsValue - The bitmask containing one or more `ObjectFlags`.
 * @returns An array of `ObjectFlags` key names corresponding to individual set flags.
 *
 * @example
 * ```ts
 * const flags = ObjectFlags.PO_RD | ObjectFlags.SO_WR | ObjectFlags.TXPDO_MAP;
 * const names = getObjectFlagNames(flags);
 * // names => ["PO_RD", "SO_WR", "TXPDO_MAP"]
 * ```
 */
export declare function getObjectFlagNames(flagsValue: number): string[];
/**
 * Returns the name of any flag (base or compound) that exactly matches the given value.
 *
 * This includes both single-bit flags (e.g., `PO_RD`) and combined flags (e.g., `ALL_RDWR`, `RXTXPDO_MAP`).
 *
 * @param flagsValue - The exact value to match.
 * @returns The matching flag name, or `undefined` if no exact match exists.
 *
 * @example
 * ```ts
 * getExactFlagName(ObjectFlags.PO_RD);       // "PO_RD"
 * getExactFlagName(ObjectFlags.ALL_RDWR);    // "ALL_RDWR"
 * getExactFlagName(ObjectFlags.PO_RD | ObjectFlags.SO_WR); // undefined
 * ```
 */
export declare function getExactObjectFlagName(flagsValue: number): string | undefined;
/**
 * Represents the EtherCAT State Machine (ESM) states.
 * These states define the different phases in the EtherCAT communication process,
 * determining the level of access and functionality available at each stage.
 */
export declare enum EthercatState {
    /** No specific state assigned; the device is inactive or uninitialized. */
    NONE = 0,
    /** Initialization state. Only EtherCAT Slave Controller (ESC) registers are accessible. */
    INIT = 1,
    /** Pre-operational state. Mailbox communication is available, but cyclic process data exchange is disabled. */
    PREOP = 2,
    /** Boot state, primarily used for firmware updates or special configurations. */
    BOOT = 3,
    /** Safe-operational state. Inputs are updated cyclically, but outputs are held in a safe (inactive) state. */
    SAFEOP = 4,
    /** Operational state. Full duplex process data exchange is active; device is fully functional. */
    OP = 8
}