@synapticon/motion-master-client 2.2.2 → 6.0.0-alpha.22

package/dist/generated/Api.js

@@ -0,0 +1,614 @@
+/* eslint-disable */
+/* tslint:disable */
+// @ts-nocheck
+/*
+ * ---------------------------------------------------------------
+ * ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API        ##
+ * ##                                                           ##
+ * ## AUTHOR: acacode                                           ##
+ * ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
+ * ---------------------------------------------------------------
+ */
+import { ContentType, HttpClient } from "./http-client.js";
+export class Api extends HttpClient {
+    /**
+     * No description
+     *
+     * @name GetAdapters
+     * @summary List network adapters on the host
+     * @request GET:/api/adapters
+     */
+    getAdapters = (params = {}) => this.request({
+        path: `/api/adapters`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * No description
+     *
+     * @name GetVersion
+     * @summary Get Motion Master version
+     * @request GET:/api/version
+     */
+    getVersion = (params = {}) => this.request({
+        path: `/api/version`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description The effective configuration after merging the JSONC config file (if any) over the built-in defaults — the same `Config` the server booted with. Read-only; changing it requires editing the config file and restarting. The shape mirrors the config file (server, fieldbus, logLevel, tls, gameLoop, recorder).
+     *
+     * @name GetStartedConfig
+     * @summary Get the configuration Motion Master was started with
+     * @request GET:/api/config
+     */
+    getStartedConfig = (params = {}) => this.request({
+        path: `/api/config`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description A best-effort snapshot of the operating system and hardware Motion Master is running on, for the Connection page's System panel. Every field is best-effort: one that cannot be determined on the current platform is returned empty (strings) or zero (numbers) rather than failing the request. Collected on demand — not cached.
+     *
+     * @name GetSystemInfo
+     * @summary Get host OS and hardware information
+     * @request GET:/api/system-info
+     */
+    getSystemInfo = (params = {}) => this.request({
+        path: `/api/system-info`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Reports the validity window and identity of the certificate the server is currently serving. `expiresSoon` trips within 7 days of `notAfter`, so the PWA can prompt the user to refresh. Note that an already-expired certificate blocks the browser from reaching this endpoint at all; the binary self-heals an expired/missing certificate at startup (fetching from the rolling release) and exposes `--update-cert` for manual refresh. Returns 500 if the certificate file cannot be read or parsed.
+     *
+     * @name GetCert
+     * @summary Get the TLS certificate validity window
+     * @request GET:/api/cert
+     */
+    getCert = (params = {}) => this.request({
+        path: `/api/cert`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Downloads a fresh certificate and key from the rolling release, validates the pair (parses, CN matches, not expired, key matches cert), and atomically installs them next to the binary. The new certificate only takes effect after a restart (the TLS listener loads the certificate once at startup), indicated by `restartRequired` in the response. Use the still-valid proactive case; an already-expired certificate is healed by the binary at startup instead.
+     *
+     * @name RefreshCert
+     * @summary Fetch and install a fresh TLS certificate
+     * @request POST:/api/cert/refresh
+     */
+    refreshCert = (params = {}) => this.request({
+        path: `/api/cert/refresh`,
+        method: "POST",
+        format: "json",
+        ...params,
+    });
+    /**
+     * No description
+     *
+     * @name GetDevice
+     * @summary Get a single fieldbus device by bus position
+     * @request GET:/api/devices/{slavePosition}
+     */
+    getDevice = (slavePosition, params = {}) => this.request({
+        path: `/api/devices/${slavePosition}`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Performs a live AL-state read for the device and reports whether its CoE/SDO mailbox is active — i.e. it is in PRE-OP, SAFE-OP, or OP. This is independent of the AL error indicator: a device in SAFE-OP+error still answers mailbox requests. Only INIT (no mailbox) and BOOT (FoE-only mailbox) report inactive. The device must already be known from a prior scan. Reading one device at a time means a single missing device reports inactive without failing the others.
+     *
+     * @name GetDeviceMailboxActive
+     * @summary Check whether a device's mailbox is active
+     * @request GET:/api/devices/{slavePosition}/mailbox
+     */
+    getDeviceMailboxActive = (slavePosition, params = {}) => this.request({
+        path: `/api/devices/${slavePosition}/mailbox`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Constructs the requested fieldbus driver, opens the network interface, and makes the driver available for subsequent calls to /api/scan. The driver defaults to SOEM when omitted. SOEM has no adapter auto-detect: a network adapter must be supplied, otherwise init fails.
+     *
+     * @name Init
+     * @summary Initialise the fieldbus driver
+     * @request POST:/api/init
+     */
+    init = (data, params = {}) => this.request({
+        path: `/api/init`,
+        method: "POST",
+        body: data,
+        type: ContentType.Json,
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Scans the fieldbus for slaves and configures their sync managers and FMMUs. Must be called after a successful POST /api/init. Slaves remain in INIT state after this call; state transitions are driven by subsequent API calls.
+     *
+     * @name Scan
+     * @summary Scan the bus for slaves
+     * @request POST:/api/scan
+     */
+    scan = (params = {}) => this.request({
+        path: `/api/scan`,
+        method: "POST",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Transitions all slaves to INIT state, closes the network interface, and removes all Device objects. After this returns, POST /api/init and POST /api/scan may be called again.
+     *
+     * @name Reset
+     * @summary Reset the fieldbus driver and clear the device list
+     * @request POST:/api/reset
+     */
+    reset = (params = {}) => this.request({
+        path: `/api/reset`,
+        method: "POST",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Returns the most recent in-memory log lines as plain text, one entry per line. The ring buffer holds up to 100 000 entries (~10 MB).
+     *
+     * @name GetLog
+     * @summary Get recent log output
+     * @request GET:/api/log
+     */
+    getLog = (params = {}) => this.request({
+        path: `/api/log`,
+        method: "GET",
+        ...params,
+    });
+    /**
+     * @description Returns the static catalogue of EtherCAT AL Status Codes defined in ETG.1000.6 §6.4.1. These codes appear in the alStatusCode field of the device state response when an error is present and identify the cause of the state transition failure.
+     *
+     * @name GetAlStatusCodes
+     * @summary List all known AL Status Codes
+     * @request GET:/api/meta/al-status-codes
+     */
+    getAlStatusCodes = (params = {}) => this.request({
+        path: `/api/meta/al-status-codes`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Returns the static catalogue of well-known EtherCAT Slave Controller registers from the Beckhoff ESC datasheet (Section II) and ETG.1000.4. Use the address and length fields as inputs to the device register read/write endpoints.
+     *
+     * @name GetRegisters
+     * @summary List all known ESC registers
+     * @request GET:/api/meta/esc-registers
+     */
+    getRegisters = (params = {}) => this.request({
+        path: `/api/meta/esc-registers`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Returns the static catalogue of standard File over EtherCAT (FoE) error codes defined in ETG.1000.6 §5.5.  These codes appear in the FoE ERROR packet sent by the slave when a file transfer fails, and are surfaced in the error message returned by the file read endpoint.  Vendor-specific codes outside the 0x8000 range are not listed here.
+     *
+     * @name GetFoeErrorCodes
+     * @summary List all known FoE error codes
+     * @request GET:/api/meta/foe-error-codes
+     */
+    getFoeErrorCodes = (params = {}) => this.request({
+        path: `/api/meta/foe-error-codes`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Returns the static catalogue of ETG.1020 data type codes used in CoE object dictionary entries.  Each entry of a `DeviceParameter` carries a `dataType` field whose value is one of the codes listed here.
+     *
+     * @name GetDataTypes
+     * @summary List all known CoE object dictionary data types
+     * @request GET:/api/meta/data-types
+     */
+    getDataTypes = (params = {}) => this.request({
+        path: `/api/meta/data-types`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Enumerates the entire CoE object dictionary of the device at `slavePosition` via the SDO Info service ("Get Object List" → "Get Object Description" → "Get Entry Description") and rebuilds its parameter map. The device must be in PRE-OP, SAFE-OP, or OP (mailbox communication active).  On a fully populated drive the call can take several seconds. When `readValues=true` each entry is additionally read via SDO upload and the decoded value is stored on the parameter; entries that fail to read keep their type-appropriate default and the call still succeeds.
+     *
+     * @name InitializeDeviceParameters
+     * @summary Initialise the parameter list for a device by enumerating its object dictionary
+     * @request POST:/api/devices/{slavePosition}/parameters/init
+     */
+    initializeDeviceParameters = (slavePosition, query, params = {}) => this.request({
+        path: `/api/devices/${slavePosition}/parameters/init`,
+        method: "POST",
+        query: query,
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Returns the parameter list populated by the most recent call to `POST /api/devices/{slavePosition}/parameters/init`.  Empty before the first call.  Entries are ordered ascending by `(index, subindex)`.
+     *
+     * @name GetDeviceParameters
+     * @summary Read the previously initialised parameter list for a device
+     * @request GET:/api/devices/{slavePosition}/parameters
+     */
+    getDeviceParameters = (slavePosition, params = {}) => this.request({
+        path: `/api/devices/${slavePosition}/parameters`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Reads `length` bytes from the ESC register at `address` on the slave at `slavePosition` using a Configured-Address Read (FPRD) datagram. Pass `address` in decimal (e.g. 272 for DL Status at 0x0110).
+     *
+     * @name ReadRegister
+     * @summary Read bytes from an ESC register
+     * @request GET:/api/devices/{slavePosition}/registers/{address}
+     */
+    readRegister = (slavePosition, address, query, params = {}) => this.request({
+        path: `/api/devices/${slavePosition}/registers/${address}`,
+        method: "GET",
+        query: query,
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Writes bytes to the ESC register at `address` on the slave at `slavePosition` using a Configured-Address Write (FPWR) datagram. Pass `address` in decimal (e.g. 272 for DL Status at 0x0110).
+     *
+     * @name WriteRegister
+     * @summary Write bytes to an ESC register
+     * @request POST:/api/devices/{slavePosition}/registers/{address}
+     */
+    writeRegister = (slavePosition, address, data, params = {}) => this.request({
+        path: `/api/devices/${slavePosition}/registers/${address}`,
+        method: "POST",
+        body: data,
+        type: ContentType.Json,
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Reads the process-data watchdog timeout the slave at `slavePosition` is configured with, decoded from the watchdog divider (0x0400) and process-data watchdog time (0x0420) ESC registers. This is the configured timeout itself, not the expiration counter exposed by `GET /api/devices/diagnostics`. A device in OP that misses process data past this timeout faults itself to SAFE-OP+error; raising it lets a device tolerate the brief PDO pause of a whole-bus re-map.
+     *
+     * @name GetProcessDataWatchdog
+     * @summary Read the process-data (sync-manager) watchdog configuration
+     * @request GET:/api/devices/{slavePosition}/watchdog
+     */
+    getProcessDataWatchdog = (slavePosition, params = {}) => this.request({
+        path: `/api/devices/${slavePosition}/watchdog`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Sets the process-data watchdog timeout of the slave at `slavePosition`, writing the process-data watchdog time register (0x0420). The device's watchdog divider (0x0400) is left untouched (it is shared with the PDI watchdog), so the achieved timeout is rounded to that divider's tick base — the response reports the value actually programmed. A `timeoutMs` of 0 disables the watchdog. The write persists across re-maps and re-scans until the ESC reloads EEPROM (power cycle).
+     *
+     * @name SetProcessDataWatchdog
+     * @summary Set the process-data (sync-manager) watchdog timeout
+     * @request PUT:/api/devices/{slavePosition}/watchdog
+     */
+    setProcessDataWatchdog = (slavePosition, data, params = {}) => this.request({
+        path: `/api/devices/${slavePosition}/watchdog`,
+        method: "PUT",
+        body: data,
+        type: ContentType.Json,
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Performs a CoE SDO upload — reads the value of object `index:subindex` from the device at `slavePosition` and returns the raw bytes as a JSON array. Both `index` and `subindex` accept decimal or hexadecimal notation; prefix with `0x` for hex (e.g. `0x6064` or `24676` for object 0x6064).
+     *
+     * @name SdoUpload
+     * @summary Upload an object dictionary entry from a device (CoE SDO upload)
+     * @request GET:/api/devices/{slavePosition}/sdo/{index}/{subindex}
+     */
+    sdoUpload = (slavePosition, index, subindex, params = {}) => this.request({
+        path: `/api/devices/${slavePosition}/sdo/${index}/${subindex}`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Performs a CoE SDO download — writes the raw bytes in the request body to object `index:subindex` on the device at `slavePosition`. The byte count must match the object's length. Requires the device to be in PRE-OP, SAFE-OP, or OP (mailbox communication active). Both `index` and `subindex` accept decimal or hexadecimal notation; prefix with `0x` for hex (e.g. `0x6064` or `24676`).
+     *
+     * @name SdoDownload
+     * @summary Download an object dictionary entry to a device (CoE SDO download)
+     * @request PUT:/api/devices/{slavePosition}/sdo/{index}/{subindex}
+     */
+    sdoDownload = (slavePosition, index, subindex, data, params = {}) => this.request({
+        path: `/api/devices/${slavePosition}/sdo/${index}/${subindex}`,
+        method: "PUT",
+        body: data,
+        type: ContentType.Json,
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Sends an FoE read request for `filename` to the device at `slavePosition` and returns the raw file bytes.  FoE is available in Boot, Pre-Op, Safe-Op, and Op states (device-dependent); the caller is responsible for ensuring the device is in a suitable state before calling.  The call blocks until the full file has been received or a per-packet timeout of 700 ms is exceeded.
+     *
+     * @name FoeReadFile
+     * @summary Read a file from a device via FoE (File over EtherCAT)
+     * @request GET:/api/devices/{slavePosition}/files/{filename}
+     */
+    foeReadFile = (slavePosition, filename, params = {}) => this.request({
+        path: `/api/devices/${slavePosition}/files/${filename}`,
+        method: "GET",
+        ...params,
+    });
+    /**
+     * @description Sends an FoE write request for `filename` to the device at `slavePosition`, streaming the raw request body as the file contents.  FoE is available in Boot, Pre-Op, Safe-Op, and Op states (device-dependent); the caller is responsible for ensuring the device is in a suitable state before calling.
+     *
+     * @name FoeWriteFile
+     * @summary Write a file to a device via FoE (File over EtherCAT)
+     * @request PUT:/api/devices/{slavePosition}/files/{filename}
+     */
+    foeWriteFile = (slavePosition, filename, data, params = {}) => this.request({
+        path: `/api/devices/${slavePosition}/files/${filename}`,
+        method: "PUT",
+        body: data,
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Reads the raw SII EEPROM image of the device at `slavePosition` through the ESC's EEPROM-control registers and returns either the parsed structure or the raw bytes, selected by the `Accept` request header. With `Accept: application/json` (or `*\/*`, or no `Accept` header) the parsed `SlaveInformationInterface` is returned — the 128-byte fixed header plus the decoded category section (strings, general info, FMMU/Sync-Manager and PDO defaults, distributed-clock settings).  With `Accept: application/octet-stream` the raw EEPROM image is returned unparsed, suitable for a hex dump or archival. EEPROM access is a control-plane operation and is most reliable while the device is in INIT or PRE-OP.  String-index fields in the parsed structure (e.g. `general.nameIdx`) are 1-based references into `category.strings`.
+     *
+     * @name ReadSii
+     * @summary Read a device's SII (Slave Information Interface / EEPROM)
+     * @request GET:/api/devices/{slavePosition}/sii
+     */
+    readSii = (slavePosition, params = {}) => this.request({
+        path: `/api/devices/${slavePosition}/sii`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Writes the raw SII image in the request body to the device's EEPROM, one 16-bit word at a time. The image is parse-validated first and rejected if it is not a well-formed SII (a guard against bricking the device). **Destructive:** a wrong image can leave the device unidentifiable until re-flashed. The device adopts the new contents only after a **power cycle**, and the write is most reliable while the device is in INIT or PRE-OP. Intended for restoring a previously downloaded image.
+     *
+     * @name WriteSii
+     * @summary Write a raw SII (EEPROM) image to a device
+     * @request PUT:/api/devices/{slavePosition}/sii
+     */
+    writeSii = (slavePosition, data, params = {}) => this.request({
+        path: `/api/devices/${slavePosition}/sii`,
+        method: "PUT",
+        body: data,
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Decodes a raw SII EEPROM image supplied in the request body and returns the parsed structure — the same decoder the device read path uses, exposed as a bus-independent utility. No device is involved; the Tools SII page uses this to view previously downloaded `.bin` files offline.
+     *
+     * @name ParseSii
+     * @summary Parse a raw SII (EEPROM) image
+     * @request POST:/api/sii/parse
+     */
+    parseSii = (data, params = {}) => this.request({
+        path: `/api/sii/parse`,
+        method: "POST",
+        body: data,
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Reads live link-quality and watchdog diagnostics from each slave's EtherCAT Slave Controller (DL Status 0x0110, error-counter block 0x0300–0x0313, watchdog block 0x0440–0x0443) via FPRD. Counters are 8-bit, saturate at 255, and are cleared only by a power cycle or explicit write — poll this endpoint and watch for a rising delta rather than an absolute value. The per-port counters localise a degrading link to a specific cable/connector; the watchdog counters distinguish a slave that stopped receiving process data from a master-side problem. Omit `positions` to query all discovered devices. Returns 500 for transports without an ESC (e.g. SPoE).
+     *
+     * @name GetDeviceDiagnostics
+     * @summary Read live ESC health diagnostics for devices
+     * @request GET:/api/devices/diagnostics
+     */
+    getDeviceDiagnostics = (query, params = {}) => this.request({
+        path: `/api/devices/diagnostics`,
+        method: "GET",
+        query: query,
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Reads each slave's distributed-clock unit live from its EtherCAT Slave Controller (system-time delay 0x0928 and system-time difference 0x092C) via FPRD. The reference clock is the first DC-capable slave; every other DC slave continuously corrects its local clock toward it, and `systemTimeDifference` is the live deviation in nanoseconds. The figure is meaningful only while the bus is exchanging process data in SAFE-OP/OP (the reference time is distributed in the cyclic frame) and converges toward zero as the slaves' drift loops settle — poll this endpoint and watch for a slave whose deviation stays large or grows rather than an absolute value. Non-DC slaves report `dcCapable` false with zeroed values. Omit `positions` to query all discovered devices. Returns 500 for transports without an ESC (e.g. SPoE).
+     *
+     * @name GetDcSync
+     * @summary Read live distributed-clock synchronisation status for devices
+     * @request GET:/api/dc-sync
+     */
+    getDcSync = (query, params = {}) => this.request({
+        path: `/api/dc-sync`,
+        method: "GET",
+        query: query,
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Reads the current EtherCAT Application Layer state for one or more devices. Omit the `positions` query parameter to query all discovered devices.
+     *
+     * @name GetDeviceStates
+     * @summary Read current AL state for devices
+     * @request GET:/api/devices/state
+     */
+    getDeviceStates = (query, params = {}) => this.request({
+        path: `/api/devices/state`,
+        method: "GET",
+        query: query,
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Commands one or more devices to the requested EtherCAT Application Layer state and blocks until all targeted devices arrive or the timeout elapses. The settled state of every targeted device is then read back and returned in `devices`, each with a `reached` flag; `ok` is true only when every device reached the target. A device that did not reach it carries an `alStatusCode` explaining why. Omit `positions` or pass an empty array to target all discovered devices. State values are the standard AL state register encodings from ETG.1000.6: 1 (Init), 2 (PreOp), 3 (Boot), 4 (SafeOp), 8 (Op).
+     *
+     * @name TransitionToState
+     * @summary Transition devices to an EtherCAT AL state
+     * @request POST:/api/devices/state
+     */
+    transitionToState = (data, params = {}) => this.request({
+        path: `/api/devices/state`,
+        method: "POST",
+        body: data,
+        type: ContentType.Json,
+        format: "json",
+        ...params,
+    });
+    /**
+     * No description
+     *
+     * @name GetDevices
+     * @summary List all fieldbus devices
+     * @request GET:/api/devices
+     */
+    getDevices = (params = {}) => this.request({
+        path: `/api/devices`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Returns the whole-bus process image: the byte sizes of each direction, the expected and last working counters and overall health, the number of retained image generations (one per re-map since the last reset), and every mapped object resolved to its absolute bit offset. While an image is live `configured` is true and the layout describes it. When no image is published (no device is in SAFE-OP/OP) but at least one generation has been mapped, `configured` is false and the layout describes the most recent retained generation — the last-known mapping — so a bus that has dropped out of SAFE-OP/OP stays inspectable; `lastWkc` then holds the final exchange value and working-counter health does not apply. The object lists are empty only before any image has ever been mapped. Object `name` is populated only for devices whose object dictionary has been enumerated.
+     *
+     * @name GetProcessImage
+     * @summary Inspect the published EtherCAT process image
+     * @request GET:/api/process-image
+     */
+    getProcessImage = (params = {}) => this.request({
+        path: `/api/process-image`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Streams the same `.mmpd` serialisation as the POST variant (the recorder's current span, with the process image embedded as a header) directly in the response body instead of writing a file — for the client SDK / browser, which parses the bytes offline. Request with `Accept: application/octet-stream`. Same span semantics as the POST; works in any state.
+     *
+     * @name StreamProcessDataDump
+     * @summary Stream the recorder ring as a binary .mmpd
+     * @request GET:/api/process-data/dump
+     */
+    streamProcessDataDump = (params = {}) => this.request({
+        path: `/api/process-data/dump`,
+        method: "GET",
+        ...params,
+    });
+    /**
+     * @description Serialises the process-data recorder's current span — every cycle from the oldest still in the ring up to the newest at the instant of the call — to a `.mmpd` file and returns its path. Each cycle's full raw input and output images, sequence, and epoch-nanosecond timestamp are written, with the process image (per-device identity and PDO object layout, including object names and data types where the object dictionary has been enumerated) embedded as a header, so the file decodes fully offline with no running Motion Master and no live bus. Works in any state: while devices are exchanging (SAFE-OP/OP) it captures tail→head at that moment and ignores cycles recorded afterwards; after the bus has left the exchange states it uses the most recent retained image layout. The file is written under the configured `recorder.dumpDir` (default: a `motion-master` subdirectory of the OS temporary directory), created if absent. Motion Master binds 127.0.0.1, so the file is on the caller's own machine — only the path is returned (there is no download, list, or delete endpoint).
+     *
+     * @name DumpProcessData
+     * @summary Dump the recorder ring to a binary .mmpd file
+     * @request POST:/api/process-data/dump
+     */
+    dumpProcessData = (params = {}) => this.request({
+        path: `/api/process-data/dump`,
+        method: "POST",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Returns the static ESC configuration the master programmed into every slave during the last scan: station/alias addresses, mapped process-data sizes, the mailbox transport windows, the distributed-clock setup, and the configured Sync Managers and FMMUs. Read from cached state with no bus I/O and valid once the bus has been scanned. The list is empty before any scan, or when the active transport has no ESC (e.g. SPoE). Numeric fields (SM/FMMU type, mailbox protocol bits, SM flags) are raw register values; the client decodes them. `deviceName` is empty when no known device occupies the slave.
+     *
+     * @name GetBusConfig
+     * @summary Inspect each slave's static EtherCAT Slave Controller configuration
+     * @request GET:/api/bus-config
+     */
+    getBusConfig = (params = {}) => this.request({
+        path: `/api/bus-config`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Returns every registered monitoring as a resource — its configuration plus, per parameter, how its value is sourced, and the current buffer fill.
+     *
+     * @name ListMonitorings
+     * @summary List all monitorings
+     * @request GET:/api/monitorings
+     */
+    listMonitorings = (params = {}) => this.request({
+        path: `/api/monitorings`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Registers a monitoring and starts sampling it off the real-time thread. Each parameter is classified once against the published process image: PDO-mapped objects are decoded from the live image; the rest are polled over SDO in the background. Create monitorings after the bus is operational so PDO objects are recognised as PDO. Monitoring is live-only — a parameter samples `null` while its owning device is not exchanging (SAFE-OP/OP).
+     *
+     * @name CreateMonitoring
+     * @summary Create a monitoring
+     * @request POST:/api/monitorings
+     */
+    createMonitoring = (data, params = {}) => this.request({
+        path: `/api/monitorings`,
+        method: "POST",
+        body: data,
+        type: ContentType.Json,
+        format: "json",
+        ...params,
+    });
+    /**
+     * No description
+     *
+     * @name GetMonitoring
+     * @summary Get a monitoring
+     * @request GET:/api/monitorings/{topic}
+     */
+    getMonitoring = (topic, params = {}) => this.request({
+        path: `/api/monitorings/${topic}`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Stops sampling and releases the monitoring's SDO parameters from the shared refresher — an object no remaining monitoring needs stops being polled.
+     *
+     * @name DeleteMonitoring
+     * @summary Delete a monitoring
+     * @request DELETE:/api/monitorings/{topic}
+     */
+    deleteMonitoring = (topic, params = {}) => this.request({
+        path: `/api/monitorings/${topic}`,
+        method: "DELETE",
+        ...params,
+    });
+    /**
+     * @description Returns one entry per cached parameter-definition file on disk, keyed by device identity (vendor, product, revision). The cache stores only the object-dictionary *definitions* (not live values), so a scan of previously-seen hardware can skip the slow SDO enumeration. Independent of the bus — works whether or not a driver is initialised.
+     *
+     * @name ListParameterCaches
+     * @summary List on-disk parameter caches
+     * @request GET:/api/parameter-caches
+     */
+    listParameterCaches = (params = {}) => this.request({
+        path: `/api/parameter-caches`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Returns the raw JSON cache file for the given id, verbatim, so it can be saved or inspected offline.
+     *
+     * @name GetParameterCache
+     * @summary Download a parameter-cache file
+     * @request GET:/api/parameter-caches/{id}
+     */
+    getParameterCache = (id, params = {}) => this.request({
+        path: `/api/parameter-caches/${id}`,
+        method: "GET",
+        format: "json",
+        ...params,
+    });
+    /**
+     * @description Removes one cached file from disk. The next scan of that hardware re-enumerates it. Useful when a vendor reused a revision across an object-dictionary change.
+     *
+     * @name DeleteParameterCache
+     * @summary Delete a parameter-cache file
+     * @request DELETE:/api/parameter-caches/{id}
+     */
+    deleteParameterCache = (id, params = {}) => this.request({
+        path: `/api/parameter-caches/${id}`,
+        method: "DELETE",
+        ...params,
+    });
+}