@kvaser/canking-api/dist/grpc.mjs

CanKing API to communicate with the CanKing service using Node.js.

import { makeGenericClientConstructor as c } from "@grpc/grpc-js";
import { q as d, i as a, p as t, o as l, n as m, m as S, E as s, U as p, I as z, e as q, G as h, h as v, k as D, a7 as B, a6 as g, a5 as M, a4 as F, a0 as C, $ as R, a3 as G, a2 as L, J as r, a1 as b, _ as A, Z as T, V as E, W as P, T as x, Q as U, P as N, R as I, O, N as k, H as y, D as w, B as n, C as W, y as o, z as Q, w as f, x as H, v as J, u as V, X, t as Y, am as Z, Y as _ } from "./status_params.mjs";
import { A as i, w as $, v as j, u as K, t as ee, s as se, r as re, q as ie, G as ae, x as te, Q as ne, O as u, aI as oe, M as fe } from "./measurement_settings.mjs";
const ue = {
  /**
   * Starts a subscription for application events.
   * @param request A request message with API preferences.
   * @returns A stream of AppEventArgs messages.
   */
  subscribeForEvents: {
    path: "/appservice.AppService/SubscribeForEvents",
    requestStream: !1,
    responseStream: !0,
    requestSerialize: (e) => Buffer.from(i.encode(e).finish()),
    requestDeserialize: (e) => i.decode(e),
    responseSerialize: (e) => Buffer.from(D.encode(e).finish()),
    responseDeserialize: (e) => D.decode(e)
  },
  /**
   * Starts a subscription for log messages.
   * @param request A request message with API preferences.
   * @returns A stream of log messages.
   */
  subscribeForLogMessages: {
    path: "/appservice.AppService/SubscribeForLogMessages",
    requestStream: !1,
    responseStream: !0,
    requestSerialize: (e) => Buffer.from(i.encode(e).finish()),
    requestDeserialize: (e) => i.decode(e),
    responseSerialize: (e) => Buffer.from(v.encode(e).finish()),
    responseDeserialize: (e) => v.decode(e)
  },
  /**
   * Gets the current log level.
   * @param request A request message with API preferences.
   * @returns A response message with the current log level.
   */
  getLogLevel: {
    path: "/appservice.AppService/GetLogLevel",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(i.encode(e).finish()),
    requestDeserialize: (e) => i.decode(e),
    responseSerialize: (e) => Buffer.from(h.encode(e).finish()),
    responseDeserialize: (e) => h.decode(e)
  },
  /**
   * Sets a new log level.
   * @param request A request message with the new log level.
   * @returns An empty response message.
   */
  setLogLevel: {
    path: "/appservice.AppService/SetLogLevel",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(q.encode(e).finish()),
    requestDeserialize: (e) => q.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to be shutdown.
   * @param request A request message with API preferences.
   * @returns An empty response message.
   */
  shutdown: {
    path: "/appservice.AppService/Shutdown",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(i.encode(e).finish()),
    requestDeserialize: (e) => i.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to install a service extension.
   * @param request A request message with a service extension .wasm-file.
   * @returns An empty response message.
   */
  installServiceExtension: {
    path: "/appservice.AppService/InstallServiceExtension",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(z.encode(e).finish()),
    requestDeserialize: (e) => z.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to uninstall a service extension.
   * @param request A request message with a service extension name.
   * @returns An empty response message.
   */
  uninstallServiceExtension: {
    path: "/appservice.AppService/UninstallServiceExtension",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(p.encode(e).finish()),
    requestDeserialize: (e) => p.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Gets a service extension's information.
   * @param request A request message with a service extension .wasm-file or an installed extension's name.
   * @returns A response message with the extension information.
   */
  getServiceExtensionInfo: {
    path: "/appservice.AppService/GetServiceExtensionInfo",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(S.encode(e).finish()),
    requestDeserialize: (e) => S.decode(e),
    responseSerialize: (e) => Buffer.from(m.encode(e).finish()),
    responseDeserialize: (e) => m.decode(e)
  },
  /**
   * Gets all registered licenses.
   * @param request A request message with API preferences.
   * @returns A response message with all registered licenses.
   */
  getLicenses: {
    path: "/appservice.AppService/GetLicenses",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(i.encode(e).finish()),
    requestDeserialize: (e) => i.decode(e),
    responseSerialize: (e) => Buffer.from(l.encode(e).finish()),
    responseDeserialize: (e) => l.decode(e)
  },
  /**
   * Asks the service to activate a license.
   * @param request A request message with the license key.
   * @returns A response message with license information.
   */
  activateLicense: {
    path: "/appservice.AppService/ActivateLicense",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(t.encode(e).finish()),
    requestDeserialize: (e) => t.decode(e),
    responseSerialize: (e) => Buffer.from(a.encode(e).finish()),
    responseDeserialize: (e) => a.decode(e)
  },
  /**
   * Asks the service to check a license.
   * @param request A request message with the license key.
   * @returns A response message with license information.
   */
  checkLicense: {
    path: "/appservice.AppService/CheckLicense",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(t.encode(e).finish()),
    requestDeserialize: (e) => t.decode(e),
    responseSerialize: (e) => Buffer.from(a.encode(e).finish()),
    responseDeserialize: (e) => a.decode(e)
  },
  /**
   * Asks the service for about information.
   * @param request A request message with API preferences.
   * @returns A response with about information.
   */
  getAbout: {
    path: "/appservice.AppService/GetAbout",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(i.encode(e).finish()),
    requestDeserialize: (e) => i.decode(e),
    responseSerialize: (e) => Buffer.from(d.encode(e).finish()),
    responseDeserialize: (e) => d.decode(e)
  }
}, pe = c(ue, "appservice.AppService"), ce = {
  /**
   * Starts a subscription for device events.
   * @param request A request message with API preferences.
   * @returns A stream of DeviceEventArgs messages.
   */
  subscribeForEvents: {
    path: "/deviceservice.DeviceService/SubscribeForEvents",
    requestStream: !1,
    responseStream: !0,
    requestSerialize: (e) => Buffer.from(i.encode(e).finish()),
    requestDeserialize: (e) => i.decode(e),
    responseSerialize: (e) => Buffer.from(te.encode(e).finish()),
    responseDeserialize: (e) => te.decode(e)
  },
  /**
   * Gets all available devices.
   * @param request A request message with API preferences.
   * @returns A response message with all available devices.
   */
  getDevices: {
    path: "/deviceservice.DeviceService/GetDevices",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(ae.encode(e).finish()),
    requestDeserialize: (e) => ae.decode(e),
    responseSerialize: (e) => Buffer.from(ie.encode(e).finish()),
    responseDeserialize: (e) => ie.decode(e)
  },
  /**
   * Gets the possible CAN channel bus speeds.
   * @param request A request message with information about the device to get bus speeds for.
   * @returns A response message with the possible CAN channel bus speeds.
   */
  getCanChannelBusSpeeds: {
    path: "/deviceservice.DeviceService/GetCanChannelBusSpeeds",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(re.encode(e).finish()),
    requestDeserialize: (e) => re.decode(e),
    responseSerialize: (e) => Buffer.from(se.encode(e).finish()),
    responseDeserialize: (e) => se.decode(e)
  },
  /**
   * Gets the possible classic CAN bus speeds.
   * @param request A request message with information about the device to get bus speeds for.
   * @returns A response message with the possible classic CAN bus speeds.
   */
  getClassicCanBusSpeeds: {
    path: "/deviceservice.DeviceService/GetClassicCanBusSpeeds",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(ee.encode(e).finish()),
    requestDeserialize: (e) => ee.decode(e),
    responseSerialize: (e) => Buffer.from(K.encode(e).finish()),
    responseDeserialize: (e) => K.decode(e)
  },
  /**
   * Gets the possible CAN-FD bus speeds.
   * @param request A request message with information about the device to get bus speeds for.
   * @returns A response message with the possible CAN-FD bus speeds.
   */
  getCanFdBusSpeeds: {
    path: "/deviceservice.DeviceService/GetCanFdBusSpeeds",
    requestStream: !1,
    responseStream: !0,
    requestSerialize: (e) => Buffer.from(j.encode(e).finish()),
    requestDeserialize: (e) => j.decode(e),
    responseSerialize: (e) => Buffer.from($.encode(e).finish()),
    responseDeserialize: (e) => $.decode(e)
  }
}, ze = c(
  ce,
  "deviceservice.DeviceService"
), de = {
  /**
   * Starts a subscription for measurement events.
   * @param request A request message with API preferences.
   * @returns A stream of MeasurementEventArgs messages.
   */
  subscribeForEvents: {
    path: "/measurementservice.MeasurementService/SubscribeForEvents",
    requestStream: !1,
    responseStream: !0,
    requestSerialize: (e) => Buffer.from(i.encode(e).finish()),
    requestDeserialize: (e) => i.decode(e),
    responseSerialize: (e) => Buffer.from(_.encode(e).finish()),
    responseDeserialize: (e) => _.decode(e)
  },
  /**
   * Starts a subscription for measurement data.
   * @param request A request message with API preferences.
   * @returns A stream of Frames messages.
   */
  subscribeForData: {
    path: "/measurementservice.MeasurementService/SubscribeForData",
    requestStream: !1,
    responseStream: !0,
    requestSerialize: (e) => Buffer.from(i.encode(e).finish()),
    requestDeserialize: (e) => i.decode(e),
    responseSerialize: (e) => Buffer.from(fe.encode(e).finish()),
    responseDeserialize: (e) => fe.decode(e)
  },
  /**
   * Starts a subscription for measurement status.
   * @param request A request message with API preferences.
   * @returns A stream of NodeStatuses messages.
   */
  subscribeForStatus: {
    path: "/measurementservice.MeasurementService/SubscribeForStatus",
    requestStream: !1,
    responseStream: !0,
    requestSerialize: (e) => Buffer.from(i.encode(e).finish()),
    requestDeserialize: (e) => i.decode(e),
    responseSerialize: (e) => Buffer.from(Z.encode(e).finish()),
    responseDeserialize: (e) => Z.decode(e)
  },
  /**
   * Asks the service to clear status for the specified node.
   * @param request A request message with a node identifier.
   * @returns An empty response message.
   */
  clearStatus: {
    path: "/measurementservice.MeasurementService/ClearStatus",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(r.encode(e).finish()),
    requestDeserialize: (e) => r.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Gets the current measurement setup.
   * @param request A request message with API preferences.
   * @returns A response message with the current setup.
   */
  getSetup: {
    path: "/measurementservice.MeasurementService/GetSetup",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(i.encode(e).finish()),
    requestDeserialize: (e) => i.decode(e),
    responseSerialize: (e) => Buffer.from(oe.encode(e).finish()),
    responseDeserialize: (e) => oe.decode(e)
  },
  /**
   * Sets a new measurement setup.
   * @param request A request message with the new setup.
   * @returns An empty response message.
   */
  setSetup: {
    path: "/measurementservice.MeasurementService/SetSetup",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(Y.encode(e).finish()),
    requestDeserialize: (e) => Y.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Gets the current online status.
   * @param request A request message with API preferences.
   * @returns A response message with the current online status.
   */
  getOnlineStatus: {
    path: "/measurementservice.MeasurementService/GetOnlineStatus",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(i.encode(e).finish()),
    requestDeserialize: (e) => i.decode(e),
    responseSerialize: (e) => Buffer.from(X.encode(e).finish()),
    responseDeserialize: (e) => X.decode(e)
  },
  /**
   * Asks the service to add all connected CAN channels with the specified settings.
   * @param request A request message with CAN channel settings.
   * @returns An empty response message.
   */
  addAllConnectedCanChannels: {
    path: "/measurementservice.MeasurementService/AddAllConnectedCanChannels",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(V.encode(e).finish()),
    requestDeserialize: (e) => V.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to add all connected LIN channels with the specified settings.
   * @param request A request message with LIN channel settings.
   * @returns An empty response message.
   */
  addAllConnectedLinChannels: {
    path: "/measurementservice.MeasurementService/AddAllConnectedLinChannels",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(J.encode(e).finish()),
    requestDeserialize: (e) => J.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to add a new source node with the specified settings.
   * @param request A request message with source node settings.
   * @returns An empty response message.
   */
  addSource: {
    path: "/measurementservice.MeasurementService/AddSource",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(f.encode(e).finish()),
    requestDeserialize: (e) => f.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Gets the source node with the specified identifier.
   * @param request A request message with source node identifier.
   * @returns A response message with the source node settings.
   */
  getSource: {
    path: "/measurementservice.MeasurementService/GetSource",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(r.encode(e).finish()),
    requestDeserialize: (e) => r.decode(e),
    responseSerialize: (e) => Buffer.from(H.encode(e).finish()),
    responseDeserialize: (e) => H.decode(e)
  },
  /**
   * Asks the service to update a source node with the specified settings.
   * @param request A request message with source node settings.
   * @returns An empty response message.
   */
  updateSource: {
    path: "/measurementservice.MeasurementService/UpdateSource",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(f.encode(e).finish()),
    requestDeserialize: (e) => f.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to delete a source node with the specified identifier.
   * @param request A request message with source node identifier.
   * @returns An empty response message.
   */
  deleteSource: {
    path: "/measurementservice.MeasurementService/DeleteSource",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(r.encode(e).finish()),
    requestDeserialize: (e) => r.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to add a new data processor node with the specified settings.
   * @param request A request message with data processor node settings.
   * @returns An empty response message.
   */
  addDataProcessor: {
    path: "/measurementservice.MeasurementService/AddDataProcessor",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(o.encode(e).finish()),
    requestDeserialize: (e) => o.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Gets the data processor node with the specified identifier.
   * @param request A request message with data processor node identifier.
   * @returns A response message with the data processor node settings.
   */
  getDataProcessor: {
    path: "/measurementservice.MeasurementService/GetDataProcessor",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(r.encode(e).finish()),
    requestDeserialize: (e) => r.decode(e),
    responseSerialize: (e) => Buffer.from(Q.encode(e).finish()),
    responseDeserialize: (e) => Q.decode(e)
  },
  /**
   * Asks the service to update a data processor node with the specified settings.
   * @param request A request message with data processor node settings.
   * @returns An empty response message.
   */
  updateDataProcessor: {
    path: "/measurementservice.MeasurementService/UpdateDataProcessor",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(o.encode(e).finish()),
    requestDeserialize: (e) => o.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to delete a data processor node with the specified identifier.
   * @param request A request message with data processor node identifier.
   * @returns An empty response message.
   */
  deleteDataProcessor: {
    path: "/measurementservice.MeasurementService/DeleteDataProcessor",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(r.encode(e).finish()),
    requestDeserialize: (e) => r.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to add a new target node with the specified settings.
   * @param request A request message with target node settings.
   * @returns An empty response message.
   */
  addTarget: {
    path: "/measurementservice.MeasurementService/AddTarget",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(n.encode(e).finish()),
    requestDeserialize: (e) => n.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Gets the target node with the specified identifier.
   * @param request A request message with target node identifier.
   * @returns A response message with the target node settings.
   */
  getTarget: {
    path: "/measurementservice.MeasurementService/GetTarget",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(r.encode(e).finish()),
    requestDeserialize: (e) => r.decode(e),
    responseSerialize: (e) => Buffer.from(W.encode(e).finish()),
    responseDeserialize: (e) => W.decode(e)
  },
  /**
   * Asks the service to update a target node with the specified settings.
   * @param request A request message with target node settings.
   * @returns An empty response message.
   */
  updateTarget: {
    path: "/measurementservice.MeasurementService/UpdateTarget",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(n.encode(e).finish()),
    requestDeserialize: (e) => n.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to delete a target node with the specified identifier.
   * @param request A request message with target node identifier.
   * @returns An empty response message.
   */
  deleteTarget: {
    path: "/measurementservice.MeasurementService/DeleteTarget",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(r.encode(e).finish()),
    requestDeserialize: (e) => r.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to connect two nodes.
   * @param request A request message with node identifiers.
   * @returns An empty response message.
   */
  connectNodes: {
    path: "/measurementservice.MeasurementService/ConnectNodes",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(w.encode(e).finish()),
    requestDeserialize: (e) => w.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to disconnect two nodes.
   * @param request A request message with node identifiers.
   * @returns An empty response message.
   */
  disconnectNodes: {
    path: "/measurementservice.MeasurementService/DisconnectNodes",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(y.encode(e).finish()),
    requestDeserialize: (e) => y.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to enable a node.
   * @param request A request message with node identifier.
   * @returns An empty response message.
   */
  enableNode: {
    path: "/measurementservice.MeasurementService/EnableNode",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(r.encode(e).finish()),
    requestDeserialize: (e) => r.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to disable a node.
   * @param request A request message with node identifier.
   * @returns An empty response message.
   */
  disableNode: {
    path: "/measurementservice.MeasurementService/DisableNode",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(r.encode(e).finish()),
    requestDeserialize: (e) => r.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to start a channel node (go bus on).
   * @param request A request message with node identifier.
   * @returns An empty response message.
   */
  startChannel: {
    path: "/measurementservice.MeasurementService/StartChannel",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(r.encode(e).finish()),
    requestDeserialize: (e) => r.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to stop a channel node (go bus off).
   * @param request A request message with node identifier.
   * @returns An empty response message.
   */
  stopChannel: {
    path: "/measurementservice.MeasurementService/StopChannel",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(r.encode(e).finish()),
    requestDeserialize: (e) => r.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to start a measurement (go online).
   * @param request A request message with API preferences.
   * @returns An empty response message.
   */
  startMeasurement: {
    path: "/measurementservice.MeasurementService/StartMeasurement",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(i.encode(e).finish()),
    requestDeserialize: (e) => i.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to stop a measurement (go offline).
   * @param request A request message with API preferences.
   * @returns An empty response message.
   */
  stopMeasurement: {
    path: "/measurementservice.MeasurementService/StopMeasurement",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(i.encode(e).finish()),
    requestDeserialize: (e) => i.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to send a message.
   * @param request A request message with information about the message to be sent out.
   * @returns An empty response message.
   */
  sendMessage: {
    path: "/measurementservice.MeasurementService/SendMessage",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(k.encode(e).finish()),
    requestDeserialize: (e) => k.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to send a LIN wakeup frame.
   * @param request A request message with information about the frame to be sent out.
   * @returns An empty response message.
   */
  sendLinWakeupFrame: {
    path: "/measurementservice.MeasurementService/SendLinWakeupFrame",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(O.encode(e).finish()),
    requestDeserialize: (e) => O.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to write a LIN message header to the LIN bus.
   * @param request A request message with information about the frame to be updated.
   * @returns An empty response message.
   */
  requestLinMessage: {
    path: "/measurementservice.MeasurementService/RequestLinMessage",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(I.encode(e).finish()),
    requestDeserialize: (e) => I.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to update a LIN slave's message buffer.
   * @param request A request message with information about the frame to be updated.
   * @returns An empty response message.
   */
  updateLinMessage: {
    path: "/measurementservice.MeasurementService/UpdateLinMessage",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(N.encode(e).finish()),
    requestDeserialize: (e) => N.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to clear a LIN slave's message buffer.
   * @param request A request message with information about the frame to be cleared.
   * @returns An empty response message.
   */
  clearLinMessage: {
    path: "/measurementservice.MeasurementService/ClearLinMessage",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(U.encode(e).finish()),
    requestDeserialize: (e) => U.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to start a periodic transmission.
   * @param request A request message with information about the periodic transmission.
   * @returns A response message with an identifier connected to the started periodic transmission.
   */
  startPeriodicTransmission: {
    path: "/measurementservice.MeasurementService/StartPeriodicTransmission",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(x.encode(e).finish()),
    requestDeserialize: (e) => x.decode(e),
    responseSerialize: (e) => Buffer.from(P.encode(e).finish()),
    responseDeserialize: (e) => P.decode(e)
  },
  /**
   * Asks the service to update a periodic transmission with new settings.
   * @param request A request message with the newsettings and the identifier of the periodic transmission.
   * @returns An empty response message.
   */
  updatePeriodicTransmission: {
    path: "/measurementservice.MeasurementService/UpdatePeriodicTransmission",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(E.encode(e).finish()),
    requestDeserialize: (e) => E.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to stop a periodic transmission.
   * @param request A request message with identifier of the periodic transmission to be stopped.
   * @returns An empty response message.
   */
  stopPeriodicTransmission: {
    path: "/measurementservice.MeasurementService/StopPeriodicTransmission",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(r.encode(e).finish()),
    requestDeserialize: (e) => r.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to start a log replay.
   * @param request A request message with identifier of the log replay to be started.
   * @returns An empty response message.
   */
  startLogReplay: {
    path: "/measurementservice.MeasurementService/StartLogReplay",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(r.encode(e).finish()),
    requestDeserialize: (e) => r.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to stop a log replay.
   * @param request A request message with identifier of the log replay to be stopped.
   * @returns An empty response message.
   */
  stopLogReplay: {
    path: "/measurementservice.MeasurementService/StopLogReplay",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(r.encode(e).finish()),
    requestDeserialize: (e) => r.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to start a traffic generator.
   * @param request A request message with identifier of the traffic generator to be started.
   * @returns An empty response message.
   */
  startTrafficGenerator: {
    path: "/measurementservice.MeasurementService/StartTrafficGenerator",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(r.encode(e).finish()),
    requestDeserialize: (e) => r.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Asks the service to stop a traffic generator.
   * @param request A request message with identifier of the traffic generator to be stopped.
   * @returns An empty response message.
   */
  stopTrafficGenerator: {
    path: "/measurementservice.MeasurementService/StopTrafficGenerator",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(r.encode(e).finish()),
    requestDeserialize: (e) => r.decode(e),
    responseSerialize: (e) => Buffer.from(s.encode(e).finish()),
    responseDeserialize: (e) => s.decode(e)
  },
  /**
   * Gets all supported log file formats.
   * @param request A request message with filter information.
   * @returns A response message with the supported log file formats.
   */
  getLogFileFormats: {
    path: "/measurementservice.MeasurementService/GetLogFileFormats",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(T.encode(e).finish()),
    requestDeserialize: (e) => T.decode(e),
    responseSerialize: (e) => Buffer.from(A.encode(e).finish()),
    responseDeserialize: (e) => A.decode(e)
  },
  /**
   * Gets all available frame definitions in the current measurement setup.
   * @param request A request message with an optional node identifier.
   * @returns A response message with the available frame definitions.
   */
  getFrameDefinitions: {
    path: "/measurementservice.MeasurementService/GetFrameDefinitions",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(r.encode(e).finish()),
    requestDeserialize: (e) => r.decode(e),
    responseSerialize: (e) => Buffer.from(u.encode(e).finish()),
    responseDeserialize: (e) => u.decode(e)
  },
  /**
   * Gets all frame definitions in the provided database files.
   * @param request A request message with the database files to be parsed.
   * @returns A response message with the frame definitions parsed from the database files.
   */
  getFrameDefinitionsFromDatabaseFiles: {
    path: "/measurementservice.MeasurementService/GetFrameDefinitionsFromDatabaseFiles",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(b.encode(e).finish()),
    requestDeserialize: (e) => b.decode(e),
    responseSerialize: (e) => Buffer.from(u.encode(e).finish()),
    responseDeserialize: (e) => u.decode(e)
  },
  /**
   * Gets all available database files in the current measurement setup.
   * @param request A request message with an optional node identifier.
   * @returns A response message with the available database files.
   */
  getDatabaseFiles: {
    path: "/measurementservice.MeasurementService/GetDatabaseFiles",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(r.encode(e).finish()),
    requestDeserialize: (e) => r.decode(e),
    responseSerialize: (e) => Buffer.from(ne.encode(e).finish()),
    responseDeserialize: (e) => ne.decode(e)
  },
  /**
   * Gets all schedule tables in the provided database files.
   * @param request A request message with the database files to be parsed.
   * @returns A response message with the schedule tables parsed from the database files.
   */
  getScheduleTablesFromDatabaseFiles: {
    path: "/measurementservice.MeasurementService/GetScheduleTablesFromDatabaseFiles",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(L.encode(e).finish()),
    requestDeserialize: (e) => L.decode(e),
    responseSerialize: (e) => Buffer.from(G.encode(e).finish()),
    responseDeserialize: (e) => G.decode(e)
  },
  /**
   * Gets all channels in the provided log file.
   * @param request A request message with the log file to be parsed and a flag saying that if needed for converting (and thereby parsing), any KME50 file at the same path with the same name as the log file may be overwritten or not.
   * @returns A response message with the channels parsed from the log file.
   */
  getChannelsFromLogFile: {
    path: "/measurementservice.MeasurementService/GetChannelsFromLogFile",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(R.encode(e).finish()),
    requestDeserialize: (e) => R.decode(e),
    responseSerialize: (e) => Buffer.from(C.encode(e).finish()),
    responseDeserialize: (e) => C.decode(e)
  },
  /**
   * Gets all signal values for a message.
   * @param request A request message with message name and message data.
   * @returns A response message with all signal values.
   */
  getSignalDataFromMessageData: {
    path: "/measurementservice.MeasurementService/GetSignalDataFromMessageData",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(F.encode(e).finish()),
    requestDeserialize: (e) => F.decode(e),
    responseSerialize: (e) => Buffer.from(M.encode(e).finish()),
    responseDeserialize: (e) => M.decode(e)
  },
  /**
   * Sets all signal values for a message.
   * @param request A request message with message name and signal values.
   * @returns A response message with message data and all updated signal values.
   */
  setSignalDataToMessageData: {
    path: "/measurementservice.MeasurementService/SetSignalDataToMessageData",
    requestStream: !1,
    responseStream: !1,
    requestSerialize: (e) => Buffer.from(g.encode(e).finish()),
    requestDeserialize: (e) => g.decode(e),
    responseSerialize: (e) => Buffer.from(B.encode(e).finish()),
    responseDeserialize: (e) => B.decode(e)
  }
}, qe = c(
  de,
  "measurementservice.MeasurementService"
);
export {
  pe as AppServiceClient,
  ue as AppServiceService,
  ze as DeviceServiceClient,
  ce as DeviceServiceService,
  qe as MeasurementServiceClient,
  de as MeasurementServiceService
};