@code0-tech/tucana 0.0.0 → 0.0.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@code0-tech/tucana",
-  "version": "0.0.0",
+  "version": "0.0.38",
   "description": "Code0 GRPC Protocol",
   "homepage": "https://github.com/code0-tech/tucana#readme",
   "bugs": {

package/pb/aquila.action_pb.client.ts

@@ -0,0 +1,41 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "aquila.action.proto" (package "aquila", syntax proto3)
+// tslint:disable
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import { ActionTransferService } from "./aquila.action_pb";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+import type { TransferResponse } from "./aquila.action_pb";
+import type { TransferRequest } from "./aquila.action_pb";
+import type { DuplexStreamingCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+/**
+ * @generated from protobuf service aquila.ActionTransferService
+ */
+export interface IActionTransferServiceClient {
+    /**
+     * This behavior achieves a bi-directional stream so that both services aren't required to be a server & client on their own
+     *
+     * @generated from protobuf rpc: Transfer
+     */
+    transfer(options?: RpcOptions): DuplexStreamingCall<TransferRequest, TransferResponse>;
+}
+/**
+ * @generated from protobuf service aquila.ActionTransferService
+ */
+export class ActionTransferServiceClient implements IActionTransferServiceClient, ServiceInfo {
+    typeName = ActionTransferService.typeName;
+    methods = ActionTransferService.methods;
+    options = ActionTransferService.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * This behavior achieves a bi-directional stream so that both services aren't required to be a server & client on their own
+     *
+     * @generated from protobuf rpc: Transfer
+     */
+    transfer(options?: RpcOptions): DuplexStreamingCall<TransferRequest, TransferResponse> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<TransferRequest, TransferResponse>("duplex", this._transport, method, opt);
+    }
+}

package/pb/aquila.action_pb.ts

@@ -0,0 +1,615 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "aquila.action.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 { Struct } from "./shared.struct_pb";
+import { DefinitionDataType } from "./shared.data_type_pb";
+import { Translation } from "./shared.translation_pb";
+import { EventType } from "./shared.event_pb";
+import { RuntimeFunctionDefinition } from "./shared.runtime_function_pb";
+import { Value } from "./shared.struct_pb";
+/**
+ * Event that gets admitted by an action
+ *
+ * @generated from protobuf message aquila.Event
+ */
+export interface Event {
+    /**
+     * Id of Event type
+     *
+     * @generated from protobuf field: string event_type = 1
+     */
+    eventType: string;
+    /**
+     * Payload (JSON) of event params
+     *
+     * @generated from protobuf field: shared.Value payload = 2
+     */
+    payload?: Value;
+}
+/**
+ * Action flow/event configuration
+ *
+ * @generated from protobuf message aquila.Configuration
+ */
+export interface Configuration {
+    /**
+     * Action identifier
+     *
+     * @generated from protobuf field: string identifier = 1
+     */
+    identifier: string;
+    /**
+     * Flow Configuration
+     *
+     * @generated from protobuf field: repeated shared.RuntimeFunctionDefinition function_definitions = 2
+     */
+    functionDefinitions: RuntimeFunctionDefinition[];
+    /**
+     * Event Configuration
+     *
+     * @generated from protobuf field: repeated shared.EventType event_types = 3
+     */
+    eventTypes: EventType[];
+    /**
+     * Application Configuration
+     *
+     * @generated from protobuf field: repeated aquila.ActionConfiguration action_configurations = 4
+     */
+    actionConfigurations: ActionConfiguration[];
+}
+/**
+ * @generated from protobuf message aquila.ActionConfiguration
+ */
+export interface ActionConfiguration {
+    /**
+     * @generated from protobuf field: repeated shared.Translation name = 1
+     */
+    name: Translation[];
+    /**
+     * @generated from protobuf field: repeated shared.Translation description = 2
+     */
+    description: Translation[];
+    /**
+     * @generated from protobuf field: shared.DefinitionDataType type = 3
+     */
+    type?: DefinitionDataType;
+    /**
+     * @generated from protobuf field: optional shared.Value default_value = 4
+     */
+    defaultValue?: Value;
+}
+/**
+ * Request to execute a request a flow
+ *
+ * @generated from protobuf message aquila.ExecutionRequest
+ */
+export interface ExecutionRequest {
+    /**
+     * Execution identifier of execution
+     *
+     * @generated from protobuf field: string execution_identifier = 1
+     */
+    executionIdentifier: string;
+    /**
+     * Function identifier of flow to execute
+     *
+     * @generated from protobuf field: string function_identifier = 2
+     */
+    functionIdentifier: string;
+    /**
+     * Parameters (JSON) of flow required to execute
+     *
+     * @generated from protobuf field: shared.Struct parameters = 3
+     */
+    parameters?: Struct;
+}
+/**
+ * Result from executed flows by an action
+ *
+ * @generated from protobuf message aquila.ExecutionResult
+ */
+export interface ExecutionResult {
+    /**
+     * Identifier of flow to execute
+     *
+     * @generated from protobuf field: string execution_identifier = 1
+     */
+    executionIdentifier: string;
+    /**
+     * Result of executed flow
+     *
+     * @generated from protobuf field: shared.Value result = 2
+     */
+    result?: Value;
+}
+/**
+ * @generated from protobuf message aquila.TransferRequest
+ */
+export interface TransferRequest {
+    /**
+     * @generated from protobuf oneof: data
+     */
+    data: {
+        oneofKind: "configuration";
+        /**
+         * Configuration of action that will be send to sagittarius
+         *
+         * Expected behavior:
+         * Aquila will abort if the first request is not a configuration
+         *
+         * @generated from protobuf field: aquila.Configuration configuration = 1
+         */
+        configuration: Configuration;
+    } | {
+        oneofKind: "event";
+        /**
+         * Event that got admitted
+         *
+         * @generated from protobuf field: aquila.Event event = 2
+         */
+        event: Event;
+    } | {
+        oneofKind: "result";
+        /**
+         * Result of execution that was triggered by a execution request
+         *
+         * @generated from protobuf field: aquila.ExecutionResult result = 3
+         */
+        result: ExecutionResult;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message aquila.TransferResponse
+ */
+export interface TransferResponse {
+    /**
+     * Execution request
+     *
+     * @generated from protobuf field: aquila.ExecutionRequest execution = 1
+     */
+    execution?: ExecutionRequest;
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class Event$Type extends MessageType<Event> {
+    constructor() {
+        super("aquila.Event", [
+            { no: 1, name: "event_type", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "payload", kind: "message", T: () => Value }
+        ]);
+    }
+    create(value?: PartialMessage<Event>): Event {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.eventType = "";
+        if (value !== undefined)
+            reflectionMergePartial<Event>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Event): Event {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string event_type */ 1:
+                    message.eventType = reader.string();
+                    break;
+                case /* shared.Value payload */ 2:
+                    message.payload = Value.internalBinaryRead(reader, reader.uint32(), options, message.payload);
+                    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: Event, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string event_type = 1; */
+        if (message.eventType !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.eventType);
+        /* shared.Value payload = 2; */
+        if (message.payload)
+            Value.internalBinaryWrite(message.payload, writer.tag(2, 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.Event
+ */
+export const Event = new Event$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Configuration$Type extends MessageType<Configuration> {
+    constructor() {
+        super("aquila.Configuration", [
+            { no: 1, name: "identifier", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "function_definitions", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => RuntimeFunctionDefinition },
+            { no: 3, name: "event_types", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => EventType },
+            { no: 4, name: "action_configurations", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ActionConfiguration }
+        ]);
+    }
+    create(value?: PartialMessage<Configuration>): Configuration {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.identifier = "";
+        message.functionDefinitions = [];
+        message.eventTypes = [];
+        message.actionConfigurations = [];
+        if (value !== undefined)
+            reflectionMergePartial<Configuration>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Configuration): Configuration {
+        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 shared.RuntimeFunctionDefinition function_definitions */ 2:
+                    message.functionDefinitions.push(RuntimeFunctionDefinition.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated shared.EventType event_types */ 3:
+                    message.eventTypes.push(EventType.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated aquila.ActionConfiguration action_configurations */ 4:
+                    message.actionConfigurations.push(ActionConfiguration.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: Configuration, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string identifier = 1; */
+        if (message.identifier !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.identifier);
+        /* repeated shared.RuntimeFunctionDefinition function_definitions = 2; */
+        for (let i = 0; i < message.functionDefinitions.length; i++)
+            RuntimeFunctionDefinition.internalBinaryWrite(message.functionDefinitions[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* repeated shared.EventType event_types = 3; */
+        for (let i = 0; i < message.eventTypes.length; i++)
+            EventType.internalBinaryWrite(message.eventTypes[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* repeated aquila.ActionConfiguration action_configurations = 4; */
+        for (let i = 0; i < message.actionConfigurations.length; i++)
+            ActionConfiguration.internalBinaryWrite(message.actionConfigurations[i], writer.tag(4, 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.Configuration
+ */
+export const Configuration = new Configuration$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ActionConfiguration$Type extends MessageType<ActionConfiguration> {
+    constructor() {
+        super("aquila.ActionConfiguration", [
+            { no: 1, name: "name", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Translation },
+            { no: 2, name: "description", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Translation },
+            { no: 3, name: "type", kind: "message", T: () => DefinitionDataType },
+            { no: 4, name: "default_value", kind: "message", T: () => Value }
+        ]);
+    }
+    create(value?: PartialMessage<ActionConfiguration>): ActionConfiguration {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.name = [];
+        message.description = [];
+        if (value !== undefined)
+            reflectionMergePartial<ActionConfiguration>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActionConfiguration): ActionConfiguration {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated shared.Translation name */ 1:
+                    message.name.push(Translation.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated shared.Translation description */ 2:
+                    message.description.push(Translation.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* shared.DefinitionDataType type */ 3:
+                    message.type = DefinitionDataType.internalBinaryRead(reader, reader.uint32(), options, message.type);
+                    break;
+                case /* optional shared.Value default_value */ 4:
+                    message.defaultValue = Value.internalBinaryRead(reader, reader.uint32(), options, message.defaultValue);
+                    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: ActionConfiguration, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated shared.Translation name = 1; */
+        for (let i = 0; i < message.name.length; i++)
+            Translation.internalBinaryWrite(message.name[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* repeated shared.Translation description = 2; */
+        for (let i = 0; i < message.description.length; i++)
+            Translation.internalBinaryWrite(message.description[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* shared.DefinitionDataType type = 3; */
+        if (message.type)
+            DefinitionDataType.internalBinaryWrite(message.type, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* optional shared.Value default_value = 4; */
+        if (message.defaultValue)
+            Value.internalBinaryWrite(message.defaultValue, writer.tag(4, 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.ActionConfiguration
+ */
+export const ActionConfiguration = new ActionConfiguration$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExecutionRequest$Type extends MessageType<ExecutionRequest> {
+    constructor() {
+        super("aquila.ExecutionRequest", [
+            { no: 1, name: "execution_identifier", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "function_identifier", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "parameters", kind: "message", T: () => Struct }
+        ]);
+    }
+    create(value?: PartialMessage<ExecutionRequest>): ExecutionRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.executionIdentifier = "";
+        message.functionIdentifier = "";
+        if (value !== undefined)
+            reflectionMergePartial<ExecutionRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionRequest): ExecutionRequest {
+        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;
+                case /* string function_identifier */ 2:
+                    message.functionIdentifier = reader.string();
+                    break;
+                case /* shared.Struct parameters */ 3:
+                    message.parameters = Struct.internalBinaryRead(reader, reader.uint32(), options, message.parameters);
+                    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: ExecutionRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string execution_identifier = 1; */
+        if (message.executionIdentifier !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.executionIdentifier);
+        /* string function_identifier = 2; */
+        if (message.functionIdentifier !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.functionIdentifier);
+        /* shared.Struct parameters = 3; */
+        if (message.parameters)
+            Struct.internalBinaryWrite(message.parameters, writer.tag(3, 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.ExecutionRequest
+ */
+export const ExecutionRequest = new ExecutionRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExecutionResult$Type extends MessageType<ExecutionResult> {
+    constructor() {
+        super("aquila.ExecutionResult", [
+            { no: 1, name: "execution_identifier", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "result", kind: "message", T: () => Value }
+        ]);
+    }
+    create(value?: PartialMessage<ExecutionResult>): ExecutionResult {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.executionIdentifier = "";
+        if (value !== undefined)
+            reflectionMergePartial<ExecutionResult>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionResult): ExecutionResult {
+        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;
+                case /* shared.Value result */ 2:
+                    message.result = Value.internalBinaryRead(reader, reader.uint32(), options, message.result);
+                    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: ExecutionResult, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string execution_identifier = 1; */
+        if (message.executionIdentifier !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.executionIdentifier);
+        /* shared.Value result = 2; */
+        if (message.result)
+            Value.internalBinaryWrite(message.result, writer.tag(2, 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.ExecutionResult
+ */
+export const ExecutionResult = new ExecutionResult$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TransferRequest$Type extends MessageType<TransferRequest> {
+    constructor() {
+        super("aquila.TransferRequest", [
+            { no: 1, name: "configuration", kind: "message", oneof: "data", T: () => Configuration },
+            { no: 2, name: "event", kind: "message", oneof: "data", T: () => Event },
+            { no: 3, name: "result", kind: "message", oneof: "data", T: () => ExecutionResult }
+        ]);
+    }
+    create(value?: PartialMessage<TransferRequest>): TransferRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.data = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial<TransferRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TransferRequest): TransferRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* aquila.Configuration configuration */ 1:
+                    message.data = {
+                        oneofKind: "configuration",
+                        configuration: Configuration.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).configuration)
+                    };
+                    break;
+                case /* aquila.Event event */ 2:
+                    message.data = {
+                        oneofKind: "event",
+                        event: Event.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).event)
+                    };
+                    break;
+                case /* aquila.ExecutionResult result */ 3:
+                    message.data = {
+                        oneofKind: "result",
+                        result: ExecutionResult.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).result)
+                    };
+                    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: TransferRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* aquila.Configuration configuration = 1; */
+        if (message.data.oneofKind === "configuration")
+            Configuration.internalBinaryWrite(message.data.configuration, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* aquila.Event event = 2; */
+        if (message.data.oneofKind === "event")
+            Event.internalBinaryWrite(message.data.event, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* aquila.ExecutionResult result = 3; */
+        if (message.data.oneofKind === "result")
+            ExecutionResult.internalBinaryWrite(message.data.result, writer.tag(3, 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.TransferRequest
+ */
+export const TransferRequest = new TransferRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TransferResponse$Type extends MessageType<TransferResponse> {
+    constructor() {
+        super("aquila.TransferResponse", [
+            { no: 1, name: "execution", kind: "message", T: () => ExecutionRequest }
+        ]);
+    }
+    create(value?: PartialMessage<TransferResponse>): TransferResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<TransferResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TransferResponse): TransferResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* aquila.ExecutionRequest execution */ 1:
+                    message.execution = ExecutionRequest.internalBinaryRead(reader, reader.uint32(), options, message.execution);
+                    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: TransferResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* aquila.ExecutionRequest execution = 1; */
+        if (message.execution)
+            ExecutionRequest.internalBinaryWrite(message.execution, 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.TransferResponse
+ */
+export const TransferResponse = new TransferResponse$Type();
+/**
+ * @generated ServiceType for protobuf service aquila.ActionTransferService
+ */
+export const ActionTransferService = new ServiceType("aquila.ActionTransferService", [
+    { name: "Transfer", serverStreaming: true, clientStreaming: true, options: {}, I: TransferRequest, O: TransferResponse }
+]);