@code0-tech/tucana 0.0.0 → 0.0.38

package/pb/aquila.data_type_pb.client.ts

@@ -0,0 +1,37 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "aquila.data_type.proto" (package "aquila", syntax proto3)
+// tslint:disable
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import { DataTypeService } from "./aquila.data_type_pb";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+import type { DataTypeUpdateResponse } from "./aquila.data_type_pb";
+import type { DataTypeUpdateRequest } from "./aquila.data_type_pb";
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+/**
+ * @generated from protobuf service aquila.DataTypeService
+ */
+export interface IDataTypeServiceClient {
+    /**
+     * @generated from protobuf rpc: Update
+     */
+    update(input: DataTypeUpdateRequest, options?: RpcOptions): UnaryCall<DataTypeUpdateRequest, DataTypeUpdateResponse>;
+}
+/**
+ * @generated from protobuf service aquila.DataTypeService
+ */
+export class DataTypeServiceClient implements IDataTypeServiceClient, ServiceInfo {
+    typeName = DataTypeService.typeName;
+    methods = DataTypeService.methods;
+    options = DataTypeService.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * @generated from protobuf rpc: Update
+     */
+    update(input: DataTypeUpdateRequest, options?: RpcOptions): UnaryCall<DataTypeUpdateRequest, DataTypeUpdateResponse> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<DataTypeUpdateRequest, DataTypeUpdateResponse>("unary", this._transport, method, opt, input);
+    }
+}

package/pb/aquila.data_type_pb.ts

@@ -0,0 +1,140 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "aquila.data_type.proto" (package "aquila", syntax proto3)
+// tslint:disable
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import { WireType } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { DefinitionDataType } from "./shared.data_type_pb";
+/**
+ * Request for updating a data type
+ *
+ * @generated from protobuf message aquila.DataTypeUpdateRequest
+ */
+export interface DataTypeUpdateRequest {
+    /**
+     * List of data types that should be updated
+     *
+     * @generated from protobuf field: repeated shared.DefinitionDataType data_types = 1
+     */
+    dataTypes: DefinitionDataType[];
+}
+/**
+ * Response of updating a data type
+ *
+ * @generated from protobuf message aquila.DataTypeUpdateResponse
+ */
+export interface DataTypeUpdateResponse {
+    /**
+     * True if was successful, false if not
+     *
+     * @generated from protobuf field: bool success = 1
+     */
+    success: boolean;
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class DataTypeUpdateRequest$Type extends MessageType<DataTypeUpdateRequest> {
+    constructor() {
+        super("aquila.DataTypeUpdateRequest", [
+            { no: 1, name: "data_types", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DefinitionDataType }
+        ]);
+    }
+    create(value?: PartialMessage<DataTypeUpdateRequest>): DataTypeUpdateRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.dataTypes = [];
+        if (value !== undefined)
+            reflectionMergePartial<DataTypeUpdateRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DataTypeUpdateRequest): DataTypeUpdateRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated shared.DefinitionDataType data_types */ 1:
+                    message.dataTypes.push(DefinitionDataType.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: DataTypeUpdateRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated shared.DefinitionDataType data_types = 1; */
+        for (let i = 0; i < message.dataTypes.length; i++)
+            DefinitionDataType.internalBinaryWrite(message.dataTypes[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message aquila.DataTypeUpdateRequest
+ */
+export const DataTypeUpdateRequest = new DataTypeUpdateRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DataTypeUpdateResponse$Type extends MessageType<DataTypeUpdateResponse> {
+    constructor() {
+        super("aquila.DataTypeUpdateResponse", [
+            { no: 1, name: "success", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value?: PartialMessage<DataTypeUpdateResponse>): DataTypeUpdateResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.success = false;
+        if (value !== undefined)
+            reflectionMergePartial<DataTypeUpdateResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DataTypeUpdateResponse): DataTypeUpdateResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bool success */ 1:
+                    message.success = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: DataTypeUpdateResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* bool success = 1; */
+        if (message.success !== false)
+            writer.tag(1, WireType.Varint).bool(message.success);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message aquila.DataTypeUpdateResponse
+ */
+export const DataTypeUpdateResponse = new DataTypeUpdateResponse$Type();
+/**
+ * @generated ServiceType for protobuf service aquila.DataTypeService
+ */
+export const DataTypeService = new ServiceType("aquila.DataTypeService", [
+    { name: "Update", options: {}, I: DataTypeUpdateRequest, O: DataTypeUpdateResponse }
+]);

package/pb/aquila.execution_pb.client.ts

@@ -0,0 +1,74 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "aquila.execution.proto" (package "aquila", syntax proto3)
+// tslint:disable
+import { ActionResultService } from "./aquila.execution_pb";
+import type { ActionResultResponse } from "./aquila.execution_pb";
+import type { ActionResultRequest } from "./aquila.execution_pb";
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import { ActionCallService } from "./aquila.execution_pb";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+import type { ActionCallResponse } from "./aquila.execution_pb";
+import type { ActionCallRequest } from "./aquila.execution_pb";
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+/**
+ * Service for calling an execution with the given parameter
+ *
+ * @generated from protobuf service aquila.ActionCallService
+ */
+export interface IActionCallServiceClient {
+    /**
+     * @generated from protobuf rpc: Call
+     */
+    call(input: ActionCallRequest, options?: RpcOptions): UnaryCall<ActionCallRequest, ActionCallResponse>;
+}
+/**
+ * Service for calling an execution with the given parameter
+ *
+ * @generated from protobuf service aquila.ActionCallService
+ */
+export class ActionCallServiceClient implements IActionCallServiceClient, ServiceInfo {
+    typeName = ActionCallService.typeName;
+    methods = ActionCallService.methods;
+    options = ActionCallService.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * @generated from protobuf rpc: Call
+     */
+    call(input: ActionCallRequest, options?: RpcOptions): UnaryCall<ActionCallRequest, ActionCallResponse> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<ActionCallRequest, ActionCallResponse>("unary", this._transport, method, opt, input);
+    }
+}
+/**
+ * Service for getting a result of an execution
+ *
+ * @generated from protobuf service aquila.ActionResultService
+ */
+export interface IActionResultServiceClient {
+    /**
+     * @generated from protobuf rpc: GetResult
+     */
+    getResult(input: ActionResultRequest, options?: RpcOptions): UnaryCall<ActionResultRequest, ActionResultResponse>;
+}
+/**
+ * Service for getting a result of an execution
+ *
+ * @generated from protobuf service aquila.ActionResultService
+ */
+export class ActionResultServiceClient implements IActionResultServiceClient, ServiceInfo {
+    typeName = ActionResultService.typeName;
+    methods = ActionResultService.methods;
+    options = ActionResultService.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * @generated from protobuf rpc: GetResult
+     */
+    getResult(input: ActionResultRequest, options?: RpcOptions): UnaryCall<ActionResultRequest, ActionResultResponse> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<ActionResultRequest, ActionResultResponse>("unary", this._transport, method, opt, input);
+    }
+}

package/pb/aquila.execution_pb.ts

@@ -0,0 +1,334 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "aquila.execution.proto" (package "aquila", syntax proto3)
+// tslint:disable
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import { WireType } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+/**
+ * Request to call an action with param. Request will be routed over Aquila
+ *
+ * @generated from protobuf message aquila.ActionCallRequest
+ */
+export interface ActionCallRequest {
+    /**
+     * Function identifier
+     *
+     * @generated from protobuf field: string identifier = 1
+     */
+    identifier: string;
+    /**
+     * List of parameters (json format --> also can just be a primitive)
+     *
+     * @generated from protobuf field: repeated string parameters = 2
+     */
+    parameters: string[];
+}
+/**
+ * Response of execution call
+ *
+ * @generated from protobuf message aquila.ActionCallResponse
+ */
+export interface ActionCallResponse {
+    /**
+     * Identifier of the execution id given by Aquila for the parameter
+     *
+     * @generated from protobuf field: string execution_identifier = 1
+     */
+    executionIdentifier: string;
+}
+/**
+ * List of results
+ *
+ * @generated from protobuf message aquila.ActionResult
+ */
+export interface ActionResult {
+    /**
+     * @generated from protobuf field: repeated string result = 1
+     */
+    result: string[];
+}
+/**
+ * Request to check if there are results for the given identifier
+ *
+ * @generated from protobuf message aquila.ActionResultRequest
+ */
+export interface ActionResultRequest {
+    /**
+     * Identifier that is connected to the parameter
+     *
+     * @generated from protobuf field: string execution_identifier = 1
+     */
+    executionIdentifier: string;
+}
+/**
+ * @generated from protobuf message aquila.ActionResultResponse
+ */
+export interface ActionResultResponse {
+    /**
+     * Result of the given parameter!
+     *
+     * @generated from protobuf field: optional aquila.ActionResult action_result = 1
+     */
+    actionResult?: ActionResult;
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class ActionCallRequest$Type extends MessageType<ActionCallRequest> {
+    constructor() {
+        super("aquila.ActionCallRequest", [
+            { no: 1, name: "identifier", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "parameters", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<ActionCallRequest>): ActionCallRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.identifier = "";
+        message.parameters = [];
+        if (value !== undefined)
+            reflectionMergePartial<ActionCallRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActionCallRequest): ActionCallRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string identifier */ 1:
+                    message.identifier = reader.string();
+                    break;
+                case /* repeated string parameters */ 2:
+                    message.parameters.push(reader.string());
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ActionCallRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string identifier = 1; */
+        if (message.identifier !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.identifier);
+        /* repeated string parameters = 2; */
+        for (let i = 0; i < message.parameters.length; i++)
+            writer.tag(2, WireType.LengthDelimited).string(message.parameters[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message aquila.ActionCallRequest
+ */
+export const ActionCallRequest = new ActionCallRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ActionCallResponse$Type extends MessageType<ActionCallResponse> {
+    constructor() {
+        super("aquila.ActionCallResponse", [
+            { no: 1, name: "execution_identifier", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<ActionCallResponse>): ActionCallResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.executionIdentifier = "";
+        if (value !== undefined)
+            reflectionMergePartial<ActionCallResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActionCallResponse): ActionCallResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string execution_identifier */ 1:
+                    message.executionIdentifier = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ActionCallResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string execution_identifier = 1; */
+        if (message.executionIdentifier !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.executionIdentifier);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message aquila.ActionCallResponse
+ */
+export const ActionCallResponse = new ActionCallResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ActionResult$Type extends MessageType<ActionResult> {
+    constructor() {
+        super("aquila.ActionResult", [
+            { no: 1, name: "result", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<ActionResult>): ActionResult {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.result = [];
+        if (value !== undefined)
+            reflectionMergePartial<ActionResult>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActionResult): ActionResult {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated string result */ 1:
+                    message.result.push(reader.string());
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ActionResult, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated string result = 1; */
+        for (let i = 0; i < message.result.length; i++)
+            writer.tag(1, WireType.LengthDelimited).string(message.result[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message aquila.ActionResult
+ */
+export const ActionResult = new ActionResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ActionResultRequest$Type extends MessageType<ActionResultRequest> {
+    constructor() {
+        super("aquila.ActionResultRequest", [
+            { no: 1, name: "execution_identifier", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<ActionResultRequest>): ActionResultRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.executionIdentifier = "";
+        if (value !== undefined)
+            reflectionMergePartial<ActionResultRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActionResultRequest): ActionResultRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string execution_identifier */ 1:
+                    message.executionIdentifier = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ActionResultRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string execution_identifier = 1; */
+        if (message.executionIdentifier !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.executionIdentifier);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message aquila.ActionResultRequest
+ */
+export const ActionResultRequest = new ActionResultRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ActionResultResponse$Type extends MessageType<ActionResultResponse> {
+    constructor() {
+        super("aquila.ActionResultResponse", [
+            { no: 1, name: "action_result", kind: "message", T: () => ActionResult }
+        ]);
+    }
+    create(value?: PartialMessage<ActionResultResponse>): ActionResultResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<ActionResultResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActionResultResponse): ActionResultResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* optional aquila.ActionResult action_result */ 1:
+                    message.actionResult = ActionResult.internalBinaryRead(reader, reader.uint32(), options, message.actionResult);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ActionResultResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* optional aquila.ActionResult action_result = 1; */
+        if (message.actionResult)
+            ActionResult.internalBinaryWrite(message.actionResult, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message aquila.ActionResultResponse
+ */
+export const ActionResultResponse = new ActionResultResponse$Type();
+/**
+ * @generated ServiceType for protobuf service aquila.ActionCallService
+ */
+export const ActionCallService = new ServiceType("aquila.ActionCallService", [
+    { name: "Call", options: {}, I: ActionCallRequest, O: ActionCallResponse }
+]);
+/**
+ * @generated ServiceType for protobuf service aquila.ActionResultService
+ */
+export const ActionResultService = new ServiceType("aquila.ActionResultService", [
+    { name: "GetResult", options: {}, I: ActionResultRequest, O: ActionResultResponse }
+]);

package/pb/aquila.flow_type_pb.client.ts

@@ -0,0 +1,41 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "aquila.flow_type.proto" (package "aquila", syntax proto3)
+// tslint:disable
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import { FlowTypeService } from "./aquila.flow_type_pb";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+import type { FlowTypeUpdateResponse } from "./aquila.flow_type_pb";
+import type { FlowTypeUpdateRequest } from "./aquila.flow_type_pb";
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+/**
+ * This service will be implemented as a server by Aquila and as a client by Draco.
+ *
+ * @generated from protobuf service aquila.FlowTypeService
+ */
+export interface IFlowTypeServiceClient {
+    /**
+     * @generated from protobuf rpc: Update
+     */
+    update(input: FlowTypeUpdateRequest, options?: RpcOptions): UnaryCall<FlowTypeUpdateRequest, FlowTypeUpdateResponse>;
+}
+/**
+ * This service will be implemented as a server by Aquila and as a client by Draco.
+ *
+ * @generated from protobuf service aquila.FlowTypeService
+ */
+export class FlowTypeServiceClient implements IFlowTypeServiceClient, ServiceInfo {
+    typeName = FlowTypeService.typeName;
+    methods = FlowTypeService.methods;
+    options = FlowTypeService.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * @generated from protobuf rpc: Update
+     */
+    update(input: FlowTypeUpdateRequest, options?: RpcOptions): UnaryCall<FlowTypeUpdateRequest, FlowTypeUpdateResponse> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<FlowTypeUpdateRequest, FlowTypeUpdateResponse>("unary", this._transport, method, opt, input);
+    }
+}