@code0-tech/tucana 0.0.0 → 0.0.38

package/pb/sagittarius.data_type_pb.ts

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

package/pb/sagittarius.flow_pb.client.ts

@@ -0,0 +1,37 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "sagittarius.flow.proto" (package "sagittarius", syntax proto3)
+// tslint:disable
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import { FlowService } from "./sagittarius.flow_pb";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+import type { FlowResponse } from "./sagittarius.flow_pb";
+import type { FlowLogonRequest } from "./sagittarius.flow_pb";
+import type { ServerStreamingCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+/**
+ * @generated from protobuf service sagittarius.FlowService
+ */
+export interface IFlowServiceClient {
+    /**
+     * @generated from protobuf rpc: Update
+     */
+    update(input: FlowLogonRequest, options?: RpcOptions): ServerStreamingCall<FlowLogonRequest, FlowResponse>;
+}
+/**
+ * @generated from protobuf service sagittarius.FlowService
+ */
+export class FlowServiceClient implements IFlowServiceClient, ServiceInfo {
+    typeName = FlowService.typeName;
+    methods = FlowService.methods;
+    options = FlowService.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * @generated from protobuf rpc: Update
+     */
+    update(input: FlowLogonRequest, options?: RpcOptions): ServerStreamingCall<FlowLogonRequest, FlowResponse> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<FlowLogonRequest, FlowResponse>("serverStreaming", this._transport, method, opt, input);
+    }
+}

package/pb/sagittarius.flow_pb.ts

@@ -0,0 +1,173 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "sagittarius.flow.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 { Flows } from "./shared.flow_pb";
+import { ValidationFlow } from "./shared.flow_pb";
+/**
+ * Aquila sends a request to initialise stream to Sagittarius
+ *
+ * @generated from protobuf message sagittarius.FlowLogonRequest
+ */
+export interface FlowLogonRequest {
+}
+/**
+ * Sagittarius sends flow to be updated
+ *
+ * @generated from protobuf message sagittarius.FlowResponse
+ */
+export interface FlowResponse {
+    /**
+     * @generated from protobuf oneof: data
+     */
+    data: {
+        oneofKind: "updatedFlow";
+        /**
+         * Updates a single flow
+         *
+         * @generated from protobuf field: shared.ValidationFlow updated_flow = 1
+         */
+        updatedFlow: ValidationFlow;
+    } | {
+        oneofKind: "deletedFlowId";
+        /**
+         * Deletes a single flow
+         *
+         * @generated from protobuf field: int64 deleted_flow_id = 2
+         */
+        deletedFlowId: bigint;
+    } | {
+        oneofKind: "flows";
+        /**
+         * Replaces all flows in Aquila (only on startup and for releases)
+         *
+         * @generated from protobuf field: shared.Flows flows = 3
+         */
+        flows: Flows;
+    } | {
+        oneofKind: undefined;
+    };
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class FlowLogonRequest$Type extends MessageType<FlowLogonRequest> {
+    constructor() {
+        super("sagittarius.FlowLogonRequest", []);
+    }
+    create(value?: PartialMessage<FlowLogonRequest>): FlowLogonRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<FlowLogonRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FlowLogonRequest): FlowLogonRequest {
+        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: FlowLogonRequest, 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.FlowLogonRequest
+ */
+export const FlowLogonRequest = new FlowLogonRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class FlowResponse$Type extends MessageType<FlowResponse> {
+    constructor() {
+        super("sagittarius.FlowResponse", [
+            { no: 1, name: "updated_flow", kind: "message", oneof: "data", T: () => ValidationFlow },
+            { no: 2, name: "deleted_flow_id", kind: "scalar", oneof: "data", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 3, name: "flows", kind: "message", oneof: "data", T: () => Flows }
+        ]);
+    }
+    create(value?: PartialMessage<FlowResponse>): FlowResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.data = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial<FlowResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FlowResponse): FlowResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* shared.ValidationFlow updated_flow */ 1:
+                    message.data = {
+                        oneofKind: "updatedFlow",
+                        updatedFlow: ValidationFlow.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).updatedFlow)
+                    };
+                    break;
+                case /* int64 deleted_flow_id */ 2:
+                    message.data = {
+                        oneofKind: "deletedFlowId",
+                        deletedFlowId: reader.int64().toBigInt()
+                    };
+                    break;
+                case /* shared.Flows flows */ 3:
+                    message.data = {
+                        oneofKind: "flows",
+                        flows: Flows.internalBinaryRead(reader, reader.uint32(), options, (message.data as any).flows)
+                    };
+                    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: FlowResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* shared.ValidationFlow updated_flow = 1; */
+        if (message.data.oneofKind === "updatedFlow")
+            ValidationFlow.internalBinaryWrite(message.data.updatedFlow, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* int64 deleted_flow_id = 2; */
+        if (message.data.oneofKind === "deletedFlowId")
+            writer.tag(2, WireType.Varint).int64(message.data.deletedFlowId);
+        /* shared.Flows flows = 3; */
+        if (message.data.oneofKind === "flows")
+            Flows.internalBinaryWrite(message.data.flows, 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.FlowResponse
+ */
+export const FlowResponse = new FlowResponse$Type();
+/**
+ * @generated ServiceType for protobuf service sagittarius.FlowService
+ */
+export const FlowService = new ServiceType("sagittarius.FlowService", [
+    { name: "Update", serverStreaming: true, options: {}, I: FlowLogonRequest, O: FlowResponse }
+]);

package/pb/sagittarius.flow_type_pb.client.ts

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

package/pb/sagittarius.flow_type_pb.ts

@@ -0,0 +1,140 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "sagittarius.flow_type.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 { FlowType } from "./shared.flow_definition_pb";
+/**
+ * Request for updating a list of adapter flow types
+ *
+ * @generated from protobuf message sagittarius.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 sagittarius.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("sagittarius.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 sagittarius.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("sagittarius.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 sagittarius.FlowTypeUpdateResponse
+ */
+export const FlowTypeUpdateResponse = new FlowTypeUpdateResponse$Type();
+/**
+ * @generated ServiceType for protobuf service sagittarius.FlowTypeService
+ */
+export const FlowTypeService = new ServiceType("sagittarius.FlowTypeService", [
+    { name: "Update", options: {}, I: FlowTypeUpdateRequest, O: FlowTypeUpdateResponse }
+]);

package/pb/sagittarius.ping_pb.client.ts

@@ -0,0 +1,36 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "sagittarius.ping.proto" (package "sagittarius", syntax proto3)
+// tslint:disable
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import { PingService } from "./sagittarius.ping_pb";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+import type { PingMessage } from "./sagittarius.ping_pb";
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+/**
+ * @generated from protobuf service sagittarius.PingService
+ */
+export interface IPingServiceClient {
+    /**
+     * @generated from protobuf rpc: Ping
+     */
+    ping(input: PingMessage, options?: RpcOptions): UnaryCall<PingMessage, PingMessage>;
+}
+/**
+ * @generated from protobuf service sagittarius.PingService
+ */
+export class PingServiceClient implements IPingServiceClient, ServiceInfo {
+    typeName = PingService.typeName;
+    methods = PingService.methods;
+    options = PingService.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * @generated from protobuf rpc: Ping
+     */
+    ping(input: PingMessage, options?: RpcOptions): UnaryCall<PingMessage, PingMessage> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<PingMessage, PingMessage>("unary", this._transport, method, opt, input);
+    }
+}

package/pb/sagittarius.ping_pb.ts

@@ -0,0 +1,75 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "sagittarius.ping.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";
+/**
+ * @generated from protobuf message sagittarius.PingMessage
+ */
+export interface PingMessage {
+    /**
+     * @generated from protobuf field: int64 ping_id = 1
+     */
+    pingId: bigint;
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class PingMessage$Type extends MessageType<PingMessage> {
+    constructor() {
+        super("sagittarius.PingMessage", [
+            { no: 1, name: "ping_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value?: PartialMessage<PingMessage>): PingMessage {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.pingId = 0n;
+        if (value !== undefined)
+            reflectionMergePartial<PingMessage>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PingMessage): PingMessage {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 ping_id */ 1:
+                    message.pingId = reader.int64().toBigInt();
+                    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: PingMessage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 ping_id = 1; */
+        if (message.pingId !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.pingId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message sagittarius.PingMessage
+ */
+export const PingMessage = new PingMessage$Type();
+/**
+ * @generated ServiceType for protobuf service sagittarius.PingService
+ */
+export const PingService = new ServiceType("sagittarius.PingService", [
+    { name: "Ping", options: {}, I: PingMessage, O: PingMessage }
+]);