diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index defa87d4..0043c66c 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -14,7 +14,8 @@ }, "ghcr.io/devcontainers-contrib/features/hatch:2": { "version": "latest" - } + }, + "ghcr.io/devcontainers/features/docker-outside-of-docker": {} }, // Use 'forwardPorts' to make a list of ports inside the container available locally. diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 00000000..17ee6355 --- /dev/null +++ b/package-lock.json @@ -0,0 +1,6 @@ +{ + "name": "TypeChat", + "lockfileVersion": 3, + "requires": true, + "packages": {} +} diff --git a/typescript/examples/aicar-zod/package.json b/typescript/examples/aicar-zod/package.json new file mode 100644 index 00000000..bbbd1e8e --- /dev/null +++ b/typescript/examples/aicar-zod/package.json @@ -0,0 +1,38 @@ +{ + "name": "aicar-zod", + "version": "0.0.1", + "main": "dist/main.js", + "scripts": { + "build": "tsc -p src", + "postbuild": "copyfiles -u 1 src/**/*Schema.ts src/**/*.txt src/**/*.html dist" + }, + "exports": { + "./*": [ + "./dist/*.js" + ] + }, + "author": "", + "license": "MIT", + "description": "", + "dependencies": { + "@bufbuild/buf": "^1.39.0", + "@bufbuild/protobuf": "^1.10.0", + "@bufbuild/protoc-gen-es": "^1.10.0", + "@connectrpc/connect": "^1.4.0", + "@connectrpc/connect-node": "^1.4.0", + "@connectrpc/protoc-gen-connect-es": "^1.4.0", + "assert": "^2.1.0", + "commander": "^12.1.0", + "dotenv": "^16.4.5", + "find-config": "^1.0.0", + "ts-progress": "^0.1.9", + "typescript": "^5.5.4", + "zod": "^3.23.8" + }, + "devDependencies": { + "@types/assert": "^1.5.10", + "@types/find-config": "^1.0.4", + "@types/node": "^22.5.1", + "copyfiles": "^2.4.1" + } +} diff --git a/typescript/examples/aicar-zod/readme.md b/typescript/examples/aicar-zod/readme.md new file mode 100644 index 00000000..c3277349 --- /dev/null +++ b/typescript/examples/aicar-zod/readme.md @@ -0,0 +1,83 @@ +# aicar-zod +--- +The goal of this example repo is to experiment with foundational AI tech (TypeChat) & models (GPT4O mini & PHI3 were tested) applied to in-car assistant scenarios. The experiment approach is to utilize the real next generation of in-car standards (Kuksa, Covesa), augment those standards & frameworks with NL understanding tech powered by LLMs, to prove that the user experience can be improved with those technologies. + +[TypeChat](https://microsoft.github.io/TypeChat/) - provides a schema first framework to improve integration between NL understanding and LLM facilitated function calling + +[Covesa VSS](https://covesa.global/) - +Covesa Vehicle Signal Specification provides a standard schema for vehicle communications. The [COVESA Vehicle Signal Specification](https://covesa.github.io/vehicle_signal_specification/) (VSS) defines the names and semantics of a large set of _data entries_ that represent the current and/or intended state of a vehicle's sensors and actuators organized in a tree-like structure. For example, the vehicle's current speed is represented by the `Vehicle.Speed` entry. +This standard has broad interest & support from key auto manufacturers and OEMs (BMW, Volvo, Bosch, Land Rover, etc.) + +[Kuksa](https://projects.eclipse.org/projects/automotive.kuksa) - +Kuksa is a top level eclipse foundation project to define a software defined vehicle ecosystem based on a vehicle schema. The VSS does not define how these signals are to be collected and managed within a vehicle, nor does it prescribe how other components in the vehicle can read or write signal values from and to the tree. + +Kuksa provides a standard databroker & GRPC interface to enable communication with vehicles. + +**Kuksa Databroker** is a resource efficient implementation of the VSS signal tree and is intended to be run within a vehicle on a microprocessor based platform. It allows applications in the vehicle to interact with the vehicle's sensors and actuators using a uniform, high level gRPC API for querying signals, updating current and target values of sensors and actuators and getting notified about changes to signals of interest. + + + +```mermaid +flowchart LR + A[AICar - TypeChat] --VSS--- DB + DB[Kuksa Databroker] --VSS--- P + P[Kuksa provider] --CAN frames etc---E + E[ECU] --- Sensor + E --- Actuator + style DB fill:#999999,stroke:#444444,color:#ffffff +``` + +At the right end, Kuksa providers implement the link between the Databroker and a vehicle's Electronic Control Units (ECU) to which the hardware sensors and actuators are physically attached. + +Data is usually exchanged with ECUs by means of a CAN bus or Ethernet based protocols like SOME/IP. Providers translate between the low level messages used by these protocols and the Databroker's high level gRPC API calls to update a sensor's current reading or to forward a set-point value to an actuator via its controlling ECU. + + +### Features + +- 100% Open Source (Apache 2.0 license) +- Written in Rust with an easy-to-use language agnostic gRPC interface +- Lightweight (<4 MB statically compiled), allowing it to run on even small vehicle computers + + + +## Setup and Environment Simulation +--- +### Databroker & Covesa +The simplest way to get an example Databroker and VSS schema for experimentation is to use the official Databroker container. + +> :memo: **Note:** The examples in this section do not use TLS nor access control. Please refer to the [Databroker User Guide](./doc/user_guide.md) for more sophisticated usage examples. + +### Prerequisites + +- [Docker Engine](https://docs.docker.com/engine/install/) or [Podman](https://podman.io/docs/installation) + +### Starting Databroker + +1. Start Databroker in a container attached to the host network on port 55556: + + ```sh + docker run --rm -it -p 55556:55555 ghcr.io/eclipse-kuksa/kuksa-databroker:main --insecure --enable-databroker-v1 + ``` + + > :bulb: **Tip:** You can stop the container using `ctrl-c`. + +### AICar MVE +To test the sample in interactive mode, use the command line below. This will leverage TypeChat to translate the natural language entered, validate it into the VSS scheme, and execute the GRPC call against the running databroker. + ```sh + node ./dist/main.js + ``` + +### Android Auto Example App (not required) +The Kuksa Companion android application provides a visual interface to see the actions taken by the AICar assistant. It is not required, but helps illustrate how the full system interacts with the databroker & the resulting car. +1. Install Android Studio +2. Start the Pixel android emulator +3. Add the Kuksa Companion APK to the emulator +4. Start the emulator & connect to the databroker + +## Initial Test Results +--- + + + +## Next Steps & Investigations +--- diff --git a/typescript/examples/aicar-zod/src/SDVCarActionZodSchema.ts b/typescript/examples/aicar-zod/src/SDVCarActionZodSchema.ts new file mode 100644 index 00000000..8aca1d99 --- /dev/null +++ b/typescript/examples/aicar-zod/src/SDVCarActionZodSchema.ts @@ -0,0 +1,199 @@ +import { z } from "zod"; +//import { VAL} from "./gen/kuksa/val/v1/val_connect"; +//import path from "path"; +//import { EntryRequest } from "./gen/kuksa/val/v1/val_pb"; + +// """ Here is a list of signals which are used inside the app: +// Door Control: bool +// Vehicle.Cabin.Door.Row1.DriverSide.IsLocked bool +// Vehicle.Cabin.Door.Row1.PassengerSide.IsLocked +// Vehicle.Cabin.Door.Row2.DriverSide.IsLocked +// Vehicle.Cabin.Door.Row2.PassengerSide.IsLocked +// Vehicle.Body.Trunk.Rear.IsLocked +// Vehicle.Cabin.Door.Row1.DriverSide.IsOpen +// Vehicle.Cabin.Door.Row1.PassengerSide.IsOpen +// Vehicle.Cabin.Door.Row2.DriverSide.IsOpen +// Vehicle.Cabin.Door.Row2.PassengerSide.IsOpen +// Vehicle.Body.Trunk.Rear.IsOpen +// Temperature Control: int32 +// Vehicle.Cabin.HVAC.Station.Row1.Driver.Temperature +// Vehicle.Cabin.HVAC.Station.Row1.Passenger.Temperature +// Vehicle.Cabin.HVAC.Station.Row2.Driver.Temperature +// Vehicle.Cabin.HVAC.Station.Row2.Passenger.Temperature +// Light Control: bool +// Vehicle.Body.Lights.Beam.High.IsOn +// Vehicle.Body.Lights.Beam.Low.IsOn +// Vehicle.Body.Lights.DirectionIndicator.Left.IsSignaling +// Vehicle.Body.Lights.DirectionIndicator.Right.IsSignaling +// Vehicle.Body.Lights.Fog.Front.IsOn +// Vehicle.Body.Lights.Fog.Rear.IsOn +// Vehicle.Body.Lights.Hazard.IsSignaling +// Vehicle.Body.Lights.Parking.IsOn +// Vehicle.Body.Lights.Running.IsOn +// Tire Pressure:uint32 +// Vehicle.Chassis.Axle.Row1.Wheel.Left.Tire.Pressure +// Vehicle.Chassis.Axle.Row1.Wheel.Right.Tire.Pressure +// Vehicle.Chassis.Axle.Row2.Wheel.Left.Tire.Pressure +// Vehicle.Chassis.Axle.Row2.Wheel.Right.Tire.Pressure """ + +export const UnknownText = z.object({ + type: z.literal('unknown'), + command: z.string().describe("The text that wasn't understood") +}); + +export const DataEntry = z.object({ + //path: z.enum(['Vehicle.Cabin.HVAC.Station.Row1.Driver.Temperature', 'Vehicle.Cabin.HVAC.Station.Row2.Driver.Temperature', 'Vehicle.Cabin.HVAC.Station.Row1.Passenger.Temperature', 'Vehicle.Cabin.HVAC.Station.Row2.Passenger.Temperature']).describe("The path to the datapoint"), + path: z.string().describe("The path to the datapoint"), + value: z.string() +}); + +//export const GetTemperature = z.instanceof(DataEntry) +export const GetTemperature = z.object({ + type: z.literal('GetTemperature'), + command: z.object({entries: z.object({path: z.enum(['Vehicle.Cabin.HVAC.Station.Row1.Driver.Temperature', + 'Vehicle.Cabin.HVAC.Station.Row2.Driver.Temperature', + 'Vehicle.Cabin.HVAC.Station.Row1.Passenger.Temperature', + 'Vehicle.Cabin.HVAC.Station.Row2.Passenger.Temperature'])}).array()}), +}); + +export const GetDoorLockState = z.object({ + type: z.literal('GetDoorLockState'), + command: z.object({entries: z.object({path: z.enum(['Vehicle.Cabin.Door.Row1.DriverSide.IsLocked', + 'Vehicle.Cabin.Door.Row2.DriverSide.IsLocked', + 'Vehicle.Cabin.Door.Row1.PassengerSide.IsLocked', + 'Vehicle.Cabin.Door.Row2.PassengerSide.IsLocked', + 'Vehicle.Body.Trunk.Rear.IsLocked'])}).array()}), +}); +export const SetTemperature = z.object({ + type: z.literal('SetTemperature'), + command: z.object({updates: z.array( + z.object({ + entry: z.object({ + path: z.enum(['Vehicle.Cabin.HVAC.Station.Row1.Driver.Temperature', + 'Vehicle.Cabin.HVAC.Station.Row2.Driver.Temperature', + 'Vehicle.Cabin.HVAC.Station.Row1.Passenger.Temperature', + 'Vehicle.Cabin.HVAC.Station.Row2.Passenger.Temperature']), + value: z.object({ int32: z.number() }) + }), + fields: z.string().array().nonempty().default(['FIELD_VALUE']) + }) + )}), + }); + +export const SetDoorLockState = z.object({ + type: z.literal('SetDoorLockState'), + command: z.object({updates: z.array( + z.object({ + entry: z.object({ + path: z.enum(['Vehicle.Cabin.Door.Row1.DriverSide.IsLocked', + 'Vehicle.Cabin.Door.Row2.DriverSide.IsLocked', + 'Vehicle.Cabin.Door.Row1.PassengerSide.IsLocked', + 'Vehicle.Cabin.Door.Row2.PassengerSide.IsLocked','Vehicle.Body.Trunk.Rear.IsLocked']).describe("which door to lock"), + value: z.object({ bool: z.boolean() }) + }), + fields: z.string().array().nonempty().default(['FIELD_VALUE']) + }) + )}), + }); + export const GetDoorOpenState = z.object({ + type: z.literal('GetDoorOpenState'), + command: z.object({entries: z.object({path: z.enum(['Vehicle.Cabin.Door.Row1.DriverSide.IsOpen', + 'Vehicle.Cabin.Door.Row2.DriverSide.IsOpen', + 'Vehicle.Cabin.Door.Row1.PassengerSide.IsOpen', + 'Vehicle.Cabin.Door.Row2.PassengerSide.IsOpen','Vehicle.Body.Trunk.Rear.IsOpen'])}).array()}), +}); + + export const SetDoorOpenState = z.object({ + type: z.literal('SetDoorOpenState'), + command: z.object({updates: z.array( + z.object({ + entry: z.object({ + path: z.enum(['Vehicle.Cabin.Door.Row1.DriverSide.IsOpen', + 'Vehicle.Cabin.Door.Row2.DriverSide.IsOpen', + 'Vehicle.Cabin.Door.Row1.PassengerSide.IsOpen', + 'Vehicle.Cabin.Door.Row2.PassengerSide.IsOpen','Vehicle.Body.Trunk.Rear.IsOpen']).describe("which door to open or close"), + value: z.object({ bool: z.boolean() }) + }), + fields: z.string().array().nonempty().default(['FIELD_VALUE']) + }) + )}), + }); + //use to turn the lights off and on + export const SetLightState = z.object({ + type: z.literal('SetLightState'), + command: z.object({updates: z.array( + z.object({ + entry: z.object({ + path: z.enum(['Vehicle.Body.Lights.Beam.High.IsOn', + 'Vehicle.Body.Lights.Beam.Low.IsOn', + 'Vehicle.Body.Lights.DirectionIndicator.Left.IsSignaling', + 'Vehicle.Body.Lights.DirectionIndicator.Right.IsSignaling', + 'Vehicle.Body.Lights.Fog.Front.IsOn', + 'Vehicle.Body.Lights.Fog.Rear.IsOn', + 'Vehicle.Body.Lights.Hazard.IsSignaling', + 'Vehicle.Body.Lights.Parking.IsOn', + 'Vehicle.Body.Lights.Running.IsOn']), + value: z.object({ bool: z.boolean() }) + }), + fields: z.string().array().nonempty().default(['FIELD_VALUE']) + }) + )}), + }); + //use to get the state of the lights + export const GetLightState = z.object({ + type: z.literal('GetLightState'), + command: z.object({entries: z.object({path: z.enum(['Vehicle.Body.Lights.Beam.High.IsOn', + 'Vehicle.Body.Lights.Beam.Low.IsOn', + 'Vehicle.Body.Lights.DirectionIndicator.Left.IsSignaling', + 'Vehicle.Body.Lights.DirectionIndicator.Right.IsSignaling', + 'Vehicle.Body.Lights.Fog.Front.IsOn', + 'Vehicle.Body.Lights.Fog.Rear.IsOn', + 'Vehicle.Body.Lights.Hazard.IsSignaling', + 'Vehicle.Body.Lights.Parking.IsOn', + 'Vehicle.Body.Lights.Running.IsOn'])}).array()}), + }); + //use to get the pressure of the tires + export const GetTirePressure = z.object({ + type: z.literal('GetTirePressure'), + command: z.object({entries: z.object({path: z.enum(['Vehicle.Chassis.Axle.Row1.Wheel.Left.Tire.Pressure', + 'Vehicle.Chassis.Axle.Row1.Wheel.Right.Tire.Pressure', + 'Vehicle.Chassis.Axle.Row2.Wheel.Left.Tire.Pressure', + 'Vehicle.Chassis.Axle.Row2.Wheel.Right.Tire.Pressure'])}).array().describe('must be an array of entries')}), + }); + //use to set the pressure of the vehicle tires + export const SetTirePressure = z.object({ + type: z.literal('SetTirePressure'), + command: z.object({updates: z.array( + z.object({ + entry: z.object({ + path: z.enum(['Vehicle.Chassis.Axle.Row1.Wheel.Left.Tire.Pressure', + 'Vehicle.Chassis.Axle.Row1.Wheel.Right.Tire.Pressure', + 'Vehicle.Chassis.Axle.Row2.Wheel.Left.Tire.Pressure', + 'Vehicle.Chassis.Axle.Row2.Wheel.Right.Tire.Pressure']), + value: z.object({ uint32: z.number() }) + }), + fields: z.string().array().nonempty().default(['FIELD_VALUE']) + }) + )}), + }); + +export const SDVCarActions = z.object({ + actions: z.discriminatedUnion("type", [ + GetDoorLockState.describe('Use this to get the state of the door locks'), + SetTemperature.describe('Use this to set the temperature'), + GetTemperature.describe('Use this to get the temperature'), + GetLightState.describe('Use this to get the state of the lights'), + SetLightState.describe('Use this to turn the lights off and on'), + SetDoorLockState.describe('Use this to lock and unlock the doors. use GetDoorOpenState for opening and closing doors'), + GetTirePressure.describe('Use this to get the tire pressure'), + GetDoorOpenState.describe('Get the door open state'), + SetDoorOpenState.describe('Use this to open and close the doors. use SetDoorLockState for locking and unlocking doors'), + SetTirePressure.describe('Use this to set the tire pressure'), + UnknownText]).array() +}); + +export const SDVCarSchema ={ + SDVCarActions: SDVCarActions.describe("The actions to perform on the car"), + UnknownText: UnknownText.describe("Use this type for order items that match nothing else") +}; + diff --git a/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/types_pb.d.ts b/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/types_pb.d.ts new file mode 100644 index 00000000..f95de1f1 --- /dev/null +++ b/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/types_pb.d.ts @@ -0,0 +1,970 @@ +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Message, proto3, Timestamp } from "@bufbuild/protobuf"; +/** + * VSS Data type of a signal + * + * Protobuf doesn't support int8, int16, uint8 or uint16. + * These are mapped to int32 and uint32 respectively. + * + * + * @generated from enum kuksa.val.v1.DataType + */ +export declare enum DataType { + /** + * @generated from enum value: DATA_TYPE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + /** + * @generated from enum value: DATA_TYPE_STRING = 1; + */ + STRING = 1, + /** + * @generated from enum value: DATA_TYPE_BOOLEAN = 2; + */ + BOOLEAN = 2, + /** + * @generated from enum value: DATA_TYPE_INT8 = 3; + */ + INT8 = 3, + /** + * @generated from enum value: DATA_TYPE_INT16 = 4; + */ + INT16 = 4, + /** + * @generated from enum value: DATA_TYPE_INT32 = 5; + */ + INT32 = 5, + /** + * @generated from enum value: DATA_TYPE_INT64 = 6; + */ + INT64 = 6, + /** + * @generated from enum value: DATA_TYPE_UINT8 = 7; + */ + UINT8 = 7, + /** + * @generated from enum value: DATA_TYPE_UINT16 = 8; + */ + UINT16 = 8, + /** + * @generated from enum value: DATA_TYPE_UINT32 = 9; + */ + UINT32 = 9, + /** + * @generated from enum value: DATA_TYPE_UINT64 = 10; + */ + UINT64 = 10, + /** + * @generated from enum value: DATA_TYPE_FLOAT = 11; + */ + FLOAT = 11, + /** + * @generated from enum value: DATA_TYPE_DOUBLE = 12; + */ + DOUBLE = 12, + /** + * @generated from enum value: DATA_TYPE_TIMESTAMP = 13; + */ + TIMESTAMP = 13, + /** + * @generated from enum value: DATA_TYPE_STRING_ARRAY = 20; + */ + STRING_ARRAY = 20, + /** + * @generated from enum value: DATA_TYPE_BOOLEAN_ARRAY = 21; + */ + BOOLEAN_ARRAY = 21, + /** + * @generated from enum value: DATA_TYPE_INT8_ARRAY = 22; + */ + INT8_ARRAY = 22, + /** + * @generated from enum value: DATA_TYPE_INT16_ARRAY = 23; + */ + INT16_ARRAY = 23, + /** + * @generated from enum value: DATA_TYPE_INT32_ARRAY = 24; + */ + INT32_ARRAY = 24, + /** + * @generated from enum value: DATA_TYPE_INT64_ARRAY = 25; + */ + INT64_ARRAY = 25, + /** + * @generated from enum value: DATA_TYPE_UINT8_ARRAY = 26; + */ + UINT8_ARRAY = 26, + /** + * @generated from enum value: DATA_TYPE_UINT16_ARRAY = 27; + */ + UINT16_ARRAY = 27, + /** + * @generated from enum value: DATA_TYPE_UINT32_ARRAY = 28; + */ + UINT32_ARRAY = 28, + /** + * @generated from enum value: DATA_TYPE_UINT64_ARRAY = 29; + */ + UINT64_ARRAY = 29, + /** + * @generated from enum value: DATA_TYPE_FLOAT_ARRAY = 30; + */ + FLOAT_ARRAY = 30, + /** + * @generated from enum value: DATA_TYPE_DOUBLE_ARRAY = 31; + */ + DOUBLE_ARRAY = 31, + /** + * @generated from enum value: DATA_TYPE_TIMESTAMP_ARRAY = 32; + */ + TIMESTAMP_ARRAY = 32 +} +/** + * Entry type + * + * @generated from enum kuksa.val.v1.EntryType + */ +export declare enum EntryType { + /** + * @generated from enum value: ENTRY_TYPE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + /** + * @generated from enum value: ENTRY_TYPE_ATTRIBUTE = 1; + */ + ATTRIBUTE = 1, + /** + * @generated from enum value: ENTRY_TYPE_SENSOR = 2; + */ + SENSOR = 2, + /** + * @generated from enum value: ENTRY_TYPE_ACTUATOR = 3; + */ + ACTUATOR = 3 +} +/** + * A `View` specifies a set of fields which should + * be populated in a `DataEntry` (in a response message) + * + * @generated from enum kuksa.val.v1.View + */ +export declare enum View { + /** + * Unspecified. Equivalent to VIEW_CURRENT_VALUE unless `fields` are explicitly set. + * + * @generated from enum value: VIEW_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + /** + * Populate DataEntry with value. + * + * @generated from enum value: VIEW_CURRENT_VALUE = 1; + */ + CURRENT_VALUE = 1, + /** + * Populate DataEntry with actuator target. + * + * @generated from enum value: VIEW_TARGET_VALUE = 2; + */ + TARGET_VALUE = 2, + /** + * Populate DataEntry with metadata. + * + * @generated from enum value: VIEW_METADATA = 3; + */ + METADATA = 3, + /** + * Populate DataEntry only with requested fields. + * + * @generated from enum value: VIEW_FIELDS = 10; + */ + FIELDS = 10, + /** + * Populate DataEntry with everything. + * + * @generated from enum value: VIEW_ALL = 20; + */ + ALL = 20 +} +/** + * A `Field` corresponds to a specific field of a `DataEntry`. + * + * It can be used to: + * * populate only specific fields of a `DataEntry` response. + * * specify which fields of a `DataEntry` should be set as + * part of a `Set` request. + * * subscribe to only specific fields of a data entry. + * * convey which fields of an updated `DataEntry` have changed. + * + * @generated from enum kuksa.val.v1.Field + */ +export declare enum Field { + /** + * "*" i.e. everything + * + * @generated from enum value: FIELD_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + /** + * path + * + * @generated from enum value: FIELD_PATH = 1; + */ + PATH = 1, + /** + * value + * + * @generated from enum value: FIELD_VALUE = 2; + */ + VALUE = 2, + /** + * actuator_target + * + * @generated from enum value: FIELD_ACTUATOR_TARGET = 3; + */ + ACTUATOR_TARGET = 3, + /** + * metadata.* + * + * @generated from enum value: FIELD_METADATA = 10; + */ + METADATA = 10, + /** + * metadata.data_type + * + * @generated from enum value: FIELD_METADATA_DATA_TYPE = 11; + */ + METADATA_DATA_TYPE = 11, + /** + * metadata.description + * + * @generated from enum value: FIELD_METADATA_DESCRIPTION = 12; + */ + METADATA_DESCRIPTION = 12, + /** + * metadata.entry_type + * + * @generated from enum value: FIELD_METADATA_ENTRY_TYPE = 13; + */ + METADATA_ENTRY_TYPE = 13, + /** + * metadata.comment + * + * @generated from enum value: FIELD_METADATA_COMMENT = 14; + */ + METADATA_COMMENT = 14, + /** + * metadata.deprecation + * + * @generated from enum value: FIELD_METADATA_DEPRECATION = 15; + */ + METADATA_DEPRECATION = 15, + /** + * metadata.unit + * + * @generated from enum value: FIELD_METADATA_UNIT = 16; + */ + METADATA_UNIT = 16, + /** + * metadata.value_restriction.* + * + * @generated from enum value: FIELD_METADATA_VALUE_RESTRICTION = 17; + */ + METADATA_VALUE_RESTRICTION = 17, + /** + * metadata.actuator.* + * + * @generated from enum value: FIELD_METADATA_ACTUATOR = 20; + */ + METADATA_ACTUATOR = 20, + /** + * metadata.sensor.* + * + * @generated from enum value: FIELD_METADATA_SENSOR = 30; + */ + METADATA_SENSOR = 30, + /** + * metadata.attribute.* + * + * @generated from enum value: FIELD_METADATA_ATTRIBUTE = 40; + */ + METADATA_ATTRIBUTE = 40 +} +/** + * Describes a VSS entry + * When requesting an entry, the amount of information returned can + * be controlled by specifying either a `View` or a set of `Field`s. + * + * @generated from message kuksa.val.v1.DataEntry + */ +export declare class DataEntry extends Message { + /** + * Defines the full VSS path of the entry. + * + * [field: FIELD_PATH] + * + * @generated from field: string path = 1; + */ + path: string; + /** + * The value (datapoint) + * + * [field: FIELD_VALUE] + * + * @generated from field: kuksa.val.v1.Datapoint value = 2; + */ + value?: Datapoint; + /** + * Actuator target (only used if the entry is an actuator) + * + * [field: FIELD_ACTUATOR_TARGET] + * + * @generated from field: kuksa.val.v1.Datapoint actuator_target = 3; + */ + actuatorTarget?: Datapoint; + /** + * Metadata for this entry + * + * [field: FIELD_METADATA] + * + * @generated from field: kuksa.val.v1.Metadata metadata = 10; + */ + metadata?: Metadata; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.DataEntry"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): DataEntry; + static fromJson(jsonValue: JsonValue, options?: Partial): DataEntry; + static fromJsonString(jsonString: string, options?: Partial): DataEntry; + static equals(a: DataEntry | PlainMessage | undefined, b: DataEntry | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.Datapoint + */ +export declare class Datapoint extends Message { + /** + * @generated from field: google.protobuf.Timestamp timestamp = 1; + */ + timestamp?: Timestamp; + /** + * @generated from oneof kuksa.val.v1.Datapoint.value + */ + value: { + /** + * @generated from field: string string = 11; + */ + value: string; + case: "string"; + } | { + /** + * @generated from field: bool bool = 12; + */ + value: boolean; + case: "bool"; + } | { + /** + * @generated from field: sint32 int32 = 13; + */ + value: number; + case: "int32"; + } | { + /** + * @generated from field: sint64 int64 = 14; + */ + value: bigint; + case: "int64"; + } | { + /** + * @generated from field: uint32 uint32 = 15; + */ + value: number; + case: "uint32"; + } | { + /** + * @generated from field: uint64 uint64 = 16; + */ + value: bigint; + case: "uint64"; + } | { + /** + * @generated from field: float float = 17; + */ + value: number; + case: "float"; + } | { + /** + * @generated from field: double double = 18; + */ + value: number; + case: "double"; + } | { + /** + * @generated from field: kuksa.val.v1.StringArray string_array = 21; + */ + value: StringArray; + case: "stringArray"; + } | { + /** + * @generated from field: kuksa.val.v1.BoolArray bool_array = 22; + */ + value: BoolArray; + case: "boolArray"; + } | { + /** + * @generated from field: kuksa.val.v1.Int32Array int32_array = 23; + */ + value: Int32Array; + case: "int32Array"; + } | { + /** + * @generated from field: kuksa.val.v1.Int64Array int64_array = 24; + */ + value: Int64Array; + case: "int64Array"; + } | { + /** + * @generated from field: kuksa.val.v1.Uint32Array uint32_array = 25; + */ + value: Uint32Array; + case: "uint32Array"; + } | { + /** + * @generated from field: kuksa.val.v1.Uint64Array uint64_array = 26; + */ + value: Uint64Array; + case: "uint64Array"; + } | { + /** + * @generated from field: kuksa.val.v1.FloatArray float_array = 27; + */ + value: FloatArray; + case: "floatArray"; + } | { + /** + * @generated from field: kuksa.val.v1.DoubleArray double_array = 28; + */ + value: DoubleArray; + case: "doubleArray"; + } | { + case: undefined; + value?: undefined; + }; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.Datapoint"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): Datapoint; + static fromJson(jsonValue: JsonValue, options?: Partial): Datapoint; + static fromJsonString(jsonString: string, options?: Partial): Datapoint; + static equals(a: Datapoint | PlainMessage | undefined, b: Datapoint | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.Metadata + */ +export declare class Metadata extends Message { + /** + * Data type + * The VSS data type of the entry (i.e. the value, min, max etc). + * + * NOTE: protobuf doesn't have int8, int16, uint8 or uint16 which means + * that these values must be serialized as int32 and uint32 respectively. + * + * [field: FIELD_METADATA_DATA_TYPE] + * + * @generated from field: kuksa.val.v1.DataType data_type = 11; + */ + dataType: DataType; + /** + * Entry type + * + * [field: FIELD_METADATA_ENTRY_TYPE] + * + * @generated from field: kuksa.val.v1.EntryType entry_type = 12; + */ + entryType: EntryType; + /** + * Description + * Describes the meaning and content of the entry. + * + * [field: FIELD_METADATA_DESCRIPTION] + * + * @generated from field: optional string description = 13; + */ + description?: string; + /** + * Comment [optional] + * A comment can be used to provide additional informal information + * on a entry. + * + * [field: FIELD_METADATA_COMMENT] + * + * @generated from field: optional string comment = 14; + */ + comment?: string; + /** + * Deprecation [optional] + * Whether this entry is deprecated. Can contain recommendations of what + * to use instead. + * + * [field: FIELD_METADATA_DEPRECATION] + * + * @generated from field: optional string deprecation = 15; + */ + deprecation?: string; + /** + * Unit [optional] + * The unit of measurement + * + * [field: FIELD_METADATA_UNIT] + * + * @generated from field: optional string unit = 16; + */ + unit?: string; + /** + * Value restrictions [optional] + * Restrict which values are allowed. + * Only restrictions matching the DataType {datatype} above are valid. + * + * [field: FIELD_METADATA_VALUE_RESTRICTION] + * + * @generated from field: kuksa.val.v1.ValueRestriction value_restriction = 17; + */ + valueRestriction?: ValueRestriction; + /** + * Entry type specific metadata + * + * @generated from oneof kuksa.val.v1.Metadata.entry_specific + */ + entrySpecific: { + /** + * [field: FIELD_METADATA_ACTUATOR] + * + * @generated from field: kuksa.val.v1.Actuator actuator = 20; + */ + value: Actuator; + case: "actuator"; + } | { + /** + * [field: FIELD_METADATA_SENSOR] + * + * @generated from field: kuksa.val.v1.Sensor sensor = 30; + */ + value: Sensor; + case: "sensor"; + } | { + /** + * [field: FIELD_METADATA_ATTRIBUTE] + * + * @generated from field: kuksa.val.v1.Attribute attribute = 40; + */ + value: Attribute; + case: "attribute"; + } | { + case: undefined; + value?: undefined; + }; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.Metadata"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): Metadata; + static fromJson(jsonValue: JsonValue, options?: Partial): Metadata; + static fromJsonString(jsonString: string, options?: Partial): Metadata; + static equals(a: Metadata | PlainMessage | undefined, b: Metadata | PlainMessage | undefined): boolean; +} +/** + * ///////////////////// + * Actuator specific fields + * + * Nothing for now + * + * @generated from message kuksa.val.v1.Actuator + */ +export declare class Actuator extends Message { + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.Actuator"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): Actuator; + static fromJson(jsonValue: JsonValue, options?: Partial): Actuator; + static fromJsonString(jsonString: string, options?: Partial): Actuator; + static equals(a: Actuator | PlainMessage | undefined, b: Actuator | PlainMessage | undefined): boolean; +} +/** + * ////////////////////// + * Sensor specific + * + * Nothing for now + * + * @generated from message kuksa.val.v1.Sensor + */ +export declare class Sensor extends Message { + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.Sensor"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): Sensor; + static fromJson(jsonValue: JsonValue, options?: Partial): Sensor; + static fromJsonString(jsonString: string, options?: Partial): Sensor; + static equals(a: Sensor | PlainMessage | undefined, b: Sensor | PlainMessage | undefined): boolean; +} +/** + * ////////////////////// + * Attribute specific + * + * Nothing for now. + * + * @generated from message kuksa.val.v1.Attribute + */ +export declare class Attribute extends Message { + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.Attribute"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): Attribute; + static fromJson(jsonValue: JsonValue, options?: Partial): Attribute; + static fromJsonString(jsonString: string, options?: Partial): Attribute; + static equals(a: Attribute | PlainMessage | undefined, b: Attribute | PlainMessage | undefined): boolean; +} +/** + * Value restriction + * + * One ValueRestriction{type} for each type, since + * they don't make sense unless the types match + * + * + * @generated from message kuksa.val.v1.ValueRestriction + */ +export declare class ValueRestriction extends Message { + /** + * @generated from oneof kuksa.val.v1.ValueRestriction.type + */ + type: { + /** + * @generated from field: kuksa.val.v1.ValueRestrictionString string = 21; + */ + value: ValueRestrictionString; + case: "string"; + } | { + /** + * For signed VSS integers + * + * @generated from field: kuksa.val.v1.ValueRestrictionInt signed = 22; + */ + value: ValueRestrictionInt; + case: "signed"; + } | { + /** + * For unsigned VSS integers + * + * @generated from field: kuksa.val.v1.ValueRestrictionUint unsigned = 23; + */ + value: ValueRestrictionUint; + case: "unsigned"; + } | { + /** + * For floating point VSS values (float and double) + * + * @generated from field: kuksa.val.v1.ValueRestrictionFloat floating_point = 24; + */ + value: ValueRestrictionFloat; + case: "floatingPoint"; + } | { + case: undefined; + value?: undefined; + }; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.ValueRestriction"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): ValueRestriction; + static fromJson(jsonValue: JsonValue, options?: Partial): ValueRestriction; + static fromJsonString(jsonString: string, options?: Partial): ValueRestriction; + static equals(a: ValueRestriction | PlainMessage | undefined, b: ValueRestriction | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.ValueRestrictionInt + */ +export declare class ValueRestrictionInt extends Message { + /** + * @generated from field: optional sint64 min = 1; + */ + min?: bigint; + /** + * @generated from field: optional sint64 max = 2; + */ + max?: bigint; + /** + * @generated from field: repeated sint64 allowed_values = 3; + */ + allowedValues: bigint[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.ValueRestrictionInt"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): ValueRestrictionInt; + static fromJson(jsonValue: JsonValue, options?: Partial): ValueRestrictionInt; + static fromJsonString(jsonString: string, options?: Partial): ValueRestrictionInt; + static equals(a: ValueRestrictionInt | PlainMessage | undefined, b: ValueRestrictionInt | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.ValueRestrictionUint + */ +export declare class ValueRestrictionUint extends Message { + /** + * @generated from field: optional uint64 min = 1; + */ + min?: bigint; + /** + * @generated from field: optional uint64 max = 2; + */ + max?: bigint; + /** + * @generated from field: repeated uint64 allowed_values = 3; + */ + allowedValues: bigint[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.ValueRestrictionUint"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): ValueRestrictionUint; + static fromJson(jsonValue: JsonValue, options?: Partial): ValueRestrictionUint; + static fromJsonString(jsonString: string, options?: Partial): ValueRestrictionUint; + static equals(a: ValueRestrictionUint | PlainMessage | undefined, b: ValueRestrictionUint | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.ValueRestrictionFloat + */ +export declare class ValueRestrictionFloat extends Message { + /** + * @generated from field: optional double min = 1; + */ + min?: number; + /** + * @generated from field: optional double max = 2; + */ + max?: number; + /** + * allowed for doubles/floats not recommended + * + * @generated from field: repeated double allowed_values = 3; + */ + allowedValues: number[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.ValueRestrictionFloat"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): ValueRestrictionFloat; + static fromJson(jsonValue: JsonValue, options?: Partial): ValueRestrictionFloat; + static fromJsonString(jsonString: string, options?: Partial): ValueRestrictionFloat; + static equals(a: ValueRestrictionFloat | PlainMessage | undefined, b: ValueRestrictionFloat | PlainMessage | undefined): boolean; +} +/** + * min, max doesn't make much sense for a string + * + * @generated from message kuksa.val.v1.ValueRestrictionString + */ +export declare class ValueRestrictionString extends Message { + /** + * @generated from field: repeated string allowed_values = 3; + */ + allowedValues: string[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.ValueRestrictionString"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): ValueRestrictionString; + static fromJson(jsonValue: JsonValue, options?: Partial): ValueRestrictionString; + static fromJsonString(jsonString: string, options?: Partial): ValueRestrictionString; + static equals(a: ValueRestrictionString | PlainMessage | undefined, b: ValueRestrictionString | PlainMessage | undefined): boolean; +} +/** + * Error response shall be an HTTP-like code. + * Should follow https://www.w3.org/TR/viss2-transport/#status-codes. + * + * @generated from message kuksa.val.v1.Error + */ +export declare class Error extends Message { + /** + * @generated from field: uint32 code = 1; + */ + code: number; + /** + * @generated from field: string reason = 2; + */ + reason: string; + /** + * @generated from field: string message = 3; + */ + message: string; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.Error"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): Error; + static fromJson(jsonValue: JsonValue, options?: Partial): Error; + static fromJsonString(jsonString: string, options?: Partial): Error; + static equals(a: Error | PlainMessage | undefined, b: Error | PlainMessage | undefined): boolean; +} +/** + * Used in get/set requests to report errors for specific entries + * + * @generated from message kuksa.val.v1.DataEntryError + */ +export declare class DataEntryError extends Message { + /** + * vss path + * + * @generated from field: string path = 1; + */ + path: string; + /** + * @generated from field: kuksa.val.v1.Error error = 2; + */ + error?: Error; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.DataEntryError"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): DataEntryError; + static fromJson(jsonValue: JsonValue, options?: Partial): DataEntryError; + static fromJsonString(jsonString: string, options?: Partial): DataEntryError; + static equals(a: DataEntryError | PlainMessage | undefined, b: DataEntryError | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.StringArray + */ +export declare class StringArray extends Message { + /** + * @generated from field: repeated string values = 1; + */ + values: string[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.StringArray"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): StringArray; + static fromJson(jsonValue: JsonValue, options?: Partial): StringArray; + static fromJsonString(jsonString: string, options?: Partial): StringArray; + static equals(a: StringArray | PlainMessage | undefined, b: StringArray | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.BoolArray + */ +export declare class BoolArray extends Message { + /** + * @generated from field: repeated bool values = 1; + */ + values: boolean[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.BoolArray"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): BoolArray; + static fromJson(jsonValue: JsonValue, options?: Partial): BoolArray; + static fromJsonString(jsonString: string, options?: Partial): BoolArray; + static equals(a: BoolArray | PlainMessage | undefined, b: BoolArray | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.Int32Array + */ +export declare class Int32Array extends Message { + /** + * @generated from field: repeated sint32 values = 1; + */ + values: number[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.Int32Array"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): Int32Array; + static fromJson(jsonValue: JsonValue, options?: Partial): Int32Array; + static fromJsonString(jsonString: string, options?: Partial): Int32Array; + static equals(a: Int32Array | PlainMessage | undefined, b: Int32Array | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.Int64Array + */ +export declare class Int64Array extends Message { + /** + * @generated from field: repeated sint64 values = 1; + */ + values: bigint[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.Int64Array"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): Int64Array; + static fromJson(jsonValue: JsonValue, options?: Partial): Int64Array; + static fromJsonString(jsonString: string, options?: Partial): Int64Array; + static equals(a: Int64Array | PlainMessage | undefined, b: Int64Array | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.Uint32Array + */ +export declare class Uint32Array extends Message { + /** + * @generated from field: repeated uint32 values = 1; + */ + values: number[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.Uint32Array"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): Uint32Array; + static fromJson(jsonValue: JsonValue, options?: Partial): Uint32Array; + static fromJsonString(jsonString: string, options?: Partial): Uint32Array; + static equals(a: Uint32Array | PlainMessage | undefined, b: Uint32Array | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.Uint64Array + */ +export declare class Uint64Array extends Message { + /** + * @generated from field: repeated uint64 values = 1; + */ + values: bigint[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.Uint64Array"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): Uint64Array; + static fromJson(jsonValue: JsonValue, options?: Partial): Uint64Array; + static fromJsonString(jsonString: string, options?: Partial): Uint64Array; + static equals(a: Uint64Array | PlainMessage | undefined, b: Uint64Array | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.FloatArray + */ +export declare class FloatArray extends Message { + /** + * @generated from field: repeated float values = 1; + */ + values: number[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.FloatArray"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): FloatArray; + static fromJson(jsonValue: JsonValue, options?: Partial): FloatArray; + static fromJsonString(jsonString: string, options?: Partial): FloatArray; + static equals(a: FloatArray | PlainMessage | undefined, b: FloatArray | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.DoubleArray + */ +export declare class DoubleArray extends Message { + /** + * @generated from field: repeated double values = 1; + */ + values: number[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.DoubleArray"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): DoubleArray; + static fromJson(jsonValue: JsonValue, options?: Partial): DoubleArray; + static fromJsonString(jsonString: string, options?: Partial): DoubleArray; + static equals(a: DoubleArray | PlainMessage | undefined, b: DoubleArray | PlainMessage | undefined): boolean; +} diff --git a/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/types_pb.js b/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/types_pb.js new file mode 100644 index 00000000..a10c4a40 --- /dev/null +++ b/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/types_pb.js @@ -0,0 +1,1118 @@ +"use strict"; +//******************************************************************************* +// Copyright (c) 2022 Contributors to the Eclipse Foundation +// +// See the NOTICE file(s) distributed with this work for additional +// information regarding copyright ownership. +// +// This program and the accompanying materials are made available under the +// terms of the Apache License 2.0 which is available at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// SPDX-License-Identifier: Apache-2.0 +//****************************************************************************** +Object.defineProperty(exports, "__esModule", { value: true }); +exports.DoubleArray = exports.FloatArray = exports.Uint64Array = exports.Uint32Array = exports.Int64Array = exports.Int32Array = exports.BoolArray = exports.StringArray = exports.DataEntryError = exports.Error = exports.ValueRestrictionString = exports.ValueRestrictionFloat = exports.ValueRestrictionUint = exports.ValueRestrictionInt = exports.ValueRestriction = exports.Attribute = exports.Sensor = exports.Actuator = exports.Metadata = exports.Datapoint = exports.DataEntry = exports.Field = exports.View = exports.EntryType = exports.DataType = void 0; +const protobuf_1 = require("@bufbuild/protobuf"); +/** + * VSS Data type of a signal + * + * Protobuf doesn't support int8, int16, uint8 or uint16. + * These are mapped to int32 and uint32 respectively. + * + * + * @generated from enum kuksa.val.v1.DataType + */ +var DataType; +(function (DataType) { + /** + * @generated from enum value: DATA_TYPE_UNSPECIFIED = 0; + */ + DataType[DataType["UNSPECIFIED"] = 0] = "UNSPECIFIED"; + /** + * @generated from enum value: DATA_TYPE_STRING = 1; + */ + DataType[DataType["STRING"] = 1] = "STRING"; + /** + * @generated from enum value: DATA_TYPE_BOOLEAN = 2; + */ + DataType[DataType["BOOLEAN"] = 2] = "BOOLEAN"; + /** + * @generated from enum value: DATA_TYPE_INT8 = 3; + */ + DataType[DataType["INT8"] = 3] = "INT8"; + /** + * @generated from enum value: DATA_TYPE_INT16 = 4; + */ + DataType[DataType["INT16"] = 4] = "INT16"; + /** + * @generated from enum value: DATA_TYPE_INT32 = 5; + */ + DataType[DataType["INT32"] = 5] = "INT32"; + /** + * @generated from enum value: DATA_TYPE_INT64 = 6; + */ + DataType[DataType["INT64"] = 6] = "INT64"; + /** + * @generated from enum value: DATA_TYPE_UINT8 = 7; + */ + DataType[DataType["UINT8"] = 7] = "UINT8"; + /** + * @generated from enum value: DATA_TYPE_UINT16 = 8; + */ + DataType[DataType["UINT16"] = 8] = "UINT16"; + /** + * @generated from enum value: DATA_TYPE_UINT32 = 9; + */ + DataType[DataType["UINT32"] = 9] = "UINT32"; + /** + * @generated from enum value: DATA_TYPE_UINT64 = 10; + */ + DataType[DataType["UINT64"] = 10] = "UINT64"; + /** + * @generated from enum value: DATA_TYPE_FLOAT = 11; + */ + DataType[DataType["FLOAT"] = 11] = "FLOAT"; + /** + * @generated from enum value: DATA_TYPE_DOUBLE = 12; + */ + DataType[DataType["DOUBLE"] = 12] = "DOUBLE"; + /** + * @generated from enum value: DATA_TYPE_TIMESTAMP = 13; + */ + DataType[DataType["TIMESTAMP"] = 13] = "TIMESTAMP"; + /** + * @generated from enum value: DATA_TYPE_STRING_ARRAY = 20; + */ + DataType[DataType["STRING_ARRAY"] = 20] = "STRING_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_BOOLEAN_ARRAY = 21; + */ + DataType[DataType["BOOLEAN_ARRAY"] = 21] = "BOOLEAN_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_INT8_ARRAY = 22; + */ + DataType[DataType["INT8_ARRAY"] = 22] = "INT8_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_INT16_ARRAY = 23; + */ + DataType[DataType["INT16_ARRAY"] = 23] = "INT16_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_INT32_ARRAY = 24; + */ + DataType[DataType["INT32_ARRAY"] = 24] = "INT32_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_INT64_ARRAY = 25; + */ + DataType[DataType["INT64_ARRAY"] = 25] = "INT64_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_UINT8_ARRAY = 26; + */ + DataType[DataType["UINT8_ARRAY"] = 26] = "UINT8_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_UINT16_ARRAY = 27; + */ + DataType[DataType["UINT16_ARRAY"] = 27] = "UINT16_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_UINT32_ARRAY = 28; + */ + DataType[DataType["UINT32_ARRAY"] = 28] = "UINT32_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_UINT64_ARRAY = 29; + */ + DataType[DataType["UINT64_ARRAY"] = 29] = "UINT64_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_FLOAT_ARRAY = 30; + */ + DataType[DataType["FLOAT_ARRAY"] = 30] = "FLOAT_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_DOUBLE_ARRAY = 31; + */ + DataType[DataType["DOUBLE_ARRAY"] = 31] = "DOUBLE_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_TIMESTAMP_ARRAY = 32; + */ + DataType[DataType["TIMESTAMP_ARRAY"] = 32] = "TIMESTAMP_ARRAY"; +})(DataType || (exports.DataType = DataType = {})); +// Retrieve enum metadata with: proto3.getEnumType(DataType) +protobuf_1.proto3.util.setEnumType(DataType, "kuksa.val.v1.DataType", [ + { no: 0, name: "DATA_TYPE_UNSPECIFIED" }, + { no: 1, name: "DATA_TYPE_STRING" }, + { no: 2, name: "DATA_TYPE_BOOLEAN" }, + { no: 3, name: "DATA_TYPE_INT8" }, + { no: 4, name: "DATA_TYPE_INT16" }, + { no: 5, name: "DATA_TYPE_INT32" }, + { no: 6, name: "DATA_TYPE_INT64" }, + { no: 7, name: "DATA_TYPE_UINT8" }, + { no: 8, name: "DATA_TYPE_UINT16" }, + { no: 9, name: "DATA_TYPE_UINT32" }, + { no: 10, name: "DATA_TYPE_UINT64" }, + { no: 11, name: "DATA_TYPE_FLOAT" }, + { no: 12, name: "DATA_TYPE_DOUBLE" }, + { no: 13, name: "DATA_TYPE_TIMESTAMP" }, + { no: 20, name: "DATA_TYPE_STRING_ARRAY" }, + { no: 21, name: "DATA_TYPE_BOOLEAN_ARRAY" }, + { no: 22, name: "DATA_TYPE_INT8_ARRAY" }, + { no: 23, name: "DATA_TYPE_INT16_ARRAY" }, + { no: 24, name: "DATA_TYPE_INT32_ARRAY" }, + { no: 25, name: "DATA_TYPE_INT64_ARRAY" }, + { no: 26, name: "DATA_TYPE_UINT8_ARRAY" }, + { no: 27, name: "DATA_TYPE_UINT16_ARRAY" }, + { no: 28, name: "DATA_TYPE_UINT32_ARRAY" }, + { no: 29, name: "DATA_TYPE_UINT64_ARRAY" }, + { no: 30, name: "DATA_TYPE_FLOAT_ARRAY" }, + { no: 31, name: "DATA_TYPE_DOUBLE_ARRAY" }, + { no: 32, name: "DATA_TYPE_TIMESTAMP_ARRAY" }, +]); +/** + * Entry type + * + * @generated from enum kuksa.val.v1.EntryType + */ +var EntryType; +(function (EntryType) { + /** + * @generated from enum value: ENTRY_TYPE_UNSPECIFIED = 0; + */ + EntryType[EntryType["UNSPECIFIED"] = 0] = "UNSPECIFIED"; + /** + * @generated from enum value: ENTRY_TYPE_ATTRIBUTE = 1; + */ + EntryType[EntryType["ATTRIBUTE"] = 1] = "ATTRIBUTE"; + /** + * @generated from enum value: ENTRY_TYPE_SENSOR = 2; + */ + EntryType[EntryType["SENSOR"] = 2] = "SENSOR"; + /** + * @generated from enum value: ENTRY_TYPE_ACTUATOR = 3; + */ + EntryType[EntryType["ACTUATOR"] = 3] = "ACTUATOR"; +})(EntryType || (exports.EntryType = EntryType = {})); +// Retrieve enum metadata with: proto3.getEnumType(EntryType) +protobuf_1.proto3.util.setEnumType(EntryType, "kuksa.val.v1.EntryType", [ + { no: 0, name: "ENTRY_TYPE_UNSPECIFIED" }, + { no: 1, name: "ENTRY_TYPE_ATTRIBUTE" }, + { no: 2, name: "ENTRY_TYPE_SENSOR" }, + { no: 3, name: "ENTRY_TYPE_ACTUATOR" }, +]); +/** + * A `View` specifies a set of fields which should + * be populated in a `DataEntry` (in a response message) + * + * @generated from enum kuksa.val.v1.View + */ +var View; +(function (View) { + /** + * Unspecified. Equivalent to VIEW_CURRENT_VALUE unless `fields` are explicitly set. + * + * @generated from enum value: VIEW_UNSPECIFIED = 0; + */ + View[View["UNSPECIFIED"] = 0] = "UNSPECIFIED"; + /** + * Populate DataEntry with value. + * + * @generated from enum value: VIEW_CURRENT_VALUE = 1; + */ + View[View["CURRENT_VALUE"] = 1] = "CURRENT_VALUE"; + /** + * Populate DataEntry with actuator target. + * + * @generated from enum value: VIEW_TARGET_VALUE = 2; + */ + View[View["TARGET_VALUE"] = 2] = "TARGET_VALUE"; + /** + * Populate DataEntry with metadata. + * + * @generated from enum value: VIEW_METADATA = 3; + */ + View[View["METADATA"] = 3] = "METADATA"; + /** + * Populate DataEntry only with requested fields. + * + * @generated from enum value: VIEW_FIELDS = 10; + */ + View[View["FIELDS"] = 10] = "FIELDS"; + /** + * Populate DataEntry with everything. + * + * @generated from enum value: VIEW_ALL = 20; + */ + View[View["ALL"] = 20] = "ALL"; +})(View || (exports.View = View = {})); +// Retrieve enum metadata with: proto3.getEnumType(View) +protobuf_1.proto3.util.setEnumType(View, "kuksa.val.v1.View", [ + { no: 0, name: "VIEW_UNSPECIFIED" }, + { no: 1, name: "VIEW_CURRENT_VALUE" }, + { no: 2, name: "VIEW_TARGET_VALUE" }, + { no: 3, name: "VIEW_METADATA" }, + { no: 10, name: "VIEW_FIELDS" }, + { no: 20, name: "VIEW_ALL" }, +]); +/** + * A `Field` corresponds to a specific field of a `DataEntry`. + * + * It can be used to: + * * populate only specific fields of a `DataEntry` response. + * * specify which fields of a `DataEntry` should be set as + * part of a `Set` request. + * * subscribe to only specific fields of a data entry. + * * convey which fields of an updated `DataEntry` have changed. + * + * @generated from enum kuksa.val.v1.Field + */ +var Field; +(function (Field) { + /** + * "*" i.e. everything + * + * @generated from enum value: FIELD_UNSPECIFIED = 0; + */ + Field[Field["UNSPECIFIED"] = 0] = "UNSPECIFIED"; + /** + * path + * + * @generated from enum value: FIELD_PATH = 1; + */ + Field[Field["PATH"] = 1] = "PATH"; + /** + * value + * + * @generated from enum value: FIELD_VALUE = 2; + */ + Field[Field["VALUE"] = 2] = "VALUE"; + /** + * actuator_target + * + * @generated from enum value: FIELD_ACTUATOR_TARGET = 3; + */ + Field[Field["ACTUATOR_TARGET"] = 3] = "ACTUATOR_TARGET"; + /** + * metadata.* + * + * @generated from enum value: FIELD_METADATA = 10; + */ + Field[Field["METADATA"] = 10] = "METADATA"; + /** + * metadata.data_type + * + * @generated from enum value: FIELD_METADATA_DATA_TYPE = 11; + */ + Field[Field["METADATA_DATA_TYPE"] = 11] = "METADATA_DATA_TYPE"; + /** + * metadata.description + * + * @generated from enum value: FIELD_METADATA_DESCRIPTION = 12; + */ + Field[Field["METADATA_DESCRIPTION"] = 12] = "METADATA_DESCRIPTION"; + /** + * metadata.entry_type + * + * @generated from enum value: FIELD_METADATA_ENTRY_TYPE = 13; + */ + Field[Field["METADATA_ENTRY_TYPE"] = 13] = "METADATA_ENTRY_TYPE"; + /** + * metadata.comment + * + * @generated from enum value: FIELD_METADATA_COMMENT = 14; + */ + Field[Field["METADATA_COMMENT"] = 14] = "METADATA_COMMENT"; + /** + * metadata.deprecation + * + * @generated from enum value: FIELD_METADATA_DEPRECATION = 15; + */ + Field[Field["METADATA_DEPRECATION"] = 15] = "METADATA_DEPRECATION"; + /** + * metadata.unit + * + * @generated from enum value: FIELD_METADATA_UNIT = 16; + */ + Field[Field["METADATA_UNIT"] = 16] = "METADATA_UNIT"; + /** + * metadata.value_restriction.* + * + * @generated from enum value: FIELD_METADATA_VALUE_RESTRICTION = 17; + */ + Field[Field["METADATA_VALUE_RESTRICTION"] = 17] = "METADATA_VALUE_RESTRICTION"; + /** + * metadata.actuator.* + * + * @generated from enum value: FIELD_METADATA_ACTUATOR = 20; + */ + Field[Field["METADATA_ACTUATOR"] = 20] = "METADATA_ACTUATOR"; + /** + * metadata.sensor.* + * + * @generated from enum value: FIELD_METADATA_SENSOR = 30; + */ + Field[Field["METADATA_SENSOR"] = 30] = "METADATA_SENSOR"; + /** + * metadata.attribute.* + * + * @generated from enum value: FIELD_METADATA_ATTRIBUTE = 40; + */ + Field[Field["METADATA_ATTRIBUTE"] = 40] = "METADATA_ATTRIBUTE"; +})(Field || (exports.Field = Field = {})); +// Retrieve enum metadata with: proto3.getEnumType(Field) +protobuf_1.proto3.util.setEnumType(Field, "kuksa.val.v1.Field", [ + { no: 0, name: "FIELD_UNSPECIFIED" }, + { no: 1, name: "FIELD_PATH" }, + { no: 2, name: "FIELD_VALUE" }, + { no: 3, name: "FIELD_ACTUATOR_TARGET" }, + { no: 10, name: "FIELD_METADATA" }, + { no: 11, name: "FIELD_METADATA_DATA_TYPE" }, + { no: 12, name: "FIELD_METADATA_DESCRIPTION" }, + { no: 13, name: "FIELD_METADATA_ENTRY_TYPE" }, + { no: 14, name: "FIELD_METADATA_COMMENT" }, + { no: 15, name: "FIELD_METADATA_DEPRECATION" }, + { no: 16, name: "FIELD_METADATA_UNIT" }, + { no: 17, name: "FIELD_METADATA_VALUE_RESTRICTION" }, + { no: 20, name: "FIELD_METADATA_ACTUATOR" }, + { no: 30, name: "FIELD_METADATA_SENSOR" }, + { no: 40, name: "FIELD_METADATA_ATTRIBUTE" }, +]); +/** + * Describes a VSS entry + * When requesting an entry, the amount of information returned can + * be controlled by specifying either a `View` or a set of `Field`s. + * + * @generated from message kuksa.val.v1.DataEntry + */ +class DataEntry extends protobuf_1.Message { + constructor(data) { + super(); + /** + * Defines the full VSS path of the entry. + * + * [field: FIELD_PATH] + * + * @generated from field: string path = 1; + */ + this.path = ""; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new DataEntry().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new DataEntry().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new DataEntry().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(DataEntry, a, b); + } +} +exports.DataEntry = DataEntry; +DataEntry.runtime = protobuf_1.proto3; +DataEntry.typeName = "kuksa.val.v1.DataEntry"; +DataEntry.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "value", kind: "message", T: Datapoint }, + { no: 3, name: "actuator_target", kind: "message", T: Datapoint }, + { no: 10, name: "metadata", kind: "message", T: Metadata }, +]); +/** + * @generated from message kuksa.val.v1.Datapoint + */ +class Datapoint extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from oneof kuksa.val.v1.Datapoint.value + */ + this.value = { case: undefined }; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new Datapoint().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new Datapoint().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new Datapoint().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(Datapoint, a, b); + } +} +exports.Datapoint = Datapoint; +Datapoint.runtime = protobuf_1.proto3; +Datapoint.typeName = "kuksa.val.v1.Datapoint"; +Datapoint.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "timestamp", kind: "message", T: protobuf_1.Timestamp }, + { no: 11, name: "string", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "value" }, + { no: 12, name: "bool", kind: "scalar", T: 8 /* ScalarType.BOOL */, oneof: "value" }, + { no: 13, name: "int32", kind: "scalar", T: 17 /* ScalarType.SINT32 */, oneof: "value" }, + { no: 14, name: "int64", kind: "scalar", T: 18 /* ScalarType.SINT64 */, oneof: "value" }, + { no: 15, name: "uint32", kind: "scalar", T: 13 /* ScalarType.UINT32 */, oneof: "value" }, + { no: 16, name: "uint64", kind: "scalar", T: 4 /* ScalarType.UINT64 */, oneof: "value" }, + { no: 17, name: "float", kind: "scalar", T: 2 /* ScalarType.FLOAT */, oneof: "value" }, + { no: 18, name: "double", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, oneof: "value" }, + { no: 21, name: "string_array", kind: "message", T: StringArray, oneof: "value" }, + { no: 22, name: "bool_array", kind: "message", T: BoolArray, oneof: "value" }, + { no: 23, name: "int32_array", kind: "message", T: Int32Array, oneof: "value" }, + { no: 24, name: "int64_array", kind: "message", T: Int64Array, oneof: "value" }, + { no: 25, name: "uint32_array", kind: "message", T: Uint32Array, oneof: "value" }, + { no: 26, name: "uint64_array", kind: "message", T: Uint64Array, oneof: "value" }, + { no: 27, name: "float_array", kind: "message", T: FloatArray, oneof: "value" }, + { no: 28, name: "double_array", kind: "message", T: DoubleArray, oneof: "value" }, +]); +/** + * @generated from message kuksa.val.v1.Metadata + */ +class Metadata extends protobuf_1.Message { + constructor(data) { + super(); + /** + * Data type + * The VSS data type of the entry (i.e. the value, min, max etc). + * + * NOTE: protobuf doesn't have int8, int16, uint8 or uint16 which means + * that these values must be serialized as int32 and uint32 respectively. + * + * [field: FIELD_METADATA_DATA_TYPE] + * + * @generated from field: kuksa.val.v1.DataType data_type = 11; + */ + this.dataType = DataType.UNSPECIFIED; + /** + * Entry type + * + * [field: FIELD_METADATA_ENTRY_TYPE] + * + * @generated from field: kuksa.val.v1.EntryType entry_type = 12; + */ + this.entryType = EntryType.UNSPECIFIED; + /** + * Entry type specific metadata + * + * @generated from oneof kuksa.val.v1.Metadata.entry_specific + */ + this.entrySpecific = { case: undefined }; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new Metadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new Metadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new Metadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(Metadata, a, b); + } +} +exports.Metadata = Metadata; +Metadata.runtime = protobuf_1.proto3; +Metadata.typeName = "kuksa.val.v1.Metadata"; +Metadata.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 11, name: "data_type", kind: "enum", T: protobuf_1.proto3.getEnumType(DataType) }, + { no: 12, name: "entry_type", kind: "enum", T: protobuf_1.proto3.getEnumType(EntryType) }, + { no: 13, name: "description", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 14, name: "comment", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 15, name: "deprecation", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 16, name: "unit", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 17, name: "value_restriction", kind: "message", T: ValueRestriction }, + { no: 20, name: "actuator", kind: "message", T: Actuator, oneof: "entry_specific" }, + { no: 30, name: "sensor", kind: "message", T: Sensor, oneof: "entry_specific" }, + { no: 40, name: "attribute", kind: "message", T: Attribute, oneof: "entry_specific" }, +]); +/** + * ///////////////////// + * Actuator specific fields + * + * Nothing for now + * + * @generated from message kuksa.val.v1.Actuator + */ +class Actuator extends protobuf_1.Message { + constructor(data) { + super(); + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new Actuator().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new Actuator().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new Actuator().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(Actuator, a, b); + } +} +exports.Actuator = Actuator; +Actuator.runtime = protobuf_1.proto3; +Actuator.typeName = "kuksa.val.v1.Actuator"; +Actuator.fields = protobuf_1.proto3.util.newFieldList(() => []); +/** + * ////////////////////// + * Sensor specific + * + * Nothing for now + * + * @generated from message kuksa.val.v1.Sensor + */ +class Sensor extends protobuf_1.Message { + constructor(data) { + super(); + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new Sensor().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new Sensor().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new Sensor().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(Sensor, a, b); + } +} +exports.Sensor = Sensor; +Sensor.runtime = protobuf_1.proto3; +Sensor.typeName = "kuksa.val.v1.Sensor"; +Sensor.fields = protobuf_1.proto3.util.newFieldList(() => []); +/** + * ////////////////////// + * Attribute specific + * + * Nothing for now. + * + * @generated from message kuksa.val.v1.Attribute + */ +class Attribute extends protobuf_1.Message { + constructor(data) { + super(); + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new Attribute().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new Attribute().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new Attribute().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(Attribute, a, b); + } +} +exports.Attribute = Attribute; +Attribute.runtime = protobuf_1.proto3; +Attribute.typeName = "kuksa.val.v1.Attribute"; +Attribute.fields = protobuf_1.proto3.util.newFieldList(() => []); +/** + * Value restriction + * + * One ValueRestriction{type} for each type, since + * they don't make sense unless the types match + * + * + * @generated from message kuksa.val.v1.ValueRestriction + */ +class ValueRestriction extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from oneof kuksa.val.v1.ValueRestriction.type + */ + this.type = { case: undefined }; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new ValueRestriction().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new ValueRestriction().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new ValueRestriction().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(ValueRestriction, a, b); + } +} +exports.ValueRestriction = ValueRestriction; +ValueRestriction.runtime = protobuf_1.proto3; +ValueRestriction.typeName = "kuksa.val.v1.ValueRestriction"; +ValueRestriction.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 21, name: "string", kind: "message", T: ValueRestrictionString, oneof: "type" }, + { no: 22, name: "signed", kind: "message", T: ValueRestrictionInt, oneof: "type" }, + { no: 23, name: "unsigned", kind: "message", T: ValueRestrictionUint, oneof: "type" }, + { no: 24, name: "floating_point", kind: "message", T: ValueRestrictionFloat, oneof: "type" }, +]); +/** + * @generated from message kuksa.val.v1.ValueRestrictionInt + */ +class ValueRestrictionInt extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated sint64 allowed_values = 3; + */ + this.allowedValues = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new ValueRestrictionInt().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new ValueRestrictionInt().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new ValueRestrictionInt().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(ValueRestrictionInt, a, b); + } +} +exports.ValueRestrictionInt = ValueRestrictionInt; +ValueRestrictionInt.runtime = protobuf_1.proto3; +ValueRestrictionInt.typeName = "kuksa.val.v1.ValueRestrictionInt"; +ValueRestrictionInt.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "min", kind: "scalar", T: 18 /* ScalarType.SINT64 */, opt: true }, + { no: 2, name: "max", kind: "scalar", T: 18 /* ScalarType.SINT64 */, opt: true }, + { no: 3, name: "allowed_values", kind: "scalar", T: 18 /* ScalarType.SINT64 */, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.ValueRestrictionUint + */ +class ValueRestrictionUint extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated uint64 allowed_values = 3; + */ + this.allowedValues = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new ValueRestrictionUint().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new ValueRestrictionUint().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new ValueRestrictionUint().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(ValueRestrictionUint, a, b); + } +} +exports.ValueRestrictionUint = ValueRestrictionUint; +ValueRestrictionUint.runtime = protobuf_1.proto3; +ValueRestrictionUint.typeName = "kuksa.val.v1.ValueRestrictionUint"; +ValueRestrictionUint.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "min", kind: "scalar", T: 4 /* ScalarType.UINT64 */, opt: true }, + { no: 2, name: "max", kind: "scalar", T: 4 /* ScalarType.UINT64 */, opt: true }, + { no: 3, name: "allowed_values", kind: "scalar", T: 4 /* ScalarType.UINT64 */, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.ValueRestrictionFloat + */ +class ValueRestrictionFloat extends protobuf_1.Message { + constructor(data) { + super(); + /** + * allowed for doubles/floats not recommended + * + * @generated from field: repeated double allowed_values = 3; + */ + this.allowedValues = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new ValueRestrictionFloat().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new ValueRestrictionFloat().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new ValueRestrictionFloat().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(ValueRestrictionFloat, a, b); + } +} +exports.ValueRestrictionFloat = ValueRestrictionFloat; +ValueRestrictionFloat.runtime = protobuf_1.proto3; +ValueRestrictionFloat.typeName = "kuksa.val.v1.ValueRestrictionFloat"; +ValueRestrictionFloat.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "min", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true }, + { no: 2, name: "max", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true }, + { no: 3, name: "allowed_values", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, repeated: true }, +]); +/** + * min, max doesn't make much sense for a string + * + * @generated from message kuksa.val.v1.ValueRestrictionString + */ +class ValueRestrictionString extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated string allowed_values = 3; + */ + this.allowedValues = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new ValueRestrictionString().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new ValueRestrictionString().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new ValueRestrictionString().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(ValueRestrictionString, a, b); + } +} +exports.ValueRestrictionString = ValueRestrictionString; +ValueRestrictionString.runtime = protobuf_1.proto3; +ValueRestrictionString.typeName = "kuksa.val.v1.ValueRestrictionString"; +ValueRestrictionString.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 3, name: "allowed_values", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, +]); +/** + * Error response shall be an HTTP-like code. + * Should follow https://www.w3.org/TR/viss2-transport/#status-codes. + * + * @generated from message kuksa.val.v1.Error + */ +class Error extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: uint32 code = 1; + */ + this.code = 0; + /** + * @generated from field: string reason = 2; + */ + this.reason = ""; + /** + * @generated from field: string message = 3; + */ + this.message = ""; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new Error().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new Error().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new Error().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(Error, a, b); + } +} +exports.Error = Error; +Error.runtime = protobuf_1.proto3; +Error.typeName = "kuksa.val.v1.Error"; +Error.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "code", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 2, name: "reason", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "message", kind: "scalar", T: 9 /* ScalarType.STRING */ }, +]); +/** + * Used in get/set requests to report errors for specific entries + * + * @generated from message kuksa.val.v1.DataEntryError + */ +class DataEntryError extends protobuf_1.Message { + constructor(data) { + super(); + /** + * vss path + * + * @generated from field: string path = 1; + */ + this.path = ""; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new DataEntryError().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new DataEntryError().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new DataEntryError().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(DataEntryError, a, b); + } +} +exports.DataEntryError = DataEntryError; +DataEntryError.runtime = protobuf_1.proto3; +DataEntryError.typeName = "kuksa.val.v1.DataEntryError"; +DataEntryError.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "error", kind: "message", T: Error }, +]); +/** + * @generated from message kuksa.val.v1.StringArray + */ +class StringArray extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated string values = 1; + */ + this.values = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new StringArray().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new StringArray().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new StringArray().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(StringArray, a, b); + } +} +exports.StringArray = StringArray; +StringArray.runtime = protobuf_1.proto3; +StringArray.typeName = "kuksa.val.v1.StringArray"; +StringArray.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.BoolArray + */ +class BoolArray extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated bool values = 1; + */ + this.values = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new BoolArray().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new BoolArray().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new BoolArray().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(BoolArray, a, b); + } +} +exports.BoolArray = BoolArray; +BoolArray.runtime = protobuf_1.proto3; +BoolArray.typeName = "kuksa.val.v1.BoolArray"; +BoolArray.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 8 /* ScalarType.BOOL */, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.Int32Array + */ +class Int32Array extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated sint32 values = 1; + */ + this.values = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new Int32Array().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new Int32Array().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new Int32Array().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(Int32Array, a, b); + } +} +exports.Int32Array = Int32Array; +Int32Array.runtime = protobuf_1.proto3; +Int32Array.typeName = "kuksa.val.v1.Int32Array"; +Int32Array.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 17 /* ScalarType.SINT32 */, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.Int64Array + */ +class Int64Array extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated sint64 values = 1; + */ + this.values = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new Int64Array().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new Int64Array().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new Int64Array().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(Int64Array, a, b); + } +} +exports.Int64Array = Int64Array; +Int64Array.runtime = protobuf_1.proto3; +Int64Array.typeName = "kuksa.val.v1.Int64Array"; +Int64Array.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 18 /* ScalarType.SINT64 */, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.Uint32Array + */ +class Uint32Array extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated uint32 values = 1; + */ + this.values = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new Uint32Array().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new Uint32Array().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new Uint32Array().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(Uint32Array, a, b); + } +} +exports.Uint32Array = Uint32Array; +Uint32Array.runtime = protobuf_1.proto3; +Uint32Array.typeName = "kuksa.val.v1.Uint32Array"; +Uint32Array.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 13 /* ScalarType.UINT32 */, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.Uint64Array + */ +class Uint64Array extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated uint64 values = 1; + */ + this.values = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new Uint64Array().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new Uint64Array().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new Uint64Array().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(Uint64Array, a, b); + } +} +exports.Uint64Array = Uint64Array; +Uint64Array.runtime = protobuf_1.proto3; +Uint64Array.typeName = "kuksa.val.v1.Uint64Array"; +Uint64Array.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 4 /* ScalarType.UINT64 */, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.FloatArray + */ +class FloatArray extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated float values = 1; + */ + this.values = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new FloatArray().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new FloatArray().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new FloatArray().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(FloatArray, a, b); + } +} +exports.FloatArray = FloatArray; +FloatArray.runtime = protobuf_1.proto3; +FloatArray.typeName = "kuksa.val.v1.FloatArray"; +FloatArray.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 2 /* ScalarType.FLOAT */, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.DoubleArray + */ +class DoubleArray extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated double values = 1; + */ + this.values = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new DoubleArray().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new DoubleArray().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new DoubleArray().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(DoubleArray, a, b); + } +} +exports.DoubleArray = DoubleArray; +DoubleArray.runtime = protobuf_1.proto3; +DoubleArray.typeName = "kuksa.val.v1.DoubleArray"; +DoubleArray.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, repeated: true }, +]); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types_pb.js","sourceRoot":"","sources":["types_pb.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/types_pb.ts b/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/types_pb.ts new file mode 100644 index 00000000..d3a30e3b --- /dev/null +++ b/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/types_pb.ts @@ -0,0 +1,1572 @@ +//******************************************************************************* +// Copyright (c) 2022 Contributors to the Eclipse Foundation +// +// See the NOTICE file(s) distributed with this work for additional +// information regarding copyright ownership. +// +// This program and the accompanying materials are made available under the +// terms of the Apache License 2.0 which is available at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// SPDX-License-Identifier: Apache-2.0 +//****************************************************************************** + +// @generated by protoc-gen-es v1.10.0 with parameter "target=ts" +// @generated from file kuksa/val/v1/types.proto (package kuksa.val.v1, syntax proto3) +/* eslint-disable */ +// @ts-nocheck + +// I added V1 as in databroker. Is this good practice? + +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Message, proto3, Timestamp } from "@bufbuild/protobuf"; + +/** + * VSS Data type of a signal + * + * Protobuf doesn't support int8, int16, uint8 or uint16. + * These are mapped to int32 and uint32 respectively. + * + * + * @generated from enum kuksa.val.v1.DataType + */ +export enum DataType { + /** + * @generated from enum value: DATA_TYPE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: DATA_TYPE_STRING = 1; + */ + STRING = 1, + + /** + * @generated from enum value: DATA_TYPE_BOOLEAN = 2; + */ + BOOLEAN = 2, + + /** + * @generated from enum value: DATA_TYPE_INT8 = 3; + */ + INT8 = 3, + + /** + * @generated from enum value: DATA_TYPE_INT16 = 4; + */ + INT16 = 4, + + /** + * @generated from enum value: DATA_TYPE_INT32 = 5; + */ + INT32 = 5, + + /** + * @generated from enum value: DATA_TYPE_INT64 = 6; + */ + INT64 = 6, + + /** + * @generated from enum value: DATA_TYPE_UINT8 = 7; + */ + UINT8 = 7, + + /** + * @generated from enum value: DATA_TYPE_UINT16 = 8; + */ + UINT16 = 8, + + /** + * @generated from enum value: DATA_TYPE_UINT32 = 9; + */ + UINT32 = 9, + + /** + * @generated from enum value: DATA_TYPE_UINT64 = 10; + */ + UINT64 = 10, + + /** + * @generated from enum value: DATA_TYPE_FLOAT = 11; + */ + FLOAT = 11, + + /** + * @generated from enum value: DATA_TYPE_DOUBLE = 12; + */ + DOUBLE = 12, + + /** + * @generated from enum value: DATA_TYPE_TIMESTAMP = 13; + */ + TIMESTAMP = 13, + + /** + * @generated from enum value: DATA_TYPE_STRING_ARRAY = 20; + */ + STRING_ARRAY = 20, + + /** + * @generated from enum value: DATA_TYPE_BOOLEAN_ARRAY = 21; + */ + BOOLEAN_ARRAY = 21, + + /** + * @generated from enum value: DATA_TYPE_INT8_ARRAY = 22; + */ + INT8_ARRAY = 22, + + /** + * @generated from enum value: DATA_TYPE_INT16_ARRAY = 23; + */ + INT16_ARRAY = 23, + + /** + * @generated from enum value: DATA_TYPE_INT32_ARRAY = 24; + */ + INT32_ARRAY = 24, + + /** + * @generated from enum value: DATA_TYPE_INT64_ARRAY = 25; + */ + INT64_ARRAY = 25, + + /** + * @generated from enum value: DATA_TYPE_UINT8_ARRAY = 26; + */ + UINT8_ARRAY = 26, + + /** + * @generated from enum value: DATA_TYPE_UINT16_ARRAY = 27; + */ + UINT16_ARRAY = 27, + + /** + * @generated from enum value: DATA_TYPE_UINT32_ARRAY = 28; + */ + UINT32_ARRAY = 28, + + /** + * @generated from enum value: DATA_TYPE_UINT64_ARRAY = 29; + */ + UINT64_ARRAY = 29, + + /** + * @generated from enum value: DATA_TYPE_FLOAT_ARRAY = 30; + */ + FLOAT_ARRAY = 30, + + /** + * @generated from enum value: DATA_TYPE_DOUBLE_ARRAY = 31; + */ + DOUBLE_ARRAY = 31, + + /** + * @generated from enum value: DATA_TYPE_TIMESTAMP_ARRAY = 32; + */ + TIMESTAMP_ARRAY = 32, +} +// Retrieve enum metadata with: proto3.getEnumType(DataType) +proto3.util.setEnumType(DataType, "kuksa.val.v1.DataType", [ + { no: 0, name: "DATA_TYPE_UNSPECIFIED" }, + { no: 1, name: "DATA_TYPE_STRING" }, + { no: 2, name: "DATA_TYPE_BOOLEAN" }, + { no: 3, name: "DATA_TYPE_INT8" }, + { no: 4, name: "DATA_TYPE_INT16" }, + { no: 5, name: "DATA_TYPE_INT32" }, + { no: 6, name: "DATA_TYPE_INT64" }, + { no: 7, name: "DATA_TYPE_UINT8" }, + { no: 8, name: "DATA_TYPE_UINT16" }, + { no: 9, name: "DATA_TYPE_UINT32" }, + { no: 10, name: "DATA_TYPE_UINT64" }, + { no: 11, name: "DATA_TYPE_FLOAT" }, + { no: 12, name: "DATA_TYPE_DOUBLE" }, + { no: 13, name: "DATA_TYPE_TIMESTAMP" }, + { no: 20, name: "DATA_TYPE_STRING_ARRAY" }, + { no: 21, name: "DATA_TYPE_BOOLEAN_ARRAY" }, + { no: 22, name: "DATA_TYPE_INT8_ARRAY" }, + { no: 23, name: "DATA_TYPE_INT16_ARRAY" }, + { no: 24, name: "DATA_TYPE_INT32_ARRAY" }, + { no: 25, name: "DATA_TYPE_INT64_ARRAY" }, + { no: 26, name: "DATA_TYPE_UINT8_ARRAY" }, + { no: 27, name: "DATA_TYPE_UINT16_ARRAY" }, + { no: 28, name: "DATA_TYPE_UINT32_ARRAY" }, + { no: 29, name: "DATA_TYPE_UINT64_ARRAY" }, + { no: 30, name: "DATA_TYPE_FLOAT_ARRAY" }, + { no: 31, name: "DATA_TYPE_DOUBLE_ARRAY" }, + { no: 32, name: "DATA_TYPE_TIMESTAMP_ARRAY" }, +]); + +/** + * Entry type + * + * @generated from enum kuksa.val.v1.EntryType + */ +export enum EntryType { + /** + * @generated from enum value: ENTRY_TYPE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: ENTRY_TYPE_ATTRIBUTE = 1; + */ + ATTRIBUTE = 1, + + /** + * @generated from enum value: ENTRY_TYPE_SENSOR = 2; + */ + SENSOR = 2, + + /** + * @generated from enum value: ENTRY_TYPE_ACTUATOR = 3; + */ + ACTUATOR = 3, +} +// Retrieve enum metadata with: proto3.getEnumType(EntryType) +proto3.util.setEnumType(EntryType, "kuksa.val.v1.EntryType", [ + { no: 0, name: "ENTRY_TYPE_UNSPECIFIED" }, + { no: 1, name: "ENTRY_TYPE_ATTRIBUTE" }, + { no: 2, name: "ENTRY_TYPE_SENSOR" }, + { no: 3, name: "ENTRY_TYPE_ACTUATOR" }, +]); + +/** + * A `View` specifies a set of fields which should + * be populated in a `DataEntry` (in a response message) + * + * @generated from enum kuksa.val.v1.View + */ +export enum View { + /** + * Unspecified. Equivalent to VIEW_CURRENT_VALUE unless `fields` are explicitly set. + * + * @generated from enum value: VIEW_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * Populate DataEntry with value. + * + * @generated from enum value: VIEW_CURRENT_VALUE = 1; + */ + CURRENT_VALUE = 1, + + /** + * Populate DataEntry with actuator target. + * + * @generated from enum value: VIEW_TARGET_VALUE = 2; + */ + TARGET_VALUE = 2, + + /** + * Populate DataEntry with metadata. + * + * @generated from enum value: VIEW_METADATA = 3; + */ + METADATA = 3, + + /** + * Populate DataEntry only with requested fields. + * + * @generated from enum value: VIEW_FIELDS = 10; + */ + FIELDS = 10, + + /** + * Populate DataEntry with everything. + * + * @generated from enum value: VIEW_ALL = 20; + */ + ALL = 20, +} +// Retrieve enum metadata with: proto3.getEnumType(View) +proto3.util.setEnumType(View, "kuksa.val.v1.View", [ + { no: 0, name: "VIEW_UNSPECIFIED" }, + { no: 1, name: "VIEW_CURRENT_VALUE" }, + { no: 2, name: "VIEW_TARGET_VALUE" }, + { no: 3, name: "VIEW_METADATA" }, + { no: 10, name: "VIEW_FIELDS" }, + { no: 20, name: "VIEW_ALL" }, +]); + +/** + * A `Field` corresponds to a specific field of a `DataEntry`. + * + * It can be used to: + * * populate only specific fields of a `DataEntry` response. + * * specify which fields of a `DataEntry` should be set as + * part of a `Set` request. + * * subscribe to only specific fields of a data entry. + * * convey which fields of an updated `DataEntry` have changed. + * + * @generated from enum kuksa.val.v1.Field + */ +export enum Field { + /** + * "*" i.e. everything + * + * @generated from enum value: FIELD_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * path + * + * @generated from enum value: FIELD_PATH = 1; + */ + PATH = 1, + + /** + * value + * + * @generated from enum value: FIELD_VALUE = 2; + */ + VALUE = 2, + + /** + * actuator_target + * + * @generated from enum value: FIELD_ACTUATOR_TARGET = 3; + */ + ACTUATOR_TARGET = 3, + + /** + * metadata.* + * + * @generated from enum value: FIELD_METADATA = 10; + */ + METADATA = 10, + + /** + * metadata.data_type + * + * @generated from enum value: FIELD_METADATA_DATA_TYPE = 11; + */ + METADATA_DATA_TYPE = 11, + + /** + * metadata.description + * + * @generated from enum value: FIELD_METADATA_DESCRIPTION = 12; + */ + METADATA_DESCRIPTION = 12, + + /** + * metadata.entry_type + * + * @generated from enum value: FIELD_METADATA_ENTRY_TYPE = 13; + */ + METADATA_ENTRY_TYPE = 13, + + /** + * metadata.comment + * + * @generated from enum value: FIELD_METADATA_COMMENT = 14; + */ + METADATA_COMMENT = 14, + + /** + * metadata.deprecation + * + * @generated from enum value: FIELD_METADATA_DEPRECATION = 15; + */ + METADATA_DEPRECATION = 15, + + /** + * metadata.unit + * + * @generated from enum value: FIELD_METADATA_UNIT = 16; + */ + METADATA_UNIT = 16, + + /** + * metadata.value_restriction.* + * + * @generated from enum value: FIELD_METADATA_VALUE_RESTRICTION = 17; + */ + METADATA_VALUE_RESTRICTION = 17, + + /** + * metadata.actuator.* + * + * @generated from enum value: FIELD_METADATA_ACTUATOR = 20; + */ + METADATA_ACTUATOR = 20, + + /** + * metadata.sensor.* + * + * @generated from enum value: FIELD_METADATA_SENSOR = 30; + */ + METADATA_SENSOR = 30, + + /** + * metadata.attribute.* + * + * @generated from enum value: FIELD_METADATA_ATTRIBUTE = 40; + */ + METADATA_ATTRIBUTE = 40, +} +// Retrieve enum metadata with: proto3.getEnumType(Field) +proto3.util.setEnumType(Field, "kuksa.val.v1.Field", [ + { no: 0, name: "FIELD_UNSPECIFIED" }, + { no: 1, name: "FIELD_PATH" }, + { no: 2, name: "FIELD_VALUE" }, + { no: 3, name: "FIELD_ACTUATOR_TARGET" }, + { no: 10, name: "FIELD_METADATA" }, + { no: 11, name: "FIELD_METADATA_DATA_TYPE" }, + { no: 12, name: "FIELD_METADATA_DESCRIPTION" }, + { no: 13, name: "FIELD_METADATA_ENTRY_TYPE" }, + { no: 14, name: "FIELD_METADATA_COMMENT" }, + { no: 15, name: "FIELD_METADATA_DEPRECATION" }, + { no: 16, name: "FIELD_METADATA_UNIT" }, + { no: 17, name: "FIELD_METADATA_VALUE_RESTRICTION" }, + { no: 20, name: "FIELD_METADATA_ACTUATOR" }, + { no: 30, name: "FIELD_METADATA_SENSOR" }, + { no: 40, name: "FIELD_METADATA_ATTRIBUTE" }, +]); + +/** + * Describes a VSS entry + * When requesting an entry, the amount of information returned can + * be controlled by specifying either a `View` or a set of `Field`s. + * + * @generated from message kuksa.val.v1.DataEntry + */ +export class DataEntry extends Message { + /** + * Defines the full VSS path of the entry. + * + * [field: FIELD_PATH] + * + * @generated from field: string path = 1; + */ + path = ""; + + /** + * The value (datapoint) + * + * [field: FIELD_VALUE] + * + * @generated from field: kuksa.val.v1.Datapoint value = 2; + */ + value?: Datapoint; + + /** + * Actuator target (only used if the entry is an actuator) + * + * [field: FIELD_ACTUATOR_TARGET] + * + * @generated from field: kuksa.val.v1.Datapoint actuator_target = 3; + */ + actuatorTarget?: Datapoint; + + /** + * Metadata for this entry + * + * [field: FIELD_METADATA] + * + * @generated from field: kuksa.val.v1.Metadata metadata = 10; + */ + metadata?: Metadata; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.DataEntry"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "value", kind: "message", T: Datapoint }, + { no: 3, name: "actuator_target", kind: "message", T: Datapoint }, + { no: 10, name: "metadata", kind: "message", T: Metadata }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): DataEntry { + return new DataEntry().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): DataEntry { + return new DataEntry().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): DataEntry { + return new DataEntry().fromJsonString(jsonString, options); + } + + static equals(a: DataEntry | PlainMessage | undefined, b: DataEntry | PlainMessage | undefined): boolean { + return proto3.util.equals(DataEntry, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.Datapoint + */ +export class Datapoint extends Message { + /** + * @generated from field: google.protobuf.Timestamp timestamp = 1; + */ + timestamp?: Timestamp; + + /** + * @generated from oneof kuksa.val.v1.Datapoint.value + */ + value: { + /** + * @generated from field: string string = 11; + */ + value: string; + case: "string"; + } | { + /** + * @generated from field: bool bool = 12; + */ + value: boolean; + case: "bool"; + } | { + /** + * @generated from field: sint32 int32 = 13; + */ + value: number; + case: "int32"; + } | { + /** + * @generated from field: sint64 int64 = 14; + */ + value: bigint; + case: "int64"; + } | { + /** + * @generated from field: uint32 uint32 = 15; + */ + value: number; + case: "uint32"; + } | { + /** + * @generated from field: uint64 uint64 = 16; + */ + value: bigint; + case: "uint64"; + } | { + /** + * @generated from field: float float = 17; + */ + value: number; + case: "float"; + } | { + /** + * @generated from field: double double = 18; + */ + value: number; + case: "double"; + } | { + /** + * @generated from field: kuksa.val.v1.StringArray string_array = 21; + */ + value: StringArray; + case: "stringArray"; + } | { + /** + * @generated from field: kuksa.val.v1.BoolArray bool_array = 22; + */ + value: BoolArray; + case: "boolArray"; + } | { + /** + * @generated from field: kuksa.val.v1.Int32Array int32_array = 23; + */ + value: Int32Array; + case: "int32Array"; + } | { + /** + * @generated from field: kuksa.val.v1.Int64Array int64_array = 24; + */ + value: Int64Array; + case: "int64Array"; + } | { + /** + * @generated from field: kuksa.val.v1.Uint32Array uint32_array = 25; + */ + value: Uint32Array; + case: "uint32Array"; + } | { + /** + * @generated from field: kuksa.val.v1.Uint64Array uint64_array = 26; + */ + value: Uint64Array; + case: "uint64Array"; + } | { + /** + * @generated from field: kuksa.val.v1.FloatArray float_array = 27; + */ + value: FloatArray; + case: "floatArray"; + } | { + /** + * @generated from field: kuksa.val.v1.DoubleArray double_array = 28; + */ + value: DoubleArray; + case: "doubleArray"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.Datapoint"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "timestamp", kind: "message", T: Timestamp }, + { no: 11, name: "string", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "value" }, + { no: 12, name: "bool", kind: "scalar", T: 8 /* ScalarType.BOOL */, oneof: "value" }, + { no: 13, name: "int32", kind: "scalar", T: 17 /* ScalarType.SINT32 */, oneof: "value" }, + { no: 14, name: "int64", kind: "scalar", T: 18 /* ScalarType.SINT64 */, oneof: "value" }, + { no: 15, name: "uint32", kind: "scalar", T: 13 /* ScalarType.UINT32 */, oneof: "value" }, + { no: 16, name: "uint64", kind: "scalar", T: 4 /* ScalarType.UINT64 */, oneof: "value" }, + { no: 17, name: "float", kind: "scalar", T: 2 /* ScalarType.FLOAT */, oneof: "value" }, + { no: 18, name: "double", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, oneof: "value" }, + { no: 21, name: "string_array", kind: "message", T: StringArray, oneof: "value" }, + { no: 22, name: "bool_array", kind: "message", T: BoolArray, oneof: "value" }, + { no: 23, name: "int32_array", kind: "message", T: Int32Array, oneof: "value" }, + { no: 24, name: "int64_array", kind: "message", T: Int64Array, oneof: "value" }, + { no: 25, name: "uint32_array", kind: "message", T: Uint32Array, oneof: "value" }, + { no: 26, name: "uint64_array", kind: "message", T: Uint64Array, oneof: "value" }, + { no: 27, name: "float_array", kind: "message", T: FloatArray, oneof: "value" }, + { no: 28, name: "double_array", kind: "message", T: DoubleArray, oneof: "value" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Datapoint { + return new Datapoint().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Datapoint { + return new Datapoint().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Datapoint { + return new Datapoint().fromJsonString(jsonString, options); + } + + static equals(a: Datapoint | PlainMessage | undefined, b: Datapoint | PlainMessage | undefined): boolean { + return proto3.util.equals(Datapoint, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.Metadata + */ +export class Metadata extends Message { + /** + * Data type + * The VSS data type of the entry (i.e. the value, min, max etc). + * + * NOTE: protobuf doesn't have int8, int16, uint8 or uint16 which means + * that these values must be serialized as int32 and uint32 respectively. + * + * [field: FIELD_METADATA_DATA_TYPE] + * + * @generated from field: kuksa.val.v1.DataType data_type = 11; + */ + dataType = DataType.UNSPECIFIED; + + /** + * Entry type + * + * [field: FIELD_METADATA_ENTRY_TYPE] + * + * @generated from field: kuksa.val.v1.EntryType entry_type = 12; + */ + entryType = EntryType.UNSPECIFIED; + + /** + * Description + * Describes the meaning and content of the entry. + * + * [field: FIELD_METADATA_DESCRIPTION] + * + * @generated from field: optional string description = 13; + */ + description?: string; + + /** + * Comment [optional] + * A comment can be used to provide additional informal information + * on a entry. + * + * [field: FIELD_METADATA_COMMENT] + * + * @generated from field: optional string comment = 14; + */ + comment?: string; + + /** + * Deprecation [optional] + * Whether this entry is deprecated. Can contain recommendations of what + * to use instead. + * + * [field: FIELD_METADATA_DEPRECATION] + * + * @generated from field: optional string deprecation = 15; + */ + deprecation?: string; + + /** + * Unit [optional] + * The unit of measurement + * + * [field: FIELD_METADATA_UNIT] + * + * @generated from field: optional string unit = 16; + */ + unit?: string; + + /** + * Value restrictions [optional] + * Restrict which values are allowed. + * Only restrictions matching the DataType {datatype} above are valid. + * + * [field: FIELD_METADATA_VALUE_RESTRICTION] + * + * @generated from field: kuksa.val.v1.ValueRestriction value_restriction = 17; + */ + valueRestriction?: ValueRestriction; + + /** + * Entry type specific metadata + * + * @generated from oneof kuksa.val.v1.Metadata.entry_specific + */ + entrySpecific: { + /** + * [field: FIELD_METADATA_ACTUATOR] + * + * @generated from field: kuksa.val.v1.Actuator actuator = 20; + */ + value: Actuator; + case: "actuator"; + } | { + /** + * [field: FIELD_METADATA_SENSOR] + * + * @generated from field: kuksa.val.v1.Sensor sensor = 30; + */ + value: Sensor; + case: "sensor"; + } | { + /** + * [field: FIELD_METADATA_ATTRIBUTE] + * + * @generated from field: kuksa.val.v1.Attribute attribute = 40; + */ + value: Attribute; + case: "attribute"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.Metadata"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 11, name: "data_type", kind: "enum", T: proto3.getEnumType(DataType) }, + { no: 12, name: "entry_type", kind: "enum", T: proto3.getEnumType(EntryType) }, + { no: 13, name: "description", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 14, name: "comment", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 15, name: "deprecation", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 16, name: "unit", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 17, name: "value_restriction", kind: "message", T: ValueRestriction }, + { no: 20, name: "actuator", kind: "message", T: Actuator, oneof: "entry_specific" }, + { no: 30, name: "sensor", kind: "message", T: Sensor, oneof: "entry_specific" }, + { no: 40, name: "attribute", kind: "message", T: Attribute, oneof: "entry_specific" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Metadata { + return new Metadata().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Metadata { + return new Metadata().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Metadata { + return new Metadata().fromJsonString(jsonString, options); + } + + static equals(a: Metadata | PlainMessage | undefined, b: Metadata | PlainMessage | undefined): boolean { + return proto3.util.equals(Metadata, a, b); + } +} + +/** + * ///////////////////// + * Actuator specific fields + * + * Nothing for now + * + * @generated from message kuksa.val.v1.Actuator + */ +export class Actuator extends Message { + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.Actuator"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Actuator { + return new Actuator().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Actuator { + return new Actuator().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Actuator { + return new Actuator().fromJsonString(jsonString, options); + } + + static equals(a: Actuator | PlainMessage | undefined, b: Actuator | PlainMessage | undefined): boolean { + return proto3.util.equals(Actuator, a, b); + } +} + +/** + * ////////////////////// + * Sensor specific + * + * Nothing for now + * + * @generated from message kuksa.val.v1.Sensor + */ +export class Sensor extends Message { + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.Sensor"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Sensor { + return new Sensor().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Sensor { + return new Sensor().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Sensor { + return new Sensor().fromJsonString(jsonString, options); + } + + static equals(a: Sensor | PlainMessage | undefined, b: Sensor | PlainMessage | undefined): boolean { + return proto3.util.equals(Sensor, a, b); + } +} + +/** + * ////////////////////// + * Attribute specific + * + * Nothing for now. + * + * @generated from message kuksa.val.v1.Attribute + */ +export class Attribute extends Message { + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.Attribute"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Attribute { + return new Attribute().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Attribute { + return new Attribute().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Attribute { + return new Attribute().fromJsonString(jsonString, options); + } + + static equals(a: Attribute | PlainMessage | undefined, b: Attribute | PlainMessage | undefined): boolean { + return proto3.util.equals(Attribute, a, b); + } +} + +/** + * Value restriction + * + * One ValueRestriction{type} for each type, since + * they don't make sense unless the types match + * + * + * @generated from message kuksa.val.v1.ValueRestriction + */ +export class ValueRestriction extends Message { + /** + * @generated from oneof kuksa.val.v1.ValueRestriction.type + */ + type: { + /** + * @generated from field: kuksa.val.v1.ValueRestrictionString string = 21; + */ + value: ValueRestrictionString; + case: "string"; + } | { + /** + * For signed VSS integers + * + * @generated from field: kuksa.val.v1.ValueRestrictionInt signed = 22; + */ + value: ValueRestrictionInt; + case: "signed"; + } | { + /** + * For unsigned VSS integers + * + * @generated from field: kuksa.val.v1.ValueRestrictionUint unsigned = 23; + */ + value: ValueRestrictionUint; + case: "unsigned"; + } | { + /** + * For floating point VSS values (float and double) + * + * @generated from field: kuksa.val.v1.ValueRestrictionFloat floating_point = 24; + */ + value: ValueRestrictionFloat; + case: "floatingPoint"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.ValueRestriction"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 21, name: "string", kind: "message", T: ValueRestrictionString, oneof: "type" }, + { no: 22, name: "signed", kind: "message", T: ValueRestrictionInt, oneof: "type" }, + { no: 23, name: "unsigned", kind: "message", T: ValueRestrictionUint, oneof: "type" }, + { no: 24, name: "floating_point", kind: "message", T: ValueRestrictionFloat, oneof: "type" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ValueRestriction { + return new ValueRestriction().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ValueRestriction { + return new ValueRestriction().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ValueRestriction { + return new ValueRestriction().fromJsonString(jsonString, options); + } + + static equals(a: ValueRestriction | PlainMessage | undefined, b: ValueRestriction | PlainMessage | undefined): boolean { + return proto3.util.equals(ValueRestriction, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.ValueRestrictionInt + */ +export class ValueRestrictionInt extends Message { + /** + * @generated from field: optional sint64 min = 1; + */ + min?: bigint; + + /** + * @generated from field: optional sint64 max = 2; + */ + max?: bigint; + + /** + * @generated from field: repeated sint64 allowed_values = 3; + */ + allowedValues: bigint[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.ValueRestrictionInt"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "min", kind: "scalar", T: 18 /* ScalarType.SINT64 */, opt: true }, + { no: 2, name: "max", kind: "scalar", T: 18 /* ScalarType.SINT64 */, opt: true }, + { no: 3, name: "allowed_values", kind: "scalar", T: 18 /* ScalarType.SINT64 */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ValueRestrictionInt { + return new ValueRestrictionInt().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ValueRestrictionInt { + return new ValueRestrictionInt().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ValueRestrictionInt { + return new ValueRestrictionInt().fromJsonString(jsonString, options); + } + + static equals(a: ValueRestrictionInt | PlainMessage | undefined, b: ValueRestrictionInt | PlainMessage | undefined): boolean { + return proto3.util.equals(ValueRestrictionInt, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.ValueRestrictionUint + */ +export class ValueRestrictionUint extends Message { + /** + * @generated from field: optional uint64 min = 1; + */ + min?: bigint; + + /** + * @generated from field: optional uint64 max = 2; + */ + max?: bigint; + + /** + * @generated from field: repeated uint64 allowed_values = 3; + */ + allowedValues: bigint[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.ValueRestrictionUint"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "min", kind: "scalar", T: 4 /* ScalarType.UINT64 */, opt: true }, + { no: 2, name: "max", kind: "scalar", T: 4 /* ScalarType.UINT64 */, opt: true }, + { no: 3, name: "allowed_values", kind: "scalar", T: 4 /* ScalarType.UINT64 */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ValueRestrictionUint { + return new ValueRestrictionUint().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ValueRestrictionUint { + return new ValueRestrictionUint().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ValueRestrictionUint { + return new ValueRestrictionUint().fromJsonString(jsonString, options); + } + + static equals(a: ValueRestrictionUint | PlainMessage | undefined, b: ValueRestrictionUint | PlainMessage | undefined): boolean { + return proto3.util.equals(ValueRestrictionUint, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.ValueRestrictionFloat + */ +export class ValueRestrictionFloat extends Message { + /** + * @generated from field: optional double min = 1; + */ + min?: number; + + /** + * @generated from field: optional double max = 2; + */ + max?: number; + + /** + * allowed for doubles/floats not recommended + * + * @generated from field: repeated double allowed_values = 3; + */ + allowedValues: number[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.ValueRestrictionFloat"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "min", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true }, + { no: 2, name: "max", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true }, + { no: 3, name: "allowed_values", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ValueRestrictionFloat { + return new ValueRestrictionFloat().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ValueRestrictionFloat { + return new ValueRestrictionFloat().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ValueRestrictionFloat { + return new ValueRestrictionFloat().fromJsonString(jsonString, options); + } + + static equals(a: ValueRestrictionFloat | PlainMessage | undefined, b: ValueRestrictionFloat | PlainMessage | undefined): boolean { + return proto3.util.equals(ValueRestrictionFloat, a, b); + } +} + +/** + * min, max doesn't make much sense for a string + * + * @generated from message kuksa.val.v1.ValueRestrictionString + */ +export class ValueRestrictionString extends Message { + /** + * @generated from field: repeated string allowed_values = 3; + */ + allowedValues: string[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.ValueRestrictionString"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 3, name: "allowed_values", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ValueRestrictionString { + return new ValueRestrictionString().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ValueRestrictionString { + return new ValueRestrictionString().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ValueRestrictionString { + return new ValueRestrictionString().fromJsonString(jsonString, options); + } + + static equals(a: ValueRestrictionString | PlainMessage | undefined, b: ValueRestrictionString | PlainMessage | undefined): boolean { + return proto3.util.equals(ValueRestrictionString, a, b); + } +} + +/** + * Error response shall be an HTTP-like code. + * Should follow https://www.w3.org/TR/viss2-transport/#status-codes. + * + * @generated from message kuksa.val.v1.Error + */ +export class Error extends Message { + /** + * @generated from field: uint32 code = 1; + */ + code = 0; + + /** + * @generated from field: string reason = 2; + */ + reason = ""; + + /** + * @generated from field: string message = 3; + */ + message = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.Error"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "code", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 2, name: "reason", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "message", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Error { + return new Error().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Error { + return new Error().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Error { + return new Error().fromJsonString(jsonString, options); + } + + static equals(a: Error | PlainMessage | undefined, b: Error | PlainMessage | undefined): boolean { + return proto3.util.equals(Error, a, b); + } +} + +/** + * Used in get/set requests to report errors for specific entries + * + * @generated from message kuksa.val.v1.DataEntryError + */ +export class DataEntryError extends Message { + /** + * vss path + * + * @generated from field: string path = 1; + */ + path = ""; + + /** + * @generated from field: kuksa.val.v1.Error error = 2; + */ + error?: Error; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.DataEntryError"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "error", kind: "message", T: Error }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): DataEntryError { + return new DataEntryError().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): DataEntryError { + return new DataEntryError().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): DataEntryError { + return new DataEntryError().fromJsonString(jsonString, options); + } + + static equals(a: DataEntryError | PlainMessage | undefined, b: DataEntryError | PlainMessage | undefined): boolean { + return proto3.util.equals(DataEntryError, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.StringArray + */ +export class StringArray extends Message { + /** + * @generated from field: repeated string values = 1; + */ + values: string[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.StringArray"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): StringArray { + return new StringArray().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): StringArray { + return new StringArray().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): StringArray { + return new StringArray().fromJsonString(jsonString, options); + } + + static equals(a: StringArray | PlainMessage | undefined, b: StringArray | PlainMessage | undefined): boolean { + return proto3.util.equals(StringArray, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.BoolArray + */ +export class BoolArray extends Message { + /** + * @generated from field: repeated bool values = 1; + */ + values: boolean[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.BoolArray"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 8 /* ScalarType.BOOL */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): BoolArray { + return new BoolArray().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): BoolArray { + return new BoolArray().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): BoolArray { + return new BoolArray().fromJsonString(jsonString, options); + } + + static equals(a: BoolArray | PlainMessage | undefined, b: BoolArray | PlainMessage | undefined): boolean { + return proto3.util.equals(BoolArray, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.Int32Array + */ +export class Int32Array extends Message { + /** + * @generated from field: repeated sint32 values = 1; + */ + values: number[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.Int32Array"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 17 /* ScalarType.SINT32 */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Int32Array { + return new Int32Array().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Int32Array { + return new Int32Array().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Int32Array { + return new Int32Array().fromJsonString(jsonString, options); + } + + static equals(a: Int32Array | PlainMessage | undefined, b: Int32Array | PlainMessage | undefined): boolean { + return proto3.util.equals(Int32Array, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.Int64Array + */ +export class Int64Array extends Message { + /** + * @generated from field: repeated sint64 values = 1; + */ + values: bigint[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.Int64Array"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 18 /* ScalarType.SINT64 */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Int64Array { + return new Int64Array().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Int64Array { + return new Int64Array().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Int64Array { + return new Int64Array().fromJsonString(jsonString, options); + } + + static equals(a: Int64Array | PlainMessage | undefined, b: Int64Array | PlainMessage | undefined): boolean { + return proto3.util.equals(Int64Array, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.Uint32Array + */ +export class Uint32Array extends Message { + /** + * @generated from field: repeated uint32 values = 1; + */ + values: number[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.Uint32Array"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 13 /* ScalarType.UINT32 */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Uint32Array { + return new Uint32Array().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Uint32Array { + return new Uint32Array().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Uint32Array { + return new Uint32Array().fromJsonString(jsonString, options); + } + + static equals(a: Uint32Array | PlainMessage | undefined, b: Uint32Array | PlainMessage | undefined): boolean { + return proto3.util.equals(Uint32Array, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.Uint64Array + */ +export class Uint64Array extends Message { + /** + * @generated from field: repeated uint64 values = 1; + */ + values: bigint[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.Uint64Array"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 4 /* ScalarType.UINT64 */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Uint64Array { + return new Uint64Array().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Uint64Array { + return new Uint64Array().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Uint64Array { + return new Uint64Array().fromJsonString(jsonString, options); + } + + static equals(a: Uint64Array | PlainMessage | undefined, b: Uint64Array | PlainMessage | undefined): boolean { + return proto3.util.equals(Uint64Array, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.FloatArray + */ +export class FloatArray extends Message { + /** + * @generated from field: repeated float values = 1; + */ + values: number[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.FloatArray"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 2 /* ScalarType.FLOAT */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): FloatArray { + return new FloatArray().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): FloatArray { + return new FloatArray().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): FloatArray { + return new FloatArray().fromJsonString(jsonString, options); + } + + static equals(a: FloatArray | PlainMessage | undefined, b: FloatArray | PlainMessage | undefined): boolean { + return proto3.util.equals(FloatArray, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.DoubleArray + */ +export class DoubleArray extends Message { + /** + * @generated from field: repeated double values = 1; + */ + values: number[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.DoubleArray"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): DoubleArray { + return new DoubleArray().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): DoubleArray { + return new DoubleArray().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): DoubleArray { + return new DoubleArray().fromJsonString(jsonString, options); + } + + static equals(a: DoubleArray | PlainMessage | undefined, b: DoubleArray | PlainMessage | undefined): boolean { + return proto3.util.equals(DoubleArray, a, b); + } +} + diff --git a/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/val_connect.d.ts b/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/val_connect.d.ts new file mode 100644 index 00000000..9ce20fcf --- /dev/null +++ b/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/val_connect.d.ts @@ -0,0 +1,69 @@ +import { GetRequest, GetResponse, GetServerInfoRequest, GetServerInfoResponse, SetRequest, SetResponse, StreamedUpdateRequest, StreamedUpdateResponse, SubscribeRequest, SubscribeResponse } from "./val_pb.js"; +import { MethodKind } from "@bufbuild/protobuf"; +/** + * @generated from service kuksa.val.v1.VAL + */ +export declare const VAL: { + readonly typeName: "kuksa.val.v1.VAL"; + readonly methods: { + /** + * Get entries + * + * @generated from rpc kuksa.val.v1.VAL.Get + */ + readonly get: { + readonly name: "Get"; + readonly I: typeof GetRequest; + readonly O: typeof GetResponse; + readonly kind: MethodKind.Unary; + }; + /** + * Set entries + * + * @generated from rpc kuksa.val.v1.VAL.Set + */ + readonly set: { + readonly name: "Set"; + readonly I: typeof SetRequest; + readonly O: typeof SetResponse; + readonly kind: MethodKind.Unary; + }; + /** + * @generated from rpc kuksa.val.v1.VAL.StreamedUpdate + */ + readonly streamedUpdate: { + readonly name: "StreamedUpdate"; + readonly I: typeof StreamedUpdateRequest; + readonly O: typeof StreamedUpdateResponse; + readonly kind: MethodKind.BiDiStreaming; + }; + /** + * Subscribe to a set of entries + * + * Returns a stream of notifications. + * + * InvalidArgument is returned if the request is malformed. + * + * @generated from rpc kuksa.val.v1.VAL.Subscribe + */ + readonly subscribe: { + readonly name: "Subscribe"; + readonly I: typeof SubscribeRequest; + readonly O: typeof SubscribeResponse; + readonly kind: MethodKind.ServerStreaming; + }; + /** + * Shall return information that allows the client to determine + * what server/server implementation/version it is talking to + * eg. kuksa-databroker 0.5.1 + * + * @generated from rpc kuksa.val.v1.VAL.GetServerInfo + */ + readonly getServerInfo: { + readonly name: "GetServerInfo"; + readonly I: typeof GetServerInfoRequest; + readonly O: typeof GetServerInfoResponse; + readonly kind: MethodKind.Unary; + }; + }; +}; diff --git a/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/val_connect.js b/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/val_connect.js new file mode 100644 index 00000000..9fcb0ebf --- /dev/null +++ b/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/val_connect.js @@ -0,0 +1,89 @@ +"use strict"; +//******************************************************************************* +// Copyright (c) 2022 Contributors to the Eclipse Foundation +// +// See the NOTICE file(s) distributed with this work for additional +// information regarding copyright ownership. +// +// This program and the accompanying materials are made available under the +// terms of the Apache License 2.0 which is available at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// SPDX-License-Identifier: Apache-2.0 +//****************************************************************************** +Object.defineProperty(exports, "__esModule", { value: true }); +exports.VAL = void 0; +// @generated by protoc-gen-connect-es v1.4.0 with parameter "target=ts" +// @generated from file kuksa/val/v1/val.proto (package kuksa.val.v1, syntax proto3) +/* eslint-disable */ +// @ts-nocheck +const val_pb_js_1 = require("./val_pb.js"); +const protobuf_1 = require("@bufbuild/protobuf"); +/** + * @generated from service kuksa.val.v1.VAL + */ +exports.VAL = { + typeName: "kuksa.val.v1.VAL", + methods: { + /** + * Get entries + * + * @generated from rpc kuksa.val.v1.VAL.Get + */ + get: { + name: "Get", + I: val_pb_js_1.GetRequest, + O: val_pb_js_1.GetResponse, + kind: protobuf_1.MethodKind.Unary, + }, + /** + * Set entries + * + * @generated from rpc kuksa.val.v1.VAL.Set + */ + set: { + name: "Set", + I: val_pb_js_1.SetRequest, + O: val_pb_js_1.SetResponse, + kind: protobuf_1.MethodKind.Unary, + }, + /** + * @generated from rpc kuksa.val.v1.VAL.StreamedUpdate + */ + streamedUpdate: { + name: "StreamedUpdate", + I: val_pb_js_1.StreamedUpdateRequest, + O: val_pb_js_1.StreamedUpdateResponse, + kind: protobuf_1.MethodKind.BiDiStreaming, + }, + /** + * Subscribe to a set of entries + * + * Returns a stream of notifications. + * + * InvalidArgument is returned if the request is malformed. + * + * @generated from rpc kuksa.val.v1.VAL.Subscribe + */ + subscribe: { + name: "Subscribe", + I: val_pb_js_1.SubscribeRequest, + O: val_pb_js_1.SubscribeResponse, + kind: protobuf_1.MethodKind.ServerStreaming, + }, + /** + * Shall return information that allows the client to determine + * what server/server implementation/version it is talking to + * eg. kuksa-databroker 0.5.1 + * + * @generated from rpc kuksa.val.v1.VAL.GetServerInfo + */ + getServerInfo: { + name: "GetServerInfo", + I: val_pb_js_1.GetServerInfoRequest, + O: val_pb_js_1.GetServerInfoResponse, + kind: protobuf_1.MethodKind.Unary, + }, + } +}; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsX2Nvbm5lY3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ2YWxfY29ubmVjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsaUZBQWlGO0FBQ2pGLDREQUE0RDtBQUM1RCxFQUFFO0FBQ0YsbUVBQW1FO0FBQ25FLDZDQUE2QztBQUM3QyxFQUFFO0FBQ0YsMkVBQTJFO0FBQzNFLHdEQUF3RDtBQUN4RCw2Q0FBNkM7QUFDN0MsRUFBRTtBQUNGLHNDQUFzQztBQUN0QyxnRkFBZ0Y7OztBQUVoRix3RUFBd0U7QUFDeEUsb0ZBQW9GO0FBQ3BGLG9CQUFvQjtBQUNwQixjQUFjO0FBRWQsMkNBQWdOO0FBQ2hOLGlEQUFnRDtBQUVoRDs7R0FFRztBQUNVLFFBQUEsR0FBRyxHQUFHO0lBQ2pCLFFBQVEsRUFBRSxrQkFBa0I7SUFDNUIsT0FBTyxFQUFFO1FBQ1A7Ozs7V0FJRztRQUNILEdBQUcsRUFBRTtZQUNILElBQUksRUFBRSxLQUFLO1lBQ1gsQ0FBQyxFQUFFLHNCQUFVO1lBQ2IsQ0FBQyxFQUFFLHVCQUFXO1lBQ2QsSUFBSSxFQUFFLHFCQUFVLENBQUMsS0FBSztTQUN2QjtRQUNEOzs7O1dBSUc7UUFDSCxHQUFHLEVBQUU7WUFDSCxJQUFJLEVBQUUsS0FBSztZQUNYLENBQUMsRUFBRSxzQkFBVTtZQUNiLENBQUMsRUFBRSx1QkFBVztZQUNkLElBQUksRUFBRSxxQkFBVSxDQUFDLEtBQUs7U0FDdkI7UUFDRDs7V0FFRztRQUNILGNBQWMsRUFBRTtZQUNkLElBQUksRUFBRSxnQkFBZ0I7WUFDdEIsQ0FBQyxFQUFFLGlDQUFxQjtZQUN4QixDQUFDLEVBQUUsa0NBQXNCO1lBQ3pCLElBQUksRUFBRSxxQkFBVSxDQUFDLGFBQWE7U0FDL0I7UUFDRDs7Ozs7Ozs7V0FRRztRQUNILFNBQVMsRUFBRTtZQUNULElBQUksRUFBRSxXQUFXO1lBQ2pCLENBQUMsRUFBRSw0QkFBZ0I7WUFDbkIsQ0FBQyxFQUFFLDZCQUFpQjtZQUNwQixJQUFJLEVBQUUscUJBQVUsQ0FBQyxlQUFlO1NBQ2pDO1FBQ0Q7Ozs7OztXQU1HO1FBQ0gsYUFBYSxFQUFFO1lBQ2IsSUFBSSxFQUFFLGVBQWU7WUFDckIsQ0FBQyxFQUFFLGdDQUFvQjtZQUN2QixDQUFDLEVBQUUsaUNBQXFCO1lBQ3hCLElBQUksRUFBRSxxQkFBVSxDQUFDLEtBQUs7U0FDdkI7S0FDRjtDQUNPLENBQUMifQ== \ No newline at end of file diff --git a/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/val_connect.ts b/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/val_connect.ts new file mode 100644 index 00000000..ed09e035 --- /dev/null +++ b/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/val_connect.ts @@ -0,0 +1,89 @@ +//******************************************************************************* +// Copyright (c) 2022 Contributors to the Eclipse Foundation +// +// See the NOTICE file(s) distributed with this work for additional +// information regarding copyright ownership. +// +// This program and the accompanying materials are made available under the +// terms of the Apache License 2.0 which is available at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// SPDX-License-Identifier: Apache-2.0 +//****************************************************************************** + +// @generated by protoc-gen-connect-es v1.4.0 with parameter "target=ts" +// @generated from file kuksa/val/v1/val.proto (package kuksa.val.v1, syntax proto3) +/* eslint-disable */ +// @ts-nocheck + +import { GetRequest, GetResponse, GetServerInfoRequest, GetServerInfoResponse, SetRequest, SetResponse, StreamedUpdateRequest, StreamedUpdateResponse, SubscribeRequest, SubscribeResponse } from "./val_pb.js"; +import { MethodKind } from "@bufbuild/protobuf"; + +/** + * @generated from service kuksa.val.v1.VAL + */ +export const VAL = { + typeName: "kuksa.val.v1.VAL", + methods: { + /** + * Get entries + * + * @generated from rpc kuksa.val.v1.VAL.Get + */ + get: { + name: "Get", + I: GetRequest, + O: GetResponse, + kind: MethodKind.Unary, + }, + /** + * Set entries + * + * @generated from rpc kuksa.val.v1.VAL.Set + */ + set: { + name: "Set", + I: SetRequest, + O: SetResponse, + kind: MethodKind.Unary, + }, + /** + * @generated from rpc kuksa.val.v1.VAL.StreamedUpdate + */ + streamedUpdate: { + name: "StreamedUpdate", + I: StreamedUpdateRequest, + O: StreamedUpdateResponse, + kind: MethodKind.BiDiStreaming, + }, + /** + * Subscribe to a set of entries + * + * Returns a stream of notifications. + * + * InvalidArgument is returned if the request is malformed. + * + * @generated from rpc kuksa.val.v1.VAL.Subscribe + */ + subscribe: { + name: "Subscribe", + I: SubscribeRequest, + O: SubscribeResponse, + kind: MethodKind.ServerStreaming, + }, + /** + * Shall return information that allows the client to determine + * what server/server implementation/version it is talking to + * eg. kuksa-databroker 0.5.1 + * + * @generated from rpc kuksa.val.v1.VAL.GetServerInfo + */ + getServerInfo: { + name: "GetServerInfo", + I: GetServerInfoRequest, + O: GetServerInfoResponse, + kind: MethodKind.Unary, + }, + } +} as const; + diff --git a/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/val_pb.d.ts b/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/val_pb.d.ts new file mode 100644 index 00000000..c39557cf --- /dev/null +++ b/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/val_pb.d.ts @@ -0,0 +1,282 @@ +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Message, proto3 } from "@bufbuild/protobuf"; +import { DataEntry, DataEntryError, Error, Field, View } from "./types_pb.js"; +/** + * Define which data we want + * + * @generated from message kuksa.val.v1.EntryRequest + */ +export declare class EntryRequest extends Message { + /** + * @generated from field: string path = 1; + */ + path: string; + /** + * @generated from field: kuksa.val.v1.View view = 2; + */ + view: View; + /** + * @generated from field: repeated kuksa.val.v1.Field fields = 3; + */ + fields: Field[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.EntryRequest"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): EntryRequest; + static fromJson(jsonValue: JsonValue, options?: Partial): EntryRequest; + static fromJsonString(jsonString: string, options?: Partial): EntryRequest; + static equals(a: EntryRequest | PlainMessage | undefined, b: EntryRequest | PlainMessage | undefined): boolean; +} +/** + * Request a set of entries. + * + * @generated from message kuksa.val.v1.GetRequest + */ +export declare class GetRequest extends Message { + /** + * @generated from field: repeated kuksa.val.v1.EntryRequest entries = 1; + */ + entries: EntryRequest[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.GetRequest"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): GetRequest; + static fromJson(jsonValue: JsonValue, options?: Partial): GetRequest; + static fromJsonString(jsonString: string, options?: Partial): GetRequest; + static equals(a: GetRequest | PlainMessage | undefined, b: GetRequest | PlainMessage | undefined): boolean; +} +/** + * Global errors are specified in `error`. + * Errors for individual entries are specified in `errors`. + * + * @generated from message kuksa.val.v1.GetResponse + */ +export declare class GetResponse extends Message { + /** + * @generated from field: repeated kuksa.val.v1.DataEntry entries = 1; + */ + entries: DataEntry[]; + /** + * @generated from field: repeated kuksa.val.v1.DataEntryError errors = 2; + */ + errors: DataEntryError[]; + /** + * @generated from field: kuksa.val.v1.Error error = 3; + */ + error?: Error; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.GetResponse"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): GetResponse; + static fromJson(jsonValue: JsonValue, options?: Partial): GetResponse; + static fromJsonString(jsonString: string, options?: Partial): GetResponse; + static equals(a: GetResponse | PlainMessage | undefined, b: GetResponse | PlainMessage | undefined): boolean; +} +/** + * Define the data we want to set + * + * @generated from message kuksa.val.v1.EntryUpdate + */ +export declare class EntryUpdate extends Message { + /** + * @generated from field: kuksa.val.v1.DataEntry entry = 1; + */ + entry?: DataEntry; + /** + * @generated from field: repeated kuksa.val.v1.Field fields = 2; + */ + fields: Field[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.EntryUpdate"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): EntryUpdate; + static fromJson(jsonValue: JsonValue, options?: Partial): EntryUpdate; + static fromJsonString(jsonString: string, options?: Partial): EntryUpdate; + static equals(a: EntryUpdate | PlainMessage | undefined, b: EntryUpdate | PlainMessage | undefined): boolean; +} +/** + * A list of entries to be updated + * + * @generated from message kuksa.val.v1.SetRequest + */ +export declare class SetRequest extends Message { + /** + * @generated from field: repeated kuksa.val.v1.EntryUpdate updates = 1; + */ + updates: EntryUpdate[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.SetRequest"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): SetRequest; + static fromJson(jsonValue: JsonValue, options?: Partial): SetRequest; + static fromJsonString(jsonString: string, options?: Partial): SetRequest; + static equals(a: SetRequest | PlainMessage | undefined, b: SetRequest | PlainMessage | undefined): boolean; +} +/** + * Global errors are specified in `error`. + * Errors for individual entries are specified in `errors`. + * + * @generated from message kuksa.val.v1.SetResponse + */ +export declare class SetResponse extends Message { + /** + * @generated from field: kuksa.val.v1.Error error = 1; + */ + error?: Error; + /** + * @generated from field: repeated kuksa.val.v1.DataEntryError errors = 2; + */ + errors: DataEntryError[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.SetResponse"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): SetResponse; + static fromJson(jsonValue: JsonValue, options?: Partial): SetResponse; + static fromJsonString(jsonString: string, options?: Partial): SetResponse; + static equals(a: SetResponse | PlainMessage | undefined, b: SetResponse | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.StreamedUpdateRequest + */ +export declare class StreamedUpdateRequest extends Message { + /** + * @generated from field: repeated kuksa.val.v1.EntryUpdate updates = 1; + */ + updates: EntryUpdate[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.StreamedUpdateRequest"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): StreamedUpdateRequest; + static fromJson(jsonValue: JsonValue, options?: Partial): StreamedUpdateRequest; + static fromJsonString(jsonString: string, options?: Partial): StreamedUpdateRequest; + static equals(a: StreamedUpdateRequest | PlainMessage | undefined, b: StreamedUpdateRequest | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.StreamedUpdateResponse + */ +export declare class StreamedUpdateResponse extends Message { + /** + * @generated from field: kuksa.val.v1.Error error = 1; + */ + error?: Error; + /** + * @generated from field: repeated kuksa.val.v1.DataEntryError errors = 2; + */ + errors: DataEntryError[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.StreamedUpdateResponse"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): StreamedUpdateResponse; + static fromJson(jsonValue: JsonValue, options?: Partial): StreamedUpdateResponse; + static fromJsonString(jsonString: string, options?: Partial): StreamedUpdateResponse; + static equals(a: StreamedUpdateResponse | PlainMessage | undefined, b: StreamedUpdateResponse | PlainMessage | undefined): boolean; +} +/** + * Define what to subscribe to + * + * @generated from message kuksa.val.v1.SubscribeEntry + */ +export declare class SubscribeEntry extends Message { + /** + * @generated from field: string path = 1; + */ + path: string; + /** + * @generated from field: kuksa.val.v1.View view = 2; + */ + view: View; + /** + * @generated from field: repeated kuksa.val.v1.Field fields = 3; + */ + fields: Field[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.SubscribeEntry"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): SubscribeEntry; + static fromJson(jsonValue: JsonValue, options?: Partial): SubscribeEntry; + static fromJsonString(jsonString: string, options?: Partial): SubscribeEntry; + static equals(a: SubscribeEntry | PlainMessage | undefined, b: SubscribeEntry | PlainMessage | undefined): boolean; +} +/** + * Subscribe to changes in datapoints. + * + * @generated from message kuksa.val.v1.SubscribeRequest + */ +export declare class SubscribeRequest extends Message { + /** + * @generated from field: repeated kuksa.val.v1.SubscribeEntry entries = 1; + */ + entries: SubscribeEntry[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.SubscribeRequest"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): SubscribeRequest; + static fromJson(jsonValue: JsonValue, options?: Partial): SubscribeRequest; + static fromJsonString(jsonString: string, options?: Partial): SubscribeRequest; + static equals(a: SubscribeRequest | PlainMessage | undefined, b: SubscribeRequest | PlainMessage | undefined): boolean; +} +/** + * A subscription response + * + * @generated from message kuksa.val.v1.SubscribeResponse + */ +export declare class SubscribeResponse extends Message { + /** + * @generated from field: repeated kuksa.val.v1.EntryUpdate updates = 1; + */ + updates: EntryUpdate[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.SubscribeResponse"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): SubscribeResponse; + static fromJson(jsonValue: JsonValue, options?: Partial): SubscribeResponse; + static fromJsonString(jsonString: string, options?: Partial): SubscribeResponse; + static equals(a: SubscribeResponse | PlainMessage | undefined, b: SubscribeResponse | PlainMessage | undefined): boolean; +} +/** + * Nothing yet + * + * @generated from message kuksa.val.v1.GetServerInfoRequest + */ +export declare class GetServerInfoRequest extends Message { + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.GetServerInfoRequest"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): GetServerInfoRequest; + static fromJson(jsonValue: JsonValue, options?: Partial): GetServerInfoRequest; + static fromJsonString(jsonString: string, options?: Partial): GetServerInfoRequest; + static equals(a: GetServerInfoRequest | PlainMessage | undefined, b: GetServerInfoRequest | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.GetServerInfoResponse + */ +export declare class GetServerInfoResponse extends Message { + /** + * @generated from field: string name = 1; + */ + name: string; + /** + * @generated from field: string version = 2; + */ + version: string; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.GetServerInfoResponse"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): GetServerInfoResponse; + static fromJson(jsonValue: JsonValue, options?: Partial): GetServerInfoResponse; + static fromJsonString(jsonString: string, options?: Partial): GetServerInfoResponse; + static equals(a: GetServerInfoResponse | PlainMessage | undefined, b: GetServerInfoResponse | PlainMessage | undefined): boolean; +} diff --git a/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/val_pb.js b/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/val_pb.js new file mode 100644 index 00000000..f0c64479 --- /dev/null +++ b/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/val_pb.js @@ -0,0 +1,471 @@ +"use strict"; +//******************************************************************************* +// Copyright (c) 2022 Contributors to the Eclipse Foundation +// +// See the NOTICE file(s) distributed with this work for additional +// information regarding copyright ownership. +// +// This program and the accompanying materials are made available under the +// terms of the Apache License 2.0 which is available at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// SPDX-License-Identifier: Apache-2.0 +//****************************************************************************** +Object.defineProperty(exports, "__esModule", { value: true }); +exports.GetServerInfoResponse = exports.GetServerInfoRequest = exports.SubscribeResponse = exports.SubscribeRequest = exports.SubscribeEntry = exports.StreamedUpdateResponse = exports.StreamedUpdateRequest = exports.SetResponse = exports.SetRequest = exports.EntryUpdate = exports.GetResponse = exports.GetRequest = exports.EntryRequest = void 0; +const protobuf_1 = require("@bufbuild/protobuf"); +const types_pb_js_1 = require("./types_pb.js"); +/** + * Define which data we want + * + * @generated from message kuksa.val.v1.EntryRequest + */ +class EntryRequest extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: string path = 1; + */ + this.path = ""; + /** + * @generated from field: kuksa.val.v1.View view = 2; + */ + this.view = types_pb_js_1.View.UNSPECIFIED; + /** + * @generated from field: repeated kuksa.val.v1.Field fields = 3; + */ + this.fields = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new EntryRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new EntryRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new EntryRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(EntryRequest, a, b); + } +} +exports.EntryRequest = EntryRequest; +EntryRequest.runtime = protobuf_1.proto3; +EntryRequest.typeName = "kuksa.val.v1.EntryRequest"; +EntryRequest.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "view", kind: "enum", T: protobuf_1.proto3.getEnumType(types_pb_js_1.View) }, + { no: 3, name: "fields", kind: "enum", T: protobuf_1.proto3.getEnumType(types_pb_js_1.Field), repeated: true }, +]); +/** + * Request a set of entries. + * + * @generated from message kuksa.val.v1.GetRequest + */ +class GetRequest extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated kuksa.val.v1.EntryRequest entries = 1; + */ + this.entries = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new GetRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new GetRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new GetRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(GetRequest, a, b); + } +} +exports.GetRequest = GetRequest; +GetRequest.runtime = protobuf_1.proto3; +GetRequest.typeName = "kuksa.val.v1.GetRequest"; +GetRequest.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "entries", kind: "message", T: EntryRequest, repeated: true }, +]); +/** + * Global errors are specified in `error`. + * Errors for individual entries are specified in `errors`. + * + * @generated from message kuksa.val.v1.GetResponse + */ +class GetResponse extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated kuksa.val.v1.DataEntry entries = 1; + */ + this.entries = []; + /** + * @generated from field: repeated kuksa.val.v1.DataEntryError errors = 2; + */ + this.errors = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new GetResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new GetResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new GetResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(GetResponse, a, b); + } +} +exports.GetResponse = GetResponse; +GetResponse.runtime = protobuf_1.proto3; +GetResponse.typeName = "kuksa.val.v1.GetResponse"; +GetResponse.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "entries", kind: "message", T: types_pb_js_1.DataEntry, repeated: true }, + { no: 2, name: "errors", kind: "message", T: types_pb_js_1.DataEntryError, repeated: true }, + { no: 3, name: "error", kind: "message", T: types_pb_js_1.Error }, +]); +/** + * Define the data we want to set + * + * @generated from message kuksa.val.v1.EntryUpdate + */ +class EntryUpdate extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated kuksa.val.v1.Field fields = 2; + */ + this.fields = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new EntryUpdate().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new EntryUpdate().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new EntryUpdate().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(EntryUpdate, a, b); + } +} +exports.EntryUpdate = EntryUpdate; +EntryUpdate.runtime = protobuf_1.proto3; +EntryUpdate.typeName = "kuksa.val.v1.EntryUpdate"; +EntryUpdate.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "entry", kind: "message", T: types_pb_js_1.DataEntry }, + { no: 2, name: "fields", kind: "enum", T: protobuf_1.proto3.getEnumType(types_pb_js_1.Field), repeated: true }, +]); +/** + * A list of entries to be updated + * + * @generated from message kuksa.val.v1.SetRequest + */ +class SetRequest extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated kuksa.val.v1.EntryUpdate updates = 1; + */ + this.updates = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new SetRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new SetRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new SetRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(SetRequest, a, b); + } +} +exports.SetRequest = SetRequest; +SetRequest.runtime = protobuf_1.proto3; +SetRequest.typeName = "kuksa.val.v1.SetRequest"; +SetRequest.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "updates", kind: "message", T: EntryUpdate, repeated: true }, +]); +/** + * Global errors are specified in `error`. + * Errors for individual entries are specified in `errors`. + * + * @generated from message kuksa.val.v1.SetResponse + */ +class SetResponse extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated kuksa.val.v1.DataEntryError errors = 2; + */ + this.errors = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new SetResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new SetResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new SetResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(SetResponse, a, b); + } +} +exports.SetResponse = SetResponse; +SetResponse.runtime = protobuf_1.proto3; +SetResponse.typeName = "kuksa.val.v1.SetResponse"; +SetResponse.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "error", kind: "message", T: types_pb_js_1.Error }, + { no: 2, name: "errors", kind: "message", T: types_pb_js_1.DataEntryError, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.StreamedUpdateRequest + */ +class StreamedUpdateRequest extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated kuksa.val.v1.EntryUpdate updates = 1; + */ + this.updates = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new StreamedUpdateRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new StreamedUpdateRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new StreamedUpdateRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(StreamedUpdateRequest, a, b); + } +} +exports.StreamedUpdateRequest = StreamedUpdateRequest; +StreamedUpdateRequest.runtime = protobuf_1.proto3; +StreamedUpdateRequest.typeName = "kuksa.val.v1.StreamedUpdateRequest"; +StreamedUpdateRequest.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "updates", kind: "message", T: EntryUpdate, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.StreamedUpdateResponse + */ +class StreamedUpdateResponse extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated kuksa.val.v1.DataEntryError errors = 2; + */ + this.errors = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new StreamedUpdateResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new StreamedUpdateResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new StreamedUpdateResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(StreamedUpdateResponse, a, b); + } +} +exports.StreamedUpdateResponse = StreamedUpdateResponse; +StreamedUpdateResponse.runtime = protobuf_1.proto3; +StreamedUpdateResponse.typeName = "kuksa.val.v1.StreamedUpdateResponse"; +StreamedUpdateResponse.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "error", kind: "message", T: types_pb_js_1.Error }, + { no: 2, name: "errors", kind: "message", T: types_pb_js_1.DataEntryError, repeated: true }, +]); +/** + * Define what to subscribe to + * + * @generated from message kuksa.val.v1.SubscribeEntry + */ +class SubscribeEntry extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: string path = 1; + */ + this.path = ""; + /** + * @generated from field: kuksa.val.v1.View view = 2; + */ + this.view = types_pb_js_1.View.UNSPECIFIED; + /** + * @generated from field: repeated kuksa.val.v1.Field fields = 3; + */ + this.fields = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new SubscribeEntry().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new SubscribeEntry().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new SubscribeEntry().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(SubscribeEntry, a, b); + } +} +exports.SubscribeEntry = SubscribeEntry; +SubscribeEntry.runtime = protobuf_1.proto3; +SubscribeEntry.typeName = "kuksa.val.v1.SubscribeEntry"; +SubscribeEntry.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "view", kind: "enum", T: protobuf_1.proto3.getEnumType(types_pb_js_1.View) }, + { no: 3, name: "fields", kind: "enum", T: protobuf_1.proto3.getEnumType(types_pb_js_1.Field), repeated: true }, +]); +/** + * Subscribe to changes in datapoints. + * + * @generated from message kuksa.val.v1.SubscribeRequest + */ +class SubscribeRequest extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated kuksa.val.v1.SubscribeEntry entries = 1; + */ + this.entries = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new SubscribeRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new SubscribeRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new SubscribeRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(SubscribeRequest, a, b); + } +} +exports.SubscribeRequest = SubscribeRequest; +SubscribeRequest.runtime = protobuf_1.proto3; +SubscribeRequest.typeName = "kuksa.val.v1.SubscribeRequest"; +SubscribeRequest.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "entries", kind: "message", T: SubscribeEntry, repeated: true }, +]); +/** + * A subscription response + * + * @generated from message kuksa.val.v1.SubscribeResponse + */ +class SubscribeResponse extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated kuksa.val.v1.EntryUpdate updates = 1; + */ + this.updates = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new SubscribeResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new SubscribeResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new SubscribeResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(SubscribeResponse, a, b); + } +} +exports.SubscribeResponse = SubscribeResponse; +SubscribeResponse.runtime = protobuf_1.proto3; +SubscribeResponse.typeName = "kuksa.val.v1.SubscribeResponse"; +SubscribeResponse.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "updates", kind: "message", T: EntryUpdate, repeated: true }, +]); +/** + * Nothing yet + * + * @generated from message kuksa.val.v1.GetServerInfoRequest + */ +class GetServerInfoRequest extends protobuf_1.Message { + constructor(data) { + super(); + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new GetServerInfoRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new GetServerInfoRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new GetServerInfoRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(GetServerInfoRequest, a, b); + } +} +exports.GetServerInfoRequest = GetServerInfoRequest; +GetServerInfoRequest.runtime = protobuf_1.proto3; +GetServerInfoRequest.typeName = "kuksa.val.v1.GetServerInfoRequest"; +GetServerInfoRequest.fields = protobuf_1.proto3.util.newFieldList(() => []); +/** + * @generated from message kuksa.val.v1.GetServerInfoResponse + */ +class GetServerInfoResponse extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: string name = 1; + */ + this.name = ""; + /** + * @generated from field: string version = 2; + */ + this.version = ""; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new GetServerInfoResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new GetServerInfoResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new GetServerInfoResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(GetServerInfoResponse, a, b); + } +} +exports.GetServerInfoResponse = GetServerInfoResponse; +GetServerInfoResponse.runtime = protobuf_1.proto3; +GetServerInfoResponse.typeName = "kuksa.val.v1.GetServerInfoResponse"; +GetServerInfoResponse.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "version", kind: "scalar", T: 9 /* ScalarType.STRING */ }, +]); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"val_pb.js","sourceRoot":"","sources":["val_pb.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/val_pb.ts b/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/val_pb.ts new file mode 100644 index 00000000..2b656bbe --- /dev/null +++ b/typescript/examples/aicar-zod/src/gen/kuksa/val/v1/val_pb.ts @@ -0,0 +1,579 @@ +//******************************************************************************* +// Copyright (c) 2022 Contributors to the Eclipse Foundation +// +// See the NOTICE file(s) distributed with this work for additional +// information regarding copyright ownership. +// +// This program and the accompanying materials are made available under the +// terms of the Apache License 2.0 which is available at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// SPDX-License-Identifier: Apache-2.0 +//****************************************************************************** + +// @generated by protoc-gen-es v1.10.0 with parameter "target=ts" +// @generated from file kuksa/val/v1/val.proto (package kuksa.val.v1, syntax proto3) +/* eslint-disable */ +// @ts-nocheck + +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Message, proto3 } from "@bufbuild/protobuf"; +import { DataEntry, DataEntryError, Error, Field, View } from "./types_pb.js"; + +/** + * Define which data we want + * + * @generated from message kuksa.val.v1.EntryRequest + */ +export class EntryRequest extends Message { + /** + * @generated from field: string path = 1; + */ + path = ""; + + /** + * @generated from field: kuksa.val.v1.View view = 2; + */ + view = View.UNSPECIFIED; + + /** + * @generated from field: repeated kuksa.val.v1.Field fields = 3; + */ + fields: Field[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.EntryRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "view", kind: "enum", T: proto3.getEnumType(View) }, + { no: 3, name: "fields", kind: "enum", T: proto3.getEnumType(Field), repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): EntryRequest { + return new EntryRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): EntryRequest { + return new EntryRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): EntryRequest { + return new EntryRequest().fromJsonString(jsonString, options); + } + + static equals(a: EntryRequest | PlainMessage | undefined, b: EntryRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(EntryRequest, a, b); + } +} + +/** + * Request a set of entries. + * + * @generated from message kuksa.val.v1.GetRequest + */ +export class GetRequest extends Message { + /** + * @generated from field: repeated kuksa.val.v1.EntryRequest entries = 1; + */ + entries: EntryRequest[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.GetRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "entries", kind: "message", T: EntryRequest, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): GetRequest { + return new GetRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): GetRequest { + return new GetRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): GetRequest { + return new GetRequest().fromJsonString(jsonString, options); + } + + static equals(a: GetRequest | PlainMessage | undefined, b: GetRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(GetRequest, a, b); + } +} + +/** + * Global errors are specified in `error`. + * Errors for individual entries are specified in `errors`. + * + * @generated from message kuksa.val.v1.GetResponse + */ +export class GetResponse extends Message { + /** + * @generated from field: repeated kuksa.val.v1.DataEntry entries = 1; + */ + entries: DataEntry[] = []; + + /** + * @generated from field: repeated kuksa.val.v1.DataEntryError errors = 2; + */ + errors: DataEntryError[] = []; + + /** + * @generated from field: kuksa.val.v1.Error error = 3; + */ + error?: Error; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.GetResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "entries", kind: "message", T: DataEntry, repeated: true }, + { no: 2, name: "errors", kind: "message", T: DataEntryError, repeated: true }, + { no: 3, name: "error", kind: "message", T: Error }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): GetResponse { + return new GetResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): GetResponse { + return new GetResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): GetResponse { + return new GetResponse().fromJsonString(jsonString, options); + } + + static equals(a: GetResponse | PlainMessage | undefined, b: GetResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(GetResponse, a, b); + } +} + +/** + * Define the data we want to set + * + * @generated from message kuksa.val.v1.EntryUpdate + */ +export class EntryUpdate extends Message { + /** + * @generated from field: kuksa.val.v1.DataEntry entry = 1; + */ + entry?: DataEntry; + + /** + * @generated from field: repeated kuksa.val.v1.Field fields = 2; + */ + fields: Field[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.EntryUpdate"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "entry", kind: "message", T: DataEntry }, + { no: 2, name: "fields", kind: "enum", T: proto3.getEnumType(Field), repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): EntryUpdate { + return new EntryUpdate().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): EntryUpdate { + return new EntryUpdate().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): EntryUpdate { + return new EntryUpdate().fromJsonString(jsonString, options); + } + + static equals(a: EntryUpdate | PlainMessage | undefined, b: EntryUpdate | PlainMessage | undefined): boolean { + return proto3.util.equals(EntryUpdate, a, b); + } +} + +/** + * A list of entries to be updated + * + * @generated from message kuksa.val.v1.SetRequest + */ +export class SetRequest extends Message { + /** + * @generated from field: repeated kuksa.val.v1.EntryUpdate updates = 1; + */ + updates: EntryUpdate[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.SetRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "updates", kind: "message", T: EntryUpdate, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SetRequest { + return new SetRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SetRequest { + return new SetRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SetRequest { + return new SetRequest().fromJsonString(jsonString, options); + } + + static equals(a: SetRequest | PlainMessage | undefined, b: SetRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(SetRequest, a, b); + } +} + +/** + * Global errors are specified in `error`. + * Errors for individual entries are specified in `errors`. + * + * @generated from message kuksa.val.v1.SetResponse + */ +export class SetResponse extends Message { + /** + * @generated from field: kuksa.val.v1.Error error = 1; + */ + error?: Error; + + /** + * @generated from field: repeated kuksa.val.v1.DataEntryError errors = 2; + */ + errors: DataEntryError[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.SetResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "error", kind: "message", T: Error }, + { no: 2, name: "errors", kind: "message", T: DataEntryError, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SetResponse { + return new SetResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SetResponse { + return new SetResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SetResponse { + return new SetResponse().fromJsonString(jsonString, options); + } + + static equals(a: SetResponse | PlainMessage | undefined, b: SetResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(SetResponse, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.StreamedUpdateRequest + */ +export class StreamedUpdateRequest extends Message { + /** + * @generated from field: repeated kuksa.val.v1.EntryUpdate updates = 1; + */ + updates: EntryUpdate[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.StreamedUpdateRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "updates", kind: "message", T: EntryUpdate, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): StreamedUpdateRequest { + return new StreamedUpdateRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): StreamedUpdateRequest { + return new StreamedUpdateRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): StreamedUpdateRequest { + return new StreamedUpdateRequest().fromJsonString(jsonString, options); + } + + static equals(a: StreamedUpdateRequest | PlainMessage | undefined, b: StreamedUpdateRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(StreamedUpdateRequest, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.StreamedUpdateResponse + */ +export class StreamedUpdateResponse extends Message { + /** + * @generated from field: kuksa.val.v1.Error error = 1; + */ + error?: Error; + + /** + * @generated from field: repeated kuksa.val.v1.DataEntryError errors = 2; + */ + errors: DataEntryError[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.StreamedUpdateResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "error", kind: "message", T: Error }, + { no: 2, name: "errors", kind: "message", T: DataEntryError, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): StreamedUpdateResponse { + return new StreamedUpdateResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): StreamedUpdateResponse { + return new StreamedUpdateResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): StreamedUpdateResponse { + return new StreamedUpdateResponse().fromJsonString(jsonString, options); + } + + static equals(a: StreamedUpdateResponse | PlainMessage | undefined, b: StreamedUpdateResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(StreamedUpdateResponse, a, b); + } +} + +/** + * Define what to subscribe to + * + * @generated from message kuksa.val.v1.SubscribeEntry + */ +export class SubscribeEntry extends Message { + /** + * @generated from field: string path = 1; + */ + path = ""; + + /** + * @generated from field: kuksa.val.v1.View view = 2; + */ + view = View.UNSPECIFIED; + + /** + * @generated from field: repeated kuksa.val.v1.Field fields = 3; + */ + fields: Field[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.SubscribeEntry"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "view", kind: "enum", T: proto3.getEnumType(View) }, + { no: 3, name: "fields", kind: "enum", T: proto3.getEnumType(Field), repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SubscribeEntry { + return new SubscribeEntry().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SubscribeEntry { + return new SubscribeEntry().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SubscribeEntry { + return new SubscribeEntry().fromJsonString(jsonString, options); + } + + static equals(a: SubscribeEntry | PlainMessage | undefined, b: SubscribeEntry | PlainMessage | undefined): boolean { + return proto3.util.equals(SubscribeEntry, a, b); + } +} + +/** + * Subscribe to changes in datapoints. + * + * @generated from message kuksa.val.v1.SubscribeRequest + */ +export class SubscribeRequest extends Message { + /** + * @generated from field: repeated kuksa.val.v1.SubscribeEntry entries = 1; + */ + entries: SubscribeEntry[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.SubscribeRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "entries", kind: "message", T: SubscribeEntry, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SubscribeRequest { + return new SubscribeRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SubscribeRequest { + return new SubscribeRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SubscribeRequest { + return new SubscribeRequest().fromJsonString(jsonString, options); + } + + static equals(a: SubscribeRequest | PlainMessage | undefined, b: SubscribeRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(SubscribeRequest, a, b); + } +} + +/** + * A subscription response + * + * @generated from message kuksa.val.v1.SubscribeResponse + */ +export class SubscribeResponse extends Message { + /** + * @generated from field: repeated kuksa.val.v1.EntryUpdate updates = 1; + */ + updates: EntryUpdate[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.SubscribeResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "updates", kind: "message", T: EntryUpdate, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SubscribeResponse { + return new SubscribeResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SubscribeResponse { + return new SubscribeResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SubscribeResponse { + return new SubscribeResponse().fromJsonString(jsonString, options); + } + + static equals(a: SubscribeResponse | PlainMessage | undefined, b: SubscribeResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(SubscribeResponse, a, b); + } +} + +/** + * Nothing yet + * + * @generated from message kuksa.val.v1.GetServerInfoRequest + */ +export class GetServerInfoRequest extends Message { + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.GetServerInfoRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): GetServerInfoRequest { + return new GetServerInfoRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): GetServerInfoRequest { + return new GetServerInfoRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): GetServerInfoRequest { + return new GetServerInfoRequest().fromJsonString(jsonString, options); + } + + static equals(a: GetServerInfoRequest | PlainMessage | undefined, b: GetServerInfoRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(GetServerInfoRequest, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.GetServerInfoResponse + */ +export class GetServerInfoResponse extends Message { + /** + * @generated from field: string name = 1; + */ + name = ""; + + /** + * @generated from field: string version = 2; + */ + version = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.GetServerInfoResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "version", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): GetServerInfoResponse { + return new GetServerInfoResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): GetServerInfoResponse { + return new GetServerInfoResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): GetServerInfoResponse { + return new GetServerInfoResponse().fromJsonString(jsonString, options); + } + + static equals(a: GetServerInfoResponse | PlainMessage | undefined, b: GetServerInfoResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(GetServerInfoResponse, a, b); + } +} + diff --git a/typescript/examples/aicar-zod/src/input.txt b/typescript/examples/aicar-zod/src/input.txt new file mode 100644 index 00000000..23ce2372 --- /dev/null +++ b/typescript/examples/aicar-zod/src/input.txt @@ -0,0 +1,49 @@ +What is the temperature on the front drivers side? +What is the temperature on the front passengar side? +What is the temperature on the rear driver side? +What is the temperature on the front passenger side? +Set the temperature on the front drivers side to 33. +Set the temperature on the rear drivers side to 33. +Is the drivers side front door locked? +Please lock the drivers side front door. +what is the temperature in all the zones of the car? +are the fog lights on? +is the left turn signal on? +turn the left turn signal on. +are the high beams on? +close the trunk. +turn the high beams on. +turn off the left turn signal. +what is the left drivers side tire pressure? +what is the right rear drivers side tire pressure? +what is the left rear passenger side tire pressure? +set the drivers front tire pressure to 33. +set the passenger rear tire pressure to 33. +open the rear passenger door. +unlock the rear passenger door. +close the rear passenger door. +lock the rear passenger door. +are the hazard lights on? what is the capital of france? +turn on the hazard lights. +is the trunk open? +open the trunk. +lock the rear passenger side door. +turn on the fog lights +turn off the fog lights and turn on the high beams. +open and unlock all the doors. +is austin texas a city? Are the doors open? +Are the doors unlocked? +turn on the right turn signal. +turn off the right turn signal. +Are the hazard lights on? +is the right turn signal on? +turn on the hazard lights and set the driver side temperature to 43. +what is the temperature on the passenger zones of the car? +turn up the driver side temperature to 55. +lock every door except for the driver side. +unlock all non driver doors +lock every door +close and lock everything +set the tire pressure on all wheels to 22. +open, unlock and turn on everything also set every temperature to 78 +close, lock and turn off everything also set every temperature to 22 \ No newline at end of file diff --git a/typescript/examples/aicar-zod/src/main.ts b/typescript/examples/aicar-zod/src/main.ts new file mode 100644 index 00000000..e69de29b diff --git a/typescript/examples/aicar-zod/src/tsconfig.json b/typescript/examples/aicar-zod/src/tsconfig.json new file mode 100644 index 00000000..3c52b822 --- /dev/null +++ b/typescript/examples/aicar-zod/src/tsconfig.json @@ -0,0 +1,23 @@ +{ + "include": [ + "." + ], + "compilerOptions": { + "target": "es2021", + "lib": ["es2021"], + "module": "node16", + "allowJs": true, + "types": ["node"], + "outDir": "../dist", + "rootDirs": ["../gen"], + "esModuleInterop": true, + "moduleResolution": "NodeNext", + "forceConsistentCasingInFileNames": true, + "strict": true, + "noUnusedLocals": false, + "inlineSourceMap": true, + "declaration": true, + "composite": true, + "skipLibCheck": true + } + } \ No newline at end of file diff --git a/typescript/examples/aicar-zod/src/utils.ts b/typescript/examples/aicar-zod/src/utils.ts new file mode 100644 index 00000000..b6171714 --- /dev/null +++ b/typescript/examples/aicar-zod/src/utils.ts @@ -0,0 +1,136 @@ +import { z } from "zod"; +import { VAL} from "./gen/kuksa/val/v1/val_connect"; +import { GetRequest, SetRequest} from "./gen/kuksa/val/v1/val_pb"; +import { createPromiseClient } from "@connectrpc/connect"; +import { createGrpcTransport } from "@connectrpc/connect-node"; +import { Command, Option, OptionValues } from 'commander'; +import path from "path"; +import { createAzureOpenAILanguageModel, createLanguageModel,createOpenAILanguageModel } from "typechat"; +import fs from "fs"; + +export class requestTracking { + request: string | undefined; + status?: string; + expectedRequest?: string; + generatedRequest?: string; + expectedAPIResponse?: string; + APIResponse?: string; + unknownRequest?: string; + errors?: string[]; + prompt?: string; +} + +export function parseCommandLine(){ + const program = new Command(); + program.addOption(new Option('-v, --validate', 'perform validattion of the input file'),); + program.addOption(new Option('-i, --inputfile ', 'file to parse input from'),); + program.addOption(new Option('-o, --outputfile ', 'file to parse input from'),); + program.addOption(new Option('-m, --model ', 'model to select from the modelconfig.json'),); + program.parse(process.argv); + return program.opts(); +}; + +export function createLLM(inputOptions: OptionValues, modelConfigPath: string | undefined){ + let llmodel; + if(inputOptions.model && modelConfigPath){ + const models = JSON.parse(fs.readFileSync(modelConfigPath, "utf8")) as ModelConfig[]; + const model = models.find(x => x.name === inputOptions.model); + if(model){ + llmodel = model.type === 'AzureOpenAI' ? createAzureOpenAILanguageModel(model.modelDetails.apiKey, model.modelDetails.apiEndpoint) + : model.type === 'Ollama' ? createOpenAILanguageModel(model.modelDetails.apiKey, model.name, model.modelDetails.apiEndpoint) + : createLanguageModel(process.env) + } + } + else{ + console.log('Model not found'); + llmodel = createLanguageModel(process.env); + } + return llmodel; +} + +export const SDVRequestResponse = z.object({ + entries: z.array( + z.object({ + path: z.string(), + value: z.object({ timestamp: z.string(), int32: z.number() }) + }) + ), + errors: z.array(z.unknown()) +}) + +export const SDVSetResponse = z.object({ + errors: z.array( + z.object({ + path: z.string(), + error: z.object({ + code: z.number(), + reason: z.string(), + message: z.string() + }) + }) + ) +}) + +export type Error = { + + code: 0; + reason: ""; + message: ""; +} +export type DataEntryError = { + path: ""; + error?: Error; +} + +export interface ModelDetails { + apiKey: string; + apiEndpoint: string; + port?: number | string; +} + +export interface ModelConfig { + name: string; + type: string; + modelDetails: ModelDetails; +} + +export async function validateCarResponse(request, translator) { + const transport = createGrpcTransport({baseUrl: "http://localhost:55556",httpVersion: "2"}); + const vl = createPromiseClient(VAL, transport); + let requestTracking: requestTracking = {request: request}; + //translator.stripNulls = true; + translator.attemptRepair = true; + requestTracking.prompt = translator.createRequestPrompt(request); + const response = await translator.translate(request); + if (!response.success) { + //console.log('Failed translation: '+JSON.stringify(response)); + requestTracking.status = "Failed"; + requestTracking.errors = [response.message]; + return requestTracking; + } + const car = response.data; + for (const item of car.actions) { + //console.log(JSON.stringify('Running Command: ' + JSON.stringify(item.command))); + if(item.type.includes('Set')) + { + requestTracking.generatedRequest = JSON.stringify(item.command); + const s1 = await vl.set(SetRequest.fromJsonString(JSON.stringify(item.command))); + requestTracking.APIResponse = JSON.stringify(s1); + requestTracking.status = s1.errors.length > 0 ? "Failed" : "Passed" + } + else if(item.type.includes('Get')) + { + requestTracking.generatedRequest = JSON.stringify(item.command); + const g1 = await vl.get(GetRequest.fromJsonString(JSON.stringify(item.command))); + requestTracking.APIResponse = JSON.stringify(g1); + requestTracking.status = g1.errors.length > 0 ? "Failed" : "Passed" + } + else + { + requestTracking.unknownRequest = JSON.stringify(item.command); + //console.log('Unknown Command: '+ JSON.stringify(item.command)); + } + } + //requestArray.push(requestTracking); + return requestTracking; +} diff --git a/typescript/examples/aicar/package.json b/typescript/examples/aicar/package.json new file mode 100644 index 00000000..84c38f6a --- /dev/null +++ b/typescript/examples/aicar/package.json @@ -0,0 +1,38 @@ +{ + "name": "aicar", + "version": "0.0.1", + "main": "dist/main.js", + "scripts": { + "build": "tsc -p src", + "postbuild": "copyfiles -u 1 src/**/*Schema.ts src/**/*.txt src/**/*.html dist" + }, + "exports": { + "./*": [ + "./dist/*.js" + ] + }, + "author": "", + "license": "MIT", + "description": "", + "dependencies": { + "@bufbuild/buf": "^1.39.0", + "@bufbuild/protobuf": "^1.10.0", + "@bufbuild/protoc-gen-es": "^1.10.0", + "@connectrpc/connect": "^1.4.0", + "@connectrpc/connect-node": "^1.4.0", + "@connectrpc/protoc-gen-connect-es": "^1.4.0", + "assert": "^2.1.0", + "commander": "^12.1.0", + "dotenv": "^16.4.5", + "find-config": "^1.0.0", + "ts-progress": "^0.1.9", + "typescript": "^5.5.4", + "zod": "^3.23.8" + }, + "devDependencies": { + "@types/assert": "^1.5.10", + "@types/find-config": "^1.0.4", + "@types/node": "^22.5.1", + "copyfiles": "^2.4.1" + } +} diff --git a/typescript/examples/aicar/readme.md b/typescript/examples/aicar/readme.md new file mode 100644 index 00000000..0d567351 --- /dev/null +++ b/typescript/examples/aicar/readme.md @@ -0,0 +1,83 @@ +# aicar +--- +The goal of this example repo is to experiment with foundational AI tech (TypeChat) & models (GPT4O mini & PHI3 were tested) applied to in-car assistant scenarios. The experiment approach is to utilize the real next generation of in-car standards (Kuksa, Covesa), augment those standards & frameworks with NL understanding tech powered by LLMs, to prove that the user experience can be improved with those technologies. + +[TypeChat](https://microsoft.github.io/TypeChat/) - provides a schema first framework to improve integration between NL understanding and LLM facilitated function calling + +[Covesa VSS](https://covesa.global/) - +Covesa Vehicle Signal Specification provides a standard schema for vehicle communications. The [COVESA Vehicle Signal Specification](https://covesa.github.io/vehicle_signal_specification/) (VSS) defines the names and semantics of a large set of _data entries_ that represent the current and/or intended state of a vehicle's sensors and actuators organized in a tree-like structure. For example, the vehicle's current speed is represented by the `Vehicle.Speed` entry. +This standard has broad interest & support from key auto manufacturers and OEMs (BMW, Volvo, Bosch, Land Rover, etc.) + +[Kuksa](https://projects.eclipse.org/projects/automotive.kuksa) - +Kuksa is a top level eclipse foundation project to define a software defined vehicle ecosystem based on a vehicle schema. The VSS does not define how these signals are to be collected and managed within a vehicle, nor does it prescribe how other components in the vehicle can read or write signal values from and to the tree. + +Kuksa provides a standard databroker & GRPC interface to enable communication with vehicles. + +**Kuksa Databroker** is a resource efficient implementation of the VSS signal tree and is intended to be run within a vehicle on a microprocessor based platform. It allows applications in the vehicle to interact with the vehicle's sensors and actuators using a uniform, high level gRPC API for querying signals, updating current and target values of sensors and actuators and getting notified about changes to signals of interest. + + + +```mermaid +flowchart LR + A[AICar - TypeChat] --VSS--- DB + DB[Kuksa Databroker] --VSS--- P + P[Kuksa provider] --CAN frames etc---E + E[ECU] --- Sensor + E --- Actuator + style DB fill:#999999,stroke:#444444,color:#ffffff +``` + +At the right end, Kuksa providers implement the link between the Databroker and a vehicle's Electronic Control Units (ECU) to which the hardware sensors and actuators are physically attached. + +Data is usually exchanged with ECUs by means of a CAN bus or Ethernet based protocols like SOME/IP. Providers translate between the low level messages used by these protocols and the Databroker's high level gRPC API calls to update a sensor's current reading or to forward a set-point value to an actuator via its controlling ECU. + + +### Features + +- 100% Open Source (Apache 2.0 license) +- Written in Rust with an easy-to-use language agnostic gRPC interface +- Lightweight (<4 MB statically compiled), allowing it to run on even small vehicle computers + + + +## Setup and Environment Simulation +--- +### Databroker & Covesa +The simplest way to get an example Databroker and VSS schema for experimentation is to use the official Databroker container. + +> :memo: **Note:** The examples in this section do not use TLS nor access control. Please refer to the [Databroker User Guide](./doc/user_guide.md) for more sophisticated usage examples. + +### Prerequisites + +- [Docker Engine](https://docs.docker.com/engine/install/) or [Podman](https://podman.io/docs/installation) + +### Starting Databroker + +1. Start Databroker in a container attached to the host network on port 55556: + + ```sh + docker run --rm -it -p 55556:55555 ghcr.io/eclipse-kuksa/kuksa-databroker:main --insecure --enable-databroker-v1 + ``` + + > :bulb: **Tip:** You can stop the container using `ctrl-c`. + +### AICar MVE +To test the sample in interactive mode, use the command line below. This will leverage TypeChat to translate the natural language entered, validate it into the VSS scheme, and execute the GRPC call against the running databroker. + ```sh + node ./dist/main.js + ``` + +### Android Auto Example App (not required) +The Kuksa Companion android application provides a visual interface to see the actions taken by the AICar assistant. It is not required, but helps illustrate how the full system interacts with the databroker & the resulting car. +1. Install Android Studio +2. Start the Pixel android emulator +3. Add the Kuksa Companion APK to the emulator +4. Start the emulator & connect to the databroker + +## Initial Test Results +--- + + + +## Next Steps & Investigations +--- diff --git a/typescript/examples/aicar/src/SDVCarActionSchema.ts b/typescript/examples/aicar/src/SDVCarActionSchema.ts new file mode 100644 index 00000000..cb304b4b --- /dev/null +++ b/typescript/examples/aicar/src/SDVCarActionSchema.ts @@ -0,0 +1,143 @@ +// The following types define the structure of an object of type CarActions that represents a list of actions you can do on a car. + +export interface CarActions { + actions: (GetTempurature | SetTemperature | GetDoorLockState + | SetDoorLockState | GetLightState | SetLightState | SetDoorOpenState + | GetTirePressure | GetDoorOpenState | SetTirePressure | UnknownAction)[]; +} + +//use this when you don't know what the user is asking for +export interface UnknownAction { + type: 'unknown'; + // text typed by the user that the system did not understand + command: string; +} + +//use this to get the temperature of the car +export interface GetTempurature { + type: "GetTemperature"; + command: { + entries: { + path: "Vehicle.Cabin.HVAC.Station.Row1.Driver.Temperature" | "Vehicle.Cabin.HVAC.Station.Row2.Driver.Temperature" | "Vehicle.Cabin.HVAC.Station.Row1.Passenger.Temperature" | "Vehicle.Cabin.HVAC.Station.Row2.Passenger.Temperature"; + }[]; + }; +}; + +//use this to set the temperature of the car +export interface SetTemperature { + type: "SetTemperature" + command: { + updates: Array<{ + entry: { + path: "Vehicle.Cabin.HVAC.Station.Row1.Driver.Temperature" | "Vehicle.Cabin.HVAC.Station.Row2.Driver.Temperature" | "Vehicle.Cabin.HVAC.Station.Row1.Passenger.Temperature" | "Vehicle.Cabin.HVAC.Station.Row2.Passenger.Temperature"; + value: {int32: number}; //always ensure thie value is set to a number and in the entry object + } + fields: string[] + }> + } +} + +//use this to lock or unlock the doors +export interface SetDoorLockState { + type: "SetDoorLockState"; + command: { + updates: { + entry: { + /** which door to lock */ + path: "Vehicle.Cabin.Door.Row1.DriverSide.IsLocked" | "Vehicle.Cabin.Door.Row2.DriverSide.IsLocked" | "Vehicle.Cabin.Door.Row1.PassengerSide.IsLocked" | "Vehicle.Cabin.Door.Row2.PassengerSide.IsLocked" | "Vehicle.Body.Trunk.Rear.IsLocked"; + value: { + bool: boolean; + }; + }; + fields: ("FIELD_VALUE")[]; + }[]; + }; +}; + +//use this to see if the doors or locked or unlocked +export interface GetDoorLockState { + type: "GetDoorLockState"; + command: { + entries: { + path: "Vehicle.Cabin.Door.Row1.DriverSide.IsLocked" | "Vehicle.Cabin.Door.Row2.DriverSide.IsLocked" | "Vehicle.Cabin.Door.Row1.PassengerSide.IsLocked" | "Vehicle.Cabin.Door.Row2.PassengerSide.IsLocked" | "Vehicle.Body.Trunk.Rear.IsLocked"; + }[]; + }; +} + +//use this to see if the lights are on or off +export interface GetLightState { + type: "GetLightState"; + command: { + entries: { + path: "Vehicle.Body.Lights.Beam.High.IsOn" | "Vehicle.Body.Lights.Beam.Low.IsOn" | "Vehicle.Body.Lights.DirectionIndicator.Left.IsSignaling" | "Vehicle.Body.Lights.DirectionIndicator.Right.IsSignaling" | "Vehicle.Body.Lights.Fog.Front.IsOn" | "Vehicle.Body.Lights.Fog.Rear.IsOn" | "Vehicle.Body.Lights.Hazard.IsSignaling" | "Vehicle.Body.Lights.Parking.IsOn" | "Vehicle.Body.Lights.Running.IsOn"; + }[]; + }; +}; + +//use this to turn the lights off and on +export interface SetLightState { + type: "SetLightState"; + command: { + updates: { + entry: { + path: "Vehicle.Body.Lights.Beam.High.IsOn" | "Vehicle.Body.Lights.Beam.Low.IsOn" | "Vehicle.Body.Lights.DirectionIndicator.Left.IsSignaling" | "Vehicle.Body.Lights.DirectionIndicator.Right.IsSignaling" | "Vehicle.Body.Lights.Fog.Front.IsOn" | "Vehicle.Body.Lights.Fog.Rear.IsOn" | "Vehicle.Body.Lights.Hazard.IsSignaling" | "Vehicle.Body.Lights.Parking.IsOn" | "Vehicle.Body.Lights.Running.IsOn"; + value: { + bool: boolean; + }; + }; + fields: ("FIELD_VALUE")[]; + }[]; + }; +}; + +//use this to get the pressure of the vehicle tires +export interface GetTirePressure { + type: "GetTirePressure"; + command: { + /** must be an array of entries */ + entries: { + path: "Vehicle.Chassis.Axle.Row1.Wheel.Left.Tire.Pressure" | "Vehicle.Chassis.Axle.Row1.Wheel.Right.Tire.Pressure" | "Vehicle.Chassis.Axle.Row2.Wheel.Left.Tire.Pressure" | "Vehicle.Chassis.Axle.Row2.Wheel.Right.Tire.Pressure"; + }[]; + }; +}; + +//use this to see if the vehicle doors are open or closed +export interface GetDoorOpenState { + type: "GetDoorOpenState"; + command: { + entries: { + path: "Vehicle.Cabin.Door.Row1.DriverSide.IsOpen" | "Vehicle.Cabin.Door.Row2.DriverSide.IsOpen" | "Vehicle.Cabin.Door.Row1.PassengerSide.IsOpen" | "Vehicle.Cabin.Door.Row2.PassengerSide.IsOpen" | "Vehicle.Body.Trunk.Rear.IsOpen"; + }[]; + }; +}; + +//use this to open or close the vehicle doors +export interface SetDoorOpenState { + type: "SetDoorOpenState"; + command: { + updates: { + entry: { + /** which door to open or close */ + path: "Vehicle.Cabin.Door.Row1.DriverSide.IsOpen" | "Vehicle.Cabin.Door.Row2.DriverSide.IsOpen" | "Vehicle.Cabin.Door.Row1.PassengerSide.IsOpen" | "Vehicle.Cabin.Door.Row2.PassengerSide.IsOpen" | "Vehicle.Body.Trunk.Rear.IsOpen"; + value: { + bool: boolean; + }; + }; + fields: ("FIELD_VALUE")[]; + }[]; + }; +}; + +//use this to set the pressure of the vehicle tires +export interface SetTirePressure { + type: "SetTirePressure"; + command: { + updates: { + entry: { + path: "Vehicle.Chassis.Axle.Row1.Wheel.Left.Tire.Pressure" | "Vehicle.Chassis.Axle.Row1.Wheel.Right.Tire.Pressure" | "Vehicle.Chassis.Axle.Row2.Wheel.Left.Tire.Pressure" | "Vehicle.Chassis.Axle.Row2.Wheel.Right.Tire.Pressure"; + value: {uint32: number}; + }; + fields: ['FIELD_VALUE']; + }[]; + }; +}; \ No newline at end of file diff --git a/typescript/examples/aicar/src/gen/kuksa/val/v1/types_pb.d.ts b/typescript/examples/aicar/src/gen/kuksa/val/v1/types_pb.d.ts new file mode 100644 index 00000000..f95de1f1 --- /dev/null +++ b/typescript/examples/aicar/src/gen/kuksa/val/v1/types_pb.d.ts @@ -0,0 +1,970 @@ +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Message, proto3, Timestamp } from "@bufbuild/protobuf"; +/** + * VSS Data type of a signal + * + * Protobuf doesn't support int8, int16, uint8 or uint16. + * These are mapped to int32 and uint32 respectively. + * + * + * @generated from enum kuksa.val.v1.DataType + */ +export declare enum DataType { + /** + * @generated from enum value: DATA_TYPE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + /** + * @generated from enum value: DATA_TYPE_STRING = 1; + */ + STRING = 1, + /** + * @generated from enum value: DATA_TYPE_BOOLEAN = 2; + */ + BOOLEAN = 2, + /** + * @generated from enum value: DATA_TYPE_INT8 = 3; + */ + INT8 = 3, + /** + * @generated from enum value: DATA_TYPE_INT16 = 4; + */ + INT16 = 4, + /** + * @generated from enum value: DATA_TYPE_INT32 = 5; + */ + INT32 = 5, + /** + * @generated from enum value: DATA_TYPE_INT64 = 6; + */ + INT64 = 6, + /** + * @generated from enum value: DATA_TYPE_UINT8 = 7; + */ + UINT8 = 7, + /** + * @generated from enum value: DATA_TYPE_UINT16 = 8; + */ + UINT16 = 8, + /** + * @generated from enum value: DATA_TYPE_UINT32 = 9; + */ + UINT32 = 9, + /** + * @generated from enum value: DATA_TYPE_UINT64 = 10; + */ + UINT64 = 10, + /** + * @generated from enum value: DATA_TYPE_FLOAT = 11; + */ + FLOAT = 11, + /** + * @generated from enum value: DATA_TYPE_DOUBLE = 12; + */ + DOUBLE = 12, + /** + * @generated from enum value: DATA_TYPE_TIMESTAMP = 13; + */ + TIMESTAMP = 13, + /** + * @generated from enum value: DATA_TYPE_STRING_ARRAY = 20; + */ + STRING_ARRAY = 20, + /** + * @generated from enum value: DATA_TYPE_BOOLEAN_ARRAY = 21; + */ + BOOLEAN_ARRAY = 21, + /** + * @generated from enum value: DATA_TYPE_INT8_ARRAY = 22; + */ + INT8_ARRAY = 22, + /** + * @generated from enum value: DATA_TYPE_INT16_ARRAY = 23; + */ + INT16_ARRAY = 23, + /** + * @generated from enum value: DATA_TYPE_INT32_ARRAY = 24; + */ + INT32_ARRAY = 24, + /** + * @generated from enum value: DATA_TYPE_INT64_ARRAY = 25; + */ + INT64_ARRAY = 25, + /** + * @generated from enum value: DATA_TYPE_UINT8_ARRAY = 26; + */ + UINT8_ARRAY = 26, + /** + * @generated from enum value: DATA_TYPE_UINT16_ARRAY = 27; + */ + UINT16_ARRAY = 27, + /** + * @generated from enum value: DATA_TYPE_UINT32_ARRAY = 28; + */ + UINT32_ARRAY = 28, + /** + * @generated from enum value: DATA_TYPE_UINT64_ARRAY = 29; + */ + UINT64_ARRAY = 29, + /** + * @generated from enum value: DATA_TYPE_FLOAT_ARRAY = 30; + */ + FLOAT_ARRAY = 30, + /** + * @generated from enum value: DATA_TYPE_DOUBLE_ARRAY = 31; + */ + DOUBLE_ARRAY = 31, + /** + * @generated from enum value: DATA_TYPE_TIMESTAMP_ARRAY = 32; + */ + TIMESTAMP_ARRAY = 32 +} +/** + * Entry type + * + * @generated from enum kuksa.val.v1.EntryType + */ +export declare enum EntryType { + /** + * @generated from enum value: ENTRY_TYPE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + /** + * @generated from enum value: ENTRY_TYPE_ATTRIBUTE = 1; + */ + ATTRIBUTE = 1, + /** + * @generated from enum value: ENTRY_TYPE_SENSOR = 2; + */ + SENSOR = 2, + /** + * @generated from enum value: ENTRY_TYPE_ACTUATOR = 3; + */ + ACTUATOR = 3 +} +/** + * A `View` specifies a set of fields which should + * be populated in a `DataEntry` (in a response message) + * + * @generated from enum kuksa.val.v1.View + */ +export declare enum View { + /** + * Unspecified. Equivalent to VIEW_CURRENT_VALUE unless `fields` are explicitly set. + * + * @generated from enum value: VIEW_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + /** + * Populate DataEntry with value. + * + * @generated from enum value: VIEW_CURRENT_VALUE = 1; + */ + CURRENT_VALUE = 1, + /** + * Populate DataEntry with actuator target. + * + * @generated from enum value: VIEW_TARGET_VALUE = 2; + */ + TARGET_VALUE = 2, + /** + * Populate DataEntry with metadata. + * + * @generated from enum value: VIEW_METADATA = 3; + */ + METADATA = 3, + /** + * Populate DataEntry only with requested fields. + * + * @generated from enum value: VIEW_FIELDS = 10; + */ + FIELDS = 10, + /** + * Populate DataEntry with everything. + * + * @generated from enum value: VIEW_ALL = 20; + */ + ALL = 20 +} +/** + * A `Field` corresponds to a specific field of a `DataEntry`. + * + * It can be used to: + * * populate only specific fields of a `DataEntry` response. + * * specify which fields of a `DataEntry` should be set as + * part of a `Set` request. + * * subscribe to only specific fields of a data entry. + * * convey which fields of an updated `DataEntry` have changed. + * + * @generated from enum kuksa.val.v1.Field + */ +export declare enum Field { + /** + * "*" i.e. everything + * + * @generated from enum value: FIELD_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + /** + * path + * + * @generated from enum value: FIELD_PATH = 1; + */ + PATH = 1, + /** + * value + * + * @generated from enum value: FIELD_VALUE = 2; + */ + VALUE = 2, + /** + * actuator_target + * + * @generated from enum value: FIELD_ACTUATOR_TARGET = 3; + */ + ACTUATOR_TARGET = 3, + /** + * metadata.* + * + * @generated from enum value: FIELD_METADATA = 10; + */ + METADATA = 10, + /** + * metadata.data_type + * + * @generated from enum value: FIELD_METADATA_DATA_TYPE = 11; + */ + METADATA_DATA_TYPE = 11, + /** + * metadata.description + * + * @generated from enum value: FIELD_METADATA_DESCRIPTION = 12; + */ + METADATA_DESCRIPTION = 12, + /** + * metadata.entry_type + * + * @generated from enum value: FIELD_METADATA_ENTRY_TYPE = 13; + */ + METADATA_ENTRY_TYPE = 13, + /** + * metadata.comment + * + * @generated from enum value: FIELD_METADATA_COMMENT = 14; + */ + METADATA_COMMENT = 14, + /** + * metadata.deprecation + * + * @generated from enum value: FIELD_METADATA_DEPRECATION = 15; + */ + METADATA_DEPRECATION = 15, + /** + * metadata.unit + * + * @generated from enum value: FIELD_METADATA_UNIT = 16; + */ + METADATA_UNIT = 16, + /** + * metadata.value_restriction.* + * + * @generated from enum value: FIELD_METADATA_VALUE_RESTRICTION = 17; + */ + METADATA_VALUE_RESTRICTION = 17, + /** + * metadata.actuator.* + * + * @generated from enum value: FIELD_METADATA_ACTUATOR = 20; + */ + METADATA_ACTUATOR = 20, + /** + * metadata.sensor.* + * + * @generated from enum value: FIELD_METADATA_SENSOR = 30; + */ + METADATA_SENSOR = 30, + /** + * metadata.attribute.* + * + * @generated from enum value: FIELD_METADATA_ATTRIBUTE = 40; + */ + METADATA_ATTRIBUTE = 40 +} +/** + * Describes a VSS entry + * When requesting an entry, the amount of information returned can + * be controlled by specifying either a `View` or a set of `Field`s. + * + * @generated from message kuksa.val.v1.DataEntry + */ +export declare class DataEntry extends Message { + /** + * Defines the full VSS path of the entry. + * + * [field: FIELD_PATH] + * + * @generated from field: string path = 1; + */ + path: string; + /** + * The value (datapoint) + * + * [field: FIELD_VALUE] + * + * @generated from field: kuksa.val.v1.Datapoint value = 2; + */ + value?: Datapoint; + /** + * Actuator target (only used if the entry is an actuator) + * + * [field: FIELD_ACTUATOR_TARGET] + * + * @generated from field: kuksa.val.v1.Datapoint actuator_target = 3; + */ + actuatorTarget?: Datapoint; + /** + * Metadata for this entry + * + * [field: FIELD_METADATA] + * + * @generated from field: kuksa.val.v1.Metadata metadata = 10; + */ + metadata?: Metadata; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.DataEntry"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): DataEntry; + static fromJson(jsonValue: JsonValue, options?: Partial): DataEntry; + static fromJsonString(jsonString: string, options?: Partial): DataEntry; + static equals(a: DataEntry | PlainMessage | undefined, b: DataEntry | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.Datapoint + */ +export declare class Datapoint extends Message { + /** + * @generated from field: google.protobuf.Timestamp timestamp = 1; + */ + timestamp?: Timestamp; + /** + * @generated from oneof kuksa.val.v1.Datapoint.value + */ + value: { + /** + * @generated from field: string string = 11; + */ + value: string; + case: "string"; + } | { + /** + * @generated from field: bool bool = 12; + */ + value: boolean; + case: "bool"; + } | { + /** + * @generated from field: sint32 int32 = 13; + */ + value: number; + case: "int32"; + } | { + /** + * @generated from field: sint64 int64 = 14; + */ + value: bigint; + case: "int64"; + } | { + /** + * @generated from field: uint32 uint32 = 15; + */ + value: number; + case: "uint32"; + } | { + /** + * @generated from field: uint64 uint64 = 16; + */ + value: bigint; + case: "uint64"; + } | { + /** + * @generated from field: float float = 17; + */ + value: number; + case: "float"; + } | { + /** + * @generated from field: double double = 18; + */ + value: number; + case: "double"; + } | { + /** + * @generated from field: kuksa.val.v1.StringArray string_array = 21; + */ + value: StringArray; + case: "stringArray"; + } | { + /** + * @generated from field: kuksa.val.v1.BoolArray bool_array = 22; + */ + value: BoolArray; + case: "boolArray"; + } | { + /** + * @generated from field: kuksa.val.v1.Int32Array int32_array = 23; + */ + value: Int32Array; + case: "int32Array"; + } | { + /** + * @generated from field: kuksa.val.v1.Int64Array int64_array = 24; + */ + value: Int64Array; + case: "int64Array"; + } | { + /** + * @generated from field: kuksa.val.v1.Uint32Array uint32_array = 25; + */ + value: Uint32Array; + case: "uint32Array"; + } | { + /** + * @generated from field: kuksa.val.v1.Uint64Array uint64_array = 26; + */ + value: Uint64Array; + case: "uint64Array"; + } | { + /** + * @generated from field: kuksa.val.v1.FloatArray float_array = 27; + */ + value: FloatArray; + case: "floatArray"; + } | { + /** + * @generated from field: kuksa.val.v1.DoubleArray double_array = 28; + */ + value: DoubleArray; + case: "doubleArray"; + } | { + case: undefined; + value?: undefined; + }; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.Datapoint"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): Datapoint; + static fromJson(jsonValue: JsonValue, options?: Partial): Datapoint; + static fromJsonString(jsonString: string, options?: Partial): Datapoint; + static equals(a: Datapoint | PlainMessage | undefined, b: Datapoint | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.Metadata + */ +export declare class Metadata extends Message { + /** + * Data type + * The VSS data type of the entry (i.e. the value, min, max etc). + * + * NOTE: protobuf doesn't have int8, int16, uint8 or uint16 which means + * that these values must be serialized as int32 and uint32 respectively. + * + * [field: FIELD_METADATA_DATA_TYPE] + * + * @generated from field: kuksa.val.v1.DataType data_type = 11; + */ + dataType: DataType; + /** + * Entry type + * + * [field: FIELD_METADATA_ENTRY_TYPE] + * + * @generated from field: kuksa.val.v1.EntryType entry_type = 12; + */ + entryType: EntryType; + /** + * Description + * Describes the meaning and content of the entry. + * + * [field: FIELD_METADATA_DESCRIPTION] + * + * @generated from field: optional string description = 13; + */ + description?: string; + /** + * Comment [optional] + * A comment can be used to provide additional informal information + * on a entry. + * + * [field: FIELD_METADATA_COMMENT] + * + * @generated from field: optional string comment = 14; + */ + comment?: string; + /** + * Deprecation [optional] + * Whether this entry is deprecated. Can contain recommendations of what + * to use instead. + * + * [field: FIELD_METADATA_DEPRECATION] + * + * @generated from field: optional string deprecation = 15; + */ + deprecation?: string; + /** + * Unit [optional] + * The unit of measurement + * + * [field: FIELD_METADATA_UNIT] + * + * @generated from field: optional string unit = 16; + */ + unit?: string; + /** + * Value restrictions [optional] + * Restrict which values are allowed. + * Only restrictions matching the DataType {datatype} above are valid. + * + * [field: FIELD_METADATA_VALUE_RESTRICTION] + * + * @generated from field: kuksa.val.v1.ValueRestriction value_restriction = 17; + */ + valueRestriction?: ValueRestriction; + /** + * Entry type specific metadata + * + * @generated from oneof kuksa.val.v1.Metadata.entry_specific + */ + entrySpecific: { + /** + * [field: FIELD_METADATA_ACTUATOR] + * + * @generated from field: kuksa.val.v1.Actuator actuator = 20; + */ + value: Actuator; + case: "actuator"; + } | { + /** + * [field: FIELD_METADATA_SENSOR] + * + * @generated from field: kuksa.val.v1.Sensor sensor = 30; + */ + value: Sensor; + case: "sensor"; + } | { + /** + * [field: FIELD_METADATA_ATTRIBUTE] + * + * @generated from field: kuksa.val.v1.Attribute attribute = 40; + */ + value: Attribute; + case: "attribute"; + } | { + case: undefined; + value?: undefined; + }; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.Metadata"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): Metadata; + static fromJson(jsonValue: JsonValue, options?: Partial): Metadata; + static fromJsonString(jsonString: string, options?: Partial): Metadata; + static equals(a: Metadata | PlainMessage | undefined, b: Metadata | PlainMessage | undefined): boolean; +} +/** + * ///////////////////// + * Actuator specific fields + * + * Nothing for now + * + * @generated from message kuksa.val.v1.Actuator + */ +export declare class Actuator extends Message { + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.Actuator"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): Actuator; + static fromJson(jsonValue: JsonValue, options?: Partial): Actuator; + static fromJsonString(jsonString: string, options?: Partial): Actuator; + static equals(a: Actuator | PlainMessage | undefined, b: Actuator | PlainMessage | undefined): boolean; +} +/** + * ////////////////////// + * Sensor specific + * + * Nothing for now + * + * @generated from message kuksa.val.v1.Sensor + */ +export declare class Sensor extends Message { + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.Sensor"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): Sensor; + static fromJson(jsonValue: JsonValue, options?: Partial): Sensor; + static fromJsonString(jsonString: string, options?: Partial): Sensor; + static equals(a: Sensor | PlainMessage | undefined, b: Sensor | PlainMessage | undefined): boolean; +} +/** + * ////////////////////// + * Attribute specific + * + * Nothing for now. + * + * @generated from message kuksa.val.v1.Attribute + */ +export declare class Attribute extends Message { + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.Attribute"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): Attribute; + static fromJson(jsonValue: JsonValue, options?: Partial): Attribute; + static fromJsonString(jsonString: string, options?: Partial): Attribute; + static equals(a: Attribute | PlainMessage | undefined, b: Attribute | PlainMessage | undefined): boolean; +} +/** + * Value restriction + * + * One ValueRestriction{type} for each type, since + * they don't make sense unless the types match + * + * + * @generated from message kuksa.val.v1.ValueRestriction + */ +export declare class ValueRestriction extends Message { + /** + * @generated from oneof kuksa.val.v1.ValueRestriction.type + */ + type: { + /** + * @generated from field: kuksa.val.v1.ValueRestrictionString string = 21; + */ + value: ValueRestrictionString; + case: "string"; + } | { + /** + * For signed VSS integers + * + * @generated from field: kuksa.val.v1.ValueRestrictionInt signed = 22; + */ + value: ValueRestrictionInt; + case: "signed"; + } | { + /** + * For unsigned VSS integers + * + * @generated from field: kuksa.val.v1.ValueRestrictionUint unsigned = 23; + */ + value: ValueRestrictionUint; + case: "unsigned"; + } | { + /** + * For floating point VSS values (float and double) + * + * @generated from field: kuksa.val.v1.ValueRestrictionFloat floating_point = 24; + */ + value: ValueRestrictionFloat; + case: "floatingPoint"; + } | { + case: undefined; + value?: undefined; + }; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.ValueRestriction"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): ValueRestriction; + static fromJson(jsonValue: JsonValue, options?: Partial): ValueRestriction; + static fromJsonString(jsonString: string, options?: Partial): ValueRestriction; + static equals(a: ValueRestriction | PlainMessage | undefined, b: ValueRestriction | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.ValueRestrictionInt + */ +export declare class ValueRestrictionInt extends Message { + /** + * @generated from field: optional sint64 min = 1; + */ + min?: bigint; + /** + * @generated from field: optional sint64 max = 2; + */ + max?: bigint; + /** + * @generated from field: repeated sint64 allowed_values = 3; + */ + allowedValues: bigint[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.ValueRestrictionInt"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): ValueRestrictionInt; + static fromJson(jsonValue: JsonValue, options?: Partial): ValueRestrictionInt; + static fromJsonString(jsonString: string, options?: Partial): ValueRestrictionInt; + static equals(a: ValueRestrictionInt | PlainMessage | undefined, b: ValueRestrictionInt | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.ValueRestrictionUint + */ +export declare class ValueRestrictionUint extends Message { + /** + * @generated from field: optional uint64 min = 1; + */ + min?: bigint; + /** + * @generated from field: optional uint64 max = 2; + */ + max?: bigint; + /** + * @generated from field: repeated uint64 allowed_values = 3; + */ + allowedValues: bigint[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.ValueRestrictionUint"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): ValueRestrictionUint; + static fromJson(jsonValue: JsonValue, options?: Partial): ValueRestrictionUint; + static fromJsonString(jsonString: string, options?: Partial): ValueRestrictionUint; + static equals(a: ValueRestrictionUint | PlainMessage | undefined, b: ValueRestrictionUint | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.ValueRestrictionFloat + */ +export declare class ValueRestrictionFloat extends Message { + /** + * @generated from field: optional double min = 1; + */ + min?: number; + /** + * @generated from field: optional double max = 2; + */ + max?: number; + /** + * allowed for doubles/floats not recommended + * + * @generated from field: repeated double allowed_values = 3; + */ + allowedValues: number[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.ValueRestrictionFloat"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): ValueRestrictionFloat; + static fromJson(jsonValue: JsonValue, options?: Partial): ValueRestrictionFloat; + static fromJsonString(jsonString: string, options?: Partial): ValueRestrictionFloat; + static equals(a: ValueRestrictionFloat | PlainMessage | undefined, b: ValueRestrictionFloat | PlainMessage | undefined): boolean; +} +/** + * min, max doesn't make much sense for a string + * + * @generated from message kuksa.val.v1.ValueRestrictionString + */ +export declare class ValueRestrictionString extends Message { + /** + * @generated from field: repeated string allowed_values = 3; + */ + allowedValues: string[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.ValueRestrictionString"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): ValueRestrictionString; + static fromJson(jsonValue: JsonValue, options?: Partial): ValueRestrictionString; + static fromJsonString(jsonString: string, options?: Partial): ValueRestrictionString; + static equals(a: ValueRestrictionString | PlainMessage | undefined, b: ValueRestrictionString | PlainMessage | undefined): boolean; +} +/** + * Error response shall be an HTTP-like code. + * Should follow https://www.w3.org/TR/viss2-transport/#status-codes. + * + * @generated from message kuksa.val.v1.Error + */ +export declare class Error extends Message { + /** + * @generated from field: uint32 code = 1; + */ + code: number; + /** + * @generated from field: string reason = 2; + */ + reason: string; + /** + * @generated from field: string message = 3; + */ + message: string; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.Error"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): Error; + static fromJson(jsonValue: JsonValue, options?: Partial): Error; + static fromJsonString(jsonString: string, options?: Partial): Error; + static equals(a: Error | PlainMessage | undefined, b: Error | PlainMessage | undefined): boolean; +} +/** + * Used in get/set requests to report errors for specific entries + * + * @generated from message kuksa.val.v1.DataEntryError + */ +export declare class DataEntryError extends Message { + /** + * vss path + * + * @generated from field: string path = 1; + */ + path: string; + /** + * @generated from field: kuksa.val.v1.Error error = 2; + */ + error?: Error; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.DataEntryError"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): DataEntryError; + static fromJson(jsonValue: JsonValue, options?: Partial): DataEntryError; + static fromJsonString(jsonString: string, options?: Partial): DataEntryError; + static equals(a: DataEntryError | PlainMessage | undefined, b: DataEntryError | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.StringArray + */ +export declare class StringArray extends Message { + /** + * @generated from field: repeated string values = 1; + */ + values: string[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.StringArray"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): StringArray; + static fromJson(jsonValue: JsonValue, options?: Partial): StringArray; + static fromJsonString(jsonString: string, options?: Partial): StringArray; + static equals(a: StringArray | PlainMessage | undefined, b: StringArray | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.BoolArray + */ +export declare class BoolArray extends Message { + /** + * @generated from field: repeated bool values = 1; + */ + values: boolean[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.BoolArray"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): BoolArray; + static fromJson(jsonValue: JsonValue, options?: Partial): BoolArray; + static fromJsonString(jsonString: string, options?: Partial): BoolArray; + static equals(a: BoolArray | PlainMessage | undefined, b: BoolArray | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.Int32Array + */ +export declare class Int32Array extends Message { + /** + * @generated from field: repeated sint32 values = 1; + */ + values: number[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.Int32Array"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): Int32Array; + static fromJson(jsonValue: JsonValue, options?: Partial): Int32Array; + static fromJsonString(jsonString: string, options?: Partial): Int32Array; + static equals(a: Int32Array | PlainMessage | undefined, b: Int32Array | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.Int64Array + */ +export declare class Int64Array extends Message { + /** + * @generated from field: repeated sint64 values = 1; + */ + values: bigint[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.Int64Array"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): Int64Array; + static fromJson(jsonValue: JsonValue, options?: Partial): Int64Array; + static fromJsonString(jsonString: string, options?: Partial): Int64Array; + static equals(a: Int64Array | PlainMessage | undefined, b: Int64Array | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.Uint32Array + */ +export declare class Uint32Array extends Message { + /** + * @generated from field: repeated uint32 values = 1; + */ + values: number[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.Uint32Array"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): Uint32Array; + static fromJson(jsonValue: JsonValue, options?: Partial): Uint32Array; + static fromJsonString(jsonString: string, options?: Partial): Uint32Array; + static equals(a: Uint32Array | PlainMessage | undefined, b: Uint32Array | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.Uint64Array + */ +export declare class Uint64Array extends Message { + /** + * @generated from field: repeated uint64 values = 1; + */ + values: bigint[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.Uint64Array"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): Uint64Array; + static fromJson(jsonValue: JsonValue, options?: Partial): Uint64Array; + static fromJsonString(jsonString: string, options?: Partial): Uint64Array; + static equals(a: Uint64Array | PlainMessage | undefined, b: Uint64Array | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.FloatArray + */ +export declare class FloatArray extends Message { + /** + * @generated from field: repeated float values = 1; + */ + values: number[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.FloatArray"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): FloatArray; + static fromJson(jsonValue: JsonValue, options?: Partial): FloatArray; + static fromJsonString(jsonString: string, options?: Partial): FloatArray; + static equals(a: FloatArray | PlainMessage | undefined, b: FloatArray | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.DoubleArray + */ +export declare class DoubleArray extends Message { + /** + * @generated from field: repeated double values = 1; + */ + values: number[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.DoubleArray"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): DoubleArray; + static fromJson(jsonValue: JsonValue, options?: Partial): DoubleArray; + static fromJsonString(jsonString: string, options?: Partial): DoubleArray; + static equals(a: DoubleArray | PlainMessage | undefined, b: DoubleArray | PlainMessage | undefined): boolean; +} diff --git a/typescript/examples/aicar/src/gen/kuksa/val/v1/types_pb.js b/typescript/examples/aicar/src/gen/kuksa/val/v1/types_pb.js new file mode 100644 index 00000000..a10c4a40 --- /dev/null +++ b/typescript/examples/aicar/src/gen/kuksa/val/v1/types_pb.js @@ -0,0 +1,1118 @@ +"use strict"; +//******************************************************************************* +// Copyright (c) 2022 Contributors to the Eclipse Foundation +// +// See the NOTICE file(s) distributed with this work for additional +// information regarding copyright ownership. +// +// This program and the accompanying materials are made available under the +// terms of the Apache License 2.0 which is available at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// SPDX-License-Identifier: Apache-2.0 +//****************************************************************************** +Object.defineProperty(exports, "__esModule", { value: true }); +exports.DoubleArray = exports.FloatArray = exports.Uint64Array = exports.Uint32Array = exports.Int64Array = exports.Int32Array = exports.BoolArray = exports.StringArray = exports.DataEntryError = exports.Error = exports.ValueRestrictionString = exports.ValueRestrictionFloat = exports.ValueRestrictionUint = exports.ValueRestrictionInt = exports.ValueRestriction = exports.Attribute = exports.Sensor = exports.Actuator = exports.Metadata = exports.Datapoint = exports.DataEntry = exports.Field = exports.View = exports.EntryType = exports.DataType = void 0; +const protobuf_1 = require("@bufbuild/protobuf"); +/** + * VSS Data type of a signal + * + * Protobuf doesn't support int8, int16, uint8 or uint16. + * These are mapped to int32 and uint32 respectively. + * + * + * @generated from enum kuksa.val.v1.DataType + */ +var DataType; +(function (DataType) { + /** + * @generated from enum value: DATA_TYPE_UNSPECIFIED = 0; + */ + DataType[DataType["UNSPECIFIED"] = 0] = "UNSPECIFIED"; + /** + * @generated from enum value: DATA_TYPE_STRING = 1; + */ + DataType[DataType["STRING"] = 1] = "STRING"; + /** + * @generated from enum value: DATA_TYPE_BOOLEAN = 2; + */ + DataType[DataType["BOOLEAN"] = 2] = "BOOLEAN"; + /** + * @generated from enum value: DATA_TYPE_INT8 = 3; + */ + DataType[DataType["INT8"] = 3] = "INT8"; + /** + * @generated from enum value: DATA_TYPE_INT16 = 4; + */ + DataType[DataType["INT16"] = 4] = "INT16"; + /** + * @generated from enum value: DATA_TYPE_INT32 = 5; + */ + DataType[DataType["INT32"] = 5] = "INT32"; + /** + * @generated from enum value: DATA_TYPE_INT64 = 6; + */ + DataType[DataType["INT64"] = 6] = "INT64"; + /** + * @generated from enum value: DATA_TYPE_UINT8 = 7; + */ + DataType[DataType["UINT8"] = 7] = "UINT8"; + /** + * @generated from enum value: DATA_TYPE_UINT16 = 8; + */ + DataType[DataType["UINT16"] = 8] = "UINT16"; + /** + * @generated from enum value: DATA_TYPE_UINT32 = 9; + */ + DataType[DataType["UINT32"] = 9] = "UINT32"; + /** + * @generated from enum value: DATA_TYPE_UINT64 = 10; + */ + DataType[DataType["UINT64"] = 10] = "UINT64"; + /** + * @generated from enum value: DATA_TYPE_FLOAT = 11; + */ + DataType[DataType["FLOAT"] = 11] = "FLOAT"; + /** + * @generated from enum value: DATA_TYPE_DOUBLE = 12; + */ + DataType[DataType["DOUBLE"] = 12] = "DOUBLE"; + /** + * @generated from enum value: DATA_TYPE_TIMESTAMP = 13; + */ + DataType[DataType["TIMESTAMP"] = 13] = "TIMESTAMP"; + /** + * @generated from enum value: DATA_TYPE_STRING_ARRAY = 20; + */ + DataType[DataType["STRING_ARRAY"] = 20] = "STRING_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_BOOLEAN_ARRAY = 21; + */ + DataType[DataType["BOOLEAN_ARRAY"] = 21] = "BOOLEAN_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_INT8_ARRAY = 22; + */ + DataType[DataType["INT8_ARRAY"] = 22] = "INT8_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_INT16_ARRAY = 23; + */ + DataType[DataType["INT16_ARRAY"] = 23] = "INT16_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_INT32_ARRAY = 24; + */ + DataType[DataType["INT32_ARRAY"] = 24] = "INT32_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_INT64_ARRAY = 25; + */ + DataType[DataType["INT64_ARRAY"] = 25] = "INT64_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_UINT8_ARRAY = 26; + */ + DataType[DataType["UINT8_ARRAY"] = 26] = "UINT8_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_UINT16_ARRAY = 27; + */ + DataType[DataType["UINT16_ARRAY"] = 27] = "UINT16_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_UINT32_ARRAY = 28; + */ + DataType[DataType["UINT32_ARRAY"] = 28] = "UINT32_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_UINT64_ARRAY = 29; + */ + DataType[DataType["UINT64_ARRAY"] = 29] = "UINT64_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_FLOAT_ARRAY = 30; + */ + DataType[DataType["FLOAT_ARRAY"] = 30] = "FLOAT_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_DOUBLE_ARRAY = 31; + */ + DataType[DataType["DOUBLE_ARRAY"] = 31] = "DOUBLE_ARRAY"; + /** + * @generated from enum value: DATA_TYPE_TIMESTAMP_ARRAY = 32; + */ + DataType[DataType["TIMESTAMP_ARRAY"] = 32] = "TIMESTAMP_ARRAY"; +})(DataType || (exports.DataType = DataType = {})); +// Retrieve enum metadata with: proto3.getEnumType(DataType) +protobuf_1.proto3.util.setEnumType(DataType, "kuksa.val.v1.DataType", [ + { no: 0, name: "DATA_TYPE_UNSPECIFIED" }, + { no: 1, name: "DATA_TYPE_STRING" }, + { no: 2, name: "DATA_TYPE_BOOLEAN" }, + { no: 3, name: "DATA_TYPE_INT8" }, + { no: 4, name: "DATA_TYPE_INT16" }, + { no: 5, name: "DATA_TYPE_INT32" }, + { no: 6, name: "DATA_TYPE_INT64" }, + { no: 7, name: "DATA_TYPE_UINT8" }, + { no: 8, name: "DATA_TYPE_UINT16" }, + { no: 9, name: "DATA_TYPE_UINT32" }, + { no: 10, name: "DATA_TYPE_UINT64" }, + { no: 11, name: "DATA_TYPE_FLOAT" }, + { no: 12, name: "DATA_TYPE_DOUBLE" }, + { no: 13, name: "DATA_TYPE_TIMESTAMP" }, + { no: 20, name: "DATA_TYPE_STRING_ARRAY" }, + { no: 21, name: "DATA_TYPE_BOOLEAN_ARRAY" }, + { no: 22, name: "DATA_TYPE_INT8_ARRAY" }, + { no: 23, name: "DATA_TYPE_INT16_ARRAY" }, + { no: 24, name: "DATA_TYPE_INT32_ARRAY" }, + { no: 25, name: "DATA_TYPE_INT64_ARRAY" }, + { no: 26, name: "DATA_TYPE_UINT8_ARRAY" }, + { no: 27, name: "DATA_TYPE_UINT16_ARRAY" }, + { no: 28, name: "DATA_TYPE_UINT32_ARRAY" }, + { no: 29, name: "DATA_TYPE_UINT64_ARRAY" }, + { no: 30, name: "DATA_TYPE_FLOAT_ARRAY" }, + { no: 31, name: "DATA_TYPE_DOUBLE_ARRAY" }, + { no: 32, name: "DATA_TYPE_TIMESTAMP_ARRAY" }, +]); +/** + * Entry type + * + * @generated from enum kuksa.val.v1.EntryType + */ +var EntryType; +(function (EntryType) { + /** + * @generated from enum value: ENTRY_TYPE_UNSPECIFIED = 0; + */ + EntryType[EntryType["UNSPECIFIED"] = 0] = "UNSPECIFIED"; + /** + * @generated from enum value: ENTRY_TYPE_ATTRIBUTE = 1; + */ + EntryType[EntryType["ATTRIBUTE"] = 1] = "ATTRIBUTE"; + /** + * @generated from enum value: ENTRY_TYPE_SENSOR = 2; + */ + EntryType[EntryType["SENSOR"] = 2] = "SENSOR"; + /** + * @generated from enum value: ENTRY_TYPE_ACTUATOR = 3; + */ + EntryType[EntryType["ACTUATOR"] = 3] = "ACTUATOR"; +})(EntryType || (exports.EntryType = EntryType = {})); +// Retrieve enum metadata with: proto3.getEnumType(EntryType) +protobuf_1.proto3.util.setEnumType(EntryType, "kuksa.val.v1.EntryType", [ + { no: 0, name: "ENTRY_TYPE_UNSPECIFIED" }, + { no: 1, name: "ENTRY_TYPE_ATTRIBUTE" }, + { no: 2, name: "ENTRY_TYPE_SENSOR" }, + { no: 3, name: "ENTRY_TYPE_ACTUATOR" }, +]); +/** + * A `View` specifies a set of fields which should + * be populated in a `DataEntry` (in a response message) + * + * @generated from enum kuksa.val.v1.View + */ +var View; +(function (View) { + /** + * Unspecified. Equivalent to VIEW_CURRENT_VALUE unless `fields` are explicitly set. + * + * @generated from enum value: VIEW_UNSPECIFIED = 0; + */ + View[View["UNSPECIFIED"] = 0] = "UNSPECIFIED"; + /** + * Populate DataEntry with value. + * + * @generated from enum value: VIEW_CURRENT_VALUE = 1; + */ + View[View["CURRENT_VALUE"] = 1] = "CURRENT_VALUE"; + /** + * Populate DataEntry with actuator target. + * + * @generated from enum value: VIEW_TARGET_VALUE = 2; + */ + View[View["TARGET_VALUE"] = 2] = "TARGET_VALUE"; + /** + * Populate DataEntry with metadata. + * + * @generated from enum value: VIEW_METADATA = 3; + */ + View[View["METADATA"] = 3] = "METADATA"; + /** + * Populate DataEntry only with requested fields. + * + * @generated from enum value: VIEW_FIELDS = 10; + */ + View[View["FIELDS"] = 10] = "FIELDS"; + /** + * Populate DataEntry with everything. + * + * @generated from enum value: VIEW_ALL = 20; + */ + View[View["ALL"] = 20] = "ALL"; +})(View || (exports.View = View = {})); +// Retrieve enum metadata with: proto3.getEnumType(View) +protobuf_1.proto3.util.setEnumType(View, "kuksa.val.v1.View", [ + { no: 0, name: "VIEW_UNSPECIFIED" }, + { no: 1, name: "VIEW_CURRENT_VALUE" }, + { no: 2, name: "VIEW_TARGET_VALUE" }, + { no: 3, name: "VIEW_METADATA" }, + { no: 10, name: "VIEW_FIELDS" }, + { no: 20, name: "VIEW_ALL" }, +]); +/** + * A `Field` corresponds to a specific field of a `DataEntry`. + * + * It can be used to: + * * populate only specific fields of a `DataEntry` response. + * * specify which fields of a `DataEntry` should be set as + * part of a `Set` request. + * * subscribe to only specific fields of a data entry. + * * convey which fields of an updated `DataEntry` have changed. + * + * @generated from enum kuksa.val.v1.Field + */ +var Field; +(function (Field) { + /** + * "*" i.e. everything + * + * @generated from enum value: FIELD_UNSPECIFIED = 0; + */ + Field[Field["UNSPECIFIED"] = 0] = "UNSPECIFIED"; + /** + * path + * + * @generated from enum value: FIELD_PATH = 1; + */ + Field[Field["PATH"] = 1] = "PATH"; + /** + * value + * + * @generated from enum value: FIELD_VALUE = 2; + */ + Field[Field["VALUE"] = 2] = "VALUE"; + /** + * actuator_target + * + * @generated from enum value: FIELD_ACTUATOR_TARGET = 3; + */ + Field[Field["ACTUATOR_TARGET"] = 3] = "ACTUATOR_TARGET"; + /** + * metadata.* + * + * @generated from enum value: FIELD_METADATA = 10; + */ + Field[Field["METADATA"] = 10] = "METADATA"; + /** + * metadata.data_type + * + * @generated from enum value: FIELD_METADATA_DATA_TYPE = 11; + */ + Field[Field["METADATA_DATA_TYPE"] = 11] = "METADATA_DATA_TYPE"; + /** + * metadata.description + * + * @generated from enum value: FIELD_METADATA_DESCRIPTION = 12; + */ + Field[Field["METADATA_DESCRIPTION"] = 12] = "METADATA_DESCRIPTION"; + /** + * metadata.entry_type + * + * @generated from enum value: FIELD_METADATA_ENTRY_TYPE = 13; + */ + Field[Field["METADATA_ENTRY_TYPE"] = 13] = "METADATA_ENTRY_TYPE"; + /** + * metadata.comment + * + * @generated from enum value: FIELD_METADATA_COMMENT = 14; + */ + Field[Field["METADATA_COMMENT"] = 14] = "METADATA_COMMENT"; + /** + * metadata.deprecation + * + * @generated from enum value: FIELD_METADATA_DEPRECATION = 15; + */ + Field[Field["METADATA_DEPRECATION"] = 15] = "METADATA_DEPRECATION"; + /** + * metadata.unit + * + * @generated from enum value: FIELD_METADATA_UNIT = 16; + */ + Field[Field["METADATA_UNIT"] = 16] = "METADATA_UNIT"; + /** + * metadata.value_restriction.* + * + * @generated from enum value: FIELD_METADATA_VALUE_RESTRICTION = 17; + */ + Field[Field["METADATA_VALUE_RESTRICTION"] = 17] = "METADATA_VALUE_RESTRICTION"; + /** + * metadata.actuator.* + * + * @generated from enum value: FIELD_METADATA_ACTUATOR = 20; + */ + Field[Field["METADATA_ACTUATOR"] = 20] = "METADATA_ACTUATOR"; + /** + * metadata.sensor.* + * + * @generated from enum value: FIELD_METADATA_SENSOR = 30; + */ + Field[Field["METADATA_SENSOR"] = 30] = "METADATA_SENSOR"; + /** + * metadata.attribute.* + * + * @generated from enum value: FIELD_METADATA_ATTRIBUTE = 40; + */ + Field[Field["METADATA_ATTRIBUTE"] = 40] = "METADATA_ATTRIBUTE"; +})(Field || (exports.Field = Field = {})); +// Retrieve enum metadata with: proto3.getEnumType(Field) +protobuf_1.proto3.util.setEnumType(Field, "kuksa.val.v1.Field", [ + { no: 0, name: "FIELD_UNSPECIFIED" }, + { no: 1, name: "FIELD_PATH" }, + { no: 2, name: "FIELD_VALUE" }, + { no: 3, name: "FIELD_ACTUATOR_TARGET" }, + { no: 10, name: "FIELD_METADATA" }, + { no: 11, name: "FIELD_METADATA_DATA_TYPE" }, + { no: 12, name: "FIELD_METADATA_DESCRIPTION" }, + { no: 13, name: "FIELD_METADATA_ENTRY_TYPE" }, + { no: 14, name: "FIELD_METADATA_COMMENT" }, + { no: 15, name: "FIELD_METADATA_DEPRECATION" }, + { no: 16, name: "FIELD_METADATA_UNIT" }, + { no: 17, name: "FIELD_METADATA_VALUE_RESTRICTION" }, + { no: 20, name: "FIELD_METADATA_ACTUATOR" }, + { no: 30, name: "FIELD_METADATA_SENSOR" }, + { no: 40, name: "FIELD_METADATA_ATTRIBUTE" }, +]); +/** + * Describes a VSS entry + * When requesting an entry, the amount of information returned can + * be controlled by specifying either a `View` or a set of `Field`s. + * + * @generated from message kuksa.val.v1.DataEntry + */ +class DataEntry extends protobuf_1.Message { + constructor(data) { + super(); + /** + * Defines the full VSS path of the entry. + * + * [field: FIELD_PATH] + * + * @generated from field: string path = 1; + */ + this.path = ""; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new DataEntry().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new DataEntry().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new DataEntry().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(DataEntry, a, b); + } +} +exports.DataEntry = DataEntry; +DataEntry.runtime = protobuf_1.proto3; +DataEntry.typeName = "kuksa.val.v1.DataEntry"; +DataEntry.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "value", kind: "message", T: Datapoint }, + { no: 3, name: "actuator_target", kind: "message", T: Datapoint }, + { no: 10, name: "metadata", kind: "message", T: Metadata }, +]); +/** + * @generated from message kuksa.val.v1.Datapoint + */ +class Datapoint extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from oneof kuksa.val.v1.Datapoint.value + */ + this.value = { case: undefined }; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new Datapoint().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new Datapoint().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new Datapoint().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(Datapoint, a, b); + } +} +exports.Datapoint = Datapoint; +Datapoint.runtime = protobuf_1.proto3; +Datapoint.typeName = "kuksa.val.v1.Datapoint"; +Datapoint.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "timestamp", kind: "message", T: protobuf_1.Timestamp }, + { no: 11, name: "string", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "value" }, + { no: 12, name: "bool", kind: "scalar", T: 8 /* ScalarType.BOOL */, oneof: "value" }, + { no: 13, name: "int32", kind: "scalar", T: 17 /* ScalarType.SINT32 */, oneof: "value" }, + { no: 14, name: "int64", kind: "scalar", T: 18 /* ScalarType.SINT64 */, oneof: "value" }, + { no: 15, name: "uint32", kind: "scalar", T: 13 /* ScalarType.UINT32 */, oneof: "value" }, + { no: 16, name: "uint64", kind: "scalar", T: 4 /* ScalarType.UINT64 */, oneof: "value" }, + { no: 17, name: "float", kind: "scalar", T: 2 /* ScalarType.FLOAT */, oneof: "value" }, + { no: 18, name: "double", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, oneof: "value" }, + { no: 21, name: "string_array", kind: "message", T: StringArray, oneof: "value" }, + { no: 22, name: "bool_array", kind: "message", T: BoolArray, oneof: "value" }, + { no: 23, name: "int32_array", kind: "message", T: Int32Array, oneof: "value" }, + { no: 24, name: "int64_array", kind: "message", T: Int64Array, oneof: "value" }, + { no: 25, name: "uint32_array", kind: "message", T: Uint32Array, oneof: "value" }, + { no: 26, name: "uint64_array", kind: "message", T: Uint64Array, oneof: "value" }, + { no: 27, name: "float_array", kind: "message", T: FloatArray, oneof: "value" }, + { no: 28, name: "double_array", kind: "message", T: DoubleArray, oneof: "value" }, +]); +/** + * @generated from message kuksa.val.v1.Metadata + */ +class Metadata extends protobuf_1.Message { + constructor(data) { + super(); + /** + * Data type + * The VSS data type of the entry (i.e. the value, min, max etc). + * + * NOTE: protobuf doesn't have int8, int16, uint8 or uint16 which means + * that these values must be serialized as int32 and uint32 respectively. + * + * [field: FIELD_METADATA_DATA_TYPE] + * + * @generated from field: kuksa.val.v1.DataType data_type = 11; + */ + this.dataType = DataType.UNSPECIFIED; + /** + * Entry type + * + * [field: FIELD_METADATA_ENTRY_TYPE] + * + * @generated from field: kuksa.val.v1.EntryType entry_type = 12; + */ + this.entryType = EntryType.UNSPECIFIED; + /** + * Entry type specific metadata + * + * @generated from oneof kuksa.val.v1.Metadata.entry_specific + */ + this.entrySpecific = { case: undefined }; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new Metadata().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new Metadata().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new Metadata().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(Metadata, a, b); + } +} +exports.Metadata = Metadata; +Metadata.runtime = protobuf_1.proto3; +Metadata.typeName = "kuksa.val.v1.Metadata"; +Metadata.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 11, name: "data_type", kind: "enum", T: protobuf_1.proto3.getEnumType(DataType) }, + { no: 12, name: "entry_type", kind: "enum", T: protobuf_1.proto3.getEnumType(EntryType) }, + { no: 13, name: "description", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 14, name: "comment", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 15, name: "deprecation", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 16, name: "unit", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 17, name: "value_restriction", kind: "message", T: ValueRestriction }, + { no: 20, name: "actuator", kind: "message", T: Actuator, oneof: "entry_specific" }, + { no: 30, name: "sensor", kind: "message", T: Sensor, oneof: "entry_specific" }, + { no: 40, name: "attribute", kind: "message", T: Attribute, oneof: "entry_specific" }, +]); +/** + * ///////////////////// + * Actuator specific fields + * + * Nothing for now + * + * @generated from message kuksa.val.v1.Actuator + */ +class Actuator extends protobuf_1.Message { + constructor(data) { + super(); + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new Actuator().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new Actuator().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new Actuator().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(Actuator, a, b); + } +} +exports.Actuator = Actuator; +Actuator.runtime = protobuf_1.proto3; +Actuator.typeName = "kuksa.val.v1.Actuator"; +Actuator.fields = protobuf_1.proto3.util.newFieldList(() => []); +/** + * ////////////////////// + * Sensor specific + * + * Nothing for now + * + * @generated from message kuksa.val.v1.Sensor + */ +class Sensor extends protobuf_1.Message { + constructor(data) { + super(); + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new Sensor().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new Sensor().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new Sensor().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(Sensor, a, b); + } +} +exports.Sensor = Sensor; +Sensor.runtime = protobuf_1.proto3; +Sensor.typeName = "kuksa.val.v1.Sensor"; +Sensor.fields = protobuf_1.proto3.util.newFieldList(() => []); +/** + * ////////////////////// + * Attribute specific + * + * Nothing for now. + * + * @generated from message kuksa.val.v1.Attribute + */ +class Attribute extends protobuf_1.Message { + constructor(data) { + super(); + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new Attribute().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new Attribute().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new Attribute().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(Attribute, a, b); + } +} +exports.Attribute = Attribute; +Attribute.runtime = protobuf_1.proto3; +Attribute.typeName = "kuksa.val.v1.Attribute"; +Attribute.fields = protobuf_1.proto3.util.newFieldList(() => []); +/** + * Value restriction + * + * One ValueRestriction{type} for each type, since + * they don't make sense unless the types match + * + * + * @generated from message kuksa.val.v1.ValueRestriction + */ +class ValueRestriction extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from oneof kuksa.val.v1.ValueRestriction.type + */ + this.type = { case: undefined }; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new ValueRestriction().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new ValueRestriction().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new ValueRestriction().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(ValueRestriction, a, b); + } +} +exports.ValueRestriction = ValueRestriction; +ValueRestriction.runtime = protobuf_1.proto3; +ValueRestriction.typeName = "kuksa.val.v1.ValueRestriction"; +ValueRestriction.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 21, name: "string", kind: "message", T: ValueRestrictionString, oneof: "type" }, + { no: 22, name: "signed", kind: "message", T: ValueRestrictionInt, oneof: "type" }, + { no: 23, name: "unsigned", kind: "message", T: ValueRestrictionUint, oneof: "type" }, + { no: 24, name: "floating_point", kind: "message", T: ValueRestrictionFloat, oneof: "type" }, +]); +/** + * @generated from message kuksa.val.v1.ValueRestrictionInt + */ +class ValueRestrictionInt extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated sint64 allowed_values = 3; + */ + this.allowedValues = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new ValueRestrictionInt().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new ValueRestrictionInt().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new ValueRestrictionInt().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(ValueRestrictionInt, a, b); + } +} +exports.ValueRestrictionInt = ValueRestrictionInt; +ValueRestrictionInt.runtime = protobuf_1.proto3; +ValueRestrictionInt.typeName = "kuksa.val.v1.ValueRestrictionInt"; +ValueRestrictionInt.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "min", kind: "scalar", T: 18 /* ScalarType.SINT64 */, opt: true }, + { no: 2, name: "max", kind: "scalar", T: 18 /* ScalarType.SINT64 */, opt: true }, + { no: 3, name: "allowed_values", kind: "scalar", T: 18 /* ScalarType.SINT64 */, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.ValueRestrictionUint + */ +class ValueRestrictionUint extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated uint64 allowed_values = 3; + */ + this.allowedValues = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new ValueRestrictionUint().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new ValueRestrictionUint().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new ValueRestrictionUint().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(ValueRestrictionUint, a, b); + } +} +exports.ValueRestrictionUint = ValueRestrictionUint; +ValueRestrictionUint.runtime = protobuf_1.proto3; +ValueRestrictionUint.typeName = "kuksa.val.v1.ValueRestrictionUint"; +ValueRestrictionUint.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "min", kind: "scalar", T: 4 /* ScalarType.UINT64 */, opt: true }, + { no: 2, name: "max", kind: "scalar", T: 4 /* ScalarType.UINT64 */, opt: true }, + { no: 3, name: "allowed_values", kind: "scalar", T: 4 /* ScalarType.UINT64 */, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.ValueRestrictionFloat + */ +class ValueRestrictionFloat extends protobuf_1.Message { + constructor(data) { + super(); + /** + * allowed for doubles/floats not recommended + * + * @generated from field: repeated double allowed_values = 3; + */ + this.allowedValues = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new ValueRestrictionFloat().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new ValueRestrictionFloat().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new ValueRestrictionFloat().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(ValueRestrictionFloat, a, b); + } +} +exports.ValueRestrictionFloat = ValueRestrictionFloat; +ValueRestrictionFloat.runtime = protobuf_1.proto3; +ValueRestrictionFloat.typeName = "kuksa.val.v1.ValueRestrictionFloat"; +ValueRestrictionFloat.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "min", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true }, + { no: 2, name: "max", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true }, + { no: 3, name: "allowed_values", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, repeated: true }, +]); +/** + * min, max doesn't make much sense for a string + * + * @generated from message kuksa.val.v1.ValueRestrictionString + */ +class ValueRestrictionString extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated string allowed_values = 3; + */ + this.allowedValues = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new ValueRestrictionString().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new ValueRestrictionString().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new ValueRestrictionString().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(ValueRestrictionString, a, b); + } +} +exports.ValueRestrictionString = ValueRestrictionString; +ValueRestrictionString.runtime = protobuf_1.proto3; +ValueRestrictionString.typeName = "kuksa.val.v1.ValueRestrictionString"; +ValueRestrictionString.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 3, name: "allowed_values", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, +]); +/** + * Error response shall be an HTTP-like code. + * Should follow https://www.w3.org/TR/viss2-transport/#status-codes. + * + * @generated from message kuksa.val.v1.Error + */ +class Error extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: uint32 code = 1; + */ + this.code = 0; + /** + * @generated from field: string reason = 2; + */ + this.reason = ""; + /** + * @generated from field: string message = 3; + */ + this.message = ""; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new Error().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new Error().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new Error().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(Error, a, b); + } +} +exports.Error = Error; +Error.runtime = protobuf_1.proto3; +Error.typeName = "kuksa.val.v1.Error"; +Error.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "code", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 2, name: "reason", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "message", kind: "scalar", T: 9 /* ScalarType.STRING */ }, +]); +/** + * Used in get/set requests to report errors for specific entries + * + * @generated from message kuksa.val.v1.DataEntryError + */ +class DataEntryError extends protobuf_1.Message { + constructor(data) { + super(); + /** + * vss path + * + * @generated from field: string path = 1; + */ + this.path = ""; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new DataEntryError().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new DataEntryError().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new DataEntryError().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(DataEntryError, a, b); + } +} +exports.DataEntryError = DataEntryError; +DataEntryError.runtime = protobuf_1.proto3; +DataEntryError.typeName = "kuksa.val.v1.DataEntryError"; +DataEntryError.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "error", kind: "message", T: Error }, +]); +/** + * @generated from message kuksa.val.v1.StringArray + */ +class StringArray extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated string values = 1; + */ + this.values = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new StringArray().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new StringArray().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new StringArray().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(StringArray, a, b); + } +} +exports.StringArray = StringArray; +StringArray.runtime = protobuf_1.proto3; +StringArray.typeName = "kuksa.val.v1.StringArray"; +StringArray.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.BoolArray + */ +class BoolArray extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated bool values = 1; + */ + this.values = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new BoolArray().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new BoolArray().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new BoolArray().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(BoolArray, a, b); + } +} +exports.BoolArray = BoolArray; +BoolArray.runtime = protobuf_1.proto3; +BoolArray.typeName = "kuksa.val.v1.BoolArray"; +BoolArray.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 8 /* ScalarType.BOOL */, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.Int32Array + */ +class Int32Array extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated sint32 values = 1; + */ + this.values = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new Int32Array().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new Int32Array().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new Int32Array().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(Int32Array, a, b); + } +} +exports.Int32Array = Int32Array; +Int32Array.runtime = protobuf_1.proto3; +Int32Array.typeName = "kuksa.val.v1.Int32Array"; +Int32Array.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 17 /* ScalarType.SINT32 */, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.Int64Array + */ +class Int64Array extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated sint64 values = 1; + */ + this.values = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new Int64Array().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new Int64Array().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new Int64Array().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(Int64Array, a, b); + } +} +exports.Int64Array = Int64Array; +Int64Array.runtime = protobuf_1.proto3; +Int64Array.typeName = "kuksa.val.v1.Int64Array"; +Int64Array.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 18 /* ScalarType.SINT64 */, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.Uint32Array + */ +class Uint32Array extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated uint32 values = 1; + */ + this.values = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new Uint32Array().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new Uint32Array().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new Uint32Array().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(Uint32Array, a, b); + } +} +exports.Uint32Array = Uint32Array; +Uint32Array.runtime = protobuf_1.proto3; +Uint32Array.typeName = "kuksa.val.v1.Uint32Array"; +Uint32Array.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 13 /* ScalarType.UINT32 */, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.Uint64Array + */ +class Uint64Array extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated uint64 values = 1; + */ + this.values = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new Uint64Array().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new Uint64Array().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new Uint64Array().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(Uint64Array, a, b); + } +} +exports.Uint64Array = Uint64Array; +Uint64Array.runtime = protobuf_1.proto3; +Uint64Array.typeName = "kuksa.val.v1.Uint64Array"; +Uint64Array.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 4 /* ScalarType.UINT64 */, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.FloatArray + */ +class FloatArray extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated float values = 1; + */ + this.values = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new FloatArray().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new FloatArray().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new FloatArray().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(FloatArray, a, b); + } +} +exports.FloatArray = FloatArray; +FloatArray.runtime = protobuf_1.proto3; +FloatArray.typeName = "kuksa.val.v1.FloatArray"; +FloatArray.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 2 /* ScalarType.FLOAT */, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.DoubleArray + */ +class DoubleArray extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated double values = 1; + */ + this.values = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new DoubleArray().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new DoubleArray().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new DoubleArray().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(DoubleArray, a, b); + } +} +exports.DoubleArray = DoubleArray; +DoubleArray.runtime = protobuf_1.proto3; +DoubleArray.typeName = "kuksa.val.v1.DoubleArray"; +DoubleArray.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, repeated: true }, +]); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types_pb.js","sourceRoot":"","sources":["types_pb.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/typescript/examples/aicar/src/gen/kuksa/val/v1/types_pb.ts b/typescript/examples/aicar/src/gen/kuksa/val/v1/types_pb.ts new file mode 100644 index 00000000..d3a30e3b --- /dev/null +++ b/typescript/examples/aicar/src/gen/kuksa/val/v1/types_pb.ts @@ -0,0 +1,1572 @@ +//******************************************************************************* +// Copyright (c) 2022 Contributors to the Eclipse Foundation +// +// See the NOTICE file(s) distributed with this work for additional +// information regarding copyright ownership. +// +// This program and the accompanying materials are made available under the +// terms of the Apache License 2.0 which is available at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// SPDX-License-Identifier: Apache-2.0 +//****************************************************************************** + +// @generated by protoc-gen-es v1.10.0 with parameter "target=ts" +// @generated from file kuksa/val/v1/types.proto (package kuksa.val.v1, syntax proto3) +/* eslint-disable */ +// @ts-nocheck + +// I added V1 as in databroker. Is this good practice? + +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Message, proto3, Timestamp } from "@bufbuild/protobuf"; + +/** + * VSS Data type of a signal + * + * Protobuf doesn't support int8, int16, uint8 or uint16. + * These are mapped to int32 and uint32 respectively. + * + * + * @generated from enum kuksa.val.v1.DataType + */ +export enum DataType { + /** + * @generated from enum value: DATA_TYPE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: DATA_TYPE_STRING = 1; + */ + STRING = 1, + + /** + * @generated from enum value: DATA_TYPE_BOOLEAN = 2; + */ + BOOLEAN = 2, + + /** + * @generated from enum value: DATA_TYPE_INT8 = 3; + */ + INT8 = 3, + + /** + * @generated from enum value: DATA_TYPE_INT16 = 4; + */ + INT16 = 4, + + /** + * @generated from enum value: DATA_TYPE_INT32 = 5; + */ + INT32 = 5, + + /** + * @generated from enum value: DATA_TYPE_INT64 = 6; + */ + INT64 = 6, + + /** + * @generated from enum value: DATA_TYPE_UINT8 = 7; + */ + UINT8 = 7, + + /** + * @generated from enum value: DATA_TYPE_UINT16 = 8; + */ + UINT16 = 8, + + /** + * @generated from enum value: DATA_TYPE_UINT32 = 9; + */ + UINT32 = 9, + + /** + * @generated from enum value: DATA_TYPE_UINT64 = 10; + */ + UINT64 = 10, + + /** + * @generated from enum value: DATA_TYPE_FLOAT = 11; + */ + FLOAT = 11, + + /** + * @generated from enum value: DATA_TYPE_DOUBLE = 12; + */ + DOUBLE = 12, + + /** + * @generated from enum value: DATA_TYPE_TIMESTAMP = 13; + */ + TIMESTAMP = 13, + + /** + * @generated from enum value: DATA_TYPE_STRING_ARRAY = 20; + */ + STRING_ARRAY = 20, + + /** + * @generated from enum value: DATA_TYPE_BOOLEAN_ARRAY = 21; + */ + BOOLEAN_ARRAY = 21, + + /** + * @generated from enum value: DATA_TYPE_INT8_ARRAY = 22; + */ + INT8_ARRAY = 22, + + /** + * @generated from enum value: DATA_TYPE_INT16_ARRAY = 23; + */ + INT16_ARRAY = 23, + + /** + * @generated from enum value: DATA_TYPE_INT32_ARRAY = 24; + */ + INT32_ARRAY = 24, + + /** + * @generated from enum value: DATA_TYPE_INT64_ARRAY = 25; + */ + INT64_ARRAY = 25, + + /** + * @generated from enum value: DATA_TYPE_UINT8_ARRAY = 26; + */ + UINT8_ARRAY = 26, + + /** + * @generated from enum value: DATA_TYPE_UINT16_ARRAY = 27; + */ + UINT16_ARRAY = 27, + + /** + * @generated from enum value: DATA_TYPE_UINT32_ARRAY = 28; + */ + UINT32_ARRAY = 28, + + /** + * @generated from enum value: DATA_TYPE_UINT64_ARRAY = 29; + */ + UINT64_ARRAY = 29, + + /** + * @generated from enum value: DATA_TYPE_FLOAT_ARRAY = 30; + */ + FLOAT_ARRAY = 30, + + /** + * @generated from enum value: DATA_TYPE_DOUBLE_ARRAY = 31; + */ + DOUBLE_ARRAY = 31, + + /** + * @generated from enum value: DATA_TYPE_TIMESTAMP_ARRAY = 32; + */ + TIMESTAMP_ARRAY = 32, +} +// Retrieve enum metadata with: proto3.getEnumType(DataType) +proto3.util.setEnumType(DataType, "kuksa.val.v1.DataType", [ + { no: 0, name: "DATA_TYPE_UNSPECIFIED" }, + { no: 1, name: "DATA_TYPE_STRING" }, + { no: 2, name: "DATA_TYPE_BOOLEAN" }, + { no: 3, name: "DATA_TYPE_INT8" }, + { no: 4, name: "DATA_TYPE_INT16" }, + { no: 5, name: "DATA_TYPE_INT32" }, + { no: 6, name: "DATA_TYPE_INT64" }, + { no: 7, name: "DATA_TYPE_UINT8" }, + { no: 8, name: "DATA_TYPE_UINT16" }, + { no: 9, name: "DATA_TYPE_UINT32" }, + { no: 10, name: "DATA_TYPE_UINT64" }, + { no: 11, name: "DATA_TYPE_FLOAT" }, + { no: 12, name: "DATA_TYPE_DOUBLE" }, + { no: 13, name: "DATA_TYPE_TIMESTAMP" }, + { no: 20, name: "DATA_TYPE_STRING_ARRAY" }, + { no: 21, name: "DATA_TYPE_BOOLEAN_ARRAY" }, + { no: 22, name: "DATA_TYPE_INT8_ARRAY" }, + { no: 23, name: "DATA_TYPE_INT16_ARRAY" }, + { no: 24, name: "DATA_TYPE_INT32_ARRAY" }, + { no: 25, name: "DATA_TYPE_INT64_ARRAY" }, + { no: 26, name: "DATA_TYPE_UINT8_ARRAY" }, + { no: 27, name: "DATA_TYPE_UINT16_ARRAY" }, + { no: 28, name: "DATA_TYPE_UINT32_ARRAY" }, + { no: 29, name: "DATA_TYPE_UINT64_ARRAY" }, + { no: 30, name: "DATA_TYPE_FLOAT_ARRAY" }, + { no: 31, name: "DATA_TYPE_DOUBLE_ARRAY" }, + { no: 32, name: "DATA_TYPE_TIMESTAMP_ARRAY" }, +]); + +/** + * Entry type + * + * @generated from enum kuksa.val.v1.EntryType + */ +export enum EntryType { + /** + * @generated from enum value: ENTRY_TYPE_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: ENTRY_TYPE_ATTRIBUTE = 1; + */ + ATTRIBUTE = 1, + + /** + * @generated from enum value: ENTRY_TYPE_SENSOR = 2; + */ + SENSOR = 2, + + /** + * @generated from enum value: ENTRY_TYPE_ACTUATOR = 3; + */ + ACTUATOR = 3, +} +// Retrieve enum metadata with: proto3.getEnumType(EntryType) +proto3.util.setEnumType(EntryType, "kuksa.val.v1.EntryType", [ + { no: 0, name: "ENTRY_TYPE_UNSPECIFIED" }, + { no: 1, name: "ENTRY_TYPE_ATTRIBUTE" }, + { no: 2, name: "ENTRY_TYPE_SENSOR" }, + { no: 3, name: "ENTRY_TYPE_ACTUATOR" }, +]); + +/** + * A `View` specifies a set of fields which should + * be populated in a `DataEntry` (in a response message) + * + * @generated from enum kuksa.val.v1.View + */ +export enum View { + /** + * Unspecified. Equivalent to VIEW_CURRENT_VALUE unless `fields` are explicitly set. + * + * @generated from enum value: VIEW_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * Populate DataEntry with value. + * + * @generated from enum value: VIEW_CURRENT_VALUE = 1; + */ + CURRENT_VALUE = 1, + + /** + * Populate DataEntry with actuator target. + * + * @generated from enum value: VIEW_TARGET_VALUE = 2; + */ + TARGET_VALUE = 2, + + /** + * Populate DataEntry with metadata. + * + * @generated from enum value: VIEW_METADATA = 3; + */ + METADATA = 3, + + /** + * Populate DataEntry only with requested fields. + * + * @generated from enum value: VIEW_FIELDS = 10; + */ + FIELDS = 10, + + /** + * Populate DataEntry with everything. + * + * @generated from enum value: VIEW_ALL = 20; + */ + ALL = 20, +} +// Retrieve enum metadata with: proto3.getEnumType(View) +proto3.util.setEnumType(View, "kuksa.val.v1.View", [ + { no: 0, name: "VIEW_UNSPECIFIED" }, + { no: 1, name: "VIEW_CURRENT_VALUE" }, + { no: 2, name: "VIEW_TARGET_VALUE" }, + { no: 3, name: "VIEW_METADATA" }, + { no: 10, name: "VIEW_FIELDS" }, + { no: 20, name: "VIEW_ALL" }, +]); + +/** + * A `Field` corresponds to a specific field of a `DataEntry`. + * + * It can be used to: + * * populate only specific fields of a `DataEntry` response. + * * specify which fields of a `DataEntry` should be set as + * part of a `Set` request. + * * subscribe to only specific fields of a data entry. + * * convey which fields of an updated `DataEntry` have changed. + * + * @generated from enum kuksa.val.v1.Field + */ +export enum Field { + /** + * "*" i.e. everything + * + * @generated from enum value: FIELD_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * path + * + * @generated from enum value: FIELD_PATH = 1; + */ + PATH = 1, + + /** + * value + * + * @generated from enum value: FIELD_VALUE = 2; + */ + VALUE = 2, + + /** + * actuator_target + * + * @generated from enum value: FIELD_ACTUATOR_TARGET = 3; + */ + ACTUATOR_TARGET = 3, + + /** + * metadata.* + * + * @generated from enum value: FIELD_METADATA = 10; + */ + METADATA = 10, + + /** + * metadata.data_type + * + * @generated from enum value: FIELD_METADATA_DATA_TYPE = 11; + */ + METADATA_DATA_TYPE = 11, + + /** + * metadata.description + * + * @generated from enum value: FIELD_METADATA_DESCRIPTION = 12; + */ + METADATA_DESCRIPTION = 12, + + /** + * metadata.entry_type + * + * @generated from enum value: FIELD_METADATA_ENTRY_TYPE = 13; + */ + METADATA_ENTRY_TYPE = 13, + + /** + * metadata.comment + * + * @generated from enum value: FIELD_METADATA_COMMENT = 14; + */ + METADATA_COMMENT = 14, + + /** + * metadata.deprecation + * + * @generated from enum value: FIELD_METADATA_DEPRECATION = 15; + */ + METADATA_DEPRECATION = 15, + + /** + * metadata.unit + * + * @generated from enum value: FIELD_METADATA_UNIT = 16; + */ + METADATA_UNIT = 16, + + /** + * metadata.value_restriction.* + * + * @generated from enum value: FIELD_METADATA_VALUE_RESTRICTION = 17; + */ + METADATA_VALUE_RESTRICTION = 17, + + /** + * metadata.actuator.* + * + * @generated from enum value: FIELD_METADATA_ACTUATOR = 20; + */ + METADATA_ACTUATOR = 20, + + /** + * metadata.sensor.* + * + * @generated from enum value: FIELD_METADATA_SENSOR = 30; + */ + METADATA_SENSOR = 30, + + /** + * metadata.attribute.* + * + * @generated from enum value: FIELD_METADATA_ATTRIBUTE = 40; + */ + METADATA_ATTRIBUTE = 40, +} +// Retrieve enum metadata with: proto3.getEnumType(Field) +proto3.util.setEnumType(Field, "kuksa.val.v1.Field", [ + { no: 0, name: "FIELD_UNSPECIFIED" }, + { no: 1, name: "FIELD_PATH" }, + { no: 2, name: "FIELD_VALUE" }, + { no: 3, name: "FIELD_ACTUATOR_TARGET" }, + { no: 10, name: "FIELD_METADATA" }, + { no: 11, name: "FIELD_METADATA_DATA_TYPE" }, + { no: 12, name: "FIELD_METADATA_DESCRIPTION" }, + { no: 13, name: "FIELD_METADATA_ENTRY_TYPE" }, + { no: 14, name: "FIELD_METADATA_COMMENT" }, + { no: 15, name: "FIELD_METADATA_DEPRECATION" }, + { no: 16, name: "FIELD_METADATA_UNIT" }, + { no: 17, name: "FIELD_METADATA_VALUE_RESTRICTION" }, + { no: 20, name: "FIELD_METADATA_ACTUATOR" }, + { no: 30, name: "FIELD_METADATA_SENSOR" }, + { no: 40, name: "FIELD_METADATA_ATTRIBUTE" }, +]); + +/** + * Describes a VSS entry + * When requesting an entry, the amount of information returned can + * be controlled by specifying either a `View` or a set of `Field`s. + * + * @generated from message kuksa.val.v1.DataEntry + */ +export class DataEntry extends Message { + /** + * Defines the full VSS path of the entry. + * + * [field: FIELD_PATH] + * + * @generated from field: string path = 1; + */ + path = ""; + + /** + * The value (datapoint) + * + * [field: FIELD_VALUE] + * + * @generated from field: kuksa.val.v1.Datapoint value = 2; + */ + value?: Datapoint; + + /** + * Actuator target (only used if the entry is an actuator) + * + * [field: FIELD_ACTUATOR_TARGET] + * + * @generated from field: kuksa.val.v1.Datapoint actuator_target = 3; + */ + actuatorTarget?: Datapoint; + + /** + * Metadata for this entry + * + * [field: FIELD_METADATA] + * + * @generated from field: kuksa.val.v1.Metadata metadata = 10; + */ + metadata?: Metadata; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.DataEntry"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "value", kind: "message", T: Datapoint }, + { no: 3, name: "actuator_target", kind: "message", T: Datapoint }, + { no: 10, name: "metadata", kind: "message", T: Metadata }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): DataEntry { + return new DataEntry().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): DataEntry { + return new DataEntry().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): DataEntry { + return new DataEntry().fromJsonString(jsonString, options); + } + + static equals(a: DataEntry | PlainMessage | undefined, b: DataEntry | PlainMessage | undefined): boolean { + return proto3.util.equals(DataEntry, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.Datapoint + */ +export class Datapoint extends Message { + /** + * @generated from field: google.protobuf.Timestamp timestamp = 1; + */ + timestamp?: Timestamp; + + /** + * @generated from oneof kuksa.val.v1.Datapoint.value + */ + value: { + /** + * @generated from field: string string = 11; + */ + value: string; + case: "string"; + } | { + /** + * @generated from field: bool bool = 12; + */ + value: boolean; + case: "bool"; + } | { + /** + * @generated from field: sint32 int32 = 13; + */ + value: number; + case: "int32"; + } | { + /** + * @generated from field: sint64 int64 = 14; + */ + value: bigint; + case: "int64"; + } | { + /** + * @generated from field: uint32 uint32 = 15; + */ + value: number; + case: "uint32"; + } | { + /** + * @generated from field: uint64 uint64 = 16; + */ + value: bigint; + case: "uint64"; + } | { + /** + * @generated from field: float float = 17; + */ + value: number; + case: "float"; + } | { + /** + * @generated from field: double double = 18; + */ + value: number; + case: "double"; + } | { + /** + * @generated from field: kuksa.val.v1.StringArray string_array = 21; + */ + value: StringArray; + case: "stringArray"; + } | { + /** + * @generated from field: kuksa.val.v1.BoolArray bool_array = 22; + */ + value: BoolArray; + case: "boolArray"; + } | { + /** + * @generated from field: kuksa.val.v1.Int32Array int32_array = 23; + */ + value: Int32Array; + case: "int32Array"; + } | { + /** + * @generated from field: kuksa.val.v1.Int64Array int64_array = 24; + */ + value: Int64Array; + case: "int64Array"; + } | { + /** + * @generated from field: kuksa.val.v1.Uint32Array uint32_array = 25; + */ + value: Uint32Array; + case: "uint32Array"; + } | { + /** + * @generated from field: kuksa.val.v1.Uint64Array uint64_array = 26; + */ + value: Uint64Array; + case: "uint64Array"; + } | { + /** + * @generated from field: kuksa.val.v1.FloatArray float_array = 27; + */ + value: FloatArray; + case: "floatArray"; + } | { + /** + * @generated from field: kuksa.val.v1.DoubleArray double_array = 28; + */ + value: DoubleArray; + case: "doubleArray"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.Datapoint"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "timestamp", kind: "message", T: Timestamp }, + { no: 11, name: "string", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "value" }, + { no: 12, name: "bool", kind: "scalar", T: 8 /* ScalarType.BOOL */, oneof: "value" }, + { no: 13, name: "int32", kind: "scalar", T: 17 /* ScalarType.SINT32 */, oneof: "value" }, + { no: 14, name: "int64", kind: "scalar", T: 18 /* ScalarType.SINT64 */, oneof: "value" }, + { no: 15, name: "uint32", kind: "scalar", T: 13 /* ScalarType.UINT32 */, oneof: "value" }, + { no: 16, name: "uint64", kind: "scalar", T: 4 /* ScalarType.UINT64 */, oneof: "value" }, + { no: 17, name: "float", kind: "scalar", T: 2 /* ScalarType.FLOAT */, oneof: "value" }, + { no: 18, name: "double", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, oneof: "value" }, + { no: 21, name: "string_array", kind: "message", T: StringArray, oneof: "value" }, + { no: 22, name: "bool_array", kind: "message", T: BoolArray, oneof: "value" }, + { no: 23, name: "int32_array", kind: "message", T: Int32Array, oneof: "value" }, + { no: 24, name: "int64_array", kind: "message", T: Int64Array, oneof: "value" }, + { no: 25, name: "uint32_array", kind: "message", T: Uint32Array, oneof: "value" }, + { no: 26, name: "uint64_array", kind: "message", T: Uint64Array, oneof: "value" }, + { no: 27, name: "float_array", kind: "message", T: FloatArray, oneof: "value" }, + { no: 28, name: "double_array", kind: "message", T: DoubleArray, oneof: "value" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Datapoint { + return new Datapoint().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Datapoint { + return new Datapoint().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Datapoint { + return new Datapoint().fromJsonString(jsonString, options); + } + + static equals(a: Datapoint | PlainMessage | undefined, b: Datapoint | PlainMessage | undefined): boolean { + return proto3.util.equals(Datapoint, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.Metadata + */ +export class Metadata extends Message { + /** + * Data type + * The VSS data type of the entry (i.e. the value, min, max etc). + * + * NOTE: protobuf doesn't have int8, int16, uint8 or uint16 which means + * that these values must be serialized as int32 and uint32 respectively. + * + * [field: FIELD_METADATA_DATA_TYPE] + * + * @generated from field: kuksa.val.v1.DataType data_type = 11; + */ + dataType = DataType.UNSPECIFIED; + + /** + * Entry type + * + * [field: FIELD_METADATA_ENTRY_TYPE] + * + * @generated from field: kuksa.val.v1.EntryType entry_type = 12; + */ + entryType = EntryType.UNSPECIFIED; + + /** + * Description + * Describes the meaning and content of the entry. + * + * [field: FIELD_METADATA_DESCRIPTION] + * + * @generated from field: optional string description = 13; + */ + description?: string; + + /** + * Comment [optional] + * A comment can be used to provide additional informal information + * on a entry. + * + * [field: FIELD_METADATA_COMMENT] + * + * @generated from field: optional string comment = 14; + */ + comment?: string; + + /** + * Deprecation [optional] + * Whether this entry is deprecated. Can contain recommendations of what + * to use instead. + * + * [field: FIELD_METADATA_DEPRECATION] + * + * @generated from field: optional string deprecation = 15; + */ + deprecation?: string; + + /** + * Unit [optional] + * The unit of measurement + * + * [field: FIELD_METADATA_UNIT] + * + * @generated from field: optional string unit = 16; + */ + unit?: string; + + /** + * Value restrictions [optional] + * Restrict which values are allowed. + * Only restrictions matching the DataType {datatype} above are valid. + * + * [field: FIELD_METADATA_VALUE_RESTRICTION] + * + * @generated from field: kuksa.val.v1.ValueRestriction value_restriction = 17; + */ + valueRestriction?: ValueRestriction; + + /** + * Entry type specific metadata + * + * @generated from oneof kuksa.val.v1.Metadata.entry_specific + */ + entrySpecific: { + /** + * [field: FIELD_METADATA_ACTUATOR] + * + * @generated from field: kuksa.val.v1.Actuator actuator = 20; + */ + value: Actuator; + case: "actuator"; + } | { + /** + * [field: FIELD_METADATA_SENSOR] + * + * @generated from field: kuksa.val.v1.Sensor sensor = 30; + */ + value: Sensor; + case: "sensor"; + } | { + /** + * [field: FIELD_METADATA_ATTRIBUTE] + * + * @generated from field: kuksa.val.v1.Attribute attribute = 40; + */ + value: Attribute; + case: "attribute"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.Metadata"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 11, name: "data_type", kind: "enum", T: proto3.getEnumType(DataType) }, + { no: 12, name: "entry_type", kind: "enum", T: proto3.getEnumType(EntryType) }, + { no: 13, name: "description", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 14, name: "comment", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 15, name: "deprecation", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 16, name: "unit", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true }, + { no: 17, name: "value_restriction", kind: "message", T: ValueRestriction }, + { no: 20, name: "actuator", kind: "message", T: Actuator, oneof: "entry_specific" }, + { no: 30, name: "sensor", kind: "message", T: Sensor, oneof: "entry_specific" }, + { no: 40, name: "attribute", kind: "message", T: Attribute, oneof: "entry_specific" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Metadata { + return new Metadata().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Metadata { + return new Metadata().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Metadata { + return new Metadata().fromJsonString(jsonString, options); + } + + static equals(a: Metadata | PlainMessage | undefined, b: Metadata | PlainMessage | undefined): boolean { + return proto3.util.equals(Metadata, a, b); + } +} + +/** + * ///////////////////// + * Actuator specific fields + * + * Nothing for now + * + * @generated from message kuksa.val.v1.Actuator + */ +export class Actuator extends Message { + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.Actuator"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Actuator { + return new Actuator().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Actuator { + return new Actuator().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Actuator { + return new Actuator().fromJsonString(jsonString, options); + } + + static equals(a: Actuator | PlainMessage | undefined, b: Actuator | PlainMessage | undefined): boolean { + return proto3.util.equals(Actuator, a, b); + } +} + +/** + * ////////////////////// + * Sensor specific + * + * Nothing for now + * + * @generated from message kuksa.val.v1.Sensor + */ +export class Sensor extends Message { + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.Sensor"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Sensor { + return new Sensor().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Sensor { + return new Sensor().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Sensor { + return new Sensor().fromJsonString(jsonString, options); + } + + static equals(a: Sensor | PlainMessage | undefined, b: Sensor | PlainMessage | undefined): boolean { + return proto3.util.equals(Sensor, a, b); + } +} + +/** + * ////////////////////// + * Attribute specific + * + * Nothing for now. + * + * @generated from message kuksa.val.v1.Attribute + */ +export class Attribute extends Message { + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.Attribute"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Attribute { + return new Attribute().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Attribute { + return new Attribute().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Attribute { + return new Attribute().fromJsonString(jsonString, options); + } + + static equals(a: Attribute | PlainMessage | undefined, b: Attribute | PlainMessage | undefined): boolean { + return proto3.util.equals(Attribute, a, b); + } +} + +/** + * Value restriction + * + * One ValueRestriction{type} for each type, since + * they don't make sense unless the types match + * + * + * @generated from message kuksa.val.v1.ValueRestriction + */ +export class ValueRestriction extends Message { + /** + * @generated from oneof kuksa.val.v1.ValueRestriction.type + */ + type: { + /** + * @generated from field: kuksa.val.v1.ValueRestrictionString string = 21; + */ + value: ValueRestrictionString; + case: "string"; + } | { + /** + * For signed VSS integers + * + * @generated from field: kuksa.val.v1.ValueRestrictionInt signed = 22; + */ + value: ValueRestrictionInt; + case: "signed"; + } | { + /** + * For unsigned VSS integers + * + * @generated from field: kuksa.val.v1.ValueRestrictionUint unsigned = 23; + */ + value: ValueRestrictionUint; + case: "unsigned"; + } | { + /** + * For floating point VSS values (float and double) + * + * @generated from field: kuksa.val.v1.ValueRestrictionFloat floating_point = 24; + */ + value: ValueRestrictionFloat; + case: "floatingPoint"; + } | { case: undefined; value?: undefined } = { case: undefined }; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.ValueRestriction"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 21, name: "string", kind: "message", T: ValueRestrictionString, oneof: "type" }, + { no: 22, name: "signed", kind: "message", T: ValueRestrictionInt, oneof: "type" }, + { no: 23, name: "unsigned", kind: "message", T: ValueRestrictionUint, oneof: "type" }, + { no: 24, name: "floating_point", kind: "message", T: ValueRestrictionFloat, oneof: "type" }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ValueRestriction { + return new ValueRestriction().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ValueRestriction { + return new ValueRestriction().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ValueRestriction { + return new ValueRestriction().fromJsonString(jsonString, options); + } + + static equals(a: ValueRestriction | PlainMessage | undefined, b: ValueRestriction | PlainMessage | undefined): boolean { + return proto3.util.equals(ValueRestriction, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.ValueRestrictionInt + */ +export class ValueRestrictionInt extends Message { + /** + * @generated from field: optional sint64 min = 1; + */ + min?: bigint; + + /** + * @generated from field: optional sint64 max = 2; + */ + max?: bigint; + + /** + * @generated from field: repeated sint64 allowed_values = 3; + */ + allowedValues: bigint[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.ValueRestrictionInt"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "min", kind: "scalar", T: 18 /* ScalarType.SINT64 */, opt: true }, + { no: 2, name: "max", kind: "scalar", T: 18 /* ScalarType.SINT64 */, opt: true }, + { no: 3, name: "allowed_values", kind: "scalar", T: 18 /* ScalarType.SINT64 */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ValueRestrictionInt { + return new ValueRestrictionInt().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ValueRestrictionInt { + return new ValueRestrictionInt().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ValueRestrictionInt { + return new ValueRestrictionInt().fromJsonString(jsonString, options); + } + + static equals(a: ValueRestrictionInt | PlainMessage | undefined, b: ValueRestrictionInt | PlainMessage | undefined): boolean { + return proto3.util.equals(ValueRestrictionInt, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.ValueRestrictionUint + */ +export class ValueRestrictionUint extends Message { + /** + * @generated from field: optional uint64 min = 1; + */ + min?: bigint; + + /** + * @generated from field: optional uint64 max = 2; + */ + max?: bigint; + + /** + * @generated from field: repeated uint64 allowed_values = 3; + */ + allowedValues: bigint[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.ValueRestrictionUint"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "min", kind: "scalar", T: 4 /* ScalarType.UINT64 */, opt: true }, + { no: 2, name: "max", kind: "scalar", T: 4 /* ScalarType.UINT64 */, opt: true }, + { no: 3, name: "allowed_values", kind: "scalar", T: 4 /* ScalarType.UINT64 */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ValueRestrictionUint { + return new ValueRestrictionUint().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ValueRestrictionUint { + return new ValueRestrictionUint().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ValueRestrictionUint { + return new ValueRestrictionUint().fromJsonString(jsonString, options); + } + + static equals(a: ValueRestrictionUint | PlainMessage | undefined, b: ValueRestrictionUint | PlainMessage | undefined): boolean { + return proto3.util.equals(ValueRestrictionUint, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.ValueRestrictionFloat + */ +export class ValueRestrictionFloat extends Message { + /** + * @generated from field: optional double min = 1; + */ + min?: number; + + /** + * @generated from field: optional double max = 2; + */ + max?: number; + + /** + * allowed for doubles/floats not recommended + * + * @generated from field: repeated double allowed_values = 3; + */ + allowedValues: number[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.ValueRestrictionFloat"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "min", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true }, + { no: 2, name: "max", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true }, + { no: 3, name: "allowed_values", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ValueRestrictionFloat { + return new ValueRestrictionFloat().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ValueRestrictionFloat { + return new ValueRestrictionFloat().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ValueRestrictionFloat { + return new ValueRestrictionFloat().fromJsonString(jsonString, options); + } + + static equals(a: ValueRestrictionFloat | PlainMessage | undefined, b: ValueRestrictionFloat | PlainMessage | undefined): boolean { + return proto3.util.equals(ValueRestrictionFloat, a, b); + } +} + +/** + * min, max doesn't make much sense for a string + * + * @generated from message kuksa.val.v1.ValueRestrictionString + */ +export class ValueRestrictionString extends Message { + /** + * @generated from field: repeated string allowed_values = 3; + */ + allowedValues: string[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.ValueRestrictionString"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 3, name: "allowed_values", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): ValueRestrictionString { + return new ValueRestrictionString().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): ValueRestrictionString { + return new ValueRestrictionString().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): ValueRestrictionString { + return new ValueRestrictionString().fromJsonString(jsonString, options); + } + + static equals(a: ValueRestrictionString | PlainMessage | undefined, b: ValueRestrictionString | PlainMessage | undefined): boolean { + return proto3.util.equals(ValueRestrictionString, a, b); + } +} + +/** + * Error response shall be an HTTP-like code. + * Should follow https://www.w3.org/TR/viss2-transport/#status-codes. + * + * @generated from message kuksa.val.v1.Error + */ +export class Error extends Message { + /** + * @generated from field: uint32 code = 1; + */ + code = 0; + + /** + * @generated from field: string reason = 2; + */ + reason = ""; + + /** + * @generated from field: string message = 3; + */ + message = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.Error"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "code", kind: "scalar", T: 13 /* ScalarType.UINT32 */ }, + { no: 2, name: "reason", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 3, name: "message", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Error { + return new Error().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Error { + return new Error().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Error { + return new Error().fromJsonString(jsonString, options); + } + + static equals(a: Error | PlainMessage | undefined, b: Error | PlainMessage | undefined): boolean { + return proto3.util.equals(Error, a, b); + } +} + +/** + * Used in get/set requests to report errors for specific entries + * + * @generated from message kuksa.val.v1.DataEntryError + */ +export class DataEntryError extends Message { + /** + * vss path + * + * @generated from field: string path = 1; + */ + path = ""; + + /** + * @generated from field: kuksa.val.v1.Error error = 2; + */ + error?: Error; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.DataEntryError"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "error", kind: "message", T: Error }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): DataEntryError { + return new DataEntryError().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): DataEntryError { + return new DataEntryError().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): DataEntryError { + return new DataEntryError().fromJsonString(jsonString, options); + } + + static equals(a: DataEntryError | PlainMessage | undefined, b: DataEntryError | PlainMessage | undefined): boolean { + return proto3.util.equals(DataEntryError, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.StringArray + */ +export class StringArray extends Message { + /** + * @generated from field: repeated string values = 1; + */ + values: string[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.StringArray"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): StringArray { + return new StringArray().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): StringArray { + return new StringArray().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): StringArray { + return new StringArray().fromJsonString(jsonString, options); + } + + static equals(a: StringArray | PlainMessage | undefined, b: StringArray | PlainMessage | undefined): boolean { + return proto3.util.equals(StringArray, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.BoolArray + */ +export class BoolArray extends Message { + /** + * @generated from field: repeated bool values = 1; + */ + values: boolean[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.BoolArray"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 8 /* ScalarType.BOOL */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): BoolArray { + return new BoolArray().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): BoolArray { + return new BoolArray().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): BoolArray { + return new BoolArray().fromJsonString(jsonString, options); + } + + static equals(a: BoolArray | PlainMessage | undefined, b: BoolArray | PlainMessage | undefined): boolean { + return proto3.util.equals(BoolArray, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.Int32Array + */ +export class Int32Array extends Message { + /** + * @generated from field: repeated sint32 values = 1; + */ + values: number[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.Int32Array"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 17 /* ScalarType.SINT32 */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Int32Array { + return new Int32Array().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Int32Array { + return new Int32Array().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Int32Array { + return new Int32Array().fromJsonString(jsonString, options); + } + + static equals(a: Int32Array | PlainMessage | undefined, b: Int32Array | PlainMessage | undefined): boolean { + return proto3.util.equals(Int32Array, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.Int64Array + */ +export class Int64Array extends Message { + /** + * @generated from field: repeated sint64 values = 1; + */ + values: bigint[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.Int64Array"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 18 /* ScalarType.SINT64 */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Int64Array { + return new Int64Array().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Int64Array { + return new Int64Array().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Int64Array { + return new Int64Array().fromJsonString(jsonString, options); + } + + static equals(a: Int64Array | PlainMessage | undefined, b: Int64Array | PlainMessage | undefined): boolean { + return proto3.util.equals(Int64Array, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.Uint32Array + */ +export class Uint32Array extends Message { + /** + * @generated from field: repeated uint32 values = 1; + */ + values: number[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.Uint32Array"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 13 /* ScalarType.UINT32 */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Uint32Array { + return new Uint32Array().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Uint32Array { + return new Uint32Array().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Uint32Array { + return new Uint32Array().fromJsonString(jsonString, options); + } + + static equals(a: Uint32Array | PlainMessage | undefined, b: Uint32Array | PlainMessage | undefined): boolean { + return proto3.util.equals(Uint32Array, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.Uint64Array + */ +export class Uint64Array extends Message { + /** + * @generated from field: repeated uint64 values = 1; + */ + values: bigint[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.Uint64Array"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 4 /* ScalarType.UINT64 */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): Uint64Array { + return new Uint64Array().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): Uint64Array { + return new Uint64Array().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): Uint64Array { + return new Uint64Array().fromJsonString(jsonString, options); + } + + static equals(a: Uint64Array | PlainMessage | undefined, b: Uint64Array | PlainMessage | undefined): boolean { + return proto3.util.equals(Uint64Array, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.FloatArray + */ +export class FloatArray extends Message { + /** + * @generated from field: repeated float values = 1; + */ + values: number[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.FloatArray"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 2 /* ScalarType.FLOAT */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): FloatArray { + return new FloatArray().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): FloatArray { + return new FloatArray().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): FloatArray { + return new FloatArray().fromJsonString(jsonString, options); + } + + static equals(a: FloatArray | PlainMessage | undefined, b: FloatArray | PlainMessage | undefined): boolean { + return proto3.util.equals(FloatArray, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.DoubleArray + */ +export class DoubleArray extends Message { + /** + * @generated from field: repeated double values = 1; + */ + values: number[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.DoubleArray"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "values", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): DoubleArray { + return new DoubleArray().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): DoubleArray { + return new DoubleArray().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): DoubleArray { + return new DoubleArray().fromJsonString(jsonString, options); + } + + static equals(a: DoubleArray | PlainMessage | undefined, b: DoubleArray | PlainMessage | undefined): boolean { + return proto3.util.equals(DoubleArray, a, b); + } +} + diff --git a/typescript/examples/aicar/src/gen/kuksa/val/v1/val_connect.d.ts b/typescript/examples/aicar/src/gen/kuksa/val/v1/val_connect.d.ts new file mode 100644 index 00000000..9ce20fcf --- /dev/null +++ b/typescript/examples/aicar/src/gen/kuksa/val/v1/val_connect.d.ts @@ -0,0 +1,69 @@ +import { GetRequest, GetResponse, GetServerInfoRequest, GetServerInfoResponse, SetRequest, SetResponse, StreamedUpdateRequest, StreamedUpdateResponse, SubscribeRequest, SubscribeResponse } from "./val_pb.js"; +import { MethodKind } from "@bufbuild/protobuf"; +/** + * @generated from service kuksa.val.v1.VAL + */ +export declare const VAL: { + readonly typeName: "kuksa.val.v1.VAL"; + readonly methods: { + /** + * Get entries + * + * @generated from rpc kuksa.val.v1.VAL.Get + */ + readonly get: { + readonly name: "Get"; + readonly I: typeof GetRequest; + readonly O: typeof GetResponse; + readonly kind: MethodKind.Unary; + }; + /** + * Set entries + * + * @generated from rpc kuksa.val.v1.VAL.Set + */ + readonly set: { + readonly name: "Set"; + readonly I: typeof SetRequest; + readonly O: typeof SetResponse; + readonly kind: MethodKind.Unary; + }; + /** + * @generated from rpc kuksa.val.v1.VAL.StreamedUpdate + */ + readonly streamedUpdate: { + readonly name: "StreamedUpdate"; + readonly I: typeof StreamedUpdateRequest; + readonly O: typeof StreamedUpdateResponse; + readonly kind: MethodKind.BiDiStreaming; + }; + /** + * Subscribe to a set of entries + * + * Returns a stream of notifications. + * + * InvalidArgument is returned if the request is malformed. + * + * @generated from rpc kuksa.val.v1.VAL.Subscribe + */ + readonly subscribe: { + readonly name: "Subscribe"; + readonly I: typeof SubscribeRequest; + readonly O: typeof SubscribeResponse; + readonly kind: MethodKind.ServerStreaming; + }; + /** + * Shall return information that allows the client to determine + * what server/server implementation/version it is talking to + * eg. kuksa-databroker 0.5.1 + * + * @generated from rpc kuksa.val.v1.VAL.GetServerInfo + */ + readonly getServerInfo: { + readonly name: "GetServerInfo"; + readonly I: typeof GetServerInfoRequest; + readonly O: typeof GetServerInfoResponse; + readonly kind: MethodKind.Unary; + }; + }; +}; diff --git a/typescript/examples/aicar/src/gen/kuksa/val/v1/val_connect.js b/typescript/examples/aicar/src/gen/kuksa/val/v1/val_connect.js new file mode 100644 index 00000000..9fcb0ebf --- /dev/null +++ b/typescript/examples/aicar/src/gen/kuksa/val/v1/val_connect.js @@ -0,0 +1,89 @@ +"use strict"; +//******************************************************************************* +// Copyright (c) 2022 Contributors to the Eclipse Foundation +// +// See the NOTICE file(s) distributed with this work for additional +// information regarding copyright ownership. +// +// This program and the accompanying materials are made available under the +// terms of the Apache License 2.0 which is available at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// SPDX-License-Identifier: Apache-2.0 +//****************************************************************************** +Object.defineProperty(exports, "__esModule", { value: true }); +exports.VAL = void 0; +// @generated by protoc-gen-connect-es v1.4.0 with parameter "target=ts" +// @generated from file kuksa/val/v1/val.proto (package kuksa.val.v1, syntax proto3) +/* eslint-disable */ +// @ts-nocheck +const val_pb_js_1 = require("./val_pb.js"); +const protobuf_1 = require("@bufbuild/protobuf"); +/** + * @generated from service kuksa.val.v1.VAL + */ +exports.VAL = { + typeName: "kuksa.val.v1.VAL", + methods: { + /** + * Get entries + * + * @generated from rpc kuksa.val.v1.VAL.Get + */ + get: { + name: "Get", + I: val_pb_js_1.GetRequest, + O: val_pb_js_1.GetResponse, + kind: protobuf_1.MethodKind.Unary, + }, + /** + * Set entries + * + * @generated from rpc kuksa.val.v1.VAL.Set + */ + set: { + name: "Set", + I: val_pb_js_1.SetRequest, + O: val_pb_js_1.SetResponse, + kind: protobuf_1.MethodKind.Unary, + }, + /** + * @generated from rpc kuksa.val.v1.VAL.StreamedUpdate + */ + streamedUpdate: { + name: "StreamedUpdate", + I: val_pb_js_1.StreamedUpdateRequest, + O: val_pb_js_1.StreamedUpdateResponse, + kind: protobuf_1.MethodKind.BiDiStreaming, + }, + /** + * Subscribe to a set of entries + * + * Returns a stream of notifications. + * + * InvalidArgument is returned if the request is malformed. + * + * @generated from rpc kuksa.val.v1.VAL.Subscribe + */ + subscribe: { + name: "Subscribe", + I: val_pb_js_1.SubscribeRequest, + O: val_pb_js_1.SubscribeResponse, + kind: protobuf_1.MethodKind.ServerStreaming, + }, + /** + * Shall return information that allows the client to determine + * what server/server implementation/version it is talking to + * eg. kuksa-databroker 0.5.1 + * + * @generated from rpc kuksa.val.v1.VAL.GetServerInfo + */ + getServerInfo: { + name: "GetServerInfo", + I: val_pb_js_1.GetServerInfoRequest, + O: val_pb_js_1.GetServerInfoResponse, + kind: protobuf_1.MethodKind.Unary, + }, + } +}; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsX2Nvbm5lY3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ2YWxfY29ubmVjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsaUZBQWlGO0FBQ2pGLDREQUE0RDtBQUM1RCxFQUFFO0FBQ0YsbUVBQW1FO0FBQ25FLDZDQUE2QztBQUM3QyxFQUFFO0FBQ0YsMkVBQTJFO0FBQzNFLHdEQUF3RDtBQUN4RCw2Q0FBNkM7QUFDN0MsRUFBRTtBQUNGLHNDQUFzQztBQUN0QyxnRkFBZ0Y7OztBQUVoRix3RUFBd0U7QUFDeEUsb0ZBQW9GO0FBQ3BGLG9CQUFvQjtBQUNwQixjQUFjO0FBRWQsMkNBQWdOO0FBQ2hOLGlEQUFnRDtBQUVoRDs7R0FFRztBQUNVLFFBQUEsR0FBRyxHQUFHO0lBQ2pCLFFBQVEsRUFBRSxrQkFBa0I7SUFDNUIsT0FBTyxFQUFFO1FBQ1A7Ozs7V0FJRztRQUNILEdBQUcsRUFBRTtZQUNILElBQUksRUFBRSxLQUFLO1lBQ1gsQ0FBQyxFQUFFLHNCQUFVO1lBQ2IsQ0FBQyxFQUFFLHVCQUFXO1lBQ2QsSUFBSSxFQUFFLHFCQUFVLENBQUMsS0FBSztTQUN2QjtRQUNEOzs7O1dBSUc7UUFDSCxHQUFHLEVBQUU7WUFDSCxJQUFJLEVBQUUsS0FBSztZQUNYLENBQUMsRUFBRSxzQkFBVTtZQUNiLENBQUMsRUFBRSx1QkFBVztZQUNkLElBQUksRUFBRSxxQkFBVSxDQUFDLEtBQUs7U0FDdkI7UUFDRDs7V0FFRztRQUNILGNBQWMsRUFBRTtZQUNkLElBQUksRUFBRSxnQkFBZ0I7WUFDdEIsQ0FBQyxFQUFFLGlDQUFxQjtZQUN4QixDQUFDLEVBQUUsa0NBQXNCO1lBQ3pCLElBQUksRUFBRSxxQkFBVSxDQUFDLGFBQWE7U0FDL0I7UUFDRDs7Ozs7Ozs7V0FRRztRQUNILFNBQVMsRUFBRTtZQUNULElBQUksRUFBRSxXQUFXO1lBQ2pCLENBQUMsRUFBRSw0QkFBZ0I7WUFDbkIsQ0FBQyxFQUFFLDZCQUFpQjtZQUNwQixJQUFJLEVBQUUscUJBQVUsQ0FBQyxlQUFlO1NBQ2pDO1FBQ0Q7Ozs7OztXQU1HO1FBQ0gsYUFBYSxFQUFFO1lBQ2IsSUFBSSxFQUFFLGVBQWU7WUFDckIsQ0FBQyxFQUFFLGdDQUFvQjtZQUN2QixDQUFDLEVBQUUsaUNBQXFCO1lBQ3hCLElBQUksRUFBRSxxQkFBVSxDQUFDLEtBQUs7U0FDdkI7S0FDRjtDQUNPLENBQUMifQ== \ No newline at end of file diff --git a/typescript/examples/aicar/src/gen/kuksa/val/v1/val_connect.ts b/typescript/examples/aicar/src/gen/kuksa/val/v1/val_connect.ts new file mode 100644 index 00000000..ed09e035 --- /dev/null +++ b/typescript/examples/aicar/src/gen/kuksa/val/v1/val_connect.ts @@ -0,0 +1,89 @@ +//******************************************************************************* +// Copyright (c) 2022 Contributors to the Eclipse Foundation +// +// See the NOTICE file(s) distributed with this work for additional +// information regarding copyright ownership. +// +// This program and the accompanying materials are made available under the +// terms of the Apache License 2.0 which is available at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// SPDX-License-Identifier: Apache-2.0 +//****************************************************************************** + +// @generated by protoc-gen-connect-es v1.4.0 with parameter "target=ts" +// @generated from file kuksa/val/v1/val.proto (package kuksa.val.v1, syntax proto3) +/* eslint-disable */ +// @ts-nocheck + +import { GetRequest, GetResponse, GetServerInfoRequest, GetServerInfoResponse, SetRequest, SetResponse, StreamedUpdateRequest, StreamedUpdateResponse, SubscribeRequest, SubscribeResponse } from "./val_pb.js"; +import { MethodKind } from "@bufbuild/protobuf"; + +/** + * @generated from service kuksa.val.v1.VAL + */ +export const VAL = { + typeName: "kuksa.val.v1.VAL", + methods: { + /** + * Get entries + * + * @generated from rpc kuksa.val.v1.VAL.Get + */ + get: { + name: "Get", + I: GetRequest, + O: GetResponse, + kind: MethodKind.Unary, + }, + /** + * Set entries + * + * @generated from rpc kuksa.val.v1.VAL.Set + */ + set: { + name: "Set", + I: SetRequest, + O: SetResponse, + kind: MethodKind.Unary, + }, + /** + * @generated from rpc kuksa.val.v1.VAL.StreamedUpdate + */ + streamedUpdate: { + name: "StreamedUpdate", + I: StreamedUpdateRequest, + O: StreamedUpdateResponse, + kind: MethodKind.BiDiStreaming, + }, + /** + * Subscribe to a set of entries + * + * Returns a stream of notifications. + * + * InvalidArgument is returned if the request is malformed. + * + * @generated from rpc kuksa.val.v1.VAL.Subscribe + */ + subscribe: { + name: "Subscribe", + I: SubscribeRequest, + O: SubscribeResponse, + kind: MethodKind.ServerStreaming, + }, + /** + * Shall return information that allows the client to determine + * what server/server implementation/version it is talking to + * eg. kuksa-databroker 0.5.1 + * + * @generated from rpc kuksa.val.v1.VAL.GetServerInfo + */ + getServerInfo: { + name: "GetServerInfo", + I: GetServerInfoRequest, + O: GetServerInfoResponse, + kind: MethodKind.Unary, + }, + } +} as const; + diff --git a/typescript/examples/aicar/src/gen/kuksa/val/v1/val_pb.d.ts b/typescript/examples/aicar/src/gen/kuksa/val/v1/val_pb.d.ts new file mode 100644 index 00000000..c39557cf --- /dev/null +++ b/typescript/examples/aicar/src/gen/kuksa/val/v1/val_pb.d.ts @@ -0,0 +1,282 @@ +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Message, proto3 } from "@bufbuild/protobuf"; +import { DataEntry, DataEntryError, Error, Field, View } from "./types_pb.js"; +/** + * Define which data we want + * + * @generated from message kuksa.val.v1.EntryRequest + */ +export declare class EntryRequest extends Message { + /** + * @generated from field: string path = 1; + */ + path: string; + /** + * @generated from field: kuksa.val.v1.View view = 2; + */ + view: View; + /** + * @generated from field: repeated kuksa.val.v1.Field fields = 3; + */ + fields: Field[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.EntryRequest"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): EntryRequest; + static fromJson(jsonValue: JsonValue, options?: Partial): EntryRequest; + static fromJsonString(jsonString: string, options?: Partial): EntryRequest; + static equals(a: EntryRequest | PlainMessage | undefined, b: EntryRequest | PlainMessage | undefined): boolean; +} +/** + * Request a set of entries. + * + * @generated from message kuksa.val.v1.GetRequest + */ +export declare class GetRequest extends Message { + /** + * @generated from field: repeated kuksa.val.v1.EntryRequest entries = 1; + */ + entries: EntryRequest[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.GetRequest"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): GetRequest; + static fromJson(jsonValue: JsonValue, options?: Partial): GetRequest; + static fromJsonString(jsonString: string, options?: Partial): GetRequest; + static equals(a: GetRequest | PlainMessage | undefined, b: GetRequest | PlainMessage | undefined): boolean; +} +/** + * Global errors are specified in `error`. + * Errors for individual entries are specified in `errors`. + * + * @generated from message kuksa.val.v1.GetResponse + */ +export declare class GetResponse extends Message { + /** + * @generated from field: repeated kuksa.val.v1.DataEntry entries = 1; + */ + entries: DataEntry[]; + /** + * @generated from field: repeated kuksa.val.v1.DataEntryError errors = 2; + */ + errors: DataEntryError[]; + /** + * @generated from field: kuksa.val.v1.Error error = 3; + */ + error?: Error; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.GetResponse"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): GetResponse; + static fromJson(jsonValue: JsonValue, options?: Partial): GetResponse; + static fromJsonString(jsonString: string, options?: Partial): GetResponse; + static equals(a: GetResponse | PlainMessage | undefined, b: GetResponse | PlainMessage | undefined): boolean; +} +/** + * Define the data we want to set + * + * @generated from message kuksa.val.v1.EntryUpdate + */ +export declare class EntryUpdate extends Message { + /** + * @generated from field: kuksa.val.v1.DataEntry entry = 1; + */ + entry?: DataEntry; + /** + * @generated from field: repeated kuksa.val.v1.Field fields = 2; + */ + fields: Field[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.EntryUpdate"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): EntryUpdate; + static fromJson(jsonValue: JsonValue, options?: Partial): EntryUpdate; + static fromJsonString(jsonString: string, options?: Partial): EntryUpdate; + static equals(a: EntryUpdate | PlainMessage | undefined, b: EntryUpdate | PlainMessage | undefined): boolean; +} +/** + * A list of entries to be updated + * + * @generated from message kuksa.val.v1.SetRequest + */ +export declare class SetRequest extends Message { + /** + * @generated from field: repeated kuksa.val.v1.EntryUpdate updates = 1; + */ + updates: EntryUpdate[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.SetRequest"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): SetRequest; + static fromJson(jsonValue: JsonValue, options?: Partial): SetRequest; + static fromJsonString(jsonString: string, options?: Partial): SetRequest; + static equals(a: SetRequest | PlainMessage | undefined, b: SetRequest | PlainMessage | undefined): boolean; +} +/** + * Global errors are specified in `error`. + * Errors for individual entries are specified in `errors`. + * + * @generated from message kuksa.val.v1.SetResponse + */ +export declare class SetResponse extends Message { + /** + * @generated from field: kuksa.val.v1.Error error = 1; + */ + error?: Error; + /** + * @generated from field: repeated kuksa.val.v1.DataEntryError errors = 2; + */ + errors: DataEntryError[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.SetResponse"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): SetResponse; + static fromJson(jsonValue: JsonValue, options?: Partial): SetResponse; + static fromJsonString(jsonString: string, options?: Partial): SetResponse; + static equals(a: SetResponse | PlainMessage | undefined, b: SetResponse | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.StreamedUpdateRequest + */ +export declare class StreamedUpdateRequest extends Message { + /** + * @generated from field: repeated kuksa.val.v1.EntryUpdate updates = 1; + */ + updates: EntryUpdate[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.StreamedUpdateRequest"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): StreamedUpdateRequest; + static fromJson(jsonValue: JsonValue, options?: Partial): StreamedUpdateRequest; + static fromJsonString(jsonString: string, options?: Partial): StreamedUpdateRequest; + static equals(a: StreamedUpdateRequest | PlainMessage | undefined, b: StreamedUpdateRequest | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.StreamedUpdateResponse + */ +export declare class StreamedUpdateResponse extends Message { + /** + * @generated from field: kuksa.val.v1.Error error = 1; + */ + error?: Error; + /** + * @generated from field: repeated kuksa.val.v1.DataEntryError errors = 2; + */ + errors: DataEntryError[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.StreamedUpdateResponse"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): StreamedUpdateResponse; + static fromJson(jsonValue: JsonValue, options?: Partial): StreamedUpdateResponse; + static fromJsonString(jsonString: string, options?: Partial): StreamedUpdateResponse; + static equals(a: StreamedUpdateResponse | PlainMessage | undefined, b: StreamedUpdateResponse | PlainMessage | undefined): boolean; +} +/** + * Define what to subscribe to + * + * @generated from message kuksa.val.v1.SubscribeEntry + */ +export declare class SubscribeEntry extends Message { + /** + * @generated from field: string path = 1; + */ + path: string; + /** + * @generated from field: kuksa.val.v1.View view = 2; + */ + view: View; + /** + * @generated from field: repeated kuksa.val.v1.Field fields = 3; + */ + fields: Field[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.SubscribeEntry"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): SubscribeEntry; + static fromJson(jsonValue: JsonValue, options?: Partial): SubscribeEntry; + static fromJsonString(jsonString: string, options?: Partial): SubscribeEntry; + static equals(a: SubscribeEntry | PlainMessage | undefined, b: SubscribeEntry | PlainMessage | undefined): boolean; +} +/** + * Subscribe to changes in datapoints. + * + * @generated from message kuksa.val.v1.SubscribeRequest + */ +export declare class SubscribeRequest extends Message { + /** + * @generated from field: repeated kuksa.val.v1.SubscribeEntry entries = 1; + */ + entries: SubscribeEntry[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.SubscribeRequest"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): SubscribeRequest; + static fromJson(jsonValue: JsonValue, options?: Partial): SubscribeRequest; + static fromJsonString(jsonString: string, options?: Partial): SubscribeRequest; + static equals(a: SubscribeRequest | PlainMessage | undefined, b: SubscribeRequest | PlainMessage | undefined): boolean; +} +/** + * A subscription response + * + * @generated from message kuksa.val.v1.SubscribeResponse + */ +export declare class SubscribeResponse extends Message { + /** + * @generated from field: repeated kuksa.val.v1.EntryUpdate updates = 1; + */ + updates: EntryUpdate[]; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.SubscribeResponse"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): SubscribeResponse; + static fromJson(jsonValue: JsonValue, options?: Partial): SubscribeResponse; + static fromJsonString(jsonString: string, options?: Partial): SubscribeResponse; + static equals(a: SubscribeResponse | PlainMessage | undefined, b: SubscribeResponse | PlainMessage | undefined): boolean; +} +/** + * Nothing yet + * + * @generated from message kuksa.val.v1.GetServerInfoRequest + */ +export declare class GetServerInfoRequest extends Message { + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.GetServerInfoRequest"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): GetServerInfoRequest; + static fromJson(jsonValue: JsonValue, options?: Partial): GetServerInfoRequest; + static fromJsonString(jsonString: string, options?: Partial): GetServerInfoRequest; + static equals(a: GetServerInfoRequest | PlainMessage | undefined, b: GetServerInfoRequest | PlainMessage | undefined): boolean; +} +/** + * @generated from message kuksa.val.v1.GetServerInfoResponse + */ +export declare class GetServerInfoResponse extends Message { + /** + * @generated from field: string name = 1; + */ + name: string; + /** + * @generated from field: string version = 2; + */ + version: string; + constructor(data?: PartialMessage); + static readonly runtime: typeof proto3; + static readonly typeName = "kuksa.val.v1.GetServerInfoResponse"; + static readonly fields: FieldList; + static fromBinary(bytes: Uint8Array, options?: Partial): GetServerInfoResponse; + static fromJson(jsonValue: JsonValue, options?: Partial): GetServerInfoResponse; + static fromJsonString(jsonString: string, options?: Partial): GetServerInfoResponse; + static equals(a: GetServerInfoResponse | PlainMessage | undefined, b: GetServerInfoResponse | PlainMessage | undefined): boolean; +} diff --git a/typescript/examples/aicar/src/gen/kuksa/val/v1/val_pb.js b/typescript/examples/aicar/src/gen/kuksa/val/v1/val_pb.js new file mode 100644 index 00000000..f0c64479 --- /dev/null +++ b/typescript/examples/aicar/src/gen/kuksa/val/v1/val_pb.js @@ -0,0 +1,471 @@ +"use strict"; +//******************************************************************************* +// Copyright (c) 2022 Contributors to the Eclipse Foundation +// +// See the NOTICE file(s) distributed with this work for additional +// information regarding copyright ownership. +// +// This program and the accompanying materials are made available under the +// terms of the Apache License 2.0 which is available at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// SPDX-License-Identifier: Apache-2.0 +//****************************************************************************** +Object.defineProperty(exports, "__esModule", { value: true }); +exports.GetServerInfoResponse = exports.GetServerInfoRequest = exports.SubscribeResponse = exports.SubscribeRequest = exports.SubscribeEntry = exports.StreamedUpdateResponse = exports.StreamedUpdateRequest = exports.SetResponse = exports.SetRequest = exports.EntryUpdate = exports.GetResponse = exports.GetRequest = exports.EntryRequest = void 0; +const protobuf_1 = require("@bufbuild/protobuf"); +const types_pb_js_1 = require("./types_pb.js"); +/** + * Define which data we want + * + * @generated from message kuksa.val.v1.EntryRequest + */ +class EntryRequest extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: string path = 1; + */ + this.path = ""; + /** + * @generated from field: kuksa.val.v1.View view = 2; + */ + this.view = types_pb_js_1.View.UNSPECIFIED; + /** + * @generated from field: repeated kuksa.val.v1.Field fields = 3; + */ + this.fields = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new EntryRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new EntryRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new EntryRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(EntryRequest, a, b); + } +} +exports.EntryRequest = EntryRequest; +EntryRequest.runtime = protobuf_1.proto3; +EntryRequest.typeName = "kuksa.val.v1.EntryRequest"; +EntryRequest.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "view", kind: "enum", T: protobuf_1.proto3.getEnumType(types_pb_js_1.View) }, + { no: 3, name: "fields", kind: "enum", T: protobuf_1.proto3.getEnumType(types_pb_js_1.Field), repeated: true }, +]); +/** + * Request a set of entries. + * + * @generated from message kuksa.val.v1.GetRequest + */ +class GetRequest extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated kuksa.val.v1.EntryRequest entries = 1; + */ + this.entries = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new GetRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new GetRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new GetRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(GetRequest, a, b); + } +} +exports.GetRequest = GetRequest; +GetRequest.runtime = protobuf_1.proto3; +GetRequest.typeName = "kuksa.val.v1.GetRequest"; +GetRequest.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "entries", kind: "message", T: EntryRequest, repeated: true }, +]); +/** + * Global errors are specified in `error`. + * Errors for individual entries are specified in `errors`. + * + * @generated from message kuksa.val.v1.GetResponse + */ +class GetResponse extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated kuksa.val.v1.DataEntry entries = 1; + */ + this.entries = []; + /** + * @generated from field: repeated kuksa.val.v1.DataEntryError errors = 2; + */ + this.errors = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new GetResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new GetResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new GetResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(GetResponse, a, b); + } +} +exports.GetResponse = GetResponse; +GetResponse.runtime = protobuf_1.proto3; +GetResponse.typeName = "kuksa.val.v1.GetResponse"; +GetResponse.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "entries", kind: "message", T: types_pb_js_1.DataEntry, repeated: true }, + { no: 2, name: "errors", kind: "message", T: types_pb_js_1.DataEntryError, repeated: true }, + { no: 3, name: "error", kind: "message", T: types_pb_js_1.Error }, +]); +/** + * Define the data we want to set + * + * @generated from message kuksa.val.v1.EntryUpdate + */ +class EntryUpdate extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated kuksa.val.v1.Field fields = 2; + */ + this.fields = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new EntryUpdate().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new EntryUpdate().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new EntryUpdate().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(EntryUpdate, a, b); + } +} +exports.EntryUpdate = EntryUpdate; +EntryUpdate.runtime = protobuf_1.proto3; +EntryUpdate.typeName = "kuksa.val.v1.EntryUpdate"; +EntryUpdate.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "entry", kind: "message", T: types_pb_js_1.DataEntry }, + { no: 2, name: "fields", kind: "enum", T: protobuf_1.proto3.getEnumType(types_pb_js_1.Field), repeated: true }, +]); +/** + * A list of entries to be updated + * + * @generated from message kuksa.val.v1.SetRequest + */ +class SetRequest extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated kuksa.val.v1.EntryUpdate updates = 1; + */ + this.updates = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new SetRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new SetRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new SetRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(SetRequest, a, b); + } +} +exports.SetRequest = SetRequest; +SetRequest.runtime = protobuf_1.proto3; +SetRequest.typeName = "kuksa.val.v1.SetRequest"; +SetRequest.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "updates", kind: "message", T: EntryUpdate, repeated: true }, +]); +/** + * Global errors are specified in `error`. + * Errors for individual entries are specified in `errors`. + * + * @generated from message kuksa.val.v1.SetResponse + */ +class SetResponse extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated kuksa.val.v1.DataEntryError errors = 2; + */ + this.errors = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new SetResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new SetResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new SetResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(SetResponse, a, b); + } +} +exports.SetResponse = SetResponse; +SetResponse.runtime = protobuf_1.proto3; +SetResponse.typeName = "kuksa.val.v1.SetResponse"; +SetResponse.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "error", kind: "message", T: types_pb_js_1.Error }, + { no: 2, name: "errors", kind: "message", T: types_pb_js_1.DataEntryError, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.StreamedUpdateRequest + */ +class StreamedUpdateRequest extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated kuksa.val.v1.EntryUpdate updates = 1; + */ + this.updates = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new StreamedUpdateRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new StreamedUpdateRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new StreamedUpdateRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(StreamedUpdateRequest, a, b); + } +} +exports.StreamedUpdateRequest = StreamedUpdateRequest; +StreamedUpdateRequest.runtime = protobuf_1.proto3; +StreamedUpdateRequest.typeName = "kuksa.val.v1.StreamedUpdateRequest"; +StreamedUpdateRequest.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "updates", kind: "message", T: EntryUpdate, repeated: true }, +]); +/** + * @generated from message kuksa.val.v1.StreamedUpdateResponse + */ +class StreamedUpdateResponse extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated kuksa.val.v1.DataEntryError errors = 2; + */ + this.errors = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new StreamedUpdateResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new StreamedUpdateResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new StreamedUpdateResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(StreamedUpdateResponse, a, b); + } +} +exports.StreamedUpdateResponse = StreamedUpdateResponse; +StreamedUpdateResponse.runtime = protobuf_1.proto3; +StreamedUpdateResponse.typeName = "kuksa.val.v1.StreamedUpdateResponse"; +StreamedUpdateResponse.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "error", kind: "message", T: types_pb_js_1.Error }, + { no: 2, name: "errors", kind: "message", T: types_pb_js_1.DataEntryError, repeated: true }, +]); +/** + * Define what to subscribe to + * + * @generated from message kuksa.val.v1.SubscribeEntry + */ +class SubscribeEntry extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: string path = 1; + */ + this.path = ""; + /** + * @generated from field: kuksa.val.v1.View view = 2; + */ + this.view = types_pb_js_1.View.UNSPECIFIED; + /** + * @generated from field: repeated kuksa.val.v1.Field fields = 3; + */ + this.fields = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new SubscribeEntry().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new SubscribeEntry().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new SubscribeEntry().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(SubscribeEntry, a, b); + } +} +exports.SubscribeEntry = SubscribeEntry; +SubscribeEntry.runtime = protobuf_1.proto3; +SubscribeEntry.typeName = "kuksa.val.v1.SubscribeEntry"; +SubscribeEntry.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "view", kind: "enum", T: protobuf_1.proto3.getEnumType(types_pb_js_1.View) }, + { no: 3, name: "fields", kind: "enum", T: protobuf_1.proto3.getEnumType(types_pb_js_1.Field), repeated: true }, +]); +/** + * Subscribe to changes in datapoints. + * + * @generated from message kuksa.val.v1.SubscribeRequest + */ +class SubscribeRequest extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated kuksa.val.v1.SubscribeEntry entries = 1; + */ + this.entries = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new SubscribeRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new SubscribeRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new SubscribeRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(SubscribeRequest, a, b); + } +} +exports.SubscribeRequest = SubscribeRequest; +SubscribeRequest.runtime = protobuf_1.proto3; +SubscribeRequest.typeName = "kuksa.val.v1.SubscribeRequest"; +SubscribeRequest.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "entries", kind: "message", T: SubscribeEntry, repeated: true }, +]); +/** + * A subscription response + * + * @generated from message kuksa.val.v1.SubscribeResponse + */ +class SubscribeResponse extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: repeated kuksa.val.v1.EntryUpdate updates = 1; + */ + this.updates = []; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new SubscribeResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new SubscribeResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new SubscribeResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(SubscribeResponse, a, b); + } +} +exports.SubscribeResponse = SubscribeResponse; +SubscribeResponse.runtime = protobuf_1.proto3; +SubscribeResponse.typeName = "kuksa.val.v1.SubscribeResponse"; +SubscribeResponse.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "updates", kind: "message", T: EntryUpdate, repeated: true }, +]); +/** + * Nothing yet + * + * @generated from message kuksa.val.v1.GetServerInfoRequest + */ +class GetServerInfoRequest extends protobuf_1.Message { + constructor(data) { + super(); + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new GetServerInfoRequest().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new GetServerInfoRequest().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new GetServerInfoRequest().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(GetServerInfoRequest, a, b); + } +} +exports.GetServerInfoRequest = GetServerInfoRequest; +GetServerInfoRequest.runtime = protobuf_1.proto3; +GetServerInfoRequest.typeName = "kuksa.val.v1.GetServerInfoRequest"; +GetServerInfoRequest.fields = protobuf_1.proto3.util.newFieldList(() => []); +/** + * @generated from message kuksa.val.v1.GetServerInfoResponse + */ +class GetServerInfoResponse extends protobuf_1.Message { + constructor(data) { + super(); + /** + * @generated from field: string name = 1; + */ + this.name = ""; + /** + * @generated from field: string version = 2; + */ + this.version = ""; + protobuf_1.proto3.util.initPartial(data, this); + } + static fromBinary(bytes, options) { + return new GetServerInfoResponse().fromBinary(bytes, options); + } + static fromJson(jsonValue, options) { + return new GetServerInfoResponse().fromJson(jsonValue, options); + } + static fromJsonString(jsonString, options) { + return new GetServerInfoResponse().fromJsonString(jsonString, options); + } + static equals(a, b) { + return protobuf_1.proto3.util.equals(GetServerInfoResponse, a, b); + } +} +exports.GetServerInfoResponse = GetServerInfoResponse; +GetServerInfoResponse.runtime = protobuf_1.proto3; +GetServerInfoResponse.typeName = "kuksa.val.v1.GetServerInfoResponse"; +GetServerInfoResponse.fields = protobuf_1.proto3.util.newFieldList(() => [ + { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "version", kind: "scalar", T: 9 /* ScalarType.STRING */ }, +]); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"val_pb.js","sourceRoot":"","sources":["val_pb.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/typescript/examples/aicar/src/gen/kuksa/val/v1/val_pb.ts b/typescript/examples/aicar/src/gen/kuksa/val/v1/val_pb.ts new file mode 100644 index 00000000..2b656bbe --- /dev/null +++ b/typescript/examples/aicar/src/gen/kuksa/val/v1/val_pb.ts @@ -0,0 +1,579 @@ +//******************************************************************************* +// Copyright (c) 2022 Contributors to the Eclipse Foundation +// +// See the NOTICE file(s) distributed with this work for additional +// information regarding copyright ownership. +// +// This program and the accompanying materials are made available under the +// terms of the Apache License 2.0 which is available at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// SPDX-License-Identifier: Apache-2.0 +//****************************************************************************** + +// @generated by protoc-gen-es v1.10.0 with parameter "target=ts" +// @generated from file kuksa/val/v1/val.proto (package kuksa.val.v1, syntax proto3) +/* eslint-disable */ +// @ts-nocheck + +import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf"; +import { Message, proto3 } from "@bufbuild/protobuf"; +import { DataEntry, DataEntryError, Error, Field, View } from "./types_pb.js"; + +/** + * Define which data we want + * + * @generated from message kuksa.val.v1.EntryRequest + */ +export class EntryRequest extends Message { + /** + * @generated from field: string path = 1; + */ + path = ""; + + /** + * @generated from field: kuksa.val.v1.View view = 2; + */ + view = View.UNSPECIFIED; + + /** + * @generated from field: repeated kuksa.val.v1.Field fields = 3; + */ + fields: Field[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.EntryRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "view", kind: "enum", T: proto3.getEnumType(View) }, + { no: 3, name: "fields", kind: "enum", T: proto3.getEnumType(Field), repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): EntryRequest { + return new EntryRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): EntryRequest { + return new EntryRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): EntryRequest { + return new EntryRequest().fromJsonString(jsonString, options); + } + + static equals(a: EntryRequest | PlainMessage | undefined, b: EntryRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(EntryRequest, a, b); + } +} + +/** + * Request a set of entries. + * + * @generated from message kuksa.val.v1.GetRequest + */ +export class GetRequest extends Message { + /** + * @generated from field: repeated kuksa.val.v1.EntryRequest entries = 1; + */ + entries: EntryRequest[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.GetRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "entries", kind: "message", T: EntryRequest, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): GetRequest { + return new GetRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): GetRequest { + return new GetRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): GetRequest { + return new GetRequest().fromJsonString(jsonString, options); + } + + static equals(a: GetRequest | PlainMessage | undefined, b: GetRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(GetRequest, a, b); + } +} + +/** + * Global errors are specified in `error`. + * Errors for individual entries are specified in `errors`. + * + * @generated from message kuksa.val.v1.GetResponse + */ +export class GetResponse extends Message { + /** + * @generated from field: repeated kuksa.val.v1.DataEntry entries = 1; + */ + entries: DataEntry[] = []; + + /** + * @generated from field: repeated kuksa.val.v1.DataEntryError errors = 2; + */ + errors: DataEntryError[] = []; + + /** + * @generated from field: kuksa.val.v1.Error error = 3; + */ + error?: Error; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.GetResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "entries", kind: "message", T: DataEntry, repeated: true }, + { no: 2, name: "errors", kind: "message", T: DataEntryError, repeated: true }, + { no: 3, name: "error", kind: "message", T: Error }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): GetResponse { + return new GetResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): GetResponse { + return new GetResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): GetResponse { + return new GetResponse().fromJsonString(jsonString, options); + } + + static equals(a: GetResponse | PlainMessage | undefined, b: GetResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(GetResponse, a, b); + } +} + +/** + * Define the data we want to set + * + * @generated from message kuksa.val.v1.EntryUpdate + */ +export class EntryUpdate extends Message { + /** + * @generated from field: kuksa.val.v1.DataEntry entry = 1; + */ + entry?: DataEntry; + + /** + * @generated from field: repeated kuksa.val.v1.Field fields = 2; + */ + fields: Field[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.EntryUpdate"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "entry", kind: "message", T: DataEntry }, + { no: 2, name: "fields", kind: "enum", T: proto3.getEnumType(Field), repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): EntryUpdate { + return new EntryUpdate().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): EntryUpdate { + return new EntryUpdate().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): EntryUpdate { + return new EntryUpdate().fromJsonString(jsonString, options); + } + + static equals(a: EntryUpdate | PlainMessage | undefined, b: EntryUpdate | PlainMessage | undefined): boolean { + return proto3.util.equals(EntryUpdate, a, b); + } +} + +/** + * A list of entries to be updated + * + * @generated from message kuksa.val.v1.SetRequest + */ +export class SetRequest extends Message { + /** + * @generated from field: repeated kuksa.val.v1.EntryUpdate updates = 1; + */ + updates: EntryUpdate[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.SetRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "updates", kind: "message", T: EntryUpdate, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SetRequest { + return new SetRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SetRequest { + return new SetRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SetRequest { + return new SetRequest().fromJsonString(jsonString, options); + } + + static equals(a: SetRequest | PlainMessage | undefined, b: SetRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(SetRequest, a, b); + } +} + +/** + * Global errors are specified in `error`. + * Errors for individual entries are specified in `errors`. + * + * @generated from message kuksa.val.v1.SetResponse + */ +export class SetResponse extends Message { + /** + * @generated from field: kuksa.val.v1.Error error = 1; + */ + error?: Error; + + /** + * @generated from field: repeated kuksa.val.v1.DataEntryError errors = 2; + */ + errors: DataEntryError[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.SetResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "error", kind: "message", T: Error }, + { no: 2, name: "errors", kind: "message", T: DataEntryError, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SetResponse { + return new SetResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SetResponse { + return new SetResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SetResponse { + return new SetResponse().fromJsonString(jsonString, options); + } + + static equals(a: SetResponse | PlainMessage | undefined, b: SetResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(SetResponse, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.StreamedUpdateRequest + */ +export class StreamedUpdateRequest extends Message { + /** + * @generated from field: repeated kuksa.val.v1.EntryUpdate updates = 1; + */ + updates: EntryUpdate[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.StreamedUpdateRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "updates", kind: "message", T: EntryUpdate, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): StreamedUpdateRequest { + return new StreamedUpdateRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): StreamedUpdateRequest { + return new StreamedUpdateRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): StreamedUpdateRequest { + return new StreamedUpdateRequest().fromJsonString(jsonString, options); + } + + static equals(a: StreamedUpdateRequest | PlainMessage | undefined, b: StreamedUpdateRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(StreamedUpdateRequest, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.StreamedUpdateResponse + */ +export class StreamedUpdateResponse extends Message { + /** + * @generated from field: kuksa.val.v1.Error error = 1; + */ + error?: Error; + + /** + * @generated from field: repeated kuksa.val.v1.DataEntryError errors = 2; + */ + errors: DataEntryError[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.StreamedUpdateResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "error", kind: "message", T: Error }, + { no: 2, name: "errors", kind: "message", T: DataEntryError, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): StreamedUpdateResponse { + return new StreamedUpdateResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): StreamedUpdateResponse { + return new StreamedUpdateResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): StreamedUpdateResponse { + return new StreamedUpdateResponse().fromJsonString(jsonString, options); + } + + static equals(a: StreamedUpdateResponse | PlainMessage | undefined, b: StreamedUpdateResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(StreamedUpdateResponse, a, b); + } +} + +/** + * Define what to subscribe to + * + * @generated from message kuksa.val.v1.SubscribeEntry + */ +export class SubscribeEntry extends Message { + /** + * @generated from field: string path = 1; + */ + path = ""; + + /** + * @generated from field: kuksa.val.v1.View view = 2; + */ + view = View.UNSPECIFIED; + + /** + * @generated from field: repeated kuksa.val.v1.Field fields = 3; + */ + fields: Field[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.SubscribeEntry"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "path", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "view", kind: "enum", T: proto3.getEnumType(View) }, + { no: 3, name: "fields", kind: "enum", T: proto3.getEnumType(Field), repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SubscribeEntry { + return new SubscribeEntry().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SubscribeEntry { + return new SubscribeEntry().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SubscribeEntry { + return new SubscribeEntry().fromJsonString(jsonString, options); + } + + static equals(a: SubscribeEntry | PlainMessage | undefined, b: SubscribeEntry | PlainMessage | undefined): boolean { + return proto3.util.equals(SubscribeEntry, a, b); + } +} + +/** + * Subscribe to changes in datapoints. + * + * @generated from message kuksa.val.v1.SubscribeRequest + */ +export class SubscribeRequest extends Message { + /** + * @generated from field: repeated kuksa.val.v1.SubscribeEntry entries = 1; + */ + entries: SubscribeEntry[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.SubscribeRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "entries", kind: "message", T: SubscribeEntry, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SubscribeRequest { + return new SubscribeRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SubscribeRequest { + return new SubscribeRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SubscribeRequest { + return new SubscribeRequest().fromJsonString(jsonString, options); + } + + static equals(a: SubscribeRequest | PlainMessage | undefined, b: SubscribeRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(SubscribeRequest, a, b); + } +} + +/** + * A subscription response + * + * @generated from message kuksa.val.v1.SubscribeResponse + */ +export class SubscribeResponse extends Message { + /** + * @generated from field: repeated kuksa.val.v1.EntryUpdate updates = 1; + */ + updates: EntryUpdate[] = []; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.SubscribeResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "updates", kind: "message", T: EntryUpdate, repeated: true }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): SubscribeResponse { + return new SubscribeResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): SubscribeResponse { + return new SubscribeResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): SubscribeResponse { + return new SubscribeResponse().fromJsonString(jsonString, options); + } + + static equals(a: SubscribeResponse | PlainMessage | undefined, b: SubscribeResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(SubscribeResponse, a, b); + } +} + +/** + * Nothing yet + * + * @generated from message kuksa.val.v1.GetServerInfoRequest + */ +export class GetServerInfoRequest extends Message { + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.GetServerInfoRequest"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): GetServerInfoRequest { + return new GetServerInfoRequest().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): GetServerInfoRequest { + return new GetServerInfoRequest().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): GetServerInfoRequest { + return new GetServerInfoRequest().fromJsonString(jsonString, options); + } + + static equals(a: GetServerInfoRequest | PlainMessage | undefined, b: GetServerInfoRequest | PlainMessage | undefined): boolean { + return proto3.util.equals(GetServerInfoRequest, a, b); + } +} + +/** + * @generated from message kuksa.val.v1.GetServerInfoResponse + */ +export class GetServerInfoResponse extends Message { + /** + * @generated from field: string name = 1; + */ + name = ""; + + /** + * @generated from field: string version = 2; + */ + version = ""; + + constructor(data?: PartialMessage) { + super(); + proto3.util.initPartial(data, this); + } + + static readonly runtime: typeof proto3 = proto3; + static readonly typeName = "kuksa.val.v1.GetServerInfoResponse"; + static readonly fields: FieldList = proto3.util.newFieldList(() => [ + { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + { no: 2, name: "version", kind: "scalar", T: 9 /* ScalarType.STRING */ }, + ]); + + static fromBinary(bytes: Uint8Array, options?: Partial): GetServerInfoResponse { + return new GetServerInfoResponse().fromBinary(bytes, options); + } + + static fromJson(jsonValue: JsonValue, options?: Partial): GetServerInfoResponse { + return new GetServerInfoResponse().fromJson(jsonValue, options); + } + + static fromJsonString(jsonString: string, options?: Partial): GetServerInfoResponse { + return new GetServerInfoResponse().fromJsonString(jsonString, options); + } + + static equals(a: GetServerInfoResponse | PlainMessage | undefined, b: GetServerInfoResponse | PlainMessage | undefined): boolean { + return proto3.util.equals(GetServerInfoResponse, a, b); + } +} + diff --git a/typescript/examples/aicar/src/input.txt b/typescript/examples/aicar/src/input.txt new file mode 100644 index 00000000..23ce2372 --- /dev/null +++ b/typescript/examples/aicar/src/input.txt @@ -0,0 +1,49 @@ +What is the temperature on the front drivers side? +What is the temperature on the front passengar side? +What is the temperature on the rear driver side? +What is the temperature on the front passenger side? +Set the temperature on the front drivers side to 33. +Set the temperature on the rear drivers side to 33. +Is the drivers side front door locked? +Please lock the drivers side front door. +what is the temperature in all the zones of the car? +are the fog lights on? +is the left turn signal on? +turn the left turn signal on. +are the high beams on? +close the trunk. +turn the high beams on. +turn off the left turn signal. +what is the left drivers side tire pressure? +what is the right rear drivers side tire pressure? +what is the left rear passenger side tire pressure? +set the drivers front tire pressure to 33. +set the passenger rear tire pressure to 33. +open the rear passenger door. +unlock the rear passenger door. +close the rear passenger door. +lock the rear passenger door. +are the hazard lights on? what is the capital of france? +turn on the hazard lights. +is the trunk open? +open the trunk. +lock the rear passenger side door. +turn on the fog lights +turn off the fog lights and turn on the high beams. +open and unlock all the doors. +is austin texas a city? Are the doors open? +Are the doors unlocked? +turn on the right turn signal. +turn off the right turn signal. +Are the hazard lights on? +is the right turn signal on? +turn on the hazard lights and set the driver side temperature to 43. +what is the temperature on the passenger zones of the car? +turn up the driver side temperature to 55. +lock every door except for the driver side. +unlock all non driver doors +lock every door +close and lock everything +set the tire pressure on all wheels to 22. +open, unlock and turn on everything also set every temperature to 78 +close, lock and turn off everything also set every temperature to 22 \ No newline at end of file diff --git a/typescript/examples/aicar/src/main.ts b/typescript/examples/aicar/src/main.ts new file mode 100644 index 00000000..268c7a2f --- /dev/null +++ b/typescript/examples/aicar/src/main.ts @@ -0,0 +1,54 @@ +import assert from "assert"; +import dotenv from "dotenv"; +import findConfig from "find-config"; +import fs from "fs"; +import path from "path"; +import { createJsonTranslator } from "typechat"; +import { createTypeScriptJsonValidator } from "typechat/ts"; +import { processRequests } from "typechat/interactive"; +import { CarActions } from "./SDVCarActionSchema"; +import {ModelConfig, requestTracking, validateCarResponse, parseCommandLine, createLLM} from "./utils" +import * as tsprogress from 'ts-progress'; + +const inputOptions = parseCommandLine(); +let models: ModelConfig[] = []; +const dotEnvPath = findConfig(".env"); +const modelConfigPath = findConfig("modelconfig.json"); +assert(dotEnvPath, ".env file not found!"); +dotenv.config({ path: dotEnvPath }); + +const llmodel = createLLM(inputOptions, modelConfigPath ?? undefined)!; +const schema = fs.readFileSync(path.join(__dirname, "SDVCarActionSchema.ts"), "utf8"); +const validator = createTypeScriptJsonValidator(schema, "CarActions"); +const translator = createJsonTranslator(llmodel, validator); + +if(inputOptions.validate){ + + if(inputOptions.inputfile) + { + const lines = fs.readFileSync(inputOptions.inputfile).toString().split(/\r?\n/); + var progress = tsprogress.create({total: lines.length}); + let responses = Promise.all(lines.map(async (x) => { + const result = await validateCarResponse(x, translator); + progress.update(); + return result; + })) + .then((values) => { + console.log('Processing Complete - Recap:'); + let passed = values.filter(e => e.status === 'Passed').length + let failed = values.filter(e => e.status === 'Failed').length + console.log('#of Requests: ' +values.length+ ' Passed: ' + passed + ' Failed: ' + failed + ' % correct: ' + (passed/values.length)*100 + '%'); + if(inputOptions.outputfile){ + fs.writeFileSync(inputOptions.outputfile, values.map(x=>JSON.stringify(x)).join('\n')); + } + }); + } +} +else{ + console.log('Interactive mode'); + processRequests("☕> ", "", async (request): Promise => { + const res: requestTracking = await validateCarResponse(request, translator); + console.log(res); + return; + }); +} diff --git a/typescript/examples/aicar/src/tsconfig.json b/typescript/examples/aicar/src/tsconfig.json new file mode 100644 index 00000000..3c52b822 --- /dev/null +++ b/typescript/examples/aicar/src/tsconfig.json @@ -0,0 +1,23 @@ +{ + "include": [ + "." + ], + "compilerOptions": { + "target": "es2021", + "lib": ["es2021"], + "module": "node16", + "allowJs": true, + "types": ["node"], + "outDir": "../dist", + "rootDirs": ["../gen"], + "esModuleInterop": true, + "moduleResolution": "NodeNext", + "forceConsistentCasingInFileNames": true, + "strict": true, + "noUnusedLocals": false, + "inlineSourceMap": true, + "declaration": true, + "composite": true, + "skipLibCheck": true + } + } \ No newline at end of file diff --git a/typescript/examples/aicar/src/utils.ts b/typescript/examples/aicar/src/utils.ts new file mode 100644 index 00000000..61180ea9 --- /dev/null +++ b/typescript/examples/aicar/src/utils.ts @@ -0,0 +1,129 @@ +import { z } from "zod"; +import { VAL} from "../src/gen/kuksa/val/v1/val_connect"; +import { GetRequest, SetRequest} from "../src/gen/kuksa/val/v1/val_pb"; +import { createPromiseClient } from "@connectrpc/connect"; +import { createGrpcTransport } from "@connectrpc/connect-node"; +import { Command, Option, OptionValues } from 'commander'; +import { createAzureOpenAILanguageModel, createLanguageModel,createOpenAILanguageModel } from "typechat"; +import fs from "fs"; + +export class requestTracking { + request: string | undefined; + status?: string; + expectedRequest?: string; + generatedRequest?: string; + expectedAPIResponse?: string; + APIResponse?: string; + unknownRequest?: string; + errors?: string[]; + prompt?: string; +} + +export function parseCommandLine(){ + const program = new Command(); + program.addOption(new Option('-v, --validate', 'perform validattion of the input file'),); + program.addOption(new Option('-i, --inputfile ', 'file to parse input from'),); + program.addOption(new Option('-o, --outputfile ', 'file to parse input from'),); + program.addOption(new Option('-m, --model ', 'model to select from the modelconfig.json'),); + program.parse(process.argv); + return program.opts(); +}; + +export function createLLM(inputOptions: OptionValues, modelConfigPath: string | undefined){ + let llmodel; + if(inputOptions.model && modelConfigPath){ + const models = JSON.parse(fs.readFileSync(modelConfigPath, "utf8")) as ModelConfig[]; + const model = models.find(x => x.name === inputOptions.model); + if(model){ + llmodel = model.type === 'AzureOpenAI' ? createAzureOpenAILanguageModel(model.modelDetails.apiKey, model.modelDetails.apiEndpoint) + : model.type === 'Ollama' ? createOpenAILanguageModel(model.modelDetails.apiKey, model.name, model.modelDetails.apiEndpoint) + : createLanguageModel(process.env) + } + } + else{ + console.log('Model not found'); + llmodel = createLanguageModel(process.env); + } + return llmodel; +} + +export const SDVRequestResponse = z.object({ + entries: z.array( + z.object({ + path: z.string(), + value: z.object({ timestamp: z.string(), int32: z.number() }) + }) + ), + errors: z.array(z.unknown()) +}) + +export const SDVSetResponse = z.object({ + errors: z.array( + z.object({ + path: z.string(), + error: z.object({ + code: z.number(), + reason: z.string(), + message: z.string() + }) + }) + ) +}) + +export type Error = { + code: 0; + reason: ""; + message: ""; +} +export type DataEntryError = { + path: ""; + error?: Error; +} + +export interface ModelDetails { + apiKey: string; + apiEndpoint: string; + port?: number | string; +} + +export interface ModelConfig { + name: string; + type: string; + modelDetails: ModelDetails; +} + +export async function validateCarResponse(request: string, translator: any) { + const transport = createGrpcTransport({baseUrl: "http://localhost:55556",httpVersion: "2"}); //assumes local databroker on commonly used port + const vl = createPromiseClient(VAL, transport); + let requestTracking: requestTracking = {request: request}; + translator.attemptRepair = true; + requestTracking.prompt = translator.createRequestPrompt(request); + const response = await translator.translate(request); + if (!response.success) { + requestTracking.status = "Failed"; + requestTracking.errors = [response.message]; + return requestTracking; + } + const car = response.data; + for (const item of car.actions) { + if(item.type.includes('Set')) + { + requestTracking.generatedRequest = JSON.stringify(item.command); + const s1 = await vl.set(SetRequest.fromJsonString(JSON.stringify(item.command))); + requestTracking.APIResponse = JSON.stringify(s1); + requestTracking.status = s1.errors.length > 0 ? "Failed" : "Passed" + } + else if(item.type.includes('Get')) + { + requestTracking.generatedRequest = JSON.stringify(item.command); + const g1 = await vl.get(GetRequest.fromJsonString(JSON.stringify(item.command))); + requestTracking.APIResponse = JSON.stringify(g1); + requestTracking.status = g1.errors.length > 0 ? "Failed" : "Passed" + } + else + { + requestTracking.unknownRequest = JSON.stringify(item.command); + } + } + return requestTracking; +} diff --git a/typescript/examples/sentiment/src/tsconfig.json b/typescript/examples/sentiment/src/tsconfig.json index 0f8bbec6..07010f4f 100644 --- a/typescript/examples/sentiment/src/tsconfig.json +++ b/typescript/examples/sentiment/src/tsconfig.json @@ -6,6 +6,7 @@ "types": ["node"], "outDir": "../dist", "esModuleInterop": true, + "moduleResolution": "Node16", "forceConsistentCasingInFileNames": true, "strict": true, "noUnusedLocals": true, diff --git a/typescript/package-lock.json b/typescript/package-lock.json index 87941205..83d6da40 100644 --- a/typescript/package-lock.json +++ b/typescript/package-lock.json @@ -31,6 +31,48 @@ } } }, + "examples/aicar": { + "version": "0.0.1", + "license": "MIT", + "dependencies": { + "@bufbuild/buf": "^1.39.0", + "@bufbuild/protobuf": "^1.10.0", + "@bufbuild/protoc-gen-es": "^1.10.0", + "@connectrpc/connect": "^1.4.0", + "@connectrpc/connect-node": "^1.4.0", + "@connectrpc/protoc-gen-connect-es": "^1.4.0", + "assert": "^2.1.0", + "commander": "^12.1.0", + "dotenv": "^16.4.5", + "find-config": "^1.0.0", + "ts-progress": "^0.1.9", + "typescript": "^5.5.4", + "zod": "^3.23.8" + }, + "devDependencies": { + "@types/assert": "^1.5.10", + "@types/find-config": "^1.0.4", + "@types/node": "^22.5.1", + "copyfiles": "^2.4.1" + } + }, + "examples/aicar/node_modules/@types/node": { + "version": "22.5.1", + "resolved": "https://registry.npmjs.org/@types/node/-/node-22.5.1.tgz", + "integrity": "sha512-KkHsxej0j9IW1KKOOAA/XBA0z08UFSrRQHErzEfA3Vgq57eXIMYboIlHJuYIfd+lwCQjtKqUu3UnmKbtUc9yRw==", + "dev": true, + "license": "MIT", + "dependencies": { + "undici-types": "~6.19.2" + } + }, + "examples/aicar/node_modules/undici-types": { + "version": "6.19.8", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.19.8.tgz", + "integrity": "sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==", + "dev": true, + "license": "MIT" + }, "examples/calendar": { "version": "0.0.1", "license": "MIT", @@ -209,6 +251,241 @@ "typescript": "^5.3.3" } }, + "node_modules/@bufbuild/buf": { + "version": "1.39.0", + "resolved": "https://registry.npmjs.org/@bufbuild/buf/-/buf-1.39.0.tgz", + "integrity": "sha512-lm7xb9pc7X04rRjCQ69o9byAAZ7/dsUQGoH+iJ9uBSXQWiwQ1Ts8gneBnuUVsAH2vdW73NFBpmNQGE9XtFauVQ==", + "hasInstallScript": true, + "license": "Apache-2.0", + "bin": { + "buf": "bin/buf", + "protoc-gen-buf-breaking": "bin/protoc-gen-buf-breaking", + "protoc-gen-buf-lint": "bin/protoc-gen-buf-lint" + }, + "engines": { + "node": ">=12" + }, + "optionalDependencies": { + "@bufbuild/buf-darwin-arm64": "1.39.0", + "@bufbuild/buf-darwin-x64": "1.39.0", + "@bufbuild/buf-linux-aarch64": "1.39.0", + "@bufbuild/buf-linux-x64": "1.39.0", + "@bufbuild/buf-win32-arm64": "1.39.0", + "@bufbuild/buf-win32-x64": "1.39.0" + } + }, + "node_modules/@bufbuild/buf-darwin-arm64": { + "version": "1.39.0", + "resolved": "https://registry.npmjs.org/@bufbuild/buf-darwin-arm64/-/buf-darwin-arm64-1.39.0.tgz", + "integrity": "sha512-Ptl0uAGssLxQTzoZhGwv1FFTbzUfcstIpEwMhN+XrwiuqsSxOg9eq/n3yXoci5VJsHokjDUHnWkR3y+j5P/5KA==", + "cpu": [ + "arm64" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@bufbuild/buf-darwin-x64": { + "version": "1.39.0", + "resolved": "https://registry.npmjs.org/@bufbuild/buf-darwin-x64/-/buf-darwin-x64-1.39.0.tgz", + "integrity": "sha512-XNCuy9sjQwVJ4NIZqxaTIyzUtlyquSkp/Uuoh5W5thJ3nzZ5RSgvXKF5iXHhZmesrfRGApktwoCx5Am8runsfQ==", + "cpu": [ + "x64" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@bufbuild/buf-linux-aarch64": { + "version": "1.39.0", + "resolved": "https://registry.npmjs.org/@bufbuild/buf-linux-aarch64/-/buf-linux-aarch64-1.39.0.tgz", + "integrity": "sha512-Am+hrw94awp/eY027ROXwRQBuwAzOpQ/4zI4dgmgsyhzeWZ8w1LWC8z2SSr8T2cqd0cm52KxtoWMW+B3b2qzbw==", + "cpu": [ + "arm64" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@bufbuild/buf-linux-x64": { + "version": "1.39.0", + "resolved": "https://registry.npmjs.org/@bufbuild/buf-linux-x64/-/buf-linux-x64-1.39.0.tgz", + "integrity": "sha512-JXVkHoMrTvmpseqdoQPJJ6MRV7/vlloYtvXHHACEzVytYjljOYCNoVET/E5gLBco/edeXFMNc40cCi1KgL3rSw==", + "cpu": [ + "x64" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@bufbuild/buf-win32-arm64": { + "version": "1.39.0", + "resolved": "https://registry.npmjs.org/@bufbuild/buf-win32-arm64/-/buf-win32-arm64-1.39.0.tgz", + "integrity": "sha512-akdGW02mo04wbLfjNMBQqxC4mPQ/L/vTU8/o79I67GSxyFYt7bKifvYIYhAA39C2gibHyB7ZLmoeRPbaU8wbYA==", + "cpu": [ + "arm64" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@bufbuild/buf-win32-x64": { + "version": "1.39.0", + "resolved": "https://registry.npmjs.org/@bufbuild/buf-win32-x64/-/buf-win32-x64-1.39.0.tgz", + "integrity": "sha512-jos08UMg9iUZsGjPrNpLXP+FNk6q6GizO+bjee/GcI0kSijIzXYMg14goQr0TKlvqs/+IRAM5vZIokQBYlAENQ==", + "cpu": [ + "x64" + ], + "license": "Apache-2.0", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@bufbuild/protobuf": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/@bufbuild/protobuf/-/protobuf-1.10.0.tgz", + "integrity": "sha512-QDdVFLoN93Zjg36NoQPZfsVH9tZew7wKDKyV5qRdj8ntT4wQCOradQjRaTdwMhWUYsgKsvCINKKm87FdEk96Ag==", + "license": "(Apache-2.0 AND BSD-3-Clause)" + }, + "node_modules/@bufbuild/protoc-gen-es": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/@bufbuild/protoc-gen-es/-/protoc-gen-es-1.10.0.tgz", + "integrity": "sha512-zBYBsVT/ul4uZb6F+kD7/k4sWNHVVbEPfJwKi0FDr+9VJo8MKIofI6pkr5ksBLr4fi/74r+e/75Xi/0clL5dXg==", + "license": "Apache-2.0", + "dependencies": { + "@bufbuild/protobuf": "^1.10.0", + "@bufbuild/protoplugin": "1.10.0" + }, + "bin": { + "protoc-gen-es": "bin/protoc-gen-es" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@bufbuild/protobuf": "1.10.0" + }, + "peerDependenciesMeta": { + "@bufbuild/protobuf": { + "optional": true + } + } + }, + "node_modules/@bufbuild/protoplugin": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/@bufbuild/protoplugin/-/protoplugin-1.10.0.tgz", + "integrity": "sha512-u6NE4vL0lw1+EK4/PiE/SQB7fKO4LRJNTEScIXVOi2x88K/c8WKc/k0KyEaA0asVBMpwekJQZGnRyj04ZtN5Gg==", + "license": "(Apache-2.0 AND BSD-3-Clause)", + "dependencies": { + "@bufbuild/protobuf": "1.10.0", + "@typescript/vfs": "^1.4.0", + "typescript": "4.5.2" + } + }, + "node_modules/@bufbuild/protoplugin/node_modules/typescript": { + "version": "4.5.2", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.5.2.tgz", + "integrity": "sha512-5BlMof9H1yGt0P8/WF+wPNw6GfctgGjXp5hkblpyT+8rkASSmkUKMXrxR0Xg8ThVCi/JnHQiKXeBaEwCeQwMFw==", + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=4.2.0" + } + }, + "node_modules/@connectrpc/connect": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/@connectrpc/connect/-/connect-1.4.0.tgz", + "integrity": "sha512-vZeOkKaAjyV4+RH3+rJZIfDFJAfr+7fyYr6sLDKbYX3uuTVszhFe9/YKf5DNqrDb5cKdKVlYkGn6DTDqMitAnA==", + "license": "Apache-2.0", + "peerDependencies": { + "@bufbuild/protobuf": "^1.4.2" + } + }, + "node_modules/@connectrpc/connect-node": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/@connectrpc/connect-node/-/connect-node-1.4.0.tgz", + "integrity": "sha512-0ANnrr6SvsjevsWEgdzHy7BaHkluZyS6s4xNoVt7RBHFR5V/kT9lPokoIbYUOU9JHzdRgTaS3x5595mwUsu15g==", + "license": "Apache-2.0", + "dependencies": { + "undici": "^5.28.3" + }, + "engines": { + "node": ">=16.0.0" + }, + "peerDependencies": { + "@bufbuild/protobuf": "^1.4.2", + "@connectrpc/connect": "1.4.0" + } + }, + "node_modules/@connectrpc/protoc-gen-connect-es": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/@connectrpc/protoc-gen-connect-es/-/protoc-gen-connect-es-1.4.0.tgz", + "integrity": "sha512-/7vQ8Q7mEBhV8qEVh/eifRQlQnf8EJ6weMwCD2DljVAQRlZYcW9SLxjYZhV1uM1ZZqQC7Cw2vvgXRg2XQswHBg==", + "license": "Apache-2.0", + "dependencies": { + "@bufbuild/protobuf": "^1.7.2", + "@bufbuild/protoplugin": "^1.7.2" + }, + "bin": { + "protoc-gen-connect-es": "bin/protoc-gen-connect-es" + }, + "engines": { + "node": ">=16.0.0" + }, + "peerDependencies": { + "@bufbuild/protoc-gen-es": "^1.7.2", + "@connectrpc/connect": "1.4.0" + }, + "peerDependenciesMeta": { + "@bufbuild/protoc-gen-es": { + "optional": true + }, + "@connectrpc/connect": { + "optional": true + } + } + }, + "node_modules/@fastify/busboy": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/@fastify/busboy/-/busboy-2.1.1.tgz", + "integrity": "sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA==", + "license": "MIT", + "engines": { + "node": ">=14" + } + }, "node_modules/@gar/promisify": { "version": "1.1.3", "resolved": "https://registry.npmjs.org/@gar/promisify/-/promisify-1.1.3.tgz", @@ -248,6 +525,13 @@ "node": ">= 6" } }, + "node_modules/@types/assert": { + "version": "1.5.10", + "resolved": "https://registry.npmjs.org/@types/assert/-/assert-1.5.10.tgz", + "integrity": "sha512-qEO+AUgYab7GVbeDDgUNCU3o0aZUoIMpNAe+w5LDbRxfxQX7vQAdDgwj1AroX+i8KaV56FWg0srXlSZROnsrIQ==", + "dev": true, + "license": "MIT" + }, "node_modules/@types/body-parser": { "version": "1.19.5", "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.5.tgz", @@ -295,7 +579,8 @@ "version": "1.0.4", "resolved": "https://registry.npmjs.org/@types/find-config/-/find-config-1.0.4.tgz", "integrity": "sha512-BCXaKgzHK7KnfCQBRQBWGTA+QajOE9uFolXPt+9EktiiMS56D8oXF2ZCh9eCxuEyfqDmX/mYIcmWg9j9f659eg==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@types/http-errors": { "version": "2.0.4", @@ -357,6 +642,41 @@ "integrity": "sha512-oZLKiI6Fck/BGd0QdmIdJCY351xQfRkfpx2Q23jIntL3YQx85vScYuFJMK81/NoSK9m7HYOl2DW4A9WomDuJOA==", "dev": true }, + "node_modules/@typescript/vfs": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/@typescript/vfs/-/vfs-1.6.0.tgz", + "integrity": "sha512-hvJUjNVeBMp77qPINuUvYXj4FyWeeMMKZkxEATEU3hqBAQ7qdTBCUFT7Sp0Zu0faeEtFf+ldXxMEDr/bk73ISg==", + "license": "MIT", + "dependencies": { + "debug": "^4.1.1" + }, + "peerDependencies": { + "typescript": "*" + } + }, + "node_modules/@typescript/vfs/node_modules/debug": { + "version": "4.3.6", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.6.tgz", + "integrity": "sha512-O/09Bd4Z1fBrU4VzkhFqVgpPzaGbw6Sm9FEkBT1A/YBXQFGuuSxa1dN2nxgxS34JmKXqYx8CZAwEVoJFImUXIg==", + "license": "MIT", + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/@typescript/vfs/node_modules/ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", + "license": "MIT" + }, "node_modules/abbrev": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz", @@ -435,6 +755,10 @@ "node": ">=8" } }, + "node_modules/aicar": { + "resolved": "examples/aicar", + "link": true + }, "node_modules/ansi-regex": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", @@ -502,11 +826,39 @@ "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz", "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==" }, + "node_modules/assert": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/assert/-/assert-2.1.0.tgz", + "integrity": "sha512-eLHpSK/Y4nhMJ07gDaAzoX/XAKS8PSaojml3M0DM4JpV1LAi5JOJ/p6H/XWrl8L+DzVEvVCW1z3vWAaB9oTsQw==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "is-nan": "^1.3.2", + "object-is": "^1.1.5", + "object.assign": "^4.1.4", + "util": "^0.12.5" + } + }, "node_modules/asynckit": { "version": "0.4.0", "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==" }, + "node_modules/available-typed-arrays": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz", + "integrity": "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==", + "license": "MIT", + "dependencies": { + "possible-typed-array-names": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/axios": { "version": "1.6.7", "resolved": "https://registry.npmjs.org/axios/-/axios-1.6.7.tgz", @@ -709,6 +1061,15 @@ "node": ">=4" } }, + "node_modules/charm": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/charm/-/charm-1.0.2.tgz", + "integrity": "sha512-wqW3VdPnlSWT4eRiYX+hcs+C6ViBPUWk1qTCd+37qw9kEm/a5n2qcyQDMBWvSYKN/ctqZzeXNQaeBjOetJJUkw==", + "license": "MIT", + "dependencies": { + "inherits": "^2.0.1" + } + }, "node_modules/chownr": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz", @@ -778,6 +1139,15 @@ "node": ">= 0.8" } }, + "node_modules/commander": { + "version": "12.1.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-12.1.0.tgz", + "integrity": "sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA==", + "license": "MIT", + "engines": { + "node": ">=18" + } + }, "node_modules/concat-map": { "version": "0.0.1", "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", @@ -897,6 +1267,23 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/define-properties": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz", + "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==", + "license": "MIT", + "dependencies": { + "define-data-property": "^1.0.1", + "has-property-descriptors": "^1.0.0", + "object-keys": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/delayed-stream": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", @@ -940,6 +1327,7 @@ "version": "16.4.5", "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.4.5.tgz", "integrity": "sha512-ZmdL2rui+eB2YwhsWzjInR8LldtZHGDoQ1ugH85ppHKwpUHL7j7rN0Ti9NCnGiQbhaZ11FpR+7ao1dNsmduNUg==", + "license": "BSD-2-Clause", "engines": { "node": ">=12" }, @@ -1134,6 +1522,7 @@ "version": "1.0.0", "resolved": "https://registry.npmjs.org/find-config/-/find-config-1.0.0.tgz", "integrity": "sha512-Z+suHH+7LSE40WfUeZPIxSxypCWvrzdVc60xAjUShZeT5eMWM0/FQUduq3HjluyfAHWvC/aOBkT1pTZktyF/jg==", + "license": "MIT", "dependencies": { "user-home": "^2.0.0" }, @@ -1160,6 +1549,15 @@ } } }, + "node_modules/for-each": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz", + "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==", + "license": "MIT", + "dependencies": { + "is-callable": "^1.1.3" + } + }, "node_modules/form-data": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz", @@ -1348,6 +1746,21 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/has-tostringtag": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz", + "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", + "license": "MIT", + "dependencies": { + "has-symbols": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/has-unicode": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz", @@ -1567,6 +1980,34 @@ "node": ">= 0.10" } }, + "node_modules/is-arguments": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-arguments/-/is-arguments-1.1.1.tgz", + "integrity": "sha512-8Q7EARjzEnKpt/PCD7e1cgUS0a6X8u5tdSiMqXhojOdoV9TsMsiO+9VLC5vAmO8N7/GmXn7yjR8qnA6bVAEzfA==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-callable": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz", + "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/is-docker": { "version": "2.2.1", "resolved": "https://registry.npmjs.org/is-docker/-/is-docker-2.2.1.tgz", @@ -1590,12 +2031,58 @@ "node": ">=8" } }, + "node_modules/is-generator-function": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.0.10.tgz", + "integrity": "sha512-jsEjy9l3yiXEQ+PsXdmBwEPcOxaXWLspKdplFUVI9vq1iZgIekeC0L167qeu86czQaxed3q/Uzuw0swL0irL8A==", + "license": "MIT", + "dependencies": { + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/is-lambda": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/is-lambda/-/is-lambda-1.0.1.tgz", "integrity": "sha512-z7CMFGNrENq5iFB9Bqo64Xk6Y9sg+epq1myIcdHaGnbMTYOxvzsEtdYqQUylB7LxfkvgrrjP32T6Ywciio9UIQ==", "optional": true }, + "node_modules/is-nan": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/is-nan/-/is-nan-1.3.2.tgz", + "integrity": "sha512-E+zBKpQ2t6MEo1VsonYmluk9NxGrbzpeeLC2xIViuO2EjU2xsXsBPwTr3Ykv9l08UYEVEdWeRZNouaZqF6RN0w==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.0", + "define-properties": "^1.1.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-typed-array": { + "version": "1.1.13", + "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.13.tgz", + "integrity": "sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==", + "license": "MIT", + "dependencies": { + "which-typed-array": "^1.1.14" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/is-wsl": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz", @@ -1970,6 +2457,49 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/object-is": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/object-is/-/object-is-1.1.6.tgz", + "integrity": "sha512-F8cZ+KfGlSGi09lJT7/Nd6KJZ9ygtvYC0/UYYLI9nmQKLMnydpB9yvbv9K1uSkEu7FU9vYPmVwLg328tX+ot3Q==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object-keys": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", + "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/object.assign": { + "version": "4.1.5", + "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.5.tgz", + "integrity": "sha512-byy+U7gp+FVwmyzKPYhW2h5l3crpmGsxl7X2s8y43IgxvG4g3QZ6CffDtsNQy1WsmZpQbO+ybo0AlW7TY6DcBQ==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.5", + "define-properties": "^1.2.1", + "has-symbols": "^1.0.3", + "object-keys": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/on-finished": { "version": "2.4.1", "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", @@ -2049,6 +2579,15 @@ "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz", "integrity": "sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ==" }, + "node_modules/possible-typed-array-names": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.0.0.tgz", + "integrity": "sha512-d7Uw+eZoloe0EHDIYoe+bQ5WXnGMOpmiZFTuMWCwpjzzkL2nTjcKiAk4hh8TjnGye2TwWOk3UXucZ+3rbmBa8Q==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, "node_modules/prebuild-install": { "version": "7.1.2", "resolved": "https://registry.npmjs.org/prebuild-install/-/prebuild-install-7.1.2.tgz", @@ -2696,6 +3235,18 @@ "node": ">=0.6" } }, + "node_modules/ts-progress": { + "version": "0.1.9", + "resolved": "https://registry.npmjs.org/ts-progress/-/ts-progress-0.1.9.tgz", + "integrity": "sha512-1jp591MFPSmQwPahlBN+NHPYOxTnackPHG0sCwZErTAb4XaH3IrK45H2PXQDJfuzXUIu1y9dLaB9l+tWBcB04g==", + "license": "MIT", + "dependencies": { + "charm": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, "node_modules/tunnel-agent": { "version": "0.6.0", "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz", @@ -2724,9 +3275,10 @@ "link": true }, "node_modules/typescript": { - "version": "5.3.3", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.3.tgz", - "integrity": "sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw==", + "version": "5.5.4", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.5.4.tgz", + "integrity": "sha512-Mtq29sKDAEYP7aljRgtPOpTvOfbwRWlS6dPRzwjdE+C0R4brX/GUyhHSecbHMFLNBLcJIPt9nl9yG5TZ1weH+Q==", + "license": "Apache-2.0", "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" @@ -2735,6 +3287,18 @@ "node": ">=14.17" } }, + "node_modules/undici": { + "version": "5.28.4", + "resolved": "https://registry.npmjs.org/undici/-/undici-5.28.4.tgz", + "integrity": "sha512-72RFADWFqKmUb2hmmvNODKL3p9hcB6Gt2DOQMis1SEBaV6a4MH8soBvzg+95CYhCKPFedut2JY9bMfrDl9D23g==", + "license": "MIT", + "dependencies": { + "@fastify/busboy": "^2.0.0" + }, + "engines": { + "node": ">=14.0" + } + }, "node_modules/undici-types": { "version": "5.26.5", "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz", @@ -2787,6 +3351,19 @@ "node": ">=0.10.0" } }, + "node_modules/util": { + "version": "0.12.5", + "resolved": "https://registry.npmjs.org/util/-/util-0.12.5.tgz", + "integrity": "sha512-kZf/K6hEIrWHI6XqOFUiiMa+79wE/D8Q+NCNAWclkyg3b4d2k7s0QGepNjiABc+aR3N1PAyHL7p6UcLY6LmrnA==", + "license": "MIT", + "dependencies": { + "inherits": "^2.0.3", + "is-arguments": "^1.0.4", + "is-generator-function": "^1.0.7", + "is-typed-array": "^1.1.3", + "which-typed-array": "^1.1.2" + } + }, "node_modules/util-deprecate": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", @@ -2823,6 +3400,25 @@ "node": ">= 8" } }, + "node_modules/which-typed-array": { + "version": "1.1.15", + "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.15.tgz", + "integrity": "sha512-oV0jmFtUky6CXfkqehVvBP/LSWJ2sy4vWMioiENyJLePrBO/yKyV9OyJySfAKosh+RYkIl5zJCNZ8/4JncrpdA==", + "license": "MIT", + "dependencies": { + "available-typed-arrays": "^1.0.7", + "call-bind": "^1.0.7", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-tostringtag": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/wide-align": { "version": "1.1.5", "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.5.tgz", @@ -2938,9 +3534,10 @@ } }, "node_modules/zod": { - "version": "3.22.4", - "resolved": "https://registry.npmjs.org/zod/-/zod-3.22.4.tgz", - "integrity": "sha512-iC+8Io04lddc+mVqQ9AZ7OQ2MrUKGN+oIQyq1vemgt46jwCwLfhq7/pwnBnNXXXZb8VTVLKwp9EDkx+ryxIWmg==", + "version": "3.23.8", + "resolved": "https://registry.npmjs.org/zod/-/zod-3.23.8.tgz", + "integrity": "sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g==", + "license": "MIT", "funding": { "url": "https://github.com/sponsors/colinhacks" }