motion-master-client 0.0.3 → 0.0.6

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

@@ -1,1990 +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 the 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", or it will 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 `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 methods related to a device accept device reference instead of just device address as an identifier.
-   * Device reference {@link DeviceRefObj} 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 the network. Each device has a type, position in the network, and device address.
-   *
-   * Motion Master will assign a unique device address to each device in the list.
-   * Device address is what the client libraries use to make requests like `getDeviceParameter` from a particular device.
-   * Device address is only valid for the duration of the session, that is until the list of devices is read again, for example
-   * when devices are power cycled or Motion Master process is restarted.
-   */
-  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.');
-  }
-
-  /**
-   * Get device parameter info.
-   *
-   * Device parameter info includes a list of all parameters for the requested device, but without the parameter values.
-   * Getting device parameter values can take more than 20ms per parameter using the IgH EtherCAT Master library.
-   * Not all clients require all the parameter values at once like OBLAC Drives, so this method is good for getting
-   * the list of available parameters and then getting the values of only some parameters.
-   *
-   * The returned list of device parameters will include some basic data for each parameter: index, subindex,
-   * name, unit, group (ARRAY or RECORD name for subitems), read and write access, min and max, and value type.
-   * The same info and more can be read from the "SOMANET_CiA_402.xml" file, but getting info from ESI file is more complicated.
-   * It requires an XML parsing library and knowing how to read objects info from a dictionary and assigned modules.
-   *
-   * In addition to fetching device parameter info, this method will map parameter base data type (ETG.1020) to proto3 types.
-   * The map removes the need to specify proto3 type field when setting a parameter value {@link parameterTypeValueKeyMap}.
-   */
-  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);
-                  }
-                }
-              }
-            }
-          }),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc getDeviceParameterInfo}
-   */
-  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.');
-  }
-
-  /**
-   * Get device parameter values.
-   */
-  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),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc getDeviceParameterValues}
-   */
-  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;
-  }
-
-  /**
-   * Get multi device parameter values.
-   */
-  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),
-    );
-  }
-
-  /**
-   * {@inheritDoc getMultiDeviceParameterValues}
-   */
-  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;
-  }
-
-  /**
-   * Set device parameter values.
-   */
-  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),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc setDeviceParameterValues}
-   */
-  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;
-  }
-
-  /**
-   * Set multi device parameter values.
-   */
-  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),
-    );
-  }
-
-  /**
-   * {@inheritDoc setMultiDeviceParameterValues}
-   */
-  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 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)}`);
-  }
-
-  /**
-   * Delete device file.
-   *
-   * Motion Master uses the Filetransfer over EtherCAT (FoE) to delete files from device flash memory.
-   *
-   * If the file to delete is written in parts, Motion Master will ensure that all parts are deleted.
-   * It does that by reading the list of files on a device, see {@link getDeviceFileList}. It will remove all parts from the list and then
-   * it will re-read the list again to ensure that there are no left overs if there were more than 32 files in the list.
-   */
-  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),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc deleteDeviceFile}
-   */
-  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)}`);
-  }
-
-  /**
-   * Start device firmware installation.
-   *
-   * When Motion Master receives this request it will do the following:
-   * - switch device to BOOT EtherCAT state, device will then run the bootloader instead of the firmware
-   * - delete files from device that it finds in the provided package (SOMANET_CiA_402.xml and stack_image.svg)
-   * - write files other than firmware binaries and SII from package to device (SOMANET_CiA_402.xml and stack_image.svg)
-   * - optionally install the SII file using the IgH EtherCAT Master library write SII function
-   * - write firmware binaries to device using the predefined names like app_firmware.bin
-   *
-   * During the firmware installation Motion Master will send progress messages back to clients.
-   * If Motion Master fails in any step other than SII write it will send error. If SII write fails only warning will be sent.
-   */
-  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),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc startDeviceFirmwareInstallation}
-   */
-  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)}`);
-  }
-
-  /**
-   * Get device log.
-   *
-   * Device log is stored in two files due to IgH EtherCAT Master library 9KB file size limitation, see {@link getDeviceFile}.
-   * Device automatically writes log to logging_curr.log and copies that file to logging_prev.log once it reaches 9KB.
-   * When Motion Master receives this request it will read the both files and return their combined contents.
-   */
-  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),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc getDeviceLog}
-   */
-  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)}`);
-  }
-
-  /**
-   * Start cogging torque recording.
-   *
-   * Cogging torque recording (CTC) can be started with or without auto-config.
-   * In the proto file skipping the auto-config is currently named skip_auto_tuning. The field name is deprecated and will be renamed.
-   *
-   * If CTC is started without auto-config then users must ensure that encoder on the motor shaft is used for all functions: commutation, position, and velocity.
-   * If this is not the case, then Motion Master will return invalid encoder configuration error.
-   * Recording can also fail if the position controller is not tuned.
-   *
-   * If CTC is started with auto-config then Motion Master will:
-   * - change the encoder configuration to have all functions on the motor shaft
-   * - disabled CTC
-   * - change the velocity feed forward value
-   * - change the position and velocity filter types and cutoff frequencies
-   * - run iterative sharpening position auto-tuning in order to compute the optimal PID values (gains) using the auto tuning
-   *
-   * All parameter values that Motion Master changes as part of the auto-config are first stored in memory and once the CTC recording is done are reverted back.
-   *
-   * CTC recording is started by changing the Modes of operation (0x6060) parameter value to -1 (Cogging compensation recording mode).
-   * During the operation Motion Master will monitor the Cogging torque compensation state parameter (0x2008:01) to know when the recording is in progress and when it's done.
-   *
-   * The result of recording CTC is the cogging_torque.bin file written to device flash memory. Size of this file is 2048 bytes.
-   * Each pair of bytes represents a 16-bit signed integer value in mNm (milli newton meter).
-   *
-   * This request will turn the motor.
-   */
-  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),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc startCoggingTorqueRecording}
-   */
-  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)}`);
-  }
-
-  /**
-   * Get cogging torque data.
-   *
-   * The cogging_torque.bin file is the result of recording cogging torque compensation, see {@link startCoggingTorqueRecording}.
-   * The size of this file is 2048 bytes where each pair of bytes represents a 16-bit signed integer value in mNm (milli newton meter).
-   *
-   * Motion Master will read the cogging_torque.bin file, convert bytes to 16-bit signed integer values and return that as an array.
-   */
-  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),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc getCoggingTorqueData}
-   */
-  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)}`);
-  }
-
-  /**
-   * Start offset detection.
-   *
-   * Running offset detection is different in firmwares <v5 and >=v5.
-   *
-   * For devices that run firmware >=v5 Motion Master will run multiple OS commands.
-   * Before starting any command device is switched to Modes of operation -2 (Diagnostics mode) and
-   * it's put into operation enabled CiA402 state. The OS commands are run in the following order:
-   * - open phase detection
-   * - phase resistance measurement
-   * - phase inductance measurement
-   * - pole pair detection
-   * - motor phase order detection
-   * - commutation offset measurement
-   *
-   * Motion Master will return error if any of the following OS commands fail: open phase detection,
-   * phase order detection, commutation offset measurement.
-   * If other OS commands fail Motion Master will continue with the procedure and only return warning.
-   *
-   * Once the commutation offset measurement command completes it will update:
-   * - 0x2001:00 Commutation angle offset to the computed offset value
-   * - 0x2009:01 Commutation offset State to 2 (OFFSET_VALID)
-   *
-   * For devices that run firmware <5 the same Modes of operation -2 is used, but it's named Commutation offset detection mode.
-   * The end result is the same, the procedure will update 0x2001:00 and 0x2009:01 parameter values.
-   *
-   * This request will turn the motor.
-   */
-  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),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc startOffsetDetection}
-   */
-  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)}`);
-  }
-
-  /**
-   * Compute auto tuning gains.
-   *
-   * Auto tuning gains can be computed for position or velocity controller.
-   *
-   * Prerequisites for running this procedure are the configured motor and the existence of
-   * plant_model.csv file created by a previous run of the system identification {@link startSystemIdentification}.
-   * Motion Master will return error if the plant_model.csv file is not found.
-   *
-   * In OBLAC Drives this request is called when the tuning sliders (damping ratio, bandwidth) are moved and
-   * during the CTC recording {@link startCoggingTorqueRecording} when auto config is not skipped.
-   *
-   * Motion Master will compute the PID gains using the Python scripts and it will
-   * update the Kp, Ki, Kd values of 0x2011 and 0x2012 parameters.
-   */
-  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),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc computeAutoTuningGains}
-   */
-  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)}`);
-  }
-
-  /**
-   * Set motion controller parameters.
-   *
-   * This request sets the target value for a device on Motion Master.
-   *
-   * A previous call to {@link enableMotionController} will set the mode of operation to CSP, CSV, or CST and optionally enable filtering.
-   */
-  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;
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc setMotionControllerParameters}
-   */
-  async setMotionControllerParametersAsync(props: MotionMasterMessage.Request.ISetMotionControllerParameters & DeviceRefObj, messageId?: string): Promise<void> {
-    return await lastValueFrom(this.setMotionControllerParameters(props, messageId), { defaultValue: undefined });
-  }
-
-  /**
-   * Enable motion controller.
-   *
-   * This request will set the mode of operation to CSP, CSV, or CST and optionally enable filtering.
-   *
-   * If filtering is enabled Motion Master will compute an intermediate target value in each cycle, and depending on the active mode of operation
-   * set the value of one of 0x607A Target position, 0x60FF Target velocity, 0x6071 Target torque to that value.
-   *
-   * Target value can be updated with {@link setMotionControllerParameters}.
-   */
-  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),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc enableMotionController}
-   */
-  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)}`);
-  }
-
-  /**
-   * Disable motion controller.
-   *
-   * Depending on the current CiA402 state this request will do the following:
-   * - if device is in Quick stop active it will transition to Switch on disabled state
-   * - if device is in Operation enabled it will transition to Switched on state
-   */
-  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),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc disableMotionController}
-   */
-  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)}`);
-  }
-
-  /**
-   * Set signal generator parameters.
-   *
-   * This request will update the signal generator parameters for a device on Motion Master.
-   * The selected signal generator is then started by {@link startSignalGenerator}.
-   * Signal generator must be started in the next 60 seconds before Motion Master invalidates the previously set parameters.
-   */
-  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),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc setSignalGeneratorParameters}
-   */
-  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)}`);
-  }
-
-  /**
-   * Start signal generator.
-   *
-   * This request will start one of the signal generators based on the
-   * previously set parameters with {@link setSignalGeneratorParameters}.
-   *
-   * Signal generators are started by changing the mode of operation, putting device into Operation enabled CiA402 state,
-   * and setting the target value. What mode of operation is set depends on the type of signal generator and controller:
-   * - For the simple & advanced step response and sine wave one of CSP, CSV, or CST is set.
-   * - For ramp, trapezoidal, and bidirectional signal generators, also called profiles, one of PP, PV, TQ is set.
-   *
-   * Currently the only profile type that firmware supports is ramp.
-   * Motion Master uses this profile type to run the following signal generators: ramp, trapezoidal, and bidirectional.
-   * Sine wave is also a profile but it is currently generated on Motion Master.
-   * Firmwares >=5.2 will support generating and running sine wave profiles on devices. This will enable lossless profile
-   * execution on possibly higher frequencies. Future Motion Master versions will switch to this method.
-   *
-   * For the simple step response Motion Master will only set the target value,
-   * wait for the specified holding duration, and then send Quick Stop.
-   *
-   * The advanced step response is similar to simple, but after the holding duration it will set the new target
-   * multiple times depending on the shape, and then send Quick Stop if repeat is set to NO. If repeat is set to YES,
-   * then the signal generator will run indefinitely and users must stop it.
-   *
-   * Before running profiles Motion Master will check if device supports the profile modes by looking at 0x6502 Supported drives modes.
-   * If profile modes are not supported then the profiles will be generated on Motion Master. This means the targets will be computed up-front.
-   * If profiles are supported then ramp, trapezoidal, and bidirectional signal generators are run in profile mode of operation.
-   * Motion Master will set the following parameters:
-   * - 0x6081:00 Profile velocity (only for position controller)
-   * - 0x6083:00 Profile acceleration
-   * - 0x6084:00 Profile deceleration
-   * Motion Master knows when the profile has completed by comparing the demand with the actual value, taking into account the
-   * holding duration and the shape of profile. Once the profile is considered complete Motion Master will send Quick Stop, but
-   * only if repeat is set to NO.
-   *
-   * Sine wave profile is generated up-front on Motion Master. Targets are computed for each master cycle (millisecond).
-   * Once the last computed target has been set, Motion Master will send Quick Stop if repeat is set to NO.
-   *
-   * For all signal generators Motion Master will modify the requested target based on
-   * the software position limits and it will return warning.
-   */
-  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),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc startSignalGenerator}
-   */
-  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)}`);
-  }
-
-  /**
-   * Stop signal generator.
-   *
-   * This request will send Quick Stop to a device.
-   */
-  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),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc stopSignalGenerator}
-   */
-  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)}`);
-  }
-
-  /**
-   * Set EtherCAT network state.
-   *
-   * Set EtherCAT network state to one of: BOOT, INIT, PRE-OP, SAFE-OP, OP.
-   *
-   * From PRE-OP to OP MM will reinitialize slaves in order to get new PDO mapping.
-   */
-  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),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc setEthercatNetworkState}
-   */
-  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)}`);
-  }
-
-  /**
-   * Set system client timeout.
-   *
-   * This request will update the client timeout.
-   *
-   * Client timeout specifies how long will Motion Master wait for the client to send ping or any other message before
-   * considering it gone and clearing the resources (stopping procedures and monitorings) related to that client.
-   *
-   * Default client timeout is 1000ms.
-   *
-   * Client will typically change this once the connection is established.
-   */
-  setSystemClientTimeout(props: MotionMasterMessage.Request.ISetSystemClientTimeout, messageId?: string) {
-    const setSystemClientTimeout = MotionMasterMessage.Request.SetSystemClientTimeout.create(props);
-    this.sendRequest({ setSystemClientTimeout }, messageId);
-    return EMPTY;
-  }
-
-  /**
-   * {@inheritDoc setSystemClientTimeout}
-   */
-  async setSystemClientTimeoutAsync(props: MotionMasterMessage.Request.ISetSystemClientTimeout, messageId?: string) {
-    return await lastValueFrom(this.setSystemClientTimeout(props, messageId), { defaultValue: undefined });
-  }
-
-  /**
-   * Start system identification.
-   *
-   * pre-condition motor and encoder configured (setup wizard), without position and velocity tuning
-   * torque only, used for computing the PID values during the auto tuning and full auto tuning and ctc which uses auto-tuning
-   * error when, fault state, cannot set op mode, state, system failed, chirp profile is generate on master, each point in a cycle (millisecond)
-   * CST sets targets, after the last target value MM sends Quick Stop, failed if fault, everything happens on master, but idea to run chirp on slave
-   * and record data on slave, so that communication doesn't impact the result, MM records velocity and torque and computes, compute how many data is missing warning
-   * error if there are not enough data, missing more than 80% of data points, if between 5%-80% warning, <5% ok, linear interpolation of missing data points
-   * conversion every all velocity to SI, check amplitude of signal no torque, no velocity, or small amplitudes warning, errors 0 amplitudes
-   * identification plant model, check stability of computed model (math only) can result in error, compute and write to plant_model.csv
-   * set parameters integral limits 0x2012:4 0x2012:8, 0x2011:4 Position|Velocity loop integral limit
-   * result plant_model.csv - check what values are and in what unit
-   *
-   * This request will turn motor
-   */
-  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),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc startSystemIdentification}
-   */
-  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)}`);
-  }
-
-  /**
-   * Get circulo encoder magnet distance.
-   *
-   * check encoder ordinal (1 or 2)
-   * ring revision
-   * is it based on fw 5 in fw <5 this doesn't exist error in that case
-   * read encoder registers with OS command, registers read 2B and 2F, some values go through math depending on the version of Circulo, port, distance value is computed
-   * @todo check what OS command
-   */
-  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),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc getCirculoEncoderMagnetDistance}
-   */
-  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)}`);
-  }
-
-  /**
-   * Start circulo encoder narrow angle calibration procedure.
-   *
-   * check encoder ordinal
-   * check fw version 5
-   * check if SMM, has to be disable safety encoder source type
-   * ignore biss status bit, OS command for encoder to ignore BiSS status bits
-   * initialize velocity profile PV
-   * check software position limits
-   * initialize intern values, feed constant, single turn resolution, si unit, get parameter values, gear ratio, what encoder, port, if gear ratio etc etc
-   * if gear box and si unit velocity not mRPM, and position only encoder, and si unit * feed constant is <10% of gear ratio, error not enough velocity resolution
-   * hardware description file, different values for RPM for different version of Circulo, inner|outer encoder ring, multiturn, not, change profile acc|dec max motor speed etc.
-   * after everything rollback
-   * check if enough turns is possible, if not enough space, error
-   * set default calibration register values
-   * set biss to raw mode, no longer position - raw position
-   * ic house lib is initialized
-   * remove previous files for high resolution data 4kHz, for each iteration, hight res data contains raw data from encoder
-   * OS command configure HRD streaming, automatically sets data from encoder, can only configure how long to record
-   * slave saves data to HRD files
-   * after each iteration which lasts 6 seconds, every iteration is one direction, MM takes data recorded in HRD files and puts that passes that to
-   * master/noniuns track data it takes 32-bit values are both splitted into 2 parts (master nonius), two arrays one master one nonious
-   * that data are passed to iChouse library which give depending on encoder type track master nonius, return some sine offset, cos offset, gain, etc.
-   * that procuderu can have errors: data out of range, motor to slow, bad data, internal error - if error in any iteration the procedure stops
-   * if no error then check if calibration succeeded depending on the values (iterativelly improve values by writing them back to some registers), if not run another iteration
-   * max iteration to run is 13 (up to 2 mins)
-   * treshold is determined by Petr
-   * if iteration is successfull, HRD files are moved after deinitializing (succesfful run),
-   * the result of calibration is setting multiple register values
-   * all parameters are reverted back, motor is rotated back to the starging position, commutation offset measurement (just one OS command) is run again
-   * how many iterations are run are based on results
-   * final itertion is for outputting does nothhing just measures the values
-   */
-  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),
-        );
-      }),
-    );
-  }
-
-  /**
-   * {@inheritDoc startCirculoEncoderNarrowAngleCalibrationProcedure}
-   */
-  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);
-  }
-
-}