@code0-tech/tucana 0.0.0 → 0.0.38

package/pb/sagittarius.runtime_function_pb.client.ts

@@ -0,0 +1,41 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "sagittarius.runtime_function.proto" (package "sagittarius", syntax proto3)
+// tslint:disable
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import { RuntimeFunctionDefinitionService } from "./sagittarius.runtime_function_pb";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+import type { RuntimeFunctionDefinitionUpdateResponse } from "./sagittarius.runtime_function_pb";
+import type { RuntimeFunctionDefinitionUpdateRequest } from "./sagittarius.runtime_function_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 Sagittarius and as a client by Aquila.
+ *
+ * @generated from protobuf service sagittarius.RuntimeFunctionDefinitionService
+ */
+export interface IRuntimeFunctionDefinitionServiceClient {
+    /**
+     * @generated from protobuf rpc: Update
+     */
+    update(input: RuntimeFunctionDefinitionUpdateRequest, options?: RpcOptions): UnaryCall<RuntimeFunctionDefinitionUpdateRequest, RuntimeFunctionDefinitionUpdateResponse>;
+}
+/**
+ * This service will be implemented as a server by Sagittarius and as a client by Aquila.
+ *
+ * @generated from protobuf service sagittarius.RuntimeFunctionDefinitionService
+ */
+export class RuntimeFunctionDefinitionServiceClient implements IRuntimeFunctionDefinitionServiceClient, ServiceInfo {
+    typeName = RuntimeFunctionDefinitionService.typeName;
+    methods = RuntimeFunctionDefinitionService.methods;
+    options = RuntimeFunctionDefinitionService.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * @generated from protobuf rpc: Update
+     */
+    update(input: RuntimeFunctionDefinitionUpdateRequest, options?: RpcOptions): UnaryCall<RuntimeFunctionDefinitionUpdateRequest, RuntimeFunctionDefinitionUpdateResponse> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<RuntimeFunctionDefinitionUpdateRequest, RuntimeFunctionDefinitionUpdateResponse>("unary", this._transport, method, opt, input);
+    }
+}

package/pb/sagittarius.runtime_function_pb.ts

@@ -0,0 +1,140 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "sagittarius.runtime_function.proto" (package "sagittarius", 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 { RuntimeFunctionDefinition } from "./shared.runtime_function_pb";
+/**
+ * Request for updating a list of runtime function definitions
+ *
+ * @generated from protobuf message sagittarius.RuntimeFunctionDefinitionUpdateRequest
+ */
+export interface RuntimeFunctionDefinitionUpdateRequest {
+    /**
+     * List of runtime function definitions
+     *
+     * @generated from protobuf field: repeated shared.RuntimeFunctionDefinition runtime_functions = 1
+     */
+    runtimeFunctions: RuntimeFunctionDefinition[];
+}
+/**
+ * Response of updating runtime function definitions
+ *
+ * @generated from protobuf message sagittarius.RuntimeFunctionDefinitionUpdateResponse
+ */
+export interface RuntimeFunctionDefinitionUpdateResponse {
+    /**
+     * 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 RuntimeFunctionDefinitionUpdateRequest$Type extends MessageType<RuntimeFunctionDefinitionUpdateRequest> {
+    constructor() {
+        super("sagittarius.RuntimeFunctionDefinitionUpdateRequest", [
+            { no: 1, name: "runtime_functions", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => RuntimeFunctionDefinition }
+        ]);
+    }
+    create(value?: PartialMessage<RuntimeFunctionDefinitionUpdateRequest>): RuntimeFunctionDefinitionUpdateRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.runtimeFunctions = [];
+        if (value !== undefined)
+            reflectionMergePartial<RuntimeFunctionDefinitionUpdateRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RuntimeFunctionDefinitionUpdateRequest): RuntimeFunctionDefinitionUpdateRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated shared.RuntimeFunctionDefinition runtime_functions */ 1:
+                    message.runtimeFunctions.push(RuntimeFunctionDefinition.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: RuntimeFunctionDefinitionUpdateRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated shared.RuntimeFunctionDefinition runtime_functions = 1; */
+        for (let i = 0; i < message.runtimeFunctions.length; i++)
+            RuntimeFunctionDefinition.internalBinaryWrite(message.runtimeFunctions[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 sagittarius.RuntimeFunctionDefinitionUpdateRequest
+ */
+export const RuntimeFunctionDefinitionUpdateRequest = new RuntimeFunctionDefinitionUpdateRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RuntimeFunctionDefinitionUpdateResponse$Type extends MessageType<RuntimeFunctionDefinitionUpdateResponse> {
+    constructor() {
+        super("sagittarius.RuntimeFunctionDefinitionUpdateResponse", [
+            { no: 1, name: "success", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value?: PartialMessage<RuntimeFunctionDefinitionUpdateResponse>): RuntimeFunctionDefinitionUpdateResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.success = false;
+        if (value !== undefined)
+            reflectionMergePartial<RuntimeFunctionDefinitionUpdateResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RuntimeFunctionDefinitionUpdateResponse): RuntimeFunctionDefinitionUpdateResponse {
+        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: RuntimeFunctionDefinitionUpdateResponse, 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 sagittarius.RuntimeFunctionDefinitionUpdateResponse
+ */
+export const RuntimeFunctionDefinitionUpdateResponse = new RuntimeFunctionDefinitionUpdateResponse$Type();
+/**
+ * @generated ServiceType for protobuf service sagittarius.RuntimeFunctionDefinitionService
+ */
+export const RuntimeFunctionDefinitionService = new ServiceType("sagittarius.RuntimeFunctionDefinitionService", [
+    { name: "Update", options: {}, I: RuntimeFunctionDefinitionUpdateRequest, O: RuntimeFunctionDefinitionUpdateResponse }
+]);

package/pb/sagittarius.text_execution_pb.client.ts

@@ -0,0 +1,37 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "sagittarius.text_execution.proto" (package "sagittarius", syntax proto3)
+// tslint:disable
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import { ExecutionService } from "./sagittarius.text_execution_pb";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+import type { ExecutionLogonResponse } from "./sagittarius.text_execution_pb";
+import type { ExecutionLogonRequest } from "./sagittarius.text_execution_pb";
+import type { DuplexStreamingCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+/**
+ * @generated from protobuf service sagittarius.ExecutionService
+ */
+export interface IExecutionServiceClient {
+    /**
+     * @generated from protobuf rpc: Test
+     */
+    test(options?: RpcOptions): DuplexStreamingCall<ExecutionLogonRequest, ExecutionLogonResponse>;
+}
+/**
+ * @generated from protobuf service sagittarius.ExecutionService
+ */
+export class ExecutionServiceClient implements IExecutionServiceClient, ServiceInfo {
+    typeName = ExecutionService.typeName;
+    methods = ExecutionService.methods;
+    options = ExecutionService.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * @generated from protobuf rpc: Test
+     */
+    test(options?: RpcOptions): DuplexStreamingCall<ExecutionLogonRequest, ExecutionLogonResponse> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<ExecutionLogonRequest, ExecutionLogonResponse>("duplex", this._transport, method, opt);
+    }
+}

package/pb/sagittarius.text_execution_pb.ts

@@ -0,0 +1,456 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "sagittarius.text_execution.proto" (package "sagittarius", syntax proto3)
+// tslint:disable
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
+import { WireType } from "@protobuf-ts/runtime";
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } 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 { Value } from "./shared.struct_pb";
+/**
+ * @generated from protobuf message sagittarius.Logon
+ */
+export interface Logon {
+}
+/**
+ * @generated from protobuf message sagittarius.TestExecutionRequest
+ */
+export interface TestExecutionRequest {
+    /**
+     * @generated from protobuf field: int64 flow_id = 1
+     */
+    flowId: bigint;
+    /**
+     * @generated from protobuf field: string execution_uuid = 2
+     */
+    executionUuid: string;
+    /**
+     * @generated from protobuf field: shared.Value body = 3
+     */
+    body?: Value;
+}
+/**
+ * @generated from protobuf message sagittarius.TestExecutionResponse
+ */
+export interface TestExecutionResponse {
+    /**
+     * @generated from protobuf field: int64 flow_id = 1
+     */
+    flowId: bigint;
+    /**
+     * @generated from protobuf field: string execution_uuid = 2
+     */
+    executionUuid: string;
+    /**
+     * @generated from protobuf field: shared.Value result = 3
+     */
+    result?: Value;
+    /**
+     * @generated from protobuf field: repeated sagittarius.Log logs = 4
+     */
+    logs: Log[];
+}
+/**
+ * @generated from protobuf message sagittarius.Log
+ */
+export interface Log {
+    /**
+     * @generated from protobuf field: string message = 1
+     */
+    message: string;
+    /**
+     * @generated from protobuf field: string level = 2
+     */
+    level: string;
+    /**
+     * @generated from protobuf field: string timestamp = 3
+     */
+    timestamp: string;
+}
+/**
+ * Aquila sends a logon request to Sagittarius that initiates a stream
+ * If the stream is initialized it will return the result after it received a request
+ *
+ * @generated from protobuf message sagittarius.ExecutionLogonRequest
+ */
+export interface ExecutionLogonRequest {
+    /**
+     * @generated from protobuf oneof: data
+     */
+    data: {
+        oneofKind: "logon";
+        /**
+         * @generated from protobuf field: sagittarius.Logon logon = 1
+         */
+        logon: Logon;
+    } | {
+        oneofKind: "response";
+        /**
+         * @generated from protobuf field: sagittarius.TestExecutionResponse response = 2
+         */
+        response: TestExecutionResponse;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * Sagittarius sends execution requests
+ *
+ * @generated from protobuf message sagittarius.ExecutionLogonResponse
+ */
+export interface ExecutionLogonResponse {
+    /**
+     * @generated from protobuf field: sagittarius.TestExecutionRequest request = 1
+     */
+    request?: TestExecutionRequest;
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class Logon$Type extends MessageType<Logon> {
+    constructor() {
+        super("sagittarius.Logon", []);
+    }
+    create(value?: PartialMessage<Logon>): Logon {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<Logon>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Logon): Logon {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                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: Logon, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message sagittarius.Logon
+ */
+export const Logon = new Logon$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TestExecutionRequest$Type extends MessageType<TestExecutionRequest> {
+    constructor() {
+        super("sagittarius.TestExecutionRequest", [
+            { no: 1, name: "flow_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "execution_uuid", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "body", kind: "message", T: () => Value }
+        ]);
+    }
+    create(value?: PartialMessage<TestExecutionRequest>): TestExecutionRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.flowId = 0n;
+        message.executionUuid = "";
+        if (value !== undefined)
+            reflectionMergePartial<TestExecutionRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TestExecutionRequest): TestExecutionRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 flow_id */ 1:
+                    message.flowId = reader.int64().toBigInt();
+                    break;
+                case /* string execution_uuid */ 2:
+                    message.executionUuid = reader.string();
+                    break;
+                case /* shared.Value body */ 3:
+                    message.body = Value.internalBinaryRead(reader, reader.uint32(), options, message.body);
+                    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: TestExecutionRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 flow_id = 1; */
+        if (message.flowId !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.flowId);
+        /* string execution_uuid = 2; */
+        if (message.executionUuid !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.executionUuid);
+        /* shared.Value body = 3; */
+        if (message.body)
+            Value.internalBinaryWrite(message.body, 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 sagittarius.TestExecutionRequest
+ */
+export const TestExecutionRequest = new TestExecutionRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TestExecutionResponse$Type extends MessageType<TestExecutionResponse> {
+    constructor() {
+        super("sagittarius.TestExecutionResponse", [
+            { no: 1, name: "flow_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "execution_uuid", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "result", kind: "message", T: () => Value },
+            { no: 4, name: "logs", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Log }
+        ]);
+    }
+    create(value?: PartialMessage<TestExecutionResponse>): TestExecutionResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.flowId = 0n;
+        message.executionUuid = "";
+        message.logs = [];
+        if (value !== undefined)
+            reflectionMergePartial<TestExecutionResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TestExecutionResponse): TestExecutionResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 flow_id */ 1:
+                    message.flowId = reader.int64().toBigInt();
+                    break;
+                case /* string execution_uuid */ 2:
+                    message.executionUuid = reader.string();
+                    break;
+                case /* shared.Value result */ 3:
+                    message.result = Value.internalBinaryRead(reader, reader.uint32(), options, message.result);
+                    break;
+                case /* repeated sagittarius.Log logs */ 4:
+                    message.logs.push(Log.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: TestExecutionResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 flow_id = 1; */
+        if (message.flowId !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.flowId);
+        /* string execution_uuid = 2; */
+        if (message.executionUuid !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.executionUuid);
+        /* shared.Value result = 3; */
+        if (message.result)
+            Value.internalBinaryWrite(message.result, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* repeated sagittarius.Log logs = 4; */
+        for (let i = 0; i < message.logs.length; i++)
+            Log.internalBinaryWrite(message.logs[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 sagittarius.TestExecutionResponse
+ */
+export const TestExecutionResponse = new TestExecutionResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Log$Type extends MessageType<Log> {
+    constructor() {
+        super("sagittarius.Log", [
+            { no: 1, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "level", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "timestamp", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Log>): Log {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.message = "";
+        message.level = "";
+        message.timestamp = "";
+        if (value !== undefined)
+            reflectionMergePartial<Log>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Log): Log {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string message */ 1:
+                    message.message = reader.string();
+                    break;
+                case /* string level */ 2:
+                    message.level = reader.string();
+                    break;
+                case /* string timestamp */ 3:
+                    message.timestamp = 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: Log, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string message = 1; */
+        if (message.message !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.message);
+        /* string level = 2; */
+        if (message.level !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.level);
+        /* string timestamp = 3; */
+        if (message.timestamp !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.timestamp);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message sagittarius.Log
+ */
+export const Log = new Log$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExecutionLogonRequest$Type extends MessageType<ExecutionLogonRequest> {
+    constructor() {
+        super("sagittarius.ExecutionLogonRequest", [
+            { no: 1, name: "logon", kind: "message", oneof: "data", T: () => Logon },
+            { no: 2, name: "response", kind: "message", oneof: "data", T: () => TestExecutionResponse }
+        ]);
+    }
+    create(value?: PartialMessage<ExecutionLogonRequest>): ExecutionLogonRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.data = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial<ExecutionLogonRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionLogonRequest): ExecutionLogonRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* sagittarius.Logon logon */ 1:
+                    message.data = {
+                        oneofKind: "logon",
+                        logon: Logon.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).logon)
+                    };
+                    break;
+                case /* sagittarius.TestExecutionResponse response */ 2:
+                    message.data = {
+                        oneofKind: "response",
+                        response: TestExecutionResponse.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).response)
+                    };
+                    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: ExecutionLogonRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* sagittarius.Logon logon = 1; */
+        if (message.data.oneofKind === "logon")
+            Logon.internalBinaryWrite(message.data.logon, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* sagittarius.TestExecutionResponse response = 2; */
+        if (message.data.oneofKind === "response")
+            TestExecutionResponse.internalBinaryWrite(message.data.response, 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 sagittarius.ExecutionLogonRequest
+ */
+export const ExecutionLogonRequest = new ExecutionLogonRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExecutionLogonResponse$Type extends MessageType<ExecutionLogonResponse> {
+    constructor() {
+        super("sagittarius.ExecutionLogonResponse", [
+            { no: 1, name: "request", kind: "message", T: () => TestExecutionRequest }
+        ]);
+    }
+    create(value?: PartialMessage<ExecutionLogonResponse>): ExecutionLogonResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<ExecutionLogonResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionLogonResponse): ExecutionLogonResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* sagittarius.TestExecutionRequest request */ 1:
+                    message.request = TestExecutionRequest.internalBinaryRead(reader, reader.uint32(), options, message.request);
+                    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: ExecutionLogonResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* sagittarius.TestExecutionRequest request = 1; */
+        if (message.request)
+            TestExecutionRequest.internalBinaryWrite(message.request, 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 sagittarius.ExecutionLogonResponse
+ */
+export const ExecutionLogonResponse = new ExecutionLogonResponse$Type();
+/**
+ * @generated ServiceType for protobuf service sagittarius.ExecutionService
+ */
+export const ExecutionService = new ServiceType("sagittarius.ExecutionService", [
+    { name: "Test", serverStreaming: true, clientStreaming: true, options: {}, I: ExecutionLogonRequest, O: ExecutionLogonResponse }
+]);