@code0-tech/tucana 0.0.0 → 0.0.37

package/pb/aquila.flow_type_pb.ts

@@ -0,0 +1,140 @@
+// @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 { 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 { FlowType } from "./shared.flow_definition_pb";
+/**
+ * Request for updating a list of adapter flow types
+ *
+ * @generated from protobuf message aquila.FlowTypeUpdateRequest
+ */
+export interface FlowTypeUpdateRequest {
+    /**
+     * List of adapter flow types
+     *
+     * @generated from protobuf field: repeated shared.FlowType flow_types = 1
+     */
+    flowTypes: FlowType[];
+}
+/**
+ * Response of updating adapter flow types
+ *
+ * @generated from protobuf message aquila.FlowTypeUpdateResponse
+ */
+export interface FlowTypeUpdateResponse {
+    /**
+     * 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 FlowTypeUpdateRequest$Type extends MessageType<FlowTypeUpdateRequest> {
+    constructor() {
+        super("aquila.FlowTypeUpdateRequest", [
+            { no: 1, name: "flow_types", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => FlowType }
+        ]);
+    }
+    create(value?: PartialMessage<FlowTypeUpdateRequest>): FlowTypeUpdateRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.flowTypes = [];
+        if (value !== undefined)
+            reflectionMergePartial<FlowTypeUpdateRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FlowTypeUpdateRequest): FlowTypeUpdateRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated shared.FlowType flow_types */ 1:
+                    message.flowTypes.push(FlowType.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: FlowTypeUpdateRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated shared.FlowType flow_types = 1; */
+        for (let i = 0; i < message.flowTypes.length; i++)
+            FlowType.internalBinaryWrite(message.flowTypes[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.FlowTypeUpdateRequest
+ */
+export const FlowTypeUpdateRequest = new FlowTypeUpdateRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class FlowTypeUpdateResponse$Type extends MessageType<FlowTypeUpdateResponse> {
+    constructor() {
+        super("aquila.FlowTypeUpdateResponse", [
+            { no: 1, name: "success", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value?: PartialMessage<FlowTypeUpdateResponse>): FlowTypeUpdateResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.success = false;
+        if (value !== undefined)
+            reflectionMergePartial<FlowTypeUpdateResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FlowTypeUpdateResponse): FlowTypeUpdateResponse {
+        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: FlowTypeUpdateResponse, 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.FlowTypeUpdateResponse
+ */
+export const FlowTypeUpdateResponse = new FlowTypeUpdateResponse$Type();
+/**
+ * @generated ServiceType for protobuf service aquila.FlowTypeService
+ */
+export const FlowTypeService = new ServiceType("aquila.FlowTypeService", [
+    { name: "Update", options: {}, I: FlowTypeUpdateRequest, O: FlowTypeUpdateResponse }
+]);

package/pb/aquila.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 "aquila.runtime_function.proto" (package "aquila", syntax proto3)
+// tslint:disable
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import { RuntimeFunctionDefinitionService } from "./aquila.runtime_function_pb";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+import type { RuntimeFunctionDefinitionUpdateResponse } from "./aquila.runtime_function_pb";
+import type { RuntimeFunctionDefinitionUpdateRequest } from "./aquila.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 Aquila and as a client by Taurus.
+ *
+ * @generated from protobuf service aquila.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 Aquila and as a client by Taurus.
+ *
+ * @generated from protobuf service aquila.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/aquila.runtime_function_pb.ts

@@ -0,0 +1,140 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "aquila.runtime_function.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 { RuntimeFunctionDefinition } from "./shared.runtime_function_pb";
+/**
+ * Request for updating a list of runtime function definitions
+ *
+ * @generated from protobuf message aquila.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 aquila.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("aquila.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 aquila.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("aquila.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 aquila.RuntimeFunctionDefinitionUpdateResponse
+ */
+export const RuntimeFunctionDefinitionUpdateResponse = new RuntimeFunctionDefinitionUpdateResponse$Type();
+/**
+ * @generated ServiceType for protobuf service aquila.RuntimeFunctionDefinitionService
+ */
+export const RuntimeFunctionDefinitionService = new ServiceType("aquila.RuntimeFunctionDefinitionService", [
+    { name: "Update", options: {}, I: RuntimeFunctionDefinitionUpdateRequest, O: RuntimeFunctionDefinitionUpdateResponse }
+]);

package/pb/sagittarius.action_pb.client.ts

@@ -0,0 +1,54 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "sagittarius.action.proto" (package "sagittarius", syntax proto3)
+// tslint:disable
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import { ActionService } from "./sagittarius.action_pb";
+import type { ActionLogoffResponse } from "./sagittarius.action_pb";
+import type { ActionLogoffRequest } from "./sagittarius.action_pb";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+import type { ActionLogonResponse } from "./sagittarius.action_pb";
+import type { ActionLogonRequest } from "./sagittarius.action_pb";
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+/**
+ * Service from Sagittarius to get called by Aquila to get informed of any action behavior & availability
+ *
+ * @generated from protobuf service sagittarius.ActionService
+ */
+export interface IActionServiceClient {
+    /**
+     * @generated from protobuf rpc: Logon
+     */
+    logon(input: ActionLogonRequest, options?: RpcOptions): UnaryCall<ActionLogonRequest, ActionLogonResponse>;
+    /**
+     * @generated from protobuf rpc: Logoff
+     */
+    logoff(input: ActionLogoffRequest, options?: RpcOptions): UnaryCall<ActionLogoffRequest, ActionLogoffResponse>;
+}
+/**
+ * Service from Sagittarius to get called by Aquila to get informed of any action behavior & availability
+ *
+ * @generated from protobuf service sagittarius.ActionService
+ */
+export class ActionServiceClient implements IActionServiceClient, ServiceInfo {
+    typeName = ActionService.typeName;
+    methods = ActionService.methods;
+    options = ActionService.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * @generated from protobuf rpc: Logon
+     */
+    logon(input: ActionLogonRequest, options?: RpcOptions): UnaryCall<ActionLogonRequest, ActionLogonResponse> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<ActionLogonRequest, ActionLogonResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: Logoff
+     */
+    logoff(input: ActionLogoffRequest, options?: RpcOptions): UnaryCall<ActionLogoffRequest, ActionLogoffResponse> {
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        return stackIntercept<ActionLogoffRequest, ActionLogoffResponse>("unary", this._transport, method, opt, input);
+    }
+}

package/pb/sagittarius.action_pb.ts

@@ -0,0 +1,239 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "sagittarius.action.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 communicating that an action went online
+ *
+ * @generated from protobuf message sagittarius.ActionLogonRequest
+ */
+export interface ActionLogonRequest {
+    /**
+     * Unique identifier of action
+     *
+     * @generated from protobuf field: string identifier = 1
+     */
+    identifier: string;
+    /**
+     * All function definitions the action holds
+     *
+     * @generated from protobuf field: repeated shared.RuntimeFunctionDefinition function_definition = 2
+     */
+    functionDefinition: RuntimeFunctionDefinition[];
+}
+/**
+ * @generated from protobuf message sagittarius.ActionLogonResponse
+ */
+export interface ActionLogonResponse {
+}
+/**
+ * Request for communication that an action went offline
+ *
+ * @generated from protobuf message sagittarius.ActionLogoffRequest
+ */
+export interface ActionLogoffRequest {
+    /**
+     * @generated from protobuf field: string identifier = 1
+     */
+    identifier: string;
+}
+/**
+ * @generated from protobuf message sagittarius.ActionLogoffResponse
+ */
+export interface ActionLogoffResponse {
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class ActionLogonRequest$Type extends MessageType<ActionLogonRequest> {
+    constructor() {
+        super("sagittarius.ActionLogonRequest", [
+            { no: 1, name: "identifier", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "function_definition", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => RuntimeFunctionDefinition }
+        ]);
+    }
+    create(value?: PartialMessage<ActionLogonRequest>): ActionLogonRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.identifier = "";
+        message.functionDefinition = [];
+        if (value !== undefined)
+            reflectionMergePartial<ActionLogonRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActionLogonRequest): ActionLogonRequest {
+        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_definition */ 2:
+                    message.functionDefinition.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: ActionLogonRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string identifier = 1; */
+        if (message.identifier !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.identifier);
+        /* repeated shared.RuntimeFunctionDefinition function_definition = 2; */
+        for (let i = 0; i < message.functionDefinition.length; i++)
+            RuntimeFunctionDefinition.internalBinaryWrite(message.functionDefinition[i], 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.ActionLogonRequest
+ */
+export const ActionLogonRequest = new ActionLogonRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ActionLogonResponse$Type extends MessageType<ActionLogonResponse> {
+    constructor() {
+        super("sagittarius.ActionLogonResponse", []);
+    }
+    create(value?: PartialMessage<ActionLogonResponse>): ActionLogonResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<ActionLogonResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActionLogonResponse): ActionLogonResponse {
+        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: ActionLogonResponse, 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.ActionLogonResponse
+ */
+export const ActionLogonResponse = new ActionLogonResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ActionLogoffRequest$Type extends MessageType<ActionLogoffRequest> {
+    constructor() {
+        super("sagittarius.ActionLogoffRequest", [
+            { no: 1, name: "identifier", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<ActionLogoffRequest>): ActionLogoffRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.identifier = "";
+        if (value !== undefined)
+            reflectionMergePartial<ActionLogoffRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActionLogoffRequest): ActionLogoffRequest {
+        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;
+                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: ActionLogoffRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string identifier = 1; */
+        if (message.identifier !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.identifier);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message sagittarius.ActionLogoffRequest
+ */
+export const ActionLogoffRequest = new ActionLogoffRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ActionLogoffResponse$Type extends MessageType<ActionLogoffResponse> {
+    constructor() {
+        super("sagittarius.ActionLogoffResponse", []);
+    }
+    create(value?: PartialMessage<ActionLogoffResponse>): ActionLogoffResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<ActionLogoffResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActionLogoffResponse): ActionLogoffResponse {
+        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: ActionLogoffResponse, 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.ActionLogoffResponse
+ */
+export const ActionLogoffResponse = new ActionLogoffResponse$Type();
+/**
+ * @generated ServiceType for protobuf service sagittarius.ActionService
+ */
+export const ActionService = new ServiceType("sagittarius.ActionService", [
+    { name: "Logon", options: {}, I: ActionLogonRequest, O: ActionLogonResponse },
+    { name: "Logoff", options: {}, I: ActionLogoffRequest, O: ActionLogoffResponse }
+]);

package/pb/sagittarius.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 "sagittarius.data_type.proto" (package "sagittarius", syntax proto3)
+// tslint:disable
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import { DataTypeService } from "./sagittarius.data_type_pb";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+import type { DataTypeUpdateResponse } from "./sagittarius.data_type_pb";
+import type { DataTypeUpdateRequest } from "./sagittarius.data_type_pb";
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+/**
+ * @generated from protobuf service sagittarius.DataTypeService
+ */
+export interface IDataTypeServiceClient {
+    /**
+     * @generated from protobuf rpc: Update
+     */
+    update(input: DataTypeUpdateRequest, options?: RpcOptions): UnaryCall<DataTypeUpdateRequest, DataTypeUpdateResponse>;
+}
+/**
+ * @generated from protobuf service sagittarius.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);
+    }
+}