import { motionmaster } from './motion-master.proto';
export import MotionMasterMessage = motionmaster.MotionMasterMessage;
export import IMotionMasterMessage = motionmaster.IMotionMasterMessage;
export type StatusKey = keyof MotionMasterMessage.IStatus;
/**
 * Request can be:
 * - started on the client side,
 * - running where Motion Master reports that the procedure is in progress,
 * - succeeded if the request was completed successfully or the progress has reached 100%,
 * - failed if anything goes wrong.
 */
export type RequestStatus = 'started' | 'running' | 'succeeded' | 'failed';
export type RequestStatusMessage = {
    request: RequestStatus;
    messageId?: string;
    /**
     * @deprecated used in OBLAC Drives with the old client library to signify that a request has started
     */
    begin?: {
        code?: number | null;
        message?: string | null;
    };
    /**
     * @deprecated used in OBLAC Drives with the old client library to signify that a request has timed out
     */
    timeout?: {
        code?: number | null;
        message?: string | null;
    };
};
export declare class RequestError extends Error {
}
export type ParameterAddress = [number, number];
export type ParameterTypeValue = Omit<MotionMasterMessage.Request.SetDeviceParameterValues.IParameterValue, 'index' | 'subindex'>;
export type ParameterTypeValueKey = keyof ParameterTypeValue;
export type ParameterValueType = string | number | Uint8Array | Array<number>;
export type ParameterAddressValue = [number, number, ParameterValueType, ParameterTypeValueKey?];
export type DeviceParameterAddressValue = [DeviceRef, number, number, ParameterValueType, ParameterTypeValueKey?];
export type DeviceParameterIds = string[] | [DeviceRef, number, number][];
export interface DeviceParameterInfo extends MotionMasterMessage.Status.DeviceParameterInfo.IParameter {
    id: string;
    index: number;
    subindex: number;
    name: string;
    typeValueKey: ParameterTypeValueKey;
}
/**
 * Request methods for a specific device, such as `getDeviceParameterInfo`, accept the type of request message
 * as the first parameter, as defined in the proto file. For `getDeviceParameterInfo`, this is
 * `MotionMasterMessage.Request.IGetDeviceParameterInfo`.
 *
 * This type is extended through type intersection with `DeviceRefObj` to support multiple ways of referencing a device.
 *
 * Motion Master only supports device addresses, which are re-generated for each device after a power cycle.
 * Since device addresses can change, it's preferable for scripts and applications to use a device reference that remains constant.
 * The device serial number, found in the hardware description file, is a unique identifier that does not change.
 * This serial number is added to each request message.
 *
 * Before sending the request to Motion Master, the device address is resolved and added to the request message.
 * Devices can be referenced not only by their device address or serial number but also by their position
 * (i.e., their sequence number in the network chain).
 */
export type DeviceRefObj = {
    deviceAddress?: number | null;
    deviceSerialNumber?: string | null;
    devicePosition?: number | null;
};
/**
 * There are multiple ways to uniquely identify a device.
 * The Motion Master API, specifically the messages exchanged between Motion Master and its clients, uses the device address.
 * Device addresses uniquely identify devices but are volatile—they change whenever the devices reinitialize (e.g., after a power cycle).
 * To handle this, the client library introduces DeviceRef, which can be one of the following:
 * - Device Address
 * - Device Serial Number
 * - Device Position
 *
 * Since both address and position are numbers, differentiation is made by checking whether the DeviceRef is higher than 0xFFFF.
 * If it's higher, it's considered a device address, as device addresses tend to be large numbers.
 * If it's lower, it's treated as a device position, since the EtherCAT network can enumerate up to 65,535 devices.
 */
export type DeviceRef = number | string;
export type ParameterInfoAndValue = MotionMasterMessage.Status.DeviceParameterInfo.IParameter & MotionMasterMessage.Status.DeviceParameterValues.IParameterValue;
export import EthercatNetworkState = MotionMasterMessage.Request.SetEthercatNetworkState.State;
export import ControllerType = MotionMasterMessage.Request.EnableMotionController.ControllerType;
export type GetDeviceParameterInfoRequest = MotionMasterMessage.Request.IGetDeviceParameterInfo & DeviceRefObj;
export type GetDeviceParameterValuesRequest = MotionMasterMessage.Request.IGetDeviceParameterValues & DeviceRefObj;
export type GetMultiDeviceParameterValuesRequest = MotionMasterMessage.Request.IGetMultiDeviceParameterValues;
export type SetDeviceParameterValuesRequest = MotionMasterMessage.Request.ISetDeviceParameterValues & DeviceRefObj;
export type SetMultiDeviceParameterValuesRequest = MotionMasterMessage.Request.ISetMultiDeviceParameterValues;
export type GetDeviceFileListRequest = MotionMasterMessage.Request.IGetDeviceFileList & DeviceRefObj;
export type GetDeviceFileRequest = MotionMasterMessage.Request.IGetDeviceFile & DeviceRefObj;
export type SetDeviceFileRequest = MotionMasterMessage.Request.ISetDeviceFile & DeviceRefObj;
export type DeleteDeviceFileRequest = MotionMasterMessage.Request.IDeleteDeviceFile & DeviceRefObj;
export type ResetDeviceFaultRequest = MotionMasterMessage.Request.IResetDeviceFault & DeviceRefObj;
export type StopDeviceRequest = MotionMasterMessage.Request.IStopDevice & DeviceRefObj;
export type StartDeviceFirmwareInstallationRequest = MotionMasterMessage.Request.IStartDeviceFirmwareInstallation & DeviceRefObj;
export type GetDeviceLogRequest = MotionMasterMessage.Request.IGetDeviceLog & DeviceRefObj;
export type StartCoggingTorqueRecordingRequest = MotionMasterMessage.Request.IStartCoggingTorqueRecording & DeviceRefObj;
export type GetCoggingTorqueDataRequest = MotionMasterMessage.Request.IGetCoggingTorqueData & DeviceRefObj;
export type StartOffsetDetectionRequest = MotionMasterMessage.Request.IStartOffsetDetection & DeviceRefObj;
export type StartPlantModelIdentificationRequest = MotionMasterMessage.Request.IStartPlantIdentification;
export type ComputeAutoTuningGainsRequest = MotionMasterMessage.Request.IComputeAutoTuningGains & DeviceRefObj;
export type SetMotionControllerParametersRequest = MotionMasterMessage.Request.ISetMotionControllerParameters & DeviceRefObj;
export type EnableMotionControllerRequest = MotionMasterMessage.Request.IEnableMotionController & DeviceRefObj;
export type DisableMotionControllerRequest = MotionMasterMessage.Request.IDisableMotionController & DeviceRefObj;
export type SetSignalGeneratorParametersRequest = MotionMasterMessage.Request.ISetSignalGeneratorParameters & DeviceRefObj;
export type StartSignalGeneratorRequest = MotionMasterMessage.Request.IStartSignalGenerator & DeviceRefObj;
export type StopSignalGeneratorRequest = MotionMasterMessage.Request.IStopSignalGenerator & DeviceRefObj;
export type StartMonitoringDeviceParameterValuesRequest = MotionMasterMessage.Request.IStartMonitoringDeviceParameterValues;
export type StopMonitoringDeviceParameterValuesRequest = MotionMasterMessage.Request.IStopMonitoringDeviceParameterValues;
export type GetEthercatNetworkStateRequest = MotionMasterMessage.Request.IGetEthercatNetworkState & DeviceRefObj;
export type SetEthercatNetworkStateRequest = MotionMasterMessage.Request.ISetEthercatNetworkState & DeviceRefObj;
export type StartNarrowAngleCalibrationRequest = MotionMasterMessage.Request.IStartNarrowAngleCalibration & DeviceRefObj;
export type SetSystemClientTimeoutRequest = MotionMasterMessage.Request.ISetSystemClientTimeout;
export type StartSystemIdentificationRequest = MotionMasterMessage.Request.IStartSystemIdentification & DeviceRefObj;
export type GetCirculoEncoderMagnetDistanceRequest = MotionMasterMessage.Request.IGetCirculoEncoderMagnetDistance & DeviceRefObj;
export type StartCirculoEncoderNarrowAngleCalibrationProcedureRequest = MotionMasterMessage.Request.IStartCirculoEncoderNarrowAngleCalibrationProcedure & DeviceRefObj;
export type GetDeviceCiA402StateRequest = MotionMasterMessage.Request.IGetDeviceCiA402State & DeviceRefObj;
export type SetDeviceCiA402StateRequest = MotionMasterMessage.Request.ISetDeviceCiA402State & DeviceRefObj;
export type StartDeviceSiiRestoreRequest = MotionMasterMessage.Request.IStartDeviceSiiRestore;
export type StartOpenLoopFieldControlRequest = MotionMasterMessage.Request.IStartOpenLoopFieldControl & DeviceRefObj;
export type ComputeFullAutoTuningGainsRequest = MotionMasterMessage.Request.IComputeFullAutoTuningGains & DeviceRefObj;
export type StartFullAutoTuningRequest = MotionMasterMessage.Request.IStartFullAutoTuning & DeviceRefObj;
export type StopFullAutoTuningRequest = MotionMasterMessage.Request.IStopFullAutoTuning & DeviceRefObj;
export type StartCirculoEncoderConfigurationRequest = MotionMasterMessage.Request.IStartCirculoEncoderConfiguration & DeviceRefObj;
export type StopCirculoEncoderNarrowAngleCalibrationProcedureRequest = MotionMasterMessage.Request.IStopCirculoEncoderNarrowAngleCalibrationProcedure & DeviceRefObj;
export type StartOsCommandRequest = MotionMasterMessage.Request.IStartOsCommand & DeviceRefObj;
export type ExecuteForwardCallRequest = MotionMasterMessage.Request.IExecuteForwardCall & DeviceRefObj;
export type SetPdoModeRequest = MotionMasterMessage.Request.ISetPdoMode & DeviceRefObj;
export type GetDeviceSiiRequest = MotionMasterMessage.Request.IGetDeviceSii & DeviceRefObj;
export type SystemVersionStatus = MotionMasterMessage.Status.ISystemVersion & RequestStatusMessage;
export type SystemInformationStatus = MotionMasterMessage.Status.ISystemInformation & RequestStatusMessage;
export type DeviceInfoStatus = MotionMasterMessage.Status.IDeviceInfo & RequestStatusMessage;
export type DeviceParameterInfoStatus = MotionMasterMessage.Status.IDeviceParameterInfo & RequestStatusMessage;
export type DeviceParameterValuesStatus = MotionMasterMessage.Status.IDeviceParameterValues & RequestStatusMessage;
export type MultiDeviceParameterValuesStatus = MotionMasterMessage.Status.IMultiDeviceParameterValues & RequestStatusMessage;
export type DeviceFileListStatus = MotionMasterMessage.Status.IDeviceFileList & RequestStatusMessage;
export type DeviceFileStatus = MotionMasterMessage.Status.IDeviceFile & RequestStatusMessage;
export type DeviceFaultResetStatus = MotionMasterMessage.Status.IDeviceFaultReset & RequestStatusMessage;
export type DeviceStopStatus = MotionMasterMessage.Status.IDeviceStop & RequestStatusMessage;
export type DeviceFirmwareInstallationStatus = MotionMasterMessage.Status.IDeviceFirmwareInstallation & RequestStatusMessage;
export type DeviceLogStatus = MotionMasterMessage.Status.IDeviceLog & RequestStatusMessage;
export type CoggingTorqueRecordingStatus = MotionMasterMessage.Status.ICoggingTorqueRecording & RequestStatusMessage;
export type CoggingTorqueDataStatus = MotionMasterMessage.Status.ICoggingTorqueData & RequestStatusMessage;
export type OffsetDetectionStatus = MotionMasterMessage.Status.IOffsetDetection & RequestStatusMessage;
export type PlantIdentificationStatus = MotionMasterMessage.Status.IPlantIdentification & RequestStatusMessage;
export type AutoTuningStatus = MotionMasterMessage.Status.IAutoTuning & RequestStatusMessage;
export type MotionControllerStatus = MotionMasterMessage.Status.IMotionController & RequestStatusMessage;
export type SignalGeneratorStatus = MotionMasterMessage.Status.ISignalGenerator & RequestStatusMessage;
export type MonitoringParameterValuesStatus = MotionMasterMessage.Status.IMonitoringParameterValues & RequestStatusMessage;
export type EthercatNetworkStateStatus = MotionMasterMessage.Status.IEthercatNetworkState & RequestStatusMessage;
export type NarrowAngleCalibrationStatus = MotionMasterMessage.Status.INarrowAngleCalibration & RequestStatusMessage;
export type SystemIdentificationStatus = MotionMasterMessage.Status.ISystemIdentification & RequestStatusMessage;
export type CirculoEncoderMagnetDistanceStatus = MotionMasterMessage.Status.ICirculoEncoderMagnetDistance & RequestStatusMessage;
export type CirculoEncoderNarrowAngleCalibrationProcedureStatus = MotionMasterMessage.Status.ICirculoEncoderNarrowAngleCalibrationProcedure & RequestStatusMessage;
export type DeviceCiA402StateStatus = MotionMasterMessage.Status.IDeviceCiA402State & RequestStatusMessage;
export type SystemLogStatus = MotionMasterMessage.Status.ISystemLog & RequestStatusMessage;
export type DeviceSiiRestoreStatus = MotionMasterMessage.Status.IDeviceSiiRestore & RequestStatusMessage;
export type OpenLoopFieldControlStatus = MotionMasterMessage.Status.IOpenLoopFieldControl & RequestStatusMessage;
export type FullAutoTuningStatus = MotionMasterMessage.Status.IFullAutoTuning & RequestStatusMessage;
export type CirculoEncoderConfigurationStatus = MotionMasterMessage.Status.ICirculoEncoderConfiguration & RequestStatusMessage;
export type OsCommandStatus = MotionMasterMessage.Status.IOsCommand & RequestStatusMessage;
export type ForwardCallStatus = MotionMasterMessage.Status.IForwardCall & RequestStatusMessage;
export type PdoModeStatus = MotionMasterMessage.Status.IPdoMode & RequestStatusMessage;
export type DeviceSiiStatus = MotionMasterMessage.Status.IDeviceSii & RequestStatusMessage;
export import ValueType = MotionMasterMessage.Status.DeviceParameterInfo.Parameter.ValueType;
export declare function isArrayOfDeviceSerialNumbers(ids: DeviceParameterIds): ids is string[];
export declare function isObjectOfDeviceSerialNumberToValues(ids: {
    [deviceParameterId: string]: ParameterValueType;
} | DeviceParameterAddressValue[]): ids is {
    [deviceParameterId: string]: ParameterValueType;
};
export declare enum RestoreDefaultParametersType {
    RESTORE_ALL_DEFAULT_PARAMETERS = 1,
    RESTORE_MANUFACTURER_DEFAULT_PARAMETERS = 4
}
export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
/**
 * Configuration for {@link MotionMasterClient.runTorqueProfile}.
 */
export interface TorqueProfileConfig {
    /**
     * Target torque (0x6071:00).
     */
    target: number;
    /**
     * Delay, in milliseconds, to hold at the target before issuing a quick stop.
     * Only effective when targetReachTimeout is set.
     */
    holdingDuration?: number;
    /**
     * Controls whether a quick stop is issued after the target is reached.
     *
     * - false (default): issues a quick stop after the target is reached and holdingDuration elapses,
     *   then waits for the CiA402 state determined by the quick stop option code (0x605A): Quick Stop
     *   Active if the code is 6, Switch On Disabled otherwise. Requires targetReachTimeout to be a
     *   positive number, otherwise an error is thrown.
     * - true: the device remains in the Operation Enabled state; no quick stop is issued.
     *   If targetReachTimeout is also set, the function still waits for the target reached bit
     *   before returning, but does not stop the drive.
     */
    skipQuickStop?: boolean;
    /**
     * Time, in milliseconds, to wait for the target reached bit to be set in the statusword (0x6041:00).
     * An error will be thrown if the target is not reached within this duration.
     */
    targetReachTimeout?: number;
    /**
     * Interval, in milliseconds, at which to poll the target reached bit (0x6041:00).
     * Only effective when targetReachTimeout is set. Defaults to 1000 ms.
     */
    monitoringInterval?: number;
    /**
     * Torque slope (0x6087:00).
     */
    slope: number;
    /**
     * Torque window (0x2014:01).
     */
    window?: number;
    /**
     * Torque window time (0x2014:02).
     */
    windowTime?: number;
}
/**
 * Configuration for {@link MotionMasterClient.runVelocityProfile}.
 */
export interface VelocityProfileConfig {
    /**
     * Profile acceleration (0x6083:00).
     */
    acceleration: number;
    /**
     * Target velocity (0x60FF:00).
     */
    target: number;
    /**
     * Profile deceleration (0x6084:00).
     */
    deceleration: number;
    /**
     * Delay, in milliseconds, to hold at the target before issuing a quick stop.
     * Only effective when targetReachTimeout is set.
     */
    holdingDuration?: number;
    /**
     * Controls whether a quick stop is issued after the target is reached.
     *
     * - false (default): issues a quick stop after the target is reached and holdingDuration elapses,
     *   then waits for the CiA402 state determined by the quick stop option code (0x605A): Quick Stop
     *   Active if the code is 6, Switch On Disabled otherwise. Requires targetReachTimeout to be a
     *   positive number, otherwise an error is thrown.
     * - true: the device remains in the Operation Enabled state; no quick stop is issued.
     *   If targetReachTimeout is also set, the function still waits for the target reached bit
     *   before returning, but does not stop the drive.
     */
    skipQuickStop?: boolean;
    /**
     * Time, in milliseconds, to wait for the target reached bit to be set in the statusword (0x6041:00).
     * An error will be thrown if the target is not reached within this duration.
     */
    targetReachTimeout?: number;
    /**
     * Interval, in milliseconds, at which to poll the target reached bit (0x6041:00).
     * Only effective when targetReachTimeout is set. Defaults to 1000 ms.
     */
    monitoringInterval?: number;
    /**
     * Velocity window (0x606D:00).
     */
    window?: number;
    /**
     * Velocity window time (0x606E:00).
     */
    windowTime?: number;
}
/**
 * Configuration for {@link MotionMasterClient.runPositionProfile}.
 */
export interface PositionProfileConfig {
    /**
     * Profile acceleration (0x6083:00).
     */
    acceleration: number;
    /**
     * Target position (0x607A:00).
     */
    target: number;
    /**
     * Profile deceleration (0x6084:00).
     */
    deceleration: number;
    /**
     * Delay, in milliseconds, to hold at the target before issuing a quick stop.
     * Only effective when targetReachTimeout is set.
     */
    holdingDuration?: number;
    /**
     * If `relative` is true, the provided target is added to the current position (0x6064) and the result is set as the target position (0x607A).
     * If `relative` is false, the target is used as the absolute target position (0x607A).
     */
    relative?: boolean;
    /**
     * Controls whether a quick stop is issued after the target is reached.
     *
     * - false (default): issues a quick stop after the target is reached and holdingDuration elapses,
     *   then waits for the CiA402 state determined by the quick stop option code (0x605A): Quick Stop
     *   Active if the code is 6, Switch On Disabled otherwise. Requires targetReachTimeout to be a
     *   positive number, otherwise an error is thrown.
     * - true: the device remains in the Operation Enabled state; no quick stop is issued.
     *   If targetReachTimeout is also set, the function still waits for the target reached bit
     *   before returning, but does not stop the drive.
     */
    skipQuickStop?: boolean;
    /**
     * Time, in milliseconds, to wait for the target reached bit to be set in the statusword (0x6041:00).
     * An error will be thrown if the target is not reached within this duration.
     */
    targetReachTimeout?: number;
    /**
     * Interval, in milliseconds, at which to poll the target reached bit (0x6041:00).
     * Only effective when targetReachTimeout is set. Defaults to 1000 ms.
     */
    monitoringInterval?: number;
    /**
     * Profile velocity (0x6081:00).
     */
    velocity: number;
    /**
     * Position window (0x6067:00).
     */
    window?: number;
    /**
     * Position window time (0x6068:00).
     */
    windowTime?: number;
}
/**
 * Configuration options for establishing connections to the Motion Master when creating a client object using {@link createMotionMasterClient}.
 */
export interface MotionMasterConnectionConfig {
    /**
     * Specifies the duration the client will wait for a response from Motion Master
     * before considering it unresponsive, such as when there is no reply to a Ping message.
     * The default value should be a multiple of pingSystemInterval, such as 1000 ms.
     */
    systemAliveTimeout: number;
    /**
     * Specifies the duration the system will wait for a response from the client before marking it as unresponsive.
     * Since this timeout is configured on the Motion Master side, a protocol message will be sent to the server to apply this timeout.
     */
    clientAliveTimeout?: number;
    /**
     * Unique identifier assigned by the client to the Motion Master.
     * The default value is generated using the `v4()` function.
     */
    clientId: string;
    /**
     * The IP address or domain name of the machine running the Motion Master process.
     * The default value is 'localhost'.
     */
    hostname: string;
    /**
     * Time interval (in milliseconds) for sending Ping messages from the client to the Motion Master.
     * The default value is 250 ms.
     */
    pingSystemInterval: number;
    /**
     * Port number for the Publish/Subscribe WebSocket connection.
     * The default value is 63525.
     */
    pubSubPort: number;
    /**
     * UI-only flag indicating whether the entered connection configuration should be stored and used in the future.
     */
    remember?: boolean;
    /**
     * Port number for the Request/Response WebSocket connection.
     * The default value is 63524.
     */
    reqResPort: number;
    /**
     * Indicates whether the client should connect using WebSocket (ws://) or WebSocket Secure (wss://).
     * Note: Currently, only the ws:// protocol is supported.
     */
    secure?: boolean;
}
/**
 * Defines the structure for storing and representing supported parameter options,
 * organized by firmware version, versioned device product ID, and positional index.
 *
 * The positional index typically refers to hardware elements such as:
 * - Encoder ports
 * - Digital I/Os (DIOs)
 * - Analog inputs (AIs)
 *
 * Each inner array represents the allowed option values (e.g., encoder types) for the corresponding position (port).
 *
 * @example Encoder type parameter options:
 * {
 *   "5.4": {
 *     "8500-01": [
 *       [0],                   // First port: no encoder types are allowed
 *       [0, 1, 2, 3, 4, 7, 9], // Second port: supports these encoder types
 *       [0, 4, 7, 9],          // Third port: supports a subset of encoder types
 *       [0],                   // Fourth port: no encoder types can be selected
 *     ],
 *   },
 * }
 */
export interface FirmwareProductSupportedOptions {
    [firmwareVersion: string]: {
        [versionedDeviceProductId: string]: number[][];
    };
}
/**
 * Represents a tabular configuration for a part, such as a motor or encoder.
 *
 * The `header` array defines the columns, each specifying a name and an optional address,
 * where the address typically includes an index and subindex identifying the parameter.
 *
 * The `values` array contains rows of configuration data, with each row aligned to the header columns.
 */
export interface PartConfigurationTable {
    /** The columns describing each part or field. */
    header: {
        /** The display name of the part or configuration field. */
        name: string;
        /** (Optional) The address (index and subindex) matching the parameter. */
        address?: string;
    }[];
    /** Rows of configuration data matching the header columns. */
    values: (string | number | boolean | null)[][];
}
/**
 * Describes the mapping of Process Data Objects (PDOs) used in the UI configuration.
 */
export interface UiPdoMapping {
    /**
     * Receive PDO mappings — maps each PDO index (e.g., "0x1600") to an array of mapped object dictionary entry identifiers.
     */
    rx: Record<string, string[]>;
    /**
     * Transmit PDO mappings — maps each PDO index (e.g., "0x1A00") to an array of mapped object dictionary entry identifiers.
     */
    tx: Record<string, string[]>;
}
/**
 * Represents the unit configuration selected by the user for displaying feed values in the UI.
 */
export interface InterfaceUnit {
    /**
     * Feed value in the selected unit.
     * Indicates the distance (e.g., mm, degrees) moved per full rotation.
     */
    feed: number;
    /**
     * Unit label selected by the user (e.g., "mm", "deg") and used throughout the UI.
     */
    unit: string;
}
/**
 * Represents the UI configuration stored on the device in the `ui.config.json` file.
 */
export interface UiConfig {
    /**
     * Optional unit associated with the feed constant.
     * Common examples: "mm", "inch", "deg", etc.
     */
    feedConstantUnit?: string;
    /**
     * Optional user-selected unit configuration for feed display.
     * Determines how feed values are presented in the UI.
     */
    interfaceUnit?: InterfaceUnit;
    /**
     * Optional mapping of PDOs for both receive (Rx) and transmit (Tx) directions.
     * Each key represents a PDO index (e.g., "0x1600"), and the value is a list of mapped entry identifiers.
     */
    pdoMapping?: UiPdoMapping;
}
/**
 * Represents a string formatted as an IPv4 address.
 *
 * The format is four decimal numbers (0–255) separated by dots, e.g. "192.168.0.1".
 * Note: This type only enforces the general string pattern and does not validate
 * the numeric ranges of each segment.
 */
export type Ipv4 = `${number}.${number}.${number}.${number}`;
/**
 * Describes a dynamic plant model defined by a transfer function
 * and associated mechanical and excitation parameters.
 *
 * The transfer function is specified using numerator and denominator
 * polynomial coefficients, while mechanical behavior is captured
 * through friction and inertia. Optional fields describe parameters
 * for excitation signals (e.g. chirp tests).
 */
export type PlantModel = {
    /** Coefficients of the transfer function numerator polynomial */
    numerator: number[];
    /** Coefficients of the transfer function denominator polynomial */
    denominator: number[];
    /** Viscous friction coefficient of the plant */
    friction: number;
    /** Inertia of the plant */
    inertia: number;
    /** Start frequency of the excitation signal (Hz) */
    startFrequency?: number;
    /** End frequency of the excitation signal (Hz) */
    endFrequency?: number;
    /** Peak torque amplitude of the excitation signal */
    torqueAmplitude?: number;
    /** Duration of the excitation signal in seconds */
    durationSeconds?: number;
    /** Type of excitation signal (e.g. logarithmic, linear) */
    signalType?: number;
};
/**
 * Strategy for loading configuration onto the device (`config.csv` file).
 *
 * - `'merge'`   : Merge the provided config with the existing device configuration.
 * - `'replace'` : Completely replace the device configuration with the provided config.
 */
export type LoadConfigStrategy = 'merge' | 'replace';
/**
 * Represents a notch filter object obtained via auto-tuning using the standalone library
 * through the execute-forward-call mechanism.
 *
 * Properties:
 * - `enabled`        : Whether the notch filter is active.
 * - `centerFrequency`: Center frequency of the notch.
 * - `rejectionBand`  : Notch bandwidth.
 * - `depth`          : Notch depth (attenuation level).
 */
export type NotchFilter = {
    enabled: boolean;
    centerFrequency: number;
    rejectionBand: number;
    depth: number;
};
/**
 * Represents structured metadata extracted from an unpacked SMM firmware binary header.
 *
 * This type includes both raw header fields and derived data, such as semantic version
 * strings for use in the OBLAC Drives UI. Some fields (e.g., encrypter initialization vectors)
 * are only present in LW2 firmware headers.
 */
export type SmmBinaryHeader = {
    /** Encoded numeric header version. */
    headerVersion: number;
    /**
     * Software version (encoded as a number).
     */
    swVersion: number;
    /** Length of binary part A in bytes. */
    lengthBinaryA: number;
    /** Length of binary part B in bytes. */
    lengthBinaryB: number;
    /** CRC checksum of binary part A. */
    crcA: number;
    /** CRC checksum of binary part B. */
    crcB: number;
};
/**
 * Represents the unpacked raw values from an SMM firmware binary header.
 *
 * This type captures both LW1 and LW2 header formats as tuples, with fields in the
 * order returned by `PythonStruct.unpack`. Each element corresponds to a specific
 * header field.
 */
export type SmmBinaryHeaderValues = [
    headerVersion: string,
    validHwVersionEntries: number,
    someField: number,
    validHwVersions: string,
    encrypterInitializationVectors: string,
    swVersion: number,
    reserved: string,
    lengthBinaryA: number,
    lengthBinaryB: number,
    crcA: number,
    crcB: number
] | [
    headerVersion: string,
    validHwVersionEntries: number,
    someField: number,
    validHwVersions: string,
    swVersion: number,
    reserved: string,
    lengthBinaryA: number,
    lengthBinaryB: number,
    crcA: number,
    crcB: number
];
/**
 * Represents the automated update state and eligibility criteria for SMM (Synapticon Motion Master) software installation.
 * This interface is used to determine whether an automated update process can be initiated
 * and what conditions are met for a specific device.
 *
 * @property {boolean} isValidProduct - Indicates whether the connected device is a recognized and valid Synapticon product.
 * @property {boolean} isDeviceLw1 - Indicates whether the device is running LW1 (Unencrypted).
 * @property {boolean} isCirculo - Indicates whether the device belongs to the Circulo product family.
 * @property {boolean} isCirculo7 - Indicates whether the device is specifically a Circulo 7 model.
 * @property {boolean} isCirculo9 - Indicates whether the device is specifically a Circulo 9 model.
 * @property {boolean} isBinaryEncrypted - Indicates whether the firmware binary intended for installation is encrypted.
 * @property {boolean} isAllowedBinaryVersion - Indicates whether the firmware binary version is permitted for installation on the device.
 * @property {boolean} canInstallV256 - Indicates whether the device SoC firmware version is >=5.5.0 to install firmware version 256.
 * @property {boolean} isAutomationAllowed - Indicates whether all conditions are met to proceed with the automated SMM software installation process.
 */
export interface SmmAutomatedUpdate {
    isValidProduct: boolean;
    isDeviceLw1: boolean;
    isCirculo: boolean;
    isCirculo7: boolean;
    isCirculo9: boolean;
    isBinaryEncrypted: boolean;
    isAllowedBinaryVersion: boolean;
    canInstallV256: boolean;
    isAutomationAllowed: boolean;
    allowedTargetSmmVersions: number[];
    binaryVersion: number;
    deviceSmmVersion: number;
    isV990: boolean;
    isV770: boolean;
    isV771: boolean;
    deviceFirmwareVersion: string;
    deviceSupportsStreaming: boolean;
}
/**
 * Represents the possible statuses of a progress step in a process.
 *
 * - `'idle'`: The step has not started yet.
 * - `'running'`: The step is currently in progress.
 * - `'succeeded'`: The step has completed successfully.
 * - `'failed'`: The step has completed with an error.
 */
export type ProgressStepStatus = 'idle' | 'running' | 'succeeded' | 'failed';
/**
 * Represents a single step in a progress sequence, typically used to track the status of multi-step operations.
 *
 * @property label - A human-readable label describing the step.
 * @property status - The current status of the step, represented by a `ProgressStepStatus` value.
 * @property value - Optional. An arbitrary value associated with the step, such as a result or intermediate data.
 * @property error - Optional. An error message if the step encountered a problem.
 */
export interface ProgressStep<T = number> {
    readonly id: string;
    readonly label: string;
    status: ProgressStepStatus;
    value?: T;
    error?: string;
}
