motion-master-client 0.0.2 → 0.0.6

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

@@ -1,1625 +0,0 @@
-import { defer, EMPTY, from, lastValueFrom, Observable, tap } from "rxjs";
-import { delay, map, mergeMap } from "rxjs/operators";
-import { v4 } from "uuid";
-import { splitDeviceParameterId } from "./device-parameter";
-import { getApiIdentifierFromHardwareDescription, getSerialNumberFromHardwareDescription, HardwareDescription } from "./hardware-description";
-import { MotionMasterReqResSocket } from "./motion-master-req-res-socket";
-import { retryWithDelay, transformMotionMasterMessageToStatus } from "./operators";
-import { makeParameterId, Parameter, splitParameterId } from "./parameter";
-import { SystemLogLine } from "./system-log-line";
-import { MotionMasterMessage, ParameterValueType, ParameterTypeValue, ParameterInfoAndValue, DeviceParameterValuesStatus, ParameterAddressValue, ParameterTypeValueKey, DeviceRefObj, RequestError } from "./types";
-import { decodeTextContent, valueTypeToParameterTypeValueKeyMap, getParameterValue, parseSystemLogContent, makeDeviceRefObj } from "./util";
-
-/**
- * This class contains methods for making requests to Motion Master using the injected request/response socket.
- *
- * Each request message defined in the proto file has two corresponding request methods in this class. One method supports Reactive and the other Promise-based API.
- * Reactive API is the default one. Unlike promises which resolve to a single value, observables can emit multiple values over time. For some requests like firmware installation,
- * Motion Master will send progress messages until the firmware installation is done.
- * Reactive request methods are named like `getDeviceInfo` and Promise-based are named like `getDeviceInfoAsync` (notice the `Async` suffix).
- *
- * Reactive and Promise-based request methods have the same set of input parameters, but they differ in the return values.
- * Call to Reactive request methods will return an Observable of (1) corresponding status message, for example call to `getDeviceInfo`
- * will return an instance of `MotionMasterMessage.Status.DeviceInfo`, (2) request status, and (3) request message id.
- * Promise-based request methods can only return (resolve to) a single value. These methods call the corresponding Reactive request method and return data
- * from the last emmited status message. For example `getDeviceInfoAsync` calls `getDeviceInfo` and returns a list of devices from
- * the last emmited status message. If the request fails on Motion Master the function will throw an error. It can also throw an error if request times out.
- *
- * Request methods have optional `messageId` input parameter. If `messageId` is not provided, one will be generated before sending the request message to Motion Master.
- * Status messages (responses) received from Motion Master that correspond to the previous request will have the same `messageId` as the one in the request.
- * This is how we match request with response messages in the full-duplex asynchronous communication (WebSockets, ZeroMQ).
- * Matching request/response by message id is inspired by [JSON-RPC 2.0 Specification](https://www.jsonrpc.org/specification).
- *
- * Almost all request methods have mandatory `requestTimeout` input parameter.
- * This parameter specifies how long (in milliseconds) will the client wait for the status (response) messages corresponding to the previous request.
- * If status message is not received in due time the request method will throw a timeout error.
- * The error doesn't mean the request has failed on Motion Master, but rather that client has given up waiting for the response(s).
- *
- * @example
- * How to handle Reactive request method timeout error:
- * ```ts
- * req.getDeviceInfo(10).subscribe({
- *   next: (status) => console.log(status),
- *   error: (err: unknown) => {
- *     if (err instanceof TimeoutError) {
- *       alert('Request has timed out');
- *     }
- *   }
- * });
- * ```
- * How to handle Promise-based request method timeout error:
- * ```ts
- * async () => {
- *   try {
- *     const devices = await req.getDeviceInfoAsync(10);
- *     console.log(devices);
- *   } catch (err: unknown) {
- *     if (err instanceof TimeoutError) {
- *       alert('Request has timed out');
- *     }
- *   }
- * }
- * ```
- *
- * Request methods for a particular device, like `getDeviceParameterInfo`, as the first input parameter accept the type of request message as defined in the proto file.
- * For `getDeviceParameterInfo` that's `MotionMasterMessage.Request.IGetDeviceParameterInfo`. This type is extended (via type intersection) by `DeviceRefObj`.
- * This is done in order to support multiple ways to reference a device. Motion Master only supports device address which it re-generates for each device on power-cycle.
- * Because device address can change, for scripts and applications it's preferred to use a device reference that won't change.
- * Device serial number in the hardware description file uniquely identifies device and doesn't change. This is what each request message is extended with.
- * Before sending the request message to Motion Master, device address gets resolved and is set on the request message.
- * Beside device address and device serial number, devices can be referenced by position (sequence number in the network).
- *
- * It is ensured that Observable returned from a call to Reactive request method will eventually complete, so a call to unsubscribe is not required.
- * Observable will complete when request status is either "succeeded" or "failed", and it can complete (error) due to timeout.
- * Finding out if a request has completed, failed or is it still on-going is different for each request - it dependends on the status messages, see {@link requestStatusResolver}.
- * Reactive request methods handle this and for each request they will emit status messages with one of "succeeded", "failed", or "running" request status.
- *
- * Beside the request methods this class contains many helper methods such as the ones for getting and setting device parameter values and
- * saving all parameters which involves complex logic like multiple repeating requests in order to determine if saving all parameters has completed successfully.
- */
-export class MotionMasterReqResClient {
-
-  /**
-   * Map device address to a map of parameter id to type value key.
-   *
-   * @example
-   * ```ts
-   * new Map([
-   *   [2045285448, new Map([
-   *     ["0x1018:02", "uintValue"]
-   *   ])]
-   * ]);
-   * ```
-   *
-   * When setting a parameter value only one of int, uint, float, string, or raw type value fields must be set.
-   * This is defined in the proto file SetDeviceParameterValues request message.
-   *
-   * Device parameters have richer set of base types defined in ESI and they're provided by DeviceParameterInfo status message.
-   * When device parameter info is fetched this map gets updated by mapping device parameters type to oneof proto type, e.g. `INTEGER32 -> intValue`.
-   *
-   * This map helps in simplifying the API by allowing users to set parameter values without specifying the type value field.
-   * One can simply call `await setParameterValue(2045285448, 0x2004, 0x03, 2500)` and the correct type value field on the proto message will be set, `uintValue` in this example.
-   */
-  readonly parameterTypeValueKeyMap = new Map<number, Map<string, ParameterTypeValueKey>>();
-
-  /**
-   * Map device serial number to device address.
-   *
-   * @example
-   * ```ts
-   * new Map([
-   *   ["8502-03-0001353-2115", 2045285448]
-   * ]);
-   * ```
-   *
-   * When making requests related to a device, device address is used as an identifier.
-   * Device address is not permanent. The number is re-generated by Motion Master when devices are power-cycled.
-   * For scripts and applications that use this library, having a permanent device identifier is a better option.
-   * Device serial number read from the hardware description file (.hardware_description) stored on a device is a permanent identifier.
-   *
-   * This map helps in making all request functions related to a device accept device reference instead of just device address as an identifier.
-   * Device reference can be one of: device address, device serial number, or device position.
-   * Prior to sending a request message to Motion Master, device address is resolved from device reference and this map is used for that.
-   */
-  readonly deviceAddressMap = new Map<string, number>();
-
-  constructor(
-    public readonly socket: MotionMasterReqResSocket,
-  ) { }
-
-  //
-  // Requests
-  //
-
-  /**
-   * Ping system.
-   *
-   * Client must send messages to Motion Master in regular intervals in order for Motion Master to consider it alive.
-   * When client is considered "not alive", Motion Master will stop the ongoing procedures and monitorings started by that client.
-   * Each client on the Motion Master side has its own default timeout which can be changed by {@link setSystemClientTimeout}.
-   */
-  pingSystem(messageId?: string) {
-    const pingSystem = MotionMasterMessage.Request.PingSystem.create();
-    this.sendRequest({ pingSystem }, messageId);
-    return EMPTY;
-  }
-
-  /**
-   * {@inheritDoc pingSystem}
-   */
-  async pingSystemAsync(messageId?: string) {
-    return await lastValueFrom(this.pingSystem(messageId), { defaultValue: undefined });
-  }
-
-  /**
-   * Get system version.
-   *
-   * Motion Master version follows [Semantic Versioning 2.0.0](https://semver.org/).
-   */
-  getSystemVersion(requestTimeout: number, messageId?: string) {
-    const getSystemVersion = MotionMasterMessage.Request.GetSystemVersion.create();
-    const id = this.sendRequest({ getSystemVersion }, messageId);
-    return this.socket.message$.pipe(
-      transformMotionMasterMessageToStatus<MotionMasterMessage.Status.SystemVersion>('systemVersion', requestTimeout, id),
-    );
-  }
-
-  /**
-   * {@inheritDoc getSystemVersion}
-   */
-  async getSystemVersionAsync(requestTimeout: number, messageId?: string) {
-    const status = await lastValueFrom(this.getSystemVersion(requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return status.version;
-    }
-
-    throw new RequestError('Get system version request failed.');
-  }
-
-  /**
-   * Get device info.
-   *
-   * Device info includes a list of devices on network.
-   * Call this method to get device addresses for requests specific to devices.
-   */
-  getDeviceInfo(requestTimeout: number, messageId?: string) {
-    const getDeviceInfo = MotionMasterMessage.Request.GetDeviceInfo.create();
-    const id = this.sendRequest({ getDeviceInfo }, messageId);
-    return this.socket.message$.pipe(
-      transformMotionMasterMessageToStatus<MotionMasterMessage.Status.DeviceInfo>('deviceInfo', requestTimeout, id),
-    );
-  }
-
-  /**
-   * {@inheritDoc getDeviceInfo}
-   */
-  async getDeviceInfoAsync(requestTimeout: number, messageId?: string) {
-    const status = await lastValueFrom(this.getDeviceInfo(requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return status.devices;
-    }
-
-    throw new Error('Get device info request failed.');
-  }
-
-  getDeviceParameterInfo(props: MotionMasterMessage.Request.IGetDeviceParameterInfo & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const getDeviceParameterInfo = MotionMasterMessage.Request.GetDeviceParameterInfo.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ getDeviceParameterInfo }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.DeviceParameterInfo>('deviceParameterInfo', requestTimeout, id),
-          tap((deviceParameterInfo) => {
-            const parameters = deviceParameterInfo?.parameters;
-            if (parameters) {
-              const map: Map<string, ParameterTypeValueKey> = new Map();
-              this.parameterTypeValueKeyMap.set(+deviceAddress, map);
-              for (const parameter of parameters) {
-                if (parameter.valueType) {
-                  const typeValueKey = valueTypeToParameterTypeValueKeyMap.get(parameter.valueType);
-                  if (typeValueKey) {
-                    map.set(makeParameterId(parameter), typeValueKey);
-                  }
-                }
-              }
-            }
-          }),
-        );
-      }),
-    );
-  }
-
-  async getDeviceParameterInfoAsync(props: MotionMasterMessage.Request.IGetDeviceParameterInfo & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<MotionMasterMessage.Status.DeviceParameterInfo.IParameter[]> {
-    const status = await lastValueFrom(this.getDeviceParameterInfo(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return status.parameters;
-    }
-
-    throw new Error('Get device parameter info request failed.');
-  }
-
-  getDeviceParameterValues(props: MotionMasterMessage.Request.IGetDeviceParameterValues & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const getDeviceParameterValues = MotionMasterMessage.Request.GetDeviceParameterValues.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ getDeviceParameterValues }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.DeviceParameterValues>('deviceParameterValues', requestTimeout, id),
-        );
-      }),
-    )
-  }
-
-  async getDeviceParameterValuesAsync(props: MotionMasterMessage.Request.IGetDeviceParameterValues & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<MotionMasterMessage.Status.DeviceParameterValues.IParameterValue[]> {
-    const status = await lastValueFrom(this.getDeviceParameterValues(props, requestTimeout, messageId));
-
-    return status.parameterValues;
-  }
-
-  getMultiDeviceParameterValues(props: MotionMasterMessage.Request.IGetMultiDeviceParameterValues, requestTimeout: number, messageId?: string) {
-    const getMultiDeviceParameterValues = MotionMasterMessage.Request.GetMultiDeviceParameterValues.create(props);
-    const id = this.sendRequest({ getMultiDeviceParameterValues }, messageId);
-    return this.socket.message$.pipe(
-      transformMotionMasterMessageToStatus<MotionMasterMessage.Status.MultiDeviceParameterValues>('multiDeviceParameterValues', requestTimeout, id),
-    );
-  }
-
-  async getMultiDeviceParameterValuesAsync(props: MotionMasterMessage.Request.IGetMultiDeviceParameterValues, requestTimeout: number, messageId?: string): Promise<MotionMasterMessage.Status.IDeviceParameterValues[]> {
-    const status = await lastValueFrom(this.getMultiDeviceParameterValues(props, requestTimeout, messageId));
-
-    return status.collection;
-  }
-
-  setDeviceParameterValues(props: MotionMasterMessage.Request.ISetDeviceParameterValues & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const setDeviceParameterValues = MotionMasterMessage.Request.SetDeviceParameterValues.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ setDeviceParameterValues }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.DeviceParameterValues>('deviceParameterValues', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async setDeviceParameterValuesAsync(props: MotionMasterMessage.Request.ISetDeviceParameterValues & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<MotionMasterMessage.Status.DeviceParameterValues.IParameterValue[]> {
-    const status = await lastValueFrom(this.setDeviceParameterValues(props, requestTimeout, messageId));
-
-    return status.parameterValues;
-  }
-
-  setMultiDeviceParameterValues(props: MotionMasterMessage.Request.ISetMultiDeviceParameterValues, requestTimeout: number, messageId?: string) {
-    const setMultiDeviceParameterValues = MotionMasterMessage.Request.SetMultiDeviceParameterValues.create(props);
-    const id = this.sendRequest({ setMultiDeviceParameterValues }, messageId);
-    return this.socket.message$.pipe(
-      transformMotionMasterMessageToStatus<MotionMasterMessage.Status.MultiDeviceParameterValues>('multiDeviceParameterValues', requestTimeout, id),
-    );
-  }
-
-  async setMultiDeviceParameterValuesAsync(props: MotionMasterMessage.Request.ISetMultiDeviceParameterValues, requestTimeout: number, messageId?: string): Promise<MotionMasterMessage.Status.IDeviceParameterValues[]> {
-    const status = await lastValueFrom(this.setMultiDeviceParameterValues(props, requestTimeout, messageId));
-
-    return status.collection;
-  }
-
-  /**
-   * Get device file list.
-   *
-   * Motion Master will use Filetransfer over EtherCAT (FoE) to get the list of files from a device.
-   * There isn't really a command for getting the list, but rather the content of a specially named file "fs-getlist" is the file list.
-   * The list can be read like any other file from a device using the IgH EtherCAT Master for Linux CLI program:
-   *
-   * ```
-   * $ ethercat foe_read fs-getlist
-   * ```
-   *
-   * At the time of writing this document "fs-getlist" returns only 32 files in the list. This is the firmware's limitation.
-   * More than 32 files can be stored on device flash memory, but they won't appear in the list.
-   * Also note that FoE can behave differently in the bootstrap firmware which runs in the BOOT EtherCAT state and
-   * SOMANET firmware which runs in other EtherCAT states like OP. Bootstrap tends to be buggier since it cannot be updated easily, so
-   * Motion Master has certain workarounds to overcome the FoE differences.
-   */
-  getDeviceFileList(props: MotionMasterMessage.Request.IGetDeviceFileList & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const getDeviceFileList = MotionMasterMessage.Request.GetDeviceFileList.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ getDeviceFileList }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.DeviceFileList>('deviceFileList', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc getDeviceFileList}
-   */
-  async getDeviceFileListAsync(props: MotionMasterMessage.Request.IGetDeviceFileList & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<string[]> {
-    const status = await lastValueFrom(this.getDeviceFileList(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return status.fileList?.files ?? [];
-    }
-
-    throw new Error(`Failed to get device file list. ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  /**
-   * Get device file.
-   *
-   * Motion Master uses the Filetransfer over EtherCAT (FoE) to read and send back the content of a file from device flash memory.
-   *
-   * The IgH EtherCAT Master library used by Motion Master limits the file read buffer to 9KB, so any file written to flash that is larger than 9KB
-   * needs to be split into parts of max 9KB. Motion Master does this automatically on request to {@link setDeviceFile}.
-   *
-   * Upon receiving this request Motion Master will first read the list of files on a device, see {@link getDeviceFileList}.
-   * It does that in order to determine if the requested file, for example "SOMANET_CiA402.xml", has been stored in multiple parts.
-   * The parts are named like "SOMANET_CiA_402.xml.zip.part000", "SOMANET_CiA_402.xml.zip.part001" and so on.
-   * Motion Master will read all parts of the requested file, unzip it and send the content back to a client.
-   * Since the number of items in the list of files is limited to 32 (based on the firmware version) Motion Master might not see the file,
-   * but in any case it will try to read the content of it. If the file exists it will return its content, otherwise it will send the file not found error.
-   *
-   * In BOOT EtherCAT state it's only allowed to read the .hardware_description file. This was done because
-   * the bootloader firmware would hang when trying to read a corrupted or missing file.
-   *
-   * If file content is empty Motion Master will return not found error. This is a subject to change now that Motion Master reads the file error codes.
-   */
-  getDeviceFile(props: MotionMasterMessage.Request.IGetDeviceFile & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const getDeviceFile = MotionMasterMessage.Request.GetDeviceFile.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ getDeviceFile }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.DeviceFile>('deviceFile', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc getDeviceFile}
-   */
-  async getDeviceFileAsync(props: MotionMasterMessage.Request.IGetDeviceFile & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<Uint8Array> {
-    const status = await lastValueFrom(this.getDeviceFile(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      if (status.content) {
-        return status.content;
-      }
-    }
-
-    throw new Error(`Failed to get device file. ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  /**
-   * Set device file.
-   *
-   * Motion Master uses the Filetransfer over EtherCAT (FoE) to write files to device flash memory.
-   *
-   * The IgH EtherCAT Master library used by Motion Master limits the file read buffer to 9KB, so any file written to flash that is larger than 9KB
-   * needs to be split into parts of max 9KB. Motion Master does this automatically by first zipping the content and then writing the parts.
-   * The parts are named like "SOMANET_CiA_402.xml.zip.part000", "SOMANET_CiA_402.xml.zip.part001" and so on.
-   */
-  setDeviceFile(props: MotionMasterMessage.Request.ISetDeviceFile & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const setDeviceFile = MotionMasterMessage.Request.SetDeviceFile.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ setDeviceFile }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.DeviceFile>('deviceFile', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc setDeviceFile}
-   */
-  async setDeviceFileAsync(props: MotionMasterMessage.Request.ISetDeviceFile & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<void> {
-    const status = await lastValueFrom(this.setDeviceFile(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed to set device file. ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  deleteDeviceFile(props: MotionMasterMessage.Request.IDeleteDeviceFile & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const deleteDeviceFile = MotionMasterMessage.Request.DeleteDeviceFile.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ deleteDeviceFile }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.DeviceFile>('deviceFile', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async deleteDeviceFileAsync(props: MotionMasterMessage.Request.IDeleteDeviceFile & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<void> {
-    const status = await lastValueFrom(this.deleteDeviceFile(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed to delete device file. ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  /**
-   * Reset device fault.
-   *
-   * When error occurs on a device it will go to Fault reaction active state (transition 13) and then automatically to Fault state (transition 14).
-   * The CiA402 state of a device can be derived from the value of Statusword object (0x6041:00).
-   * In order to go out of Fault and into Switch on disabled state (transition 15) master must send Fault reset command via Controlword object (0x6040:00).
-   *
-   * When this request is sent to Motion Master it will try to reset fault. Resetting fault can succeed or fail.
-   * While resetting the fault Motion Master will use the current Controlword value and set the Reset fault bit to 1,
-   * but when it completes (either success or error) it will set it back to 0.
-   *
-   * Motion Master will return "No Fault" warning when this request is sent and device is not in Fault or Fault reaction active state.
-   * If this request is sent when device is in Fault reaction active state, then Motion Master will
-   * wait for the automatic transition (14) to Fault state before trying to reset fault.
-   * When Motion Master sets the Controlword Fault bit to 1, it will occasionally check if device is no longer in Fault state.
-   * After a couple of seconds, if device is still in Fault state, it will give up and return the time out error.
-   */
-  resetDeviceFault(props: MotionMasterMessage.Request.IResetDeviceFault & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const resetDeviceFault = MotionMasterMessage.Request.ResetDeviceFault.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ resetDeviceFault }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.IDeviceFaultReset>('deviceFaultReset', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc resetDeviceFault}
-   */
-  async resetDeviceFaultAsync(props: MotionMasterMessage.Request.IResetDeviceFault & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<void> {
-    const status = await lastValueFrom(this.resetDeviceFault(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed to reset device fault. ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  /**
-   * Stop device.
-   *
-   * Motion Master will use the current value of the Controlword object and set the command on it to Quick stop.
-   * It will then wait for up to 2 seconds for a device to get into one of the following CiA402 states: Switch on disabled, Operation enabled, Fault.
-   * It does that by periodically checking the value of the Statusword object. If the device doesn't go into one of those states
-   * Motion Master will return the timeout or quick stop failed error.
-   */
-  stopDevice(props: MotionMasterMessage.Request.IStopDevice & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const stopDevice = MotionMasterMessage.Request.StopDevice.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ stopDevice }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.DeviceStop>('deviceStop', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc stopDevice}
-   */
-  async stopDeviceAsync(props: MotionMasterMessage.Request.IStopDevice & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<void> {
-    const status = await lastValueFrom(this.stopDevice(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed to stop device. ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  startDeviceFirmwareInstallation(props: MotionMasterMessage.Request.IStartDeviceFirmwareInstallation & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const startDeviceFirmwareInstallation = MotionMasterMessage.Request.StartDeviceFirmwareInstallation.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ startDeviceFirmwareInstallation }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.DeviceFirmwareInstallation>('deviceFirmwareInstallation', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async startDeviceFirmwareInstallationAsync(props: MotionMasterMessage.Request.IStartDeviceFirmwareInstallation & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<void> {
-    const status = await lastValueFrom(this.startDeviceFirmwareInstallation(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed to start device firmware installation. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  getDeviceLog(props: MotionMasterMessage.Request.IGetDeviceLog & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const getDeviceLog = MotionMasterMessage.Request.GetDeviceLog.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ getDeviceLog }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.IDeviceLog>('deviceLog', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async getDeviceLogAsync(props: MotionMasterMessage.Request.IGetDeviceLog & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<string | null | undefined> {
-    const status = await lastValueFrom(this.getDeviceLog(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return status.content;
-    }
-
-    throw new Error(`Failed to get device log. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  startCoggingTorqueRecording(props: MotionMasterMessage.Request.IStartCoggingTorqueRecording & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const startCoggingTorqueRecording = MotionMasterMessage.Request.StartCoggingTorqueRecording.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ startCoggingTorqueRecording }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.ICoggingTorqueRecording>('coggingTorqueRecording', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async startCoggingTorqueRecordingAsync(props: MotionMasterMessage.Request.IStartCoggingTorqueRecording & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<void> {
-    const status = await lastValueFrom(this.startCoggingTorqueRecording(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed to start cogging torque recording. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  getCoggingTorqueData(props: MotionMasterMessage.Request.IGetCoggingTorqueData & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const getCoggingTorqueData = MotionMasterMessage.Request.GetCoggingTorqueData.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ getCoggingTorqueData }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.ICoggingTorqueData>('coggingTorqueData', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async getCoggingTorqueDataAsync(props: MotionMasterMessage.Request.IGetCoggingTorqueData & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<number[]> {
-    const status = await lastValueFrom(this.getCoggingTorqueData(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return status.table?.data ?? [];
-    }
-
-    throw new Error(`Failed to get cogging torque data. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  startOffsetDetection(props: MotionMasterMessage.Request.IStartOffsetDetection & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const startOffsetDetection = MotionMasterMessage.Request.StartOffsetDetection.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ startOffsetDetection }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.IOffsetDetection>('offsetDetection', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async startOffsetDetectionAsync(props: MotionMasterMessage.Request.IStartOffsetDetection & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<void> {
-    const status = await lastValueFrom(this.startOffsetDetection(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed start offset detection. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  /**
-   * @deprecated
-   */
-  startPlantIdentification(props: MotionMasterMessage.Request.IStartPlantIdentification & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const startPlantIdentification = MotionMasterMessage.Request.StartPlantIdentification.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ startPlantIdentification }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.IPlantIdentification>('plantIdentification', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  /**
-   * @deprecated
-   */
-  async startPlantIdentificationAsync(props: MotionMasterMessage.Request.IStartPlantIdentification & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    const status = await lastValueFrom(this.startPlantIdentification(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed start plant identification. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  computeAutoTuningGains(props: MotionMasterMessage.Request.IComputeAutoTuningGains & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const computeAutoTuningGains = MotionMasterMessage.Request.ComputeAutoTuningGains.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ computeAutoTuningGains }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.IAutoTuning>('autoTuning', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async computeAutoTuningGainsAsync(props: MotionMasterMessage.Request.IComputeAutoTuningGains & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    const status = await lastValueFrom(this.computeAutoTuningGains(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed to compute auto tuning gains. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  setMotionControllerParameters(props: MotionMasterMessage.Request.ISetMotionControllerParameters & DeviceRefObj, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const setMotionControllerParameters = MotionMasterMessage.Request.SetMotionControllerParameters.create({ ...props, deviceAddress });
-        this.sendRequest({ setMotionControllerParameters }, messageId);
-        return EMPTY;
-      }),
-    );
-  }
-
-  async setMotionControllerParametersAsync(props: MotionMasterMessage.Request.ISetMotionControllerParameters & DeviceRefObj, messageId?: string): Promise<void> {
-    return await lastValueFrom(this.setMotionControllerParameters(props, messageId), { defaultValue: undefined });
-  }
-
-  enableMotionController(props: MotionMasterMessage.Request.IEnableMotionController & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const enableMotionController = MotionMasterMessage.Request.EnableMotionController.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ enableMotionController }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.MotionController>('motionController', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async enableMotionControllerAsync(props: MotionMasterMessage.Request.IEnableMotionController & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<{ controllerType: MotionMasterMessage.Request.EnableMotionController.ControllerType, enabled: boolean, filter: boolean }> {
-    const status = await lastValueFrom(this.enableMotionController(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return (({ controllerType, enabled, filter }) => ({ controllerType, enabled, filter }))(status);
-    }
-
-    throw new Error(`Failed to enable motion controller. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  disableMotionController(props: MotionMasterMessage.Request.IDisableMotionController & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const disableMotionController = MotionMasterMessage.Request.DisableMotionController.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ disableMotionController }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.MotionController>('motionController', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async disableMotionControllerAsync(props: MotionMasterMessage.Request.IDisableMotionController & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<{ controllerType: MotionMasterMessage.Request.EnableMotionController.ControllerType, enabled: boolean, filter: boolean }> {
-    const status = await lastValueFrom(this.disableMotionController(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return (({ controllerType, enabled, filter }) => ({ controllerType, enabled, filter }))(status);
-    }
-
-    throw new Error(`Failed to disable motion controller. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  setSignalGeneratorParameters(props: MotionMasterMessage.Request.ISetSignalGeneratorParameters & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const setSignalGeneratorParameters = MotionMasterMessage.Request.SetSignalGeneratorParameters.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ setSignalGeneratorParameters }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.SignalGenerator>('signalGenerator', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async setSignalGeneratorParametersAsync(props: MotionMasterMessage.Request.ISetSignalGeneratorParameters & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<void> {
-    const status = await lastValueFrom(this.setSignalGeneratorParameters(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed to set signal generator parameters. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  startSignalGenerator(props: MotionMasterMessage.Request.IStartSignalGenerator & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const startSignalGenerator = MotionMasterMessage.Request.StartSignalGenerator.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ startSignalGenerator }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.SignalGenerator>('signalGenerator', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async startSignalGeneratorAsync(props: MotionMasterMessage.Request.IStartSignalGenerator & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<void> {
-    const status = await lastValueFrom(this.startSignalGenerator(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed to start signal generator. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  stopSignalGenerator(props: MotionMasterMessage.Request.IStopSignalGenerator & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const stopSignalGenerator = MotionMasterMessage.Request.StopSignalGenerator.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ stopSignalGenerator }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.SignalGenerator>('signalGenerator', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async stopSignalGeneratorAsync(props: MotionMasterMessage.Request.IStopSignalGenerator & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<void> {
-    const status = await lastValueFrom(this.stopSignalGenerator(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed to stop signal generator. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  startMonitoringDeviceParameterValues(props: MotionMasterMessage.Request.IStartMonitoringDeviceParameterValues, requestTimeout: number, messageId?: string) {
-    const startMonitoringDeviceParameterValues = MotionMasterMessage.Request.StartMonitoringDeviceParameterValues.create(props);
-    const id = this.sendRequest({ startMonitoringDeviceParameterValues }, messageId);
-    return this.socket.message$.pipe(
-      transformMotionMasterMessageToStatus<MotionMasterMessage.Status.MonitoringParameterValues>('monitoringParameterValues', requestTimeout, id),
-    );
-  }
-
-  async startMonitoringDeviceParameterValuesAsync(props: MotionMasterMessage.Request.IStartMonitoringDeviceParameterValues, requestTimeout: number, messageId?: string): Promise<string | undefined> {
-    const status = await lastValueFrom(this.startMonitoringDeviceParameterValues(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return status.messageId;
-    }
-
-    throw new Error(`Failed to start monitoring device parameter values. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  stopMonitoringDeviceParameterValues(props: MotionMasterMessage.Request.IStopMonitoringDeviceParameterValues, messageId?: string) {
-    const stopMonitoringDeviceParameterValues = MotionMasterMessage.Request.StopMonitoringDeviceParameterValues.create(props);
-    this.sendRequest({ stopMonitoringDeviceParameterValues }, messageId);
-    return EMPTY;
-  }
-
-  async stopMonitoringDeviceParameterValuesAsync(props: MotionMasterMessage.Request.IStopMonitoringDeviceParameterValues, messageId?: string) {
-    return await lastValueFrom(this.stopMonitoringDeviceParameterValues(props, messageId), { defaultValue: undefined });
-  }
-
-  getEthercatNetworkState(props: MotionMasterMessage.Request.IGetEthercatNetworkState & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const getEthercatNetworkState = MotionMasterMessage.Request.GetEthercatNetworkState.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ getEthercatNetworkState }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.IEthercatNetworkState>('ethercatNetworkState', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async getEthercatNetworkStateAsync(props: MotionMasterMessage.Request.IGetEthercatNetworkState & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<MotionMasterMessage.Status.EthercatNetworkState.State> {
-    const status = await lastValueFrom(this.getEthercatNetworkState(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      if (typeof status.state === 'number') {
-        return status.state;
-      }
-    }
-
-    throw new Error(`Failed get ethercat network state. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  setEthercatNetworkState(props: MotionMasterMessage.Request.ISetEthercatNetworkState & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const setEthercatNetworkState = MotionMasterMessage.Request.SetEthercatNetworkState.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ setEthercatNetworkState }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.IEthercatNetworkState>('ethercatNetworkState', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async setEthercatNetworkStateAsync(props: MotionMasterMessage.Request.ISetEthercatNetworkState & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<void> {
-    const status = await lastValueFrom(this.setEthercatNetworkState(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed set ethercat network state. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  /**
-   * @deprecated
-   */
-  startNarrowAngleCalibration(props: MotionMasterMessage.Request.IStartNarrowAngleCalibration & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const startNarrowAngleCalibration = MotionMasterMessage.Request.StartNarrowAngleCalibration.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ startNarrowAngleCalibration }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.INarrowAngleCalibration>('narrowAngleCalibration', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  /**
-   * @deprecated
-   */
-  async startNarrowAngleCalibrationAsync(props: MotionMasterMessage.Request.IStartNarrowAngleCalibration & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<void> {
-    const status = await lastValueFrom(this.startNarrowAngleCalibration(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed start narrow angle calibration. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  setSystemClientTimeout(props: MotionMasterMessage.Request.ISetSystemClientTimeout, messageId?: string) {
-    const setSystemClientTimeout = MotionMasterMessage.Request.SetSystemClientTimeout.create(props);
-    this.sendRequest({ setSystemClientTimeout }, messageId);
-    return EMPTY;
-  }
-
-  async setSystemClientTimeoutAsync(props: MotionMasterMessage.Request.ISetSystemClientTimeout, messageId?: string) {
-    return await lastValueFrom(this.setSystemClientTimeout(props, messageId), { defaultValue: undefined });
-  }
-
-  startSystemIdentification(props: MotionMasterMessage.Request.IStartSystemIdentification & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const startSystemIdentification = MotionMasterMessage.Request.StartSystemIdentification.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ startSystemIdentification }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.ISystemIdentification>('systemIdentification', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async startSystemIdentificationAsync(props: MotionMasterMessage.Request.IStartSystemIdentification & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<void> {
-    const status = await lastValueFrom(this.startSystemIdentification(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed start system identification. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  getCirculoEncoderMagnetDistance(props: MotionMasterMessage.Request.IGetCirculoEncoderMagnetDistance & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const getCirculoEncoderMagnetDistance = MotionMasterMessage.Request.GetCirculoEncoderMagnetDistance.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ getCirculoEncoderMagnetDistance }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.ICirculoEncoderMagnetDistance>('circuloEncoderMagnetDistance', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async getCirculoEncoderMagnetDistanceAsync(props: MotionMasterMessage.Request.IGetCirculoEncoderMagnetDistance & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<{ distance: number | null | undefined, encoderOrdinal: number | null | undefined, position: number | null | undefined }> {
-    const status = await lastValueFrom(this.getCirculoEncoderMagnetDistance(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return (({ distance, encoderOrdinal, position }) => ({ distance, encoderOrdinal, position }))(status);
-    }
-
-    throw new Error(`Failed to get circulo encoder magnet distance. ${JSON.stringify(props)}`);
-  }
-
-  startCirculoEncoderNarrowAngleCalibrationProcedure(props: MotionMasterMessage.Request.IStartCirculoEncoderNarrowAngleCalibrationProcedure & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const startCirculoEncoderNarrowAngleCalibrationProcedure = MotionMasterMessage.Request.StartCirculoEncoderNarrowAngleCalibrationProcedure.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ startCirculoEncoderNarrowAngleCalibrationProcedure }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.CirculoEncoderNarrowAngleCalibrationProcedure>('circuloEncoderNarrowAngleCalibrationProcedure', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async startCirculoEncoderNarrowAngleCalibrationProcedureAsync(props: MotionMasterMessage.Request.IStartCirculoEncoderNarrowAngleCalibrationProcedure & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    const status = await lastValueFrom(this.startCirculoEncoderNarrowAngleCalibrationProcedure(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed start circulo encoder narrow angle calibration procedure. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  getDeviceCia402State(props: MotionMasterMessage.Request.IGetDeviceCiA402State & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const getDeviceCia402State = MotionMasterMessage.Request.GetDeviceCiA402State.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ getDeviceCia402State }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.DeviceCiA402State>('deviceCia402State', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async getDeviceCia402StateAsync(props: MotionMasterMessage.Request.IGetDeviceCiA402State & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<MotionMasterMessage.Status.DeviceCiA402State.State> {
-    const status = await lastValueFrom(this.getDeviceCia402State(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      if (status.state) {
-        return status.state;
-      }
-    }
-
-    throw new Error(`Failed to get device cia 402 state. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  setDeviceCia402State(props: MotionMasterMessage.Request.ISetDeviceCiA402State & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const setDeviceCia402State = MotionMasterMessage.Request.SetDeviceCiA402State.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ setDeviceCia402State }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.DeviceCiA402State>('deviceCia402State', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async setDeviceCia402StateAsync(props: MotionMasterMessage.Request.ISetDeviceCiA402State & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<void> {
-    const status = await lastValueFrom(this.setDeviceCia402State(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed to set device cia 402 state. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  getSystemLog(requestTimeout: number, messageId?: string) {
-    const getSystemLog = MotionMasterMessage.Request.GetSystemVersion.create();
-    const id = this.sendRequest({ getSystemLog }, messageId);
-    return this.socket.message$.pipe(
-      transformMotionMasterMessageToStatus<MotionMasterMessage.Status.SystemLog>('systemLog', requestTimeout, id),
-    );
-  }
-
-  async getSystemLogAsync(requestTimeout: number): Promise<{ content: string, runEnv: string }> {
-    const status = await lastValueFrom(this.getSystemLog(requestTimeout));
-
-    if (status.request === 'succeeded') {
-      return (({ content, runEnv }) => ({ content, runEnv }))(status);
-    }
-
-    throw new Error(`Failed to get system log.`);
-  }
-
-  startDeviceSiiRestore(props: MotionMasterMessage.Request.IStartDeviceSiiRestore, requestTimeout: number, messageId?: string) {
-    const startDeviceSiiRestore = MotionMasterMessage.Request.StartDeviceSiiRestore.create(props);
-    const id = this.sendRequest({ startDeviceSiiRestore }, messageId);
-    return this.socket.message$.pipe(
-      transformMotionMasterMessageToStatus<MotionMasterMessage.Status.DeviceSiiRestore>('deviceSiiRestore', requestTimeout, id),
-    );
-  }
-
-  async startDeviceSiiRestoreAsync(props: MotionMasterMessage.Request.IStartDeviceSiiRestore, requestTimeout: number, messageId?: string): Promise<void> {
-    const status = await lastValueFrom(this.startDeviceSiiRestore(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed to start device sii restore. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  startOpenLoopFieldControl(props: MotionMasterMessage.Request.IStartOpenLoopFieldControl & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const startOpenLoopFieldControl = MotionMasterMessage.Request.StartOpenLoopFieldControl.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ startOpenLoopFieldControl }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.OpenLoopFieldControl>('openLoopFieldControl', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async startOpenLoopFieldControlAsync(props: MotionMasterMessage.Request.IStartOpenLoopFieldControl & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<void> {
-    const status = await lastValueFrom(this.startOpenLoopFieldControl(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed to start open loop field control. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  /**
-   * @deprecated
-   */
-  computeFullAutoTuningGains(props: MotionMasterMessage.Request.IComputeFullAutoTuningGains & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const computeFullAutoTuningGains = MotionMasterMessage.Request.ComputeFullAutoTuningGains.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ computeFullAutoTuningGains }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.FullAutoTuning>('fullAutoTuning', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  /**
-   * @deprecated
-   */
-  async computeFullAutoTuningGainsAsync(props: MotionMasterMessage.Request.IComputeFullAutoTuningGains & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<void> {
-    const status = await lastValueFrom(this.computeFullAutoTuningGains(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed to compute full auto tuning gains. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  startFullAutoTuning(props: MotionMasterMessage.Request.IStartFullAutoTuning & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const startFullAutoTuning = MotionMasterMessage.Request.StartFullAutoTuning.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ startFullAutoTuning }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.FullAutoTuning>('fullAutoTuning', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async startFullAutoTuningAsync(props: MotionMasterMessage.Request.IStartFullAutoTuning & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    const status = await lastValueFrom(this.startFullAutoTuning(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      if (status.settlingTimeOrBandwidth === 'bandwidth') {
-        return (({ bandwidth, dampingRatio }) => ({ bandwidth, dampingRatio }))(status);
-      } else if (status.settlingTimeOrBandwidth === 'settlingTime') {
-        return (({ settlingTime, dampingRatio }) => ({ dampingRatio, settlingTime }))(status);
-      }
-    }
-
-    throw new Error(`Failed to start full auto tuning. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  stopFullAutoTuning(props: MotionMasterMessage.Request.IStopFullAutoTuning & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const stopFullAutoTuning = MotionMasterMessage.Request.StopFullAutoTuning.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ stopFullAutoTuning }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.FullAutoTuning>('fullAutoTuning', requestTimeout, id),
-          map((status) => {
-            if (status.success?.code === MotionMasterMessage.Status.FullAutoTuning.Success.Code.POSITION_STOPPED ||
-              status.success?.code === MotionMasterMessage.Status.FullAutoTuning.Success.Code.VELOCITY_STOPPED) {
-              // Full auto tuning status is shared between start and stop.
-              // When full auto tuning has stopped this request is considered successful.
-              status.request = 'succeeded';
-            }
-            return status;
-          }),
-        );
-      }),
-    );
-  }
-
-  async stopFullAutoTuningAsync(props: MotionMasterMessage.Request.IStopFullAutoTuning & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<void> {
-    const status = await lastValueFrom(this.stopFullAutoTuning(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed to stop full auto tuning. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  startCirculoEncoderConfiguration(props: MotionMasterMessage.Request.IStartCirculoEncoderConfiguration & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const startCirculoEncoderConfiguration = MotionMasterMessage.Request.StartCirculoEncoderConfiguration.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ startCirculoEncoderConfiguration }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.CirculoEncoderConfiguration>('circuloEncoderConfiguration', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async startCirculoEncoderConfigurationAsync(props: MotionMasterMessage.Request.IStartCirculoEncoderConfiguration & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<void> {
-    const status = await lastValueFrom(this.startCirculoEncoderConfiguration(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed to start circulo encoder configuration. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  stopCirculoEncoderNarrowAngleCalibrationProcedure(props: MotionMasterMessage.Request.IStopCirculoEncoderNarrowAngleCalibrationProcedure & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const stopCirculoEncoderNarrowAngleCalibrationProcedure = MotionMasterMessage.Request.StopCirculoEncoderNarrowAngleCalibrationProcedure.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ stopCirculoEncoderNarrowAngleCalibrationProcedure }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.CirculoEncoderNarrowAngleCalibrationProcedure>('circuloEncoderNarrowAngleCalibrationProcedure', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async stopCirculoEncoderNarrowAngleCalibrationProcedureAsync(props: MotionMasterMessage.Request.IStopCirculoEncoderNarrowAngleCalibrationProcedure & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    const status = await lastValueFrom(this.stopCirculoEncoderNarrowAngleCalibrationProcedure(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed to stop circulo encoder narrow angle calibration procedure. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  startOsCommand(props: MotionMasterMessage.Request.IStartOsCommand & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const startOsCommand = MotionMasterMessage.Request.StartOsCommand.create({ ...props, deviceAddress });
-        const id = this.sendRequest({ startOsCommand }, messageId);
-        return this.socket.message$.pipe(
-          transformMotionMasterMessageToStatus<MotionMasterMessage.Status.OsCommand>('osCommand', requestTimeout, id),
-        );
-      }),
-    );
-  }
-
-  async startOsCommandAsync(props: MotionMasterMessage.Request.IStartOsCommand & DeviceRefObj, requestTimeout: number, messageId?: string): Promise<Uint8Array> {
-    const status = await lastValueFrom(this.startOsCommand(props, requestTimeout, messageId));
-
-    if (status.request === 'succeeded') {
-      return status.response;
-    }
-
-    throw new Error(`Failed to start os command. ${status.error?.code}: ${status.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  sendRequest(request: MotionMasterMessage.IRequest, messageId?: string) {
-    const id = messageId ?? v4();
-    const message = MotionMasterMessage.create({ request, id });
-    this.socket.send(message);
-    return id;
-  }
-
-  //
-  // Helpers
-  //
-
-  async resolveDeviceAddress(deviceRefObj: DeviceRefObj): Promise<number> {
-    if (deviceRefObj.deviceAddress) {
-      return deviceRefObj.deviceAddress;
-    }
-
-    if (this.deviceAddressMap.size === 0) {
-      const devices = await this.getDeviceInfoAsync(2000);
-      for (const device of devices) {
-        if (device.deviceAddress) {
-          const hardwareDescripition = await this.getDeviceHardwareDescription(device.deviceAddress);
-          const serialNumber = getSerialNumberFromHardwareDescription(hardwareDescripition);
-          this.deviceAddressMap.set(serialNumber, device.deviceAddress);
-        }
-      }
-    }
-
-    if (deviceRefObj.deviceSerialNumber) {
-      const deviceAddress = this.deviceAddressMap.get(deviceRefObj.deviceSerialNumber);
-      if (deviceAddress) {
-        return deviceAddress;
-      }
-      throw new Error(`No device found by device serial number "${deviceRefObj.deviceSerialNumber}" when resolving device address`);
-    }
-
-    if (typeof deviceRefObj.devicePosition === 'number') {
-      const values = Array.from(this.deviceAddressMap.values());
-      const deviceAddress = values[deviceRefObj.devicePosition];
-      if (typeof deviceAddress === 'number') {
-        return deviceAddress;
-      }
-      throw new Error(`No device found by device position when resolving device address: ${deviceRefObj.devicePosition}`);
-    }
-
-    throw new Error(`Failed to resolve device address. One of device address, serial number, or position must be specified.`);
-  }
-
-  async getDeviceAddresses(requestTimeout = 2000): Promise<number[]> {
-    const deviceInfo = await this.getDeviceInfoAsync(requestTimeout);
-    if (deviceInfo) {
-      return deviceInfo.reduce((acc, val) => {
-        if (typeof val.deviceAddress === 'number') {
-          acc.push(val.deviceAddress);
-        }
-        return acc;
-      }, [] as number[]);
-    }
-    return [];
-  }
-
-  async getDeviceHardwareDescription(deviceRef: number | string, requestTimeout = 2000): Promise<HardwareDescription> {
-    const deviceRefObj = makeDeviceRefObj(deviceRef);
-    const content = await this.getDecodedDeviceFile({ ...deviceRefObj, name: '.hardware_description' }, requestTimeout);
-    return JSON.parse(content) as HardwareDescription;
-  }
-
-  async getSystemLogLines(requestTimeout = 2000): Promise<SystemLogLine[]> {
-    const systemLog = await this.getSystemLogAsync(requestTimeout);
-    return parseSystemLogContent(systemLog.content);
-  }
-
-  getAllParameters(props: { loadFromCache?: boolean, sendProgress?: boolean } & DeviceRefObj, requestTimeout: number): Observable<Parameter[]> {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        return this.getDeviceParameterInfo({ deviceAddress }, requestTimeout).pipe(
-          mergeMap(deviceParameterInfoStatus => {
-            const { loadFromCache, sendProgress } = props;
-            const parameters = deviceParameterInfoStatus.parameters.map(p => ({ index: p.index ?? 0, subindex: p.subindex ?? 0, loadFromCache }));
-            return this.getDeviceParameterValues({ deviceAddress, sendProgress, parameters }, requestTimeout).pipe(
-              map(deviceParameterValuesStatus => {
-                const parameters: Parameter[] = deviceParameterValuesStatus.parameterValues.map((value, i) => {
-                  const index = value.index ?? 0;
-                  const subindex = value.subindex ?? 0;
-                  return ({ ...value, ...deviceParameterInfoStatus.parameters[i], index, subindex, value: getParameterValue(value) }) as Parameter;
-                });
-                return parameters;
-              }),
-            );
-          }),
-        );
-      }),
-    );
-  }
-
-  async getAllParametersAsync(props: { loadFromCache?: boolean, sendProgress?: boolean } & DeviceRefObj, requestTimeout: number) {
-    return await lastValueFrom(
-      this.getAllParameters(props, requestTimeout),
-    );
-  }
-
-  async getParameterValue<T extends ParameterValueType = number>(deviceParameterId: string, loadFromCache?: boolean, requestTimeout?: number): Promise<T>;
-  async getParameterValue<T extends ParameterValueType = number>(deviceRef: number | string, parameter: [number, number] | { index: number, subindex: number } | string, loadFromCache?: boolean, requestTimeout?: number): Promise<T>;
-  async getParameterValue<T extends ParameterValueType = number>(deviceRef: number | string, index: number, subindex: number, loadFromCache?: boolean, requestTimeout?: number): Promise<T>;
-  async getParameterValue<T extends ParameterValueType = number>(a: string | number, b?: boolean | { index: number, subindex: number } | [number, number] | number | string, c?: number | boolean, d?: boolean | number, e?: number): Promise<T> {
-    let deviceSerialNumber: string;
-    let index: number | undefined;
-    let subindex = 0;
-    let loadFromCache = false;
-    let requestTimeout = 1000;
-    let deviceRefObj: DeviceRefObj | undefined;
-
-    if (Array.isArray(b)) { // tuple of index and subindex, e.g. [0x2110, 0]
-      deviceRefObj = makeDeviceRefObj(a);
-      [index, subindex] = b;
-      if (typeof c === 'boolean') {
-        loadFromCache = c;
-      }
-      if (typeof d === 'number') {
-        requestTimeout = d;
-      }
-    } else if (typeof b === 'object') { // object with index and subindex properties, e.g. { index: 0x2110, subindex: 0x1A }
-      deviceRefObj = makeDeviceRefObj(a);
-      index = b.index;
-      subindex = b.subindex;
-      if (typeof c === 'boolean') {
-        loadFromCache = c;
-      }
-      if (typeof d === 'number') {
-        requestTimeout = d;
-      }
-    } else if (typeof b === 'string') { // parameter id, e.g. "0x2110:1A"
-      [index, subindex] = splitParameterId(b);
-      deviceRefObj = makeDeviceRefObj(a);
-      if (typeof c === 'boolean') {
-        loadFromCache = c;
-      }
-      if (typeof d === 'number') {
-        requestTimeout = d;
-      }
-    } else if (typeof b === 'number') { // object index, e.g. 0x2110
-      deviceRefObj = makeDeviceRefObj(a);
-      index = b;
-      if (typeof c === 'number') {
-        subindex = c;
-      }
-      if (typeof d === 'boolean') {
-        loadFromCache = d;
-      }
-      if (typeof e === 'number') {
-        requestTimeout = e;
-      }
-    } else if (typeof a === 'string') { // device parameter id, e.g. "0x2110:1A.8502-03-0001353-2115"
-      [deviceSerialNumber, index, subindex] = splitDeviceParameterId(a);
-      deviceRefObj = makeDeviceRefObj(deviceSerialNumber);
-      if (typeof b === 'boolean') {
-        loadFromCache = b;
-      }
-      if (typeof c === 'number') {
-        requestTimeout = c;
-      }
-    }
-
-    const status = await lastValueFrom(
-      this.getDeviceParameterValues({ ...deviceRefObj, parameters: [{ index, subindex, loadFromCache }] }, requestTimeout),
-    );
-
-    const parameterValue = status.parameterValues[0] as MotionMasterMessage.Status.DeviceParameterValues.ParameterValue;
-
-    if (parameterValue.success) {
-      const typeValue = parameterValue.typeValue;
-      if (typeValue) {
-        return status.parameterValues[0][typeValue] as T;
-      }
-    }
-
-    const props = { ...deviceRefObj, index, subindex, loadFromCache };
-
-    const errorCodeName = MotionMasterMessage.Status.DeviceParameterValues.ParameterValue.Error.Code[status.parameterValues[0]?.error?.code ?? 0];
-    throw new Error(`Failed to get parameter value. ${errorCodeName} ${JSON.stringify(props)}`);
-  }
-
-  async setParameterValue(deviceRef: number | string, index: number, subindex: number, value: ParameterValueType, valueTypeKey?: keyof Required<ParameterTypeValue>, requestTimeout = 1000): Promise<void> {
-    const deviceRefObj = makeDeviceRefObj(deviceRef);
-    const deviceAddress = await this.resolveDeviceAddress(deviceRefObj);
-
-    const props = { ...deviceRefObj, index, subindex, value, valueTypeKey };
-
-    if (!valueTypeKey) {
-      const parameterId = makeParameterId(index, subindex);
-      valueTypeKey = this.parameterTypeValueKeyMap.get(deviceAddress)?.get(parameterId);
-      if (!valueTypeKey) {
-        throw new Error(`Failed to set device parameter value. Value type key is not set. ${JSON.stringify(props)}`);
-      }
-    }
-
-    const parameterValue: MotionMasterMessage.Request.SetDeviceParameterValues.IParameterValue = { index, subindex, [valueTypeKey]: value };
-
-    const status = await lastValueFrom(
-      this.setDeviceParameterValues({ deviceAddress, parameterValues: [parameterValue] }, requestTimeout),
-    );
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed to set device parameter value. ${status.parameterValues[0]?.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  async setParameterValues(deviceRef: number | string, values: ParameterAddressValue[], requestTimeout = 1000): Promise<void> {
-    const deviceRefObj = makeDeviceRefObj(deviceRef);
-    const deviceAddress = await this.resolveDeviceAddress(deviceRefObj);
-
-    const props = { deviceAddress, parameters: values };
-
-    const parameterValues = values.map(([index, subindex, value, valueTypeKey]) => {
-      if (!valueTypeKey) {
-        const parameterId = makeParameterId(index, subindex);
-        valueTypeKey = this.parameterTypeValueKeyMap.get(deviceAddress)?.get(parameterId);
-        if (!valueTypeKey) {
-          throw new Error(`Failed to set device parameter values. Value type key is not set. ${JSON.stringify(props)}`);
-        }
-      }
-      return { index, subindex, [valueTypeKey]: value };
-    }) as MotionMasterMessage.Request.SetDeviceParameterValues.IParameterValue[];
-
-    const status = await lastValueFrom(
-      this.setDeviceParameterValues({ deviceAddress, parameterValues }, requestTimeout),
-    );
-
-    if (status.request === 'succeeded') {
-      return;
-    }
-
-    throw new Error(`Failed to set device parameter values. ${status.parameterValues[0]?.error?.message} ${JSON.stringify(props)}`);
-  }
-
-  async getDecodedDeviceFile(props: MotionMasterMessage.Request.IGetDeviceFile, requestTimeout: number, messageId?: string): Promise<string> {
-    const content = await this.getDeviceFileAsync(props, requestTimeout, messageId);
-    return decodeTextContent(content);
-  }
-
-  async getDeviceFiles(deviceRef: number | string, requestTimeout = 30000) {
-    const deviceRefObj = makeDeviceRefObj(deviceRef);
-    return this.getDeviceFileListAsync(deviceRefObj, requestTimeout);
-  }
-
-  getDeviceParameterInfoAndValues(props: { deviceAddress?: number | null, loadFromCache?: boolean | null, sendProgress?: boolean | null }, requestTimeout: number): Observable<DeviceParameterValuesStatus> {
-    const { deviceAddress, loadFromCache, sendProgress } = props;
-    return this.getDeviceParameterInfo({ deviceAddress }, requestTimeout).pipe(
-      mergeMap(deviceParameterInfo => {
-        const parameters = deviceParameterInfo.parameters.map(p => ({ index: p.index ?? 0, subindex: p.subindex ?? 0, loadFromCache }));
-        return this.getDeviceParameterValues({ deviceAddress, parameters, sendProgress }, requestTimeout).pipe(
-          map(deviceParameterValues => {
-            const parameters: ParameterInfoAndValue[] = deviceParameterValues.parameterValues
-              .map((value, index) => ({ ...value, ...deviceParameterInfo.parameters[index] }));
-            deviceParameterValues.parameterValues = parameters;
-            return deviceParameterValues;
-          }),
-        );
-      }),
-    );
-  }
-
-  async getDeviceParameterInfoAndValuesAsync(props: { deviceAddress?: number | null, loadFromCache?: boolean | null, sendProgress?: boolean | null }, requestTimeout: number) {
-    const status = await lastValueFrom(
-      this.getDeviceParameterInfoAndValues(props, requestTimeout),
-    );
-
-    if (status.request === 'succeeded') {
-      return status.parameterValues;
-    }
-
-    throw new Error(`Failed to get device parameter info and values. ${JSON.stringify(props)}`);
-  }
-
-  saveAllParameters(deviceRef: number | string, requestTimeout: number) {
-    const deviceRefObj = makeDeviceRefObj(deviceRef);
-
-    return from(this.resolveDeviceAddress(deviceRefObj)).pipe(
-      mergeMap((deviceAddress) => {
-        const parameter: MotionMasterMessage.Request.SetDeviceParameterValues.IParameterValue = { index: 0x1010, subindex: 1, uintValue: 0x65766173 }; // "evas"
-        const parameterId = makeParameterId(parameter);
-
-        const result$ = defer(() => this.checkDeviceParameterValue({ deviceAddress, parameter, expectedValue: 1 }, requestTimeout)).pipe(
-          retryWithDelay<void>(500, 10),
-        );
-
-        return this.setDeviceParameterValues({ deviceAddress, parameterValues: [parameter] }, requestTimeout).pipe(
-          delay(2000), // give some initial time for operation to complete
-          mergeMap(({ parameterValues }) => {
-            const parameter = parameterValues[0];
-            if (parameter) {
-              if (parameter.error) {
-                throw new Error(`Failed to set ${parameterId} value to ${parameter.uintValue} on device ${deviceAddress}`);
-              }
-            } else {
-              throw new Error(`No parameters in status for ${parameterId} on device ${deviceAddress}`);
-            }
-            return result$;
-          }),
-        );
-      }),
-    );
-  }
-
-  restoreAllDefaultParameters(deviceRef: number | string, requestTimeout: number) {
-    const deviceRefObj = makeDeviceRefObj(deviceRef);
-
-    return from(this.resolveDeviceAddress(deviceRefObj)).pipe(
-      mergeMap((deviceAddress) => {
-        const parameter: MotionMasterMessage.Request.SetDeviceParameterValues.IParameterValue = { index: 0x1011, subindex: 1, uintValue: 0x64616f6c }; // "daol"
-        const parameterId = makeParameterId(parameter);
-
-        const result$ = defer(() => this.checkDeviceParameterValue({ deviceAddress, parameter, expectedValue: 1 }, requestTimeout)).pipe(
-          retryWithDelay<void>(500, 10),
-        );
-
-        return this.setDeviceParameterValues({ deviceAddress, parameterValues: [parameter] }, requestTimeout).pipe(
-          delay(500), // give some initial time for operation to complete
-          mergeMap(({ parameterValues }) => {
-            const parameter = parameterValues[0];
-            if (parameter) {
-              if (parameter.error) {
-                throw new Error(`Failed to set ${parameterId} value to ${parameter.uintValue} on device ${deviceAddress}`);
-              }
-            } else {
-              throw new Error(`No parameters in status for ${parameterId} on device ${deviceAddress}`);
-            }
-            return result$;
-          }),
-        );
-      }),
-    );
-  }
-
-  checkDeviceParameterValue(props: { parameter: MotionMasterMessage.Request.GetDeviceParameterValues.IParameter, expectedValue: number | string } & DeviceRefObj, requestTimeout: number, messageId?: string) {
-    return from(this.resolveDeviceAddress(props)).pipe(
-      mergeMap((deviceAddress) => {
-        const { expectedValue } = props;
-        const parameterId = makeParameterId(props.parameter);
-
-        return this.getDeviceParameterValues({ deviceAddress, parameters: [props.parameter] }, requestTimeout, messageId).pipe(
-          map(({ parameterValues }) => {
-            const parameter = parameterValues[0];
-            if (parameter) {
-              const parameterValue = getParameterValue(parameter);
-              if (parameter.error) {
-                throw new Error(`Failed to get ${parameterId} on device ${deviceAddress}`);
-              } else if (parameterValue !== expectedValue) {
-                throw new Error(`Value of ${parameterId} didn't change to ${expectedValue} on device ${deviceAddress}`);
-              }
-            } else {
-              throw new Error(`No parameters in status for ${parameterId} on ${deviceAddress}`);
-            }
-          }),
-        );
-      }),
-    );
-  }
-
-  async getDeviceApiIdentifier(deviceRef: number | string, requestTimeout = 2000) {
-    const hardwareDescription = await this.getDeviceHardwareDescription(deviceRef, requestTimeout);
-    return getApiIdentifierFromHardwareDescription(hardwareDescription);
-  }
-
-  async enableMotion(deviceRef: number | string, controllerType: MotionMasterMessage.Request.EnableMotionController.ControllerType, filter = false, requestTimeout = 2000) {
-    const deviceRefObj = makeDeviceRefObj(deviceRef);
-    return await this.enableMotionControllerAsync({ ...deviceRefObj, controllerType, filter }, requestTimeout);
-  }
-
-  async setMotionTarget(deviceRef: number | string, target: number) {
-    const deviceRefObj = makeDeviceRefObj(deviceRef);
-    return await this.setMotionControllerParametersAsync({ ...deviceRefObj, target });
-  }
-
-  async disableMotion(deviceRef: number | string, requestTimeout = 3000) {
-    const deviceRefObj = makeDeviceRefObj(deviceRef);
-    return await this.disableMotionControllerAsync(deviceRefObj, requestTimeout);
-  }
-
-}