@kvaser/canking-api 7.1.0-beta.231

package/dist/protos/measurement_settings.d.ts

@@ -0,0 +1,453 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import Long from "long";
+import { WriteFrame } from "./frame_params";
+/** Possible CAN modes. */
+export declare enum CanMode {
+    CAN_MODE_UNSPECIFIED = 0,
+    CAN_MODE_CAN = 1,
+    CAN_MODE_CAN_FD = 2,
+    CAN_MODE_CAN_FD_NONISO = 3,
+    UNRECOGNIZED = -1
+}
+export declare function canModeFromJSON(object: any): CanMode;
+export declare function canModeToJSON(object: CanMode): string;
+/** Possible access modes. */
+export declare enum AccessMode {
+    ACCESS_MODE_UNSPECIFIED = 0,
+    ACCESS_MODE_INIT_ACCESS = 1,
+    /**
+     * ACCESS_MODE_NO_INIT_ACCESS - Don't open the handle with init access.
+     * A handle opened without init access will still set default bitrate when going on bus,
+     * if no other handle has opened the channel with init access at the time of the bus on.
+     */
+    ACCESS_MODE_NO_INIT_ACCESS = 2,
+    /**
+     * ACCESS_MODE_EXCLUSIVE_ACCESS - Don't allow sharing of this CANlib channel.
+     * Two or more threads or applications can share the same CAN channel by opening multiple handles
+     * to the same CANlib channel. If this is not desired you can open a single exclusive handle to a
+     * channel which is done by using passing the canOPEN_EXCLUSIVE flag in the flags argument to canOpenChannel().
+     * If a handle to the CANlib channel is already open, the call to canOpenChannel() will fail.
+     */
+    ACCESS_MODE_EXCLUSIVE_ACCESS = 3,
+    UNRECOGNIZED = -1
+}
+export declare function accessModeFromJSON(object: any): AccessMode;
+export declare function accessModeToJSON(object: AccessMode): string;
+/** Possible signal value trigger operators. */
+export declare enum SignalValueTriggerOperator {
+    SIGNAL_VALUE_TRIGGER_OPERATOR_UNSPECIFIED = 0,
+    SIGNAL_VALUE_TRIGGER_OPERATOR_EQUAL_TO = 1,
+    SIGNAL_VALUE_TRIGGER_OPERATOR_NOT_EQUAL_TO = 2,
+    SIGNAL_VALUE_TRIGGER_OPERATOR_LESS_THAN = 3,
+    SIGNAL_VALUE_TRIGGER_OPERATOR_LESS_THAN_OR_EQUAL = 4,
+    SIGNAL_VALUE_TRIGGER_OPERATOR_GREATER_THAN_OR_EQUAL = 5,
+    SIGNAL_VALUE_TRIGGER_OPERATOR_GREATER_THAN = 6,
+    SIGNAL_VALUE_TRIGGER_OPERATOR_CHANGE_TO = 7,
+    SIGNAL_VALUE_TRIGGER_OPERATOR_CHANGE_FROM = 8,
+    SIGNAL_VALUE_TRIGGER_OPERATOR_ON_CHANGE = 9,
+    UNRECOGNIZED = -1
+}
+export declare function signalValueTriggerOperatorFromJSON(object: any): SignalValueTriggerOperator;
+export declare function signalValueTriggerOperatorToJSON(object: SignalValueTriggerOperator): string;
+/** Possible trigger operators. */
+export declare enum TriggerOperator {
+    TRIGGER_OPERATOR_UNSPECIFIED = 0,
+    TRIGGER_OPERATOR_AND = 1,
+    TRIGGER_OPERATOR_OR = 2,
+    UNRECOGNIZED = -1
+}
+export declare function triggerOperatorFromJSON(object: any): TriggerOperator;
+export declare function triggerOperatorToJSON(object: TriggerOperator): string;
+/** Possible log file formats. The values must match the kvlclib FILE_FORMAT values. */
+export declare enum LogFileFormat {
+    LOG_FILE_FORMAT_UNSPECIFIED = 0,
+    /** LOG_FILE_FORMAT_KME24 - Input and output file format. */
+    LOG_FILE_FORMAT_KME24 = 1,
+    /** LOG_FILE_FORMAT_KME25 - Input and output file format. */
+    LOG_FILE_FORMAT_KME25 = 2,
+    /** LOG_FILE_FORMAT_VECTOR_ASC - Input and output file format. */
+    LOG_FILE_FORMAT_VECTOR_ASC = 3,
+    /** LOG_FILE_FORMAT_CSV - Output file format. */
+    LOG_FILE_FORMAT_CSV = 4,
+    /** LOG_FILE_FORMAT_PLAIN_ASC - Input and output file format. */
+    LOG_FILE_FORMAT_PLAIN_ASC = 5,
+    /** LOG_FILE_FORMAT_MEMO_LOG - Input (internal device logfile format). */
+    LOG_FILE_FORMAT_MEMO_LOG = 6,
+    /** LOG_FILE_FORMAT_KME40 - Input and output file format. */
+    LOG_FILE_FORMAT_KME40 = 7,
+    /** LOG_FILE_FORMAT_VECTOR_BLF - Output file format. */
+    LOG_FILE_FORMAT_VECTOR_BLF = 8,
+    /** LOG_FILE_FORMAT_KME50 - Input and output file format. */
+    LOG_FILE_FORMAT_KME50 = 9,
+    /** LOG_FILE_FORMAT_CSV_SIGNAL - Output file format. */
+    LOG_FILE_FORMAT_CSV_SIGNAL = 100,
+    /** LOG_FILE_FORMAT_MDF - Input and output file format. */
+    LOG_FILE_FORMAT_MDF = 101,
+    /** LOG_FILE_FORMAT_MATLAB - Output file format. */
+    LOG_FILE_FORMAT_MATLAB = 102,
+    /** LOG_FILE_FORMAT_J1587 - Output file format. */
+    LOG_FILE_FORMAT_J1587 = 103,
+    /** LOG_FILE_FORMAT_J1587_ALT - Obsolete. */
+    LOG_FILE_FORMAT_J1587_ALT = 104,
+    /** LOG_FILE_FORMAT_FAMOS - Output file format. */
+    LOG_FILE_FORMAT_FAMOS = 105,
+    /** LOG_FILE_FORMAT_MDF_SIGNAL - Output file format. */
+    LOG_FILE_FORMAT_MDF_SIGNAL = 106,
+    /** LOG_FILE_FORMAT_MDF_4X - Output file format. */
+    LOG_FILE_FORMAT_MDF_4X = 107,
+    /** LOG_FILE_FORMAT_MDF_4X_SIGNAL - Output file format. */
+    LOG_FILE_FORMAT_MDF_4X_SIGNAL = 108,
+    /** LOG_FILE_FORMAT_VECTOR_BLF_FD - Input and output file format. */
+    LOG_FILE_FORMAT_VECTOR_BLF_FD = 109,
+    /** LOG_FILE_FORMAT_XCP - Not supported. */
+    LOG_FILE_FORMAT_XCP = 200,
+    /** LOG_FILE_FORMAT_FAMOS_XCP - Not supported. */
+    LOG_FILE_FORMAT_FAMOS_XCP = 201,
+    /** LOG_FILE_FORMAT_DEBUG - Reserved for debug. */
+    LOG_FILE_FORMAT_DEBUG = 1000,
+    UNRECOGNIZED = -1
+}
+export declare function logFileFormatFromJSON(object: any): LogFileFormat;
+export declare function logFileFormatToJSON(object: LogFileFormat): string;
+/** Possible actions to use if a log file already exists with the same name. */
+export declare enum FileConflictAction {
+    FILE_CONFLICT_ACTION_UNSPECIFIED = 0,
+    FILE_CONFLICT_ACTION_OVERWRITE = 1,
+    FILE_CONFLICT_ACTION_APPEND_INDEX = 2,
+    FILE_CONFLICT_ACTION_APPEND_TIMESTAMP = 3,
+    UNRECOGNIZED = -1
+}
+export declare function fileConflictActionFromJSON(object: any): FileConflictAction;
+export declare function fileConflictActionToJSON(object: FileConflictAction): string;
+export declare enum DecimalChar {
+    DECIMAL_CHAR_UNSPECIFIED = 0,
+    DECIMAL_CHAR_DEC_DOT = 1,
+    DECIMAL_CHAR_DEC_COMMA = 2,
+    UNRECOGNIZED = -1
+}
+export declare function decimalCharFromJSON(object: any): DecimalChar;
+export declare function decimalCharToJSON(object: DecimalChar): string;
+export declare enum Separator {
+    SEPARATOR_UNSPECIFIED = 0,
+    SEPARATOR_COMMA = 1,
+    SEPARATOR_SEMICOLON = 2,
+    UNRECOGNIZED = -1
+}
+export declare function separatorFromJSON(object: any): Separator;
+export declare function separatorToJSON(object: Separator): string;
+export declare enum TimeReference {
+    TIME_REFERENCE_UNSPECIFIED = 0,
+    TIME_REFERENCE_FIRST_TRIGGER = 1,
+    TIME_REFERENCE_START_OF_MEASUREMENT = 2,
+    UNRECOGNIZED = -1
+}
+export declare function timeReferenceFromJSON(object: any): TimeReference;
+export declare function timeReferenceToJSON(object: TimeReference): string;
+/** A message for defining the selected CAN bus speed. */
+export interface CanBusSpeed {
+    /** Bit rate (measured in bits per second); or one of the predefined constants (canBITRATE_xxx for classic CAN and canFD_BITRATE_xxx for CAN FD). */
+    bitRate: number;
+    /** Time segment 1, that is, the number of quanta from (but not including) the Sync Segment to the sampling point. */
+    timeSegment1: number;
+    /** Time segment 2, that is, the number of quanta from the sampling point to the end of the bit. */
+    timeSegment2: number;
+    /** The Synchronization Jump Width. */
+    syncJumpWidth: number;
+    /** The number of sampling points; can be 1 or 3. */
+    numberOfSamplePoints: number;
+    /** The prescaler */
+    prescaler: number;
+}
+/** A message for defining a CAN channel's configuration. */
+export interface CanChannelConfiguration {
+    /** The CAN mode to use. */
+    canMode: CanMode;
+    /** The access mode to use. */
+    accessMode: AccessMode;
+    /** Set to true to enable silent mode, otherwise the channel will be setup as normal. */
+    silentMode: boolean;
+    /** The selected bus speed for classic CAN or the selected bus seed for the arbitration phase in CAN FD. */
+    busSpeed: CanBusSpeed | undefined;
+    /** The selected bus speed for the data phase in CAN FD. */
+    busSpeedDataPhase: CanBusSpeed | undefined;
+}
+/** A message for defining a LIN channel's configuration. */
+export interface LinChannelConfiguration {
+    /** Bit rate in bits per second, possible values are 1000-20000 bps. */
+    bitRate: number;
+    /** The LIN protocol version, possible values 1.3, 2.0, 2.1 or 2.2. */
+    protocolVersion: string;
+    /** Set to true to act as master, otherwise the channel will be setup as slave. */
+    masterMode: boolean;
+    /** If master mode is set to true, this is the LIN configuration file to use. */
+    databaseFile?: string | undefined;
+    /** If master mode is set to true, this is the schedule table to use. */
+    scheduleTable?: string | undefined;
+}
+/** A message for defining a channel's settings. */
+export interface ChannelSettings {
+    /** The canlib channel number */
+    channelNumber: number;
+    /** Lock the channel to a specific serial number */
+    lockedToSerialNumber: boolean;
+    /** The device product code */
+    deviceProductCode: string;
+    /** The device serial number */
+    deviceSerialNumber: string;
+    /** The channel number on the device */
+    channelNumberOnDevice: number;
+    /** The device card type */
+    deviceCardType: number;
+    /** The device card number */
+    deviceCardNumber: number;
+    /** The CAN channel configuration */
+    canConfiguration?: CanChannelConfiguration | undefined;
+    /** The LIN channel configuration */
+    linConfiguration?: LinChannelConfiguration | undefined;
+}
+/** A message for defining a log replay's settings. */
+export interface LogReplaySettings {
+    /** A dictionary consisting of the channels found in the log file mapped to the channel identifiers to be used when replaying the file. */
+    channelIdentifiers: {
+        [key: string]: string;
+    };
+    /** Full path to the log file to read CAN frames from. */
+    logFile: string;
+    /** Number of iterations to loop the log file. Set to -1 to iterate forever. Default value is 1. */
+    iterations: number;
+    /** Static sample rate in milliseconds to send the CAN frames at. If zero, timestamps from the log file will be used. Default value is 0. */
+    sampleRateMs: number;
+    /** If only Rx (1), Tx (2), or both (3) messages shall be replayed. Default value is 1 (Rx). */
+    transceiverMode: number;
+    /** Replay error frames as well. Default value is false. */
+    includeErrorFrames: boolean;
+    /** Send the first message straight away (1), after the time specified in the log file (2) or after an offset (3). Default value is 1 (send directly). */
+    sendFirstMessageMode: number;
+    /** Time offset in milliseconds until sending the first message. Default value is 0. This parameter shall be used together with the mode for sending the first message after an offset (3). */
+    timeOffsetMs?: number | undefined;
+    /** Factor in percentage (0-100) for speeding up or down the waiting time until sending the next message. Default value is 0 (no change in replay speed). */
+    timeFactor?: number | undefined;
+    /** The lower variance relative to the time factor. Default value is 0. */
+    lowerVariance?: number | undefined;
+    /** The higher variance relative to the time factor. Default value is 0. */
+    higherVariance?: number | undefined;
+    /** Increase the speed by the time factor. Default value is true. */
+    increaseSpeed?: boolean | undefined;
+}
+export interface LogReplaySettings_ChannelIdentifiersEntry {
+    key: string;
+    value: string;
+}
+/** A message defining a periodic transmission setup. */
+export interface PeriodicTransmissionSettings {
+    /** The channel to be used */
+    channelIdentifier: string;
+    /** The message frame to be sent out */
+    frame: WriteFrame | undefined;
+    /** Send out with random or constant interval */
+    randomInterval: boolean;
+    /** Constant interval in milliseconds that is used if random_interval is false */
+    constantIntervalMs: number;
+    /** Random min interval in milliseconds that is used if random_interval is true */
+    randomIntervalMinMs: number;
+    /** Random max interval in milliseconds that is used if random_interval is true */
+    randomIntervalMaxMs: number;
+    /** Number of messages to send out, if set to 0 then messages will be sent out continuously until stop is called */
+    numberOfMessages: number;
+    /** Randomize the messages' data length */
+    randomDataLength: boolean;
+    /** Randomize the messages' data */
+    randomMessageData: boolean;
+    /** Send out with random identifier, ignored if scan_identifier is set */
+    randomIdentifier: boolean;
+    /** Send out with identifier set from min to max */
+    scanIdentifier: boolean;
+    /** Random/Scan min identifier */
+    identifierMin: number;
+    /** Random/Scan max identifier */
+    identifierMax: number;
+    /** Send out with random or constant burst size */
+    randomBurstSize: boolean;
+    /** Constant burst size that is used if random_burst_size is false */
+    constantBurstSize: number;
+    /** Random min burst size that is used if random_burst_size is true */
+    randomBurstSizeMin: number;
+    /** Random max burst size that is used if random_burst_size is true */
+    randomBurstSizeMax: number;
+}
+/** A message for defining a CAN message filter's settings. */
+export interface CanMessageFilterSettings {
+    stdCanIds: string;
+    extCanIds: string;
+    filterType: string;
+}
+/** A message for defining a database's settings. */
+export interface DatabasesSettings {
+    databaseFiles: string[];
+}
+/** A message for defining interpreter settings */
+export interface InterpreterSettings {
+    /** J1939 */
+    j1939Settings?: J1939InterpreterSettings | undefined;
+}
+/** A message for defining a J1939 interpreter's specific settings */
+export interface J1939InterpreterSettings {
+}
+/** A message for defining service extension settings. */
+export interface ServiceExtensionSettings {
+    extensionName: string;
+    configuration?: string | undefined;
+}
+/** A message for defining an On Frame Received trigger. */
+export interface FrameReceivedTrigger {
+    /** The identifier of the frame to look for. Prefix with 0x to indicate hex-format. */
+    frameId: string;
+    /** The type of identifier used, 'extended' or 'standard' */
+    frameIdType: string;
+}
+/** A message for defining an On Signal Value trigger. */
+export interface SignalValueTrigger {
+    /** The identifier of the frame containing the signal. Prefix with 0x to indicate hex-format. */
+    frameId: string;
+    /** The name of the signal. */
+    signalQualifiedName: string;
+    /** The value to look for, if a single value is used. */
+    signalValue: number;
+    /** The min value to look for, if a value range is used. */
+    signalMinValue: number;
+    /** The max value to look for, if a value range is used. */
+    signalMaxValue: number;
+    /** The operator to use. */
+    operator: SignalValueTriggerOperator;
+    /** The type of id used, 'extended' or 'standard' */
+    frameIdType: string;
+}
+/** A message for defining a trigger condition. */
+export interface TriggerSettings {
+    /** A timeout trigger, e.g. can be used as stop trigger to stop after a specific time. Specified in milliseconds. */
+    timeoutTrigger?: number | undefined;
+    /** An on frame received trigger. */
+    frameReceivedTrigger?: FrameReceivedTrigger | undefined;
+    /** An on signal value trigger. */
+    signalValueTrigger?: SignalValueTrigger | undefined;
+}
+/** A message for defining a message logger's settings. */
+export interface MessageLoggerSettings {
+    /** Name of the file to log messages to */
+    fileName: string;
+    /** The file format to be used */
+    fileFormat: LogFileFormat;
+    /** Name conflict action */
+    fileConflictAction: FileConflictAction;
+    /** Any filter */
+    canMessageFilter: CanMessageFilterSettings | undefined;
+    /** Any start triggers */
+    startTriggerSettings: TriggerSettings[];
+    /** The trigger operator to be used between start triggers */
+    startTriggersOperator: TriggerOperator;
+    /** Any stop triggers */
+    stopTriggerSettings: TriggerSettings[];
+    /** The trigger operator to be used between stop triggers */
+    stopTriggersOperator: TriggerOperator;
+    /** A flag indicating if the logger should auto-restart after stop. Default value is false */
+    autoRestartAfterStop: boolean;
+    /** Write file header. Default value is true */
+    writeFileHeader?: boolean | undefined;
+    /** Write data in hexadecimal format. Default value is true */
+    dataInHex?: boolean | undefined;
+    /** Write ID in hexadecimal format. Default value is true */
+    idInHex?: boolean | undefined;
+    /** The decimal separator to be used. Default value is a dot (.) */
+    decimalSeparator?: DecimalChar | undefined;
+    /** The column separator to be used. Default value is a comma (,) */
+    colSeparator?: Separator | undefined;
+    /** Number of data bytes to max write to the log file (1-64). Default value is 8. */
+    dataBytesLimit?: number | undefined;
+    /** Number of time decimals (0-9). Default value is 4 */
+    numberOfTimeDecimals?: number | undefined;
+    /** Use the specified time reference. Default value is FIRST_TRIGGER */
+    timeReference?: TimeReference | undefined;
+    /** Write timestamps in calendar time instead of seconds. Default value is false */
+    calendarTime?: boolean | undefined;
+    /** Use UTC instead of local time for absolute timestamps. Default value is false */
+    utcTime?: boolean | undefined;
+}
+/** A message for defining base node properties. */
+export interface BaseNodeProperties {
+    identifier: string;
+    name: string;
+    description: string[];
+    readOnlyProperties: boolean;
+    readOnlyConnections: boolean;
+    disabled: boolean;
+}
+/** A message for defining a source node properties. */
+export interface SourceNodeProperties {
+    baseNode: BaseNodeProperties | undefined;
+    isDataGenerator: boolean;
+    channelSettings?: ChannelSettings | undefined;
+    logReplaySettings?: LogReplaySettings | undefined;
+    trafficGeneratorSettings?: PeriodicTransmissionSettings | undefined;
+}
+/** A message for defining a data processor node properties. */
+export interface DataProcessorNodeProperties {
+    baseNode: BaseNodeProperties | undefined;
+    connectedNodes: string[];
+    canMessageFilterSettings?: CanMessageFilterSettings | undefined;
+    databasesSettings?: DatabasesSettings | undefined;
+    interpreterSettings?: InterpreterSettings | undefined;
+    extensionSettings?: ServiceExtensionSettings | undefined;
+}
+/** A message for defining a target node properties. */
+export interface TargetNodeProperties {
+    baseNode: BaseNodeProperties | undefined;
+    connectedNodes: string[];
+    messageLoggerSettings?: MessageLoggerSettings | undefined;
+}
+/** A message for defining a measurement setup. */
+export interface MeasurementSetup {
+    sources: SourceNodeProperties[];
+    dataProcessors: DataProcessorNodeProperties[];
+    targets: TargetNodeProperties[];
+    language: string;
+}
+export declare const CanBusSpeed: MessageFns<CanBusSpeed>;
+export declare const CanChannelConfiguration: MessageFns<CanChannelConfiguration>;
+export declare const LinChannelConfiguration: MessageFns<LinChannelConfiguration>;
+export declare const ChannelSettings: MessageFns<ChannelSettings>;
+export declare const LogReplaySettings: MessageFns<LogReplaySettings>;
+export declare const LogReplaySettings_ChannelIdentifiersEntry: MessageFns<LogReplaySettings_ChannelIdentifiersEntry>;
+export declare const PeriodicTransmissionSettings: MessageFns<PeriodicTransmissionSettings>;
+export declare const CanMessageFilterSettings: MessageFns<CanMessageFilterSettings>;
+export declare const DatabasesSettings: MessageFns<DatabasesSettings>;
+export declare const InterpreterSettings: MessageFns<InterpreterSettings>;
+export declare const J1939InterpreterSettings: MessageFns<J1939InterpreterSettings>;
+export declare const ServiceExtensionSettings: MessageFns<ServiceExtensionSettings>;
+export declare const FrameReceivedTrigger: MessageFns<FrameReceivedTrigger>;
+export declare const SignalValueTrigger: MessageFns<SignalValueTrigger>;
+export declare const TriggerSettings: MessageFns<TriggerSettings>;
+export declare const MessageLoggerSettings: MessageFns<MessageLoggerSettings>;
+export declare const BaseNodeProperties: MessageFns<BaseNodeProperties>;
+export declare const SourceNodeProperties: MessageFns<SourceNodeProperties>;
+export declare const DataProcessorNodeProperties: MessageFns<DataProcessorNodeProperties>;
+export declare const TargetNodeProperties: MessageFns<TargetNodeProperties>;
+export declare const MeasurementSetup: MessageFns<MeasurementSetup>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};

package/dist/protos/signal_params.d.ts

@@ -0,0 +1,72 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import Long from "long";
+/** Possible signal encodings. The value must match the kvadblib value. */
+export declare enum SignalEncoding {
+    SIGNAL_ENCODING_INTEL = 0,
+    SIGNAL_ENCODING_MOTOROLA = 1,
+    UNRECOGNIZED = -1
+}
+export declare function signalEncodingFromJSON(object: any): SignalEncoding;
+export declare function signalEncodingToJSON(object: SignalEncoding): string;
+/** Possible signal types. The value must match the kvadblib value. */
+export declare enum SignalType {
+    SIGNAL_TYPE_INVALID = 0,
+    /** SIGNAL_TYPE_SIGNED - Signed integer */
+    SIGNAL_TYPE_SIGNED = 1,
+    /** SIGNAL_TYPE_UNSIGNED - Unsigned integer */
+    SIGNAL_TYPE_UNSIGNED = 2,
+    /** SIGNAL_TYPE_FLOAT - Float, strictly 32 bit long */
+    SIGNAL_TYPE_FLOAT = 3,
+    /** SIGNAL_TYPE_DOUBLE - Double, strictly 64 bit long */
+    SIGNAL_TYPE_DOUBLE = 4,
+    UNRECOGNIZED = -1
+}
+export declare function signalTypeFromJSON(object: any): SignalType;
+export declare function signalTypeToJSON(object: SignalType): string;
+/** A message that holds information about a signal. */
+export interface SignalDefinition {
+    name: string;
+    qualifiedName: string;
+    comment: string;
+    encoding: SignalEncoding;
+    dataType: SignalType;
+    startbit: number;
+    length: number;
+    unit: string;
+    factor: number;
+    offset: number;
+    minValue: number;
+    maxValue: number;
+    enumValues: {
+        [key: string]: number;
+    };
+}
+export interface SignalDefinition_EnumValuesEntry {
+    key: string;
+    value: number;
+}
+export interface SignalDefinitions {
+    items: SignalDefinition[];
+}
+export declare const SignalDefinition: MessageFns<SignalDefinition>;
+export declare const SignalDefinition_EnumValuesEntry: MessageFns<SignalDefinition_EnumValuesEntry>;
+export declare const SignalDefinitions: MessageFns<SignalDefinitions>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};

package/dist/protos/status_params.d.ts

@@ -0,0 +1,118 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import Long from "long";
+/** Possible CAN frame flags. The flag value must match the canlib flag value. */
+export declare enum StatusLevel {
+    STATUS_LEVEL_NONE = 0,
+    STATUS_LEVEL_OK = 1,
+    STATUS_LEVEL_WARNING = 2,
+    STATUS_LEVEL_ERROR = 3,
+    UNRECOGNIZED = -1
+}
+export declare function statusLevelFromJSON(object: any): StatusLevel;
+export declare function statusLevelToJSON(object: StatusLevel): string;
+/** Possible log replay states. */
+export declare enum LogReplayState {
+    LOG_REPLAY_STATE_UNSPECIFIED = 0,
+    LOG_REPLAY_STATE_STARTED = 1,
+    LOG_REPLAY_STATE_STOPPED = 2,
+    UNRECOGNIZED = -1
+}
+export declare function logReplayStateFromJSON(object: any): LogReplayState;
+export declare function logReplayStateToJSON(object: LogReplayState): string;
+/** Possible message logger states. */
+export declare enum MessageLoggerState {
+    MESSAGE_LOGGER_STATE_UNSPECIFIED = 0,
+    MESSAGE_LOGGER_STATE_PRESTART = 1,
+    MESSAGE_LOGGER_STATE_STARTED = 2,
+    MESSAGE_LOGGER_STATE_STOPPED = 3,
+    UNRECOGNIZED = -1
+}
+export declare function messageLoggerStateFromJSON(object: any): MessageLoggerState;
+export declare function messageLoggerStateToJSON(object: MessageLoggerState): string;
+/** A message holding bus status information. */
+export interface BusStatus {
+    rxMessageCounter: number;
+    rxMessagesPerSecond: number;
+    txMessageCounter: number;
+    txMessagesPerSecond: number;
+    errorFrameCounter: number;
+    errorFramesPerSecond: number;
+    overrunCounter: number;
+    overrunsPerSecond: number;
+    rxErrorCounter: number;
+    txErrorCounter: number;
+    overrunErrorCounter: number;
+    busOnStatus: StatusLevel;
+    errorStatus: StatusLevel;
+    overrunStatus: StatusLevel;
+    busLoad: number;
+}
+/** A message holding special data processing status information. */
+export interface DataProcessingStatus {
+    errorCounter: number;
+    lastExecutionTime: Long;
+    minExecutionTime: Long;
+    maxExecutionTime: Long;
+}
+/** A message holding special log replay status information. */
+export interface LogReplayStatus {
+    state: LogReplayState;
+}
+/** A message holding special message logger status information. */
+export interface MessageLoggerStatus {
+    state: MessageLoggerState;
+}
+/** A message holding any errors associated with a node. */
+export interface ErrorStatus {
+    /** The errors, set to an empty string when any errors have been cleared. */
+    errors: string;
+}
+/** A message for sending node status. */
+export interface NodeStatus {
+    /** Identifier of the node */
+    nodeId: string;
+    /** Name of the node */
+    nodeName: string;
+    /** Identifier of the stream node */
+    streamId: string;
+    /** Special bus status */
+    busStatus: BusStatus | undefined;
+    /** Special data processing status */
+    dataProcessingStatus: DataProcessingStatus | undefined;
+    /** Special log replay status */
+    logReplayStatus: LogReplayStatus | undefined;
+    /** Special message logger status */
+    messageLoggerStatus: MessageLoggerStatus | undefined;
+    /** Error status */
+    errorStatus: ErrorStatus | undefined;
+}
+/** A collection of node status items. */
+export interface NodeStatuses {
+    items: NodeStatus[];
+}
+export declare const BusStatus: MessageFns<BusStatus>;
+export declare const DataProcessingStatus: MessageFns<DataProcessingStatus>;
+export declare const LogReplayStatus: MessageFns<LogReplayStatus>;
+export declare const MessageLoggerStatus: MessageFns<MessageLoggerStatus>;
+export declare const ErrorStatus: MessageFns<ErrorStatus>;
+export declare const NodeStatus: MessageFns<NodeStatus>;
+export declare const NodeStatuses: MessageFns<NodeStatuses>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};