motion-master-client 0.0.1

package/src/lib/motion-master-req-res-client.d.ts

@@ -0,0 +1,370 @@
+import { Observable } from "rxjs";
+import { HardwareDescription } from "./hardware-description";
+import { MotionMasterReqResSocket } from "./motion-master-req-res-socket";
+import { Parameter } from "./parameter";
+import { SystemLogLine } from "./system-log-line";
+import { MotionMasterMessage, ParameterValueType, ParameterTypeValue, DeviceParameterValuesStatus, ParameterAddressValue, DeviceRef } from "./types";
+export declare class MotionMasterReqResClient {
+    readonly socket: MotionMasterReqResSocket;
+    readonly parameterAddressToParameterTypeValueKeyMap: Map<string, "intValue" | "uintValue" | "floatValue" | "stringValue" | "rawValue">;
+    readonly deviceSerialNumberToDeviceAddressMap: Map<string, number>;
+    constructor(socket: MotionMasterReqResSocket);
+    pingSystem(messageId?: string): Observable<undefined>;
+    pingSystemAsync(messageId?: string): Promise<void>;
+    getSystemVersion(requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.SystemVersion & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    getSystemVersionAsync(requestTimeout: number): Promise<string>;
+    getDeviceInfo(requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.DeviceInfo & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    getDeviceInfoAsync(requestTimeout: number): Promise<MotionMasterMessage.Status.DeviceInfo.IDevice[]>;
+    getDeviceParameterInfo(props: MotionMasterMessage.Request.IGetDeviceParameterInfo & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.DeviceParameterInfo & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    getDeviceParameterInfoAsync(props: MotionMasterMessage.Request.IGetDeviceParameterInfo & DeviceRef, requestTimeout: number, messageId?: string): Promise<MotionMasterMessage.Status.DeviceParameterInfo.IParameter[]>;
+    getDeviceParameterValues(props: MotionMasterMessage.Request.IGetDeviceParameterValues & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.DeviceParameterValues & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    getDeviceParameterValuesAsync(props: MotionMasterMessage.Request.IGetDeviceParameterValues & DeviceRef, requestTimeout: number, messageId?: string): Promise<MotionMasterMessage.Status.DeviceParameterValues.IParameterValue[]>;
+    getMultiDeviceParameterValues(props: MotionMasterMessage.Request.IGetMultiDeviceParameterValues, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.MultiDeviceParameterValues & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    getMultiDeviceParameterValuesAsync(props: MotionMasterMessage.Request.IGetMultiDeviceParameterValues, requestTimeout: number, messageId?: string): Promise<MotionMasterMessage.Status.IDeviceParameterValues[]>;
+    setDeviceParameterValues(props: MotionMasterMessage.Request.ISetDeviceParameterValues & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.DeviceParameterValues & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    setDeviceParameterValuesAsync(props: MotionMasterMessage.Request.ISetDeviceParameterValues & DeviceRef, requestTimeout: number, messageId?: string): Promise<MotionMasterMessage.Status.DeviceParameterValues.IParameterValue[]>;
+    setMultiDeviceParameterValues(props: MotionMasterMessage.Request.ISetMultiDeviceParameterValues, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.MultiDeviceParameterValues & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    setMultiDeviceParameterValuesAsync(props: MotionMasterMessage.Request.ISetMultiDeviceParameterValues, requestTimeout: number, messageId?: string): Promise<MotionMasterMessage.Status.IDeviceParameterValues[]>;
+    getDeviceFileList(props: MotionMasterMessage.Request.IGetDeviceFileList & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.DeviceFileList & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    getDeviceFileListAsync(props: MotionMasterMessage.Request.IGetDeviceFileList & DeviceRef, requestTimeout: number, messageId?: string): Promise<string[]>;
+    getDeviceFile(props: MotionMasterMessage.Request.IGetDeviceFile & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.DeviceFile & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    getDeviceFileAsync(props: MotionMasterMessage.Request.IGetDeviceFile & DeviceRef, requestTimeout: number, messageId?: string): Promise<Uint8Array>;
+    setDeviceFile(props: MotionMasterMessage.Request.ISetDeviceFile & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.DeviceFile & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    setDeviceFileAsync(props: MotionMasterMessage.Request.ISetDeviceFile & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    deleteDeviceFile(props: MotionMasterMessage.Request.IDeleteDeviceFile & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.DeviceFile & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    deleteDeviceFileAsync(props: MotionMasterMessage.Request.IDeleteDeviceFile & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    resetDeviceFault(props: MotionMasterMessage.Request.IResetDeviceFault & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.IDeviceFaultReset & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    resetDeviceFaultAsync(props: MotionMasterMessage.Request.IResetDeviceFault & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    stopDevice(props: MotionMasterMessage.Request.IStopDevice & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.DeviceStop & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    stopDeviceAsync(props: MotionMasterMessage.Request.IStopDevice & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    startDeviceFirmwareInstallation(props: MotionMasterMessage.Request.IStartDeviceFirmwareInstallation & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.DeviceFirmwareInstallation & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    startDeviceFirmwareInstallationAsync(props: MotionMasterMessage.Request.IStartDeviceFirmwareInstallation & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    getDeviceLog(props: MotionMasterMessage.Request.IGetDeviceLog & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.IDeviceLog & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    getDeviceLogAsync(props: MotionMasterMessage.Request.IGetDeviceLog & DeviceRef, requestTimeout: number, messageId?: string): Promise<string | null | undefined>;
+    startCoggingTorqueRecording(props: MotionMasterMessage.Request.IStartCoggingTorqueRecording & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.ICoggingTorqueRecording & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    startCoggingTorqueRecordingAsync(props: MotionMasterMessage.Request.IStartCoggingTorqueRecording & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    getCoggingTorqueData(props: MotionMasterMessage.Request.IGetCoggingTorqueData & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.ICoggingTorqueData & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    getCoggingTorqueDataAsync(props: MotionMasterMessage.Request.IGetCoggingTorqueData & DeviceRef, requestTimeout: number, messageId?: string): Promise<number[]>;
+    startOffsetDetection(props: MotionMasterMessage.Request.IStartOffsetDetection & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.IOffsetDetection & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    startOffsetDetectionAsync(props: MotionMasterMessage.Request.IStartOffsetDetection & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    /**
+     * @deprecated
+     */
+    startPlantIdentification(props: MotionMasterMessage.Request.IStartPlantIdentification & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.IPlantIdentification & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    /**
+     * @deprecated
+     */
+    startPlantIdentificationAsync(props: MotionMasterMessage.Request.IStartPlantIdentification & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    computeAutoTuningGains(props: MotionMasterMessage.Request.IComputeAutoTuningGains & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.IAutoTuning & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    computeAutoTuningGainsAsync(props: MotionMasterMessage.Request.IComputeAutoTuningGains & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    setMotionControllerParameters(props: MotionMasterMessage.Request.ISetMotionControllerParameters & DeviceRef, messageId?: string): Observable<undefined>;
+    setMotionControllerParametersAsync(props: MotionMasterMessage.Request.ISetMotionControllerParameters & DeviceRef, messageId?: string): Promise<void>;
+    enableMotionController(props: MotionMasterMessage.Request.IEnableMotionController & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.MotionController & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    enableMotionControllerAsync(props: MotionMasterMessage.Request.IEnableMotionController & DeviceRef, requestTimeout: number, messageId?: string): Promise<{
+        controllerType: MotionMasterMessage.Request.EnableMotionController.ControllerType;
+        enabled: boolean;
+        filter: boolean;
+    }>;
+    disableMotionController(props: MotionMasterMessage.Request.IDisableMotionController & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.MotionController & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    disableMotionControllerAsync(props: MotionMasterMessage.Request.IDisableMotionController & DeviceRef, requestTimeout: number, messageId?: string): Promise<{
+        controllerType: MotionMasterMessage.Request.EnableMotionController.ControllerType;
+        enabled: boolean;
+        filter: boolean;
+    }>;
+    setSignalGeneratorParameters(props: MotionMasterMessage.Request.ISetSignalGeneratorParameters & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.SignalGenerator & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    setSignalGeneratorParametersAsync(props: MotionMasterMessage.Request.ISetSignalGeneratorParameters & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    startSignalGenerator(props: MotionMasterMessage.Request.IStartSignalGenerator & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.SignalGenerator & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    startSignalGeneratorAsync(props: MotionMasterMessage.Request.IStartSignalGenerator & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    stopSignalGenerator(props: MotionMasterMessage.Request.IStopSignalGenerator & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.SignalGenerator & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    stopSignalGeneratorAsync(props: MotionMasterMessage.Request.IStopSignalGenerator & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    startMonitoringDeviceParameterValues(props: MotionMasterMessage.Request.IStartMonitoringDeviceParameterValues, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.MonitoringParameterValues & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    startMonitoringDeviceParameterValuesAsync(props: MotionMasterMessage.Request.IStartMonitoringDeviceParameterValues, requestTimeout: number, messageId?: string): Promise<string | undefined>;
+    stopMonitoringDeviceParameterValues(props: MotionMasterMessage.Request.IStopMonitoringDeviceParameterValues, messageId?: string): Observable<undefined>;
+    stopMonitoringDeviceParameterValuesAsync(props: MotionMasterMessage.Request.IStopMonitoringDeviceParameterValues, messageId?: string): Promise<undefined>;
+    getEthercatNetworkState(props: MotionMasterMessage.Request.IGetEthercatNetworkState & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.IEthercatNetworkState & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    getEthercatNetworkStateAsync(props: MotionMasterMessage.Request.IGetEthercatNetworkState & DeviceRef, requestTimeout: number, messageId?: string): Promise<MotionMasterMessage.Status.EthercatNetworkState.State>;
+    setEthercatNetworkState(props: MotionMasterMessage.Request.ISetEthercatNetworkState & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.IEthercatNetworkState & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    setEthercatNetworkStateAsync(props: MotionMasterMessage.Request.ISetEthercatNetworkState & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    /**
+     * @deprecated
+     */
+    startNarrowAngleCalibration(props: MotionMasterMessage.Request.IStartNarrowAngleCalibration & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.INarrowAngleCalibration & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    /**
+     * @deprecated
+     */
+    startNarrowAngleCalibrationAsync(props: MotionMasterMessage.Request.IStartNarrowAngleCalibration & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    setSystemClientTimeout(props: MotionMasterMessage.Request.ISetSystemClientTimeout, messageId?: string): Observable<undefined>;
+    setSystemClientTimeoutAsync(props: MotionMasterMessage.Request.ISetSystemClientTimeout, messageId?: string): Promise<undefined>;
+    startSystemIdentification(props: MotionMasterMessage.Request.IStartSystemIdentification & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.ISystemIdentification & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    startSystemIdentificationAsync(props: MotionMasterMessage.Request.IStartSystemIdentification & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    getCirculoEncoderMagnetDistance(props: MotionMasterMessage.Request.IGetCirculoEncoderMagnetDistance & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.ICirculoEncoderMagnetDistance & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    getCirculoEncoderMagnetDistanceAsync(props: MotionMasterMessage.Request.IGetCirculoEncoderMagnetDistance & DeviceRef, requestTimeout: number, messageId?: string): Promise<{
+        distance: number | null | undefined;
+        encoderOrdinal: number | null | undefined;
+        position: number | null | undefined;
+    }>;
+    startCirculoEncoderNarrowAngleCalibrationProcedure(props: MotionMasterMessage.Request.IStartCirculoEncoderNarrowAngleCalibrationProcedure & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.CirculoEncoderNarrowAngleCalibrationProcedure & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    startCirculoEncoderNarrowAngleCalibrationProcedureAsync(props: MotionMasterMessage.Request.IStartCirculoEncoderNarrowAngleCalibrationProcedure & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    getDeviceCia402State(props: MotionMasterMessage.Request.IGetDeviceCiA402State & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.DeviceCiA402State & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    getDeviceCia402StateAsync(props: MotionMasterMessage.Request.IGetDeviceCiA402State & DeviceRef, requestTimeout: number, messageId?: string): Promise<MotionMasterMessage.Status.DeviceCiA402State.State>;
+    setDeviceCia402State(props: MotionMasterMessage.Request.ISetDeviceCiA402State & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.DeviceCiA402State & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    setDeviceCia402StateAsync(props: MotionMasterMessage.Request.ISetDeviceCiA402State & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    getSystemLog(requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.SystemLog & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    getSystemLogAsync(requestTimeout: number): Promise<{
+        content: string;
+        runEnv: string;
+    }>;
+    startDeviceSiiRestore(props: MotionMasterMessage.Request.IStartDeviceSiiRestore, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.DeviceSiiRestore & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    startDeviceSiiRestoreAsync(props: MotionMasterMessage.Request.IStartDeviceSiiRestore, requestTimeout: number, messageId?: string): Promise<void>;
+    startOpenLoopFieldControl(props: MotionMasterMessage.Request.IStartOpenLoopFieldControl & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.OpenLoopFieldControl & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    startOpenLoopFieldControlAsync(props: MotionMasterMessage.Request.IStartOpenLoopFieldControl & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    /**
+     * @deprecated
+     */
+    computeFullAutoTuningGains(props: MotionMasterMessage.Request.IComputeFullAutoTuningGains & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.FullAutoTuning & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    /**
+     * @deprecated
+     */
+    computeFullAutoTuningGainsAsync(props: MotionMasterMessage.Request.IComputeFullAutoTuningGains & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    startFullAutoTuning(props: MotionMasterMessage.Request.IStartFullAutoTuning & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.FullAutoTuning & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    startFullAutoTuningAsync(props: MotionMasterMessage.Request.IStartFullAutoTuning & DeviceRef, requestTimeout: number, messageId?: string): Promise<{
+        bandwidth: number | null | undefined;
+        dampingRatio: number;
+    } | {
+        dampingRatio: number;
+        settlingTime: number | null | undefined;
+    }>;
+    stopFullAutoTuning(props: MotionMasterMessage.Request.IStopFullAutoTuning & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.FullAutoTuning & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    stopFullAutoTuningAsync(props: MotionMasterMessage.Request.IStopFullAutoTuning & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    startCirculoEncoderConfiguration(props: MotionMasterMessage.Request.IStartCirculoEncoderConfiguration & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.CirculoEncoderConfiguration & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    startCirculoEncoderConfigurationAsync(props: MotionMasterMessage.Request.IStartCirculoEncoderConfiguration & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    stopCirculoEncoderNarrowAngleCalibrationProcedure(props: MotionMasterMessage.Request.IStopCirculoEncoderNarrowAngleCalibrationProcedure & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.CirculoEncoderNarrowAngleCalibrationProcedure & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    stopCirculoEncoderNarrowAngleCalibrationProcedureAsync(props: MotionMasterMessage.Request.IStopCirculoEncoderNarrowAngleCalibrationProcedure & DeviceRef, requestTimeout: number, messageId?: string): Promise<void>;
+    startOsCommand(props: MotionMasterMessage.Request.IStartOsCommand & DeviceRef, requestTimeout: number, messageId?: string): Observable<MotionMasterMessage.Status.OsCommand & {
+        request: import("./types").RequestStatus;
+    } & {
+        messageId: string | undefined;
+    }>;
+    startOsCommandAsync(props: MotionMasterMessage.Request.IStartOsCommand & DeviceRef, requestTimeout: number, messageId?: string): Promise<Uint8Array>;
+    sendRequest(request: MotionMasterMessage.IRequest, messageId?: string): string;
+    resolveDeviceAddress(deviceRef: DeviceRef): Promise<number>;
+    getDeviceAddresses(requestTimeout?: number): Promise<number[]>;
+    getDeviceHardwareDescription(deviceAddress: number, requestTimeout?: number): Promise<HardwareDescription>;
+    getSystemLogLines(requestTimeout?: number): Promise<SystemLogLine[]>;
+    getAllParameters(props: {
+        deviceAddress: number;
+        loadFromCache?: boolean;
+        sendProgress?: boolean;
+    }, requestTimeout: number): Observable<Parameter[]>;
+    getAllParametersAsync(props: {
+        deviceAddress: number;
+        loadFromCache?: boolean;
+        sendProgress?: boolean;
+    }, requestTimeout: number): Promise<Parameter[]>;
+    getParameterValue<T extends ParameterValueType = number>(deviceAddress: number, index: number, subindex: number, loadFromCache?: boolean, requestTimeout?: number): Promise<T>;
+    setParameterValue(deviceAddress: number, index: number, subindex: number, value: ParameterValueType, valueTypeKey?: keyof Required<ParameterTypeValue>, requestTimeout?: number): Promise<void>;
+    setParameterValues(deviceAddress: number, values: ParameterAddressValue[], requestTimeout?: number): Promise<void>;
+    getDecodedDeviceFile(props: MotionMasterMessage.Request.IGetDeviceFile, requestTimeout: number, messageId?: string): Promise<string>;
+    getDeviceFiles(deviceAddress: number, requestTimeout?: number): Promise<string[]>;
+    getDeviceParameterInfoAndValues(props: {
+        deviceAddress?: number | null;
+        loadFromCache?: boolean | null;
+        sendProgress?: boolean | null;
+    }, requestTimeout: number): Observable<DeviceParameterValuesStatus>;
+    getDeviceParameterInfoAndValuesAsync(props: {
+        deviceAddress?: number | null;
+        loadFromCache?: boolean | null;
+        sendProgress?: boolean | null;
+    }, requestTimeout: number): Promise<MotionMasterMessage.Status.DeviceParameterValues.IParameterValue[] | null | undefined>;
+    saveAllParameters(props: {
+        deviceAddress?: number | null;
+    }, requestTimeout: number): Observable<void>;
+    restoreAllDefaultParameters(props: {
+        deviceAddress?: number | null;
+    }, requestTimeout: number): Observable<void>;
+    checkDeviceParameterValue(props: {
+        deviceAddress?: number | null;
+        parameter: MotionMasterMessage.Request.GetDeviceParameterValues.IParameter;
+        expectedValue: number | string;
+    }, requestTimeout: number, messageId?: string): Observable<void>;
+    getDeviceApiIdentifier(deviceAddress: number, requestTimeout?: number): Promise<string>;
+    enableMotion(deviceAddress: number, controllerType: MotionMasterMessage.Request.EnableMotionController.ControllerType, filter?: boolean, requestTimeout?: number): Promise<{
+        controllerType: MotionMasterMessage.Request.EnableMotionController.ControllerType;
+        enabled: boolean;
+        filter: boolean;
+    }>;
+    setMotionTarget(deviceAddress: number, target: number): Promise<void>;
+    disableMotion(deviceAddress: number, requestTimeout?: number): Promise<{
+        controllerType: MotionMasterMessage.Request.EnableMotionController.ControllerType;
+        enabled: boolean;
+        filter: boolean;
+    }>;
+}