@kvaser/canking-api 7.1.0-beta.231

package/dist/protos/device_service.d.ts

@@ -0,0 +1,154 @@
+import { type CallOptions, ChannelCredentials, Client, type ClientOptions, ClientReadableStream, type ClientUnaryCall, handleServerStreamingCall, type handleUnaryCall, Metadata, type ServiceError, type UntypedServiceImplementation } from "@grpc/grpc-js";
+import { ApiPreferences } from "./common_params";
+import { DeviceEventArgs, GetCanChannelBusSpeedsRequest, GetCanChannelBusSpeedsResponse, GetCanFdBusSpeedsRequest, GetCanFdBusSpeedsResponse, GetClassicCanBusSpeedsRequest, GetClassicCanBusSpeedsResponse, GetDevicesRequest, GetDevicesResponse } from "./device_params";
+/** The device service. This service is responsible for keeping track of all available devices. */
+export type DeviceServiceService = typeof DeviceServiceService;
+export declare const DeviceServiceService: {
+    /**
+     * Starts a subscription for device events.
+     * @param request A request message with API preferences.
+     * @returns A stream of DeviceEventArgs messages.
+     */
+    readonly subscribeForEvents: {
+        readonly path: "/deviceservice.DeviceService/SubscribeForEvents";
+        readonly requestStream: false;
+        readonly responseStream: true;
+        readonly requestSerialize: (value: ApiPreferences) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ApiPreferences;
+        readonly responseSerialize: (value: DeviceEventArgs) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => DeviceEventArgs;
+    };
+    /**
+     * Gets all available devices.
+     * @param request A request message with API preferences.
+     * @returns A response message with all available devices.
+     */
+    readonly getDevices: {
+        readonly path: "/deviceservice.DeviceService/GetDevices";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetDevicesRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetDevicesRequest;
+        readonly responseSerialize: (value: GetDevicesResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => GetDevicesResponse;
+    };
+    /**
+     * 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.
+     */
+    readonly getCanChannelBusSpeeds: {
+        readonly path: "/deviceservice.DeviceService/GetCanChannelBusSpeeds";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetCanChannelBusSpeedsRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetCanChannelBusSpeedsRequest;
+        readonly responseSerialize: (value: GetCanChannelBusSpeedsResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => GetCanChannelBusSpeedsResponse;
+    };
+    /**
+     * 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.
+     */
+    readonly getClassicCanBusSpeeds: {
+        readonly path: "/deviceservice.DeviceService/GetClassicCanBusSpeeds";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetClassicCanBusSpeedsRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetClassicCanBusSpeedsRequest;
+        readonly responseSerialize: (value: GetClassicCanBusSpeedsResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => GetClassicCanBusSpeedsResponse;
+    };
+    /**
+     * 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.
+     */
+    readonly getCanFdBusSpeeds: {
+        readonly path: "/deviceservice.DeviceService/GetCanFdBusSpeeds";
+        readonly requestStream: false;
+        readonly responseStream: true;
+        readonly requestSerialize: (value: GetCanFdBusSpeedsRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetCanFdBusSpeedsRequest;
+        readonly responseSerialize: (value: GetCanFdBusSpeedsResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => GetCanFdBusSpeedsResponse;
+    };
+};
+export interface DeviceServiceServer extends UntypedServiceImplementation {
+    /**
+     * Starts a subscription for device events.
+     * @param request A request message with API preferences.
+     * @returns A stream of DeviceEventArgs messages.
+     */
+    subscribeForEvents: handleServerStreamingCall<ApiPreferences, DeviceEventArgs>;
+    /**
+     * Gets all available devices.
+     * @param request A request message with API preferences.
+     * @returns A response message with all available devices.
+     */
+    getDevices: handleUnaryCall<GetDevicesRequest, GetDevicesResponse>;
+    /**
+     * 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: handleUnaryCall<GetCanChannelBusSpeedsRequest, GetCanChannelBusSpeedsResponse>;
+    /**
+     * 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: handleUnaryCall<GetClassicCanBusSpeedsRequest, GetClassicCanBusSpeedsResponse>;
+    /**
+     * 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: handleServerStreamingCall<GetCanFdBusSpeedsRequest, GetCanFdBusSpeedsResponse>;
+}
+export interface DeviceServiceClient extends Client {
+    /**
+     * Starts a subscription for device events.
+     * @param request A request message with API preferences.
+     * @returns A stream of DeviceEventArgs messages.
+     */
+    subscribeForEvents(request: ApiPreferences, options?: Partial<CallOptions>): ClientReadableStream<DeviceEventArgs>;
+    subscribeForEvents(request: ApiPreferences, metadata?: Metadata, options?: Partial<CallOptions>): ClientReadableStream<DeviceEventArgs>;
+    /**
+     * Gets all available devices.
+     * @param request A request message with API preferences.
+     * @returns A response message with all available devices.
+     */
+    getDevices(request: GetDevicesRequest, callback: (error: ServiceError | null, response: GetDevicesResponse) => void): ClientUnaryCall;
+    getDevices(request: GetDevicesRequest, metadata: Metadata, callback: (error: ServiceError | null, response: GetDevicesResponse) => void): ClientUnaryCall;
+    getDevices(request: GetDevicesRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: GetDevicesResponse) => void): ClientUnaryCall;
+    /**
+     * 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(request: GetCanChannelBusSpeedsRequest, callback: (error: ServiceError | null, response: GetCanChannelBusSpeedsResponse) => void): ClientUnaryCall;
+    getCanChannelBusSpeeds(request: GetCanChannelBusSpeedsRequest, metadata: Metadata, callback: (error: ServiceError | null, response: GetCanChannelBusSpeedsResponse) => void): ClientUnaryCall;
+    getCanChannelBusSpeeds(request: GetCanChannelBusSpeedsRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: GetCanChannelBusSpeedsResponse) => void): ClientUnaryCall;
+    /**
+     * 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(request: GetClassicCanBusSpeedsRequest, callback: (error: ServiceError | null, response: GetClassicCanBusSpeedsResponse) => void): ClientUnaryCall;
+    getClassicCanBusSpeeds(request: GetClassicCanBusSpeedsRequest, metadata: Metadata, callback: (error: ServiceError | null, response: GetClassicCanBusSpeedsResponse) => void): ClientUnaryCall;
+    getClassicCanBusSpeeds(request: GetClassicCanBusSpeedsRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: GetClassicCanBusSpeedsResponse) => void): ClientUnaryCall;
+    /**
+     * 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(request: GetCanFdBusSpeedsRequest, options?: Partial<CallOptions>): ClientReadableStream<GetCanFdBusSpeedsResponse>;
+    getCanFdBusSpeeds(request: GetCanFdBusSpeedsRequest, metadata?: Metadata, options?: Partial<CallOptions>): ClientReadableStream<GetCanFdBusSpeedsResponse>;
+}
+export declare const DeviceServiceClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): DeviceServiceClient;
+    service: typeof DeviceServiceService;
+    serviceName: string;
+};

package/dist/protos/frame_params.d.ts

@@ -0,0 +1,189 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import Long from "long";
+import { SignalDefinition } from "./signal_params";
+/** Possible CAN frame flags. The flag value must match the canlib flag value. */
+export declare enum CanFrameFlag {
+    CAN_FRAME_FLAG_UNSPECIFIED = 0,
+    CAN_FRAME_FLAG_RTR = 1,
+    CAN_FRAME_FLAG_STD = 2,
+    CAN_FRAME_FLAG_EXT = 4,
+    CAN_FRAME_FLAG_WAKEUP = 8,
+    CAN_FRAME_FLAG_NERR = 16,
+    CAN_FRAME_FLAG_ERROR_FRAME = 32,
+    CAN_FRAME_FLAG_TXACK = 64,
+    CAN_FRAME_FLAG_TXRQ = 128,
+    CAN_FRAME_FLAG_DELAY_MSG = 256,
+    CAN_FRAME_FLAG_LOCAL_TXACK = 268435456,
+    CAN_FRAME_FLAG_SINGLE_SHOT = 16777216,
+    CAN_FRAME_FLAG_TXNACK = 33554432,
+    CAN_FRAME_FLAG_ABL = 67108864,
+    CAN_FRAME_FLAG_FD_FDF = 65536,
+    CAN_FRAME_FLAG_FD_BRS = 131072,
+    CAN_FRAME_FLAG_FD_ESI = 262144,
+    CAN_FRAME_FLAG_ERR_HW_OVERRUN = 512,
+    CAN_FRAME_FLAG_ERR_SW_OVERRUN = 1024,
+    CAN_FRAME_FLAG_ERR_STUFF = 2048,
+    CAN_FRAME_FLAG_ERR_FORM = 4096,
+    CAN_FRAME_FLAG_ERR_CRC = 8192,
+    CAN_FRAME_FLAG_ERR_BIT0 = 16384,
+    CAN_FRAME_FLAG_ERR_BIT1 = 32768,
+    UNRECOGNIZED = -1
+}
+export declare function canFrameFlagFromJSON(object: any): CanFrameFlag;
+export declare function canFrameFlagToJSON(object: CanFrameFlag): string;
+/** Possible LIN frame flags. The flag value must match the linlib flag value. */
+export declare enum LinFrameFlag {
+    LIN_FRAME_FLAG_UNSPECIFIED = 0,
+    LIN_FRAME_FLAG_TX = 1,
+    LIN_FRAME_FLAG_RX = 2,
+    LIN_FRAME_FLAG_WAKEUP_FRAME = 4,
+    LIN_FRAME_FLAG_NODATA = 8,
+    LIN_FRAME_FLAG_CSUM_ERROR = 16,
+    LIN_FRAME_FLAG_PARITY_ERROR = 32,
+    LIN_FRAME_FLAG_SYNCH_ERROR = 64,
+    LIN_FRAME_FLAG_BIT_ERROR = 128,
+    UNRECOGNIZED = -1
+}
+export declare function linFrameFlagFromJSON(object: any): LinFrameFlag;
+export declare function linFrameFlagToJSON(object: LinFrameFlag): string;
+/**
+ * A message holding a combination of CanFrameFlag enums.
+ * This is a work-around since it's not possible to use repeated fields as oneof fields.
+ */
+export interface CanFrameFlags {
+    flags: CanFrameFlag[];
+}
+/**
+ * A message holding a combination of LinFrameFlag enums.
+ * This is a work-around since it's not possible to use repeated fields as oneof fields.
+ */
+export interface LinFrameFlags {
+    flags: LinFrameFlag[];
+}
+/** A message that holds an extra frame property. */
+export interface FramePropertyValue {
+    stringValue?: string | undefined;
+    doubleValue?: number | undefined;
+}
+/** A message that holds a signal's value. */
+export interface SignalValue {
+    name: string;
+    qualifiedName: string;
+    unit: string;
+    stringValue?: string | undefined;
+    doubleValue?: number | undefined;
+}
+/** A message describing a frame. */
+export interface Frame {
+    /** Identifier of the source node */
+    sourceId: string;
+    /** Name of the source node */
+    sourceName: string;
+    /** Identifier of the stream node */
+    streamId: string;
+    /** Frame identifier */
+    id: number;
+    /** Frame identifier */
+    messageName: string;
+    /** Frame data */
+    data: number[];
+    /** Timestamp in seconds when the frame was recieved or transmitted */
+    time: number;
+    /** Flag indicating if this message was transmitted or recieved */
+    tx: boolean;
+    /** Frame DLC */
+    dlc: number;
+    /** Frame hash code, a unique key that identifies the frame */
+    hashCode: number;
+    /** Extra properties */
+    properties: {
+        [key: string]: FramePropertyValue;
+    };
+    /** Signal values */
+    signalValues: SignalValue[];
+    /** Special CAN flags */
+    canFrameFlags?: CanFrameFlags | undefined;
+    /** Special LIN flags */
+    linFrameFlags?: LinFrameFlags | undefined;
+}
+export interface Frame_PropertiesEntry {
+    key: string;
+    value: FramePropertyValue | undefined;
+}
+export interface Frames {
+    items: Frame[];
+}
+/** A message describing a frame that will be used for writing message to a bus. */
+export interface WriteFrame {
+    /** Frame identifier */
+    id: number;
+    /** Frame data, TODO: Why doesn't it work using bytes? */
+    data: number[];
+    /** Special CAN flags */
+    canFrameFlags?: CanFrameFlags | undefined;
+    /** Special LIN flags */
+    linFrameFlags?: LinFrameFlags | undefined;
+}
+/** A message describing a frame definition. */
+export interface FrameDefinition {
+    /** Frame identifier */
+    id: number;
+    /** Message name */
+    messageName: string;
+    /** Message qualified name */
+    messageQualifiedName: string;
+    /** Signal definitions */
+    signals: SignalDefinition[];
+    /** Special CAN flags */
+    canFrameFlags?: CanFrameFlags | undefined;
+}
+export interface FrameDefinitions {
+    items: FrameDefinition[];
+}
+/** A message describing an entry in a schedule table. */
+export interface ScheduleTableEntry {
+    /** Message qualified name */
+    messageQualifiedName: string;
+    /** Delay in milliseconds */
+    delay: number;
+}
+/** A message describing a schedule table. */
+export interface ScheduleTable {
+    /** Name of the schedule table */
+    name: string;
+    /** Qualified name of the schedule table */
+    qualifiedName: string;
+    /** Schedule table entries */
+    entries: ScheduleTableEntry[];
+}
+export declare const CanFrameFlags: MessageFns<CanFrameFlags>;
+export declare const LinFrameFlags: MessageFns<LinFrameFlags>;
+export declare const FramePropertyValue: MessageFns<FramePropertyValue>;
+export declare const SignalValue: MessageFns<SignalValue>;
+export declare const Frame: MessageFns<Frame>;
+export declare const Frame_PropertiesEntry: MessageFns<Frame_PropertiesEntry>;
+export declare const Frames: MessageFns<Frames>;
+export declare const WriteFrame: MessageFns<WriteFrame>;
+export declare const FrameDefinition: MessageFns<FrameDefinition>;
+export declare const FrameDefinitions: MessageFns<FrameDefinitions>;
+export declare const ScheduleTableEntry: MessageFns<ScheduleTableEntry>;
+export declare const ScheduleTable: MessageFns<ScheduleTable>;
+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/google/protobuf/empty.d.ts

@@ -0,0 +1,35 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import Long from "long";
+/**
+ * A generic empty message that you can re-use to avoid defining duplicated
+ * empty messages in your APIs. A typical example is to use it as the request
+ * or the response type of an API method. For instance:
+ *
+ *     service Foo {
+ *       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+ *     }
+ *
+ * The JSON representation for `Empty` is empty JSON object `{}`.
+ */
+export interface Empty {
+}
+export declare const Empty: MessageFns<Empty>;
+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 {};