/// <reference types="node" />
import * as encapsulation from "./encapsulation";
import * as CIP from "./cip";
import { TagList } from "../tag-list";
import { TagGroup } from "../tag-group";
import { EventEmitter } from 'events';
/**
 * Low Level Ethernet/IP
 *
 * @class ENIP
 * @extends {Socket}
 * @fires ENIP#Session Registration Failed
 * @fires ENIP#Session Registered
 * @fires ENIP#Session Unregistered
 * @fires ENIP#SendRRData Received
 * @fires ENIP#SendUnitData Received
 * @fires ENIP#Unhandled Encapsulated Command Received
 */
export default class ENIP extends EventEmitter {
    private socket;
    state: ({
        scan_rate?: number;
        timeout_sp: any;
        rpi: any;
        scanning: any;
        connectedMessaging: any;
        controller: any;
        fwd_open_serial: number;
        tagList?: TagList;
        subs?: TagGroup;
        unconnectedSendTimeout?: number;
        TCP: {
            establishing: boolean;
            established: boolean;
        };
        session: {
            id: number | null;
            establishing: boolean;
            established: boolean;
        };
        connection: {
            id: number | null;
            establishing: boolean;
            established: boolean;
            seq_num: number;
        };
        error: {
            code: number | null;
            msg: string | null;
        };
    });
    static encapsulation: any;
    constructor();
    /**
     * Returns an Object
     *  - <number> error code
     *  - <string> human readable error
     *
     * @readonly
     * @memberof ENIP
     */
    get error(): {
        code: number | null;
        msg: string | null;
    };
    /**
     * Session Establishment In Progress
     *
     * @readonly
     * @memberof ENIP
     */
    get establishing(): boolean;
    /**
     * Session Established Successfully
     *
     * @readonly
     * @memberof ENIP
     */
    get established(): boolean;
    /**
     * Get ENIP Session ID
     *
     * @readonly
     * @memberof ENIP
     */
    get session_id(): number | null;
    /**
     * Various setters for Connection parameters
     *
     * @memberof ENIP
     */
    set establishing_conn(newEstablish: boolean);
    set established_conn(newEstablished: boolean);
    set id_conn(newID: number | null);
    set seq_conn(newSeq: number);
    /**
     * Various getters for Connection parameters
     *
     * @memberof ENIP
     */
    get establishing_conn(): boolean;
    get established_conn(): boolean;
    get id_conn(): number | null;
    get seq_conn(): number;
    connect(IP_ADDR: string, timeoutSP?: number | undefined): Promise<unknown>;
    /**
     * Writes Ethernet/IP Data to Socket as an Unconnected Message
     * or a Transport Class 1 Datagram
     *
     * NOTE: Cant Override Socket Write due to net.Socket.write
     *        implementation. =[. Thus, I am spinning up a new Method to
     *        handle it. Dont Use Enip.write, use this function instead.
     *
     * @param {buffer} data - Data Buffer to be Encapsulated
     * @param {boolean} [connected=false]
     * @param {number} [timeout=10] - Timeout (sec)
     * @param {function} [cb=null] - Callback to be Passed to Parent.Write()
     * @memberof ENIP
     */
    write_cip(data: any, connected?: boolean, timeout?: number, cb?: null): void;
    /**
     * Sends Unregister Session Command and Destroys Underlying TCP Socket
     *
     * @override
     * @param {Exception} exception - Gets passed to 'error' event handler
     * @memberof ENIP
     */
    destroy(exception?: Error): this;
    _initializeEventHandlers(): void;
    /**
     * @typedef EncapsulationData
     * @type {Object}
     * @property {number} commandCode - Ecapsulation Command Code
     * @property {string} command - Encapsulation Command String Interpretation
     * @property {number} length - Length of Encapsulated Data
     * @property {number} session - Session ID
     * @property {number} statusCode - Status Code
     * @property {string} status - Status Code String Interpretation
     * @property {number} options - Options (Typically 0x00)
     * @property {Buffer} data - Encapsulated Data Buffer
     */
    /*****************************************************************/
    /**
     * Socket.on('data) Event Handler
     *
     * @param {Buffer} - Data Received from Socket.on('data', ...)
     * @memberof ENIP
     */
    _handleDataEvent(data: any): void;
    /**
     * Socket.on('close',...) Event Handler
     *
     * @param {Boolean} hadError
     * @memberof ENIP
     */
    _handleCloseEvent(hadError: any): void;
}
export { CIP, encapsulation };