@fraym/proto 0.1.0

package/dist/freym/projections/management/service.d.ts

@@ -0,0 +1,94 @@
+/// <reference types="node" />
+import { CallOptions, ChannelCredentials, Client, ClientDuplexStream, ClientOptions, ClientUnaryCall, handleBidiStreamingCall, handleUnaryCall, Metadata, ServiceError, UntypedServiceImplementation } from "@grpc/grpc-js";
+import { DataToTransform, DataTransformationRequest } from "./data_transformation";
+import { FinishMigrationRequest, FinishMigrationResponse, GetMigrationStatusRequest, GetMigrationStatusResponse, RegisterMigrationRequest, RegisterMigrationResponse, RollbackMigrationRequest, RollbackMigrationResponse, StartMigrationRequest, StartMigrationResponse } from "./migration";
+export declare const protobufPackage = "freym.projections.management";
+export type ServiceService = typeof ServiceService;
+export declare const ServiceService: {
+    readonly registerMigration: {
+        readonly path: "/freym.projections.management.Service/RegisterMigration";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: RegisterMigrationRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => RegisterMigrationRequest;
+        readonly responseSerialize: (value: RegisterMigrationResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => RegisterMigrationResponse;
+    };
+    readonly startMigration: {
+        readonly path: "/freym.projections.management.Service/StartMigration";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: StartMigrationRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => StartMigrationRequest;
+        readonly responseSerialize: (value: StartMigrationResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => StartMigrationResponse;
+    };
+    readonly finishMigration: {
+        readonly path: "/freym.projections.management.Service/FinishMigration";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: FinishMigrationRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => FinishMigrationRequest;
+        readonly responseSerialize: (value: FinishMigrationResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => FinishMigrationResponse;
+    };
+    readonly rollbackMigration: {
+        readonly path: "/freym.projections.management.Service/RollbackMigration";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: RollbackMigrationRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => RollbackMigrationRequest;
+        readonly responseSerialize: (value: RollbackMigrationResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => RollbackMigrationResponse;
+    };
+    readonly getMigrationStatus: {
+        readonly path: "/freym.projections.management.Service/GetMigrationStatus";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetMigrationStatusRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetMigrationStatusRequest;
+        readonly responseSerialize: (value: GetMigrationStatusResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => GetMigrationStatusResponse;
+    };
+    readonly dataTransformation: {
+        readonly path: "/freym.projections.management.Service/DataTransformation";
+        readonly requestStream: true;
+        readonly responseStream: true;
+        readonly requestSerialize: (value: DataTransformationRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => DataTransformationRequest;
+        readonly responseSerialize: (value: DataToTransform) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => DataToTransform;
+    };
+};
+export interface ServiceServer extends UntypedServiceImplementation {
+    registerMigration: handleUnaryCall<RegisterMigrationRequest, RegisterMigrationResponse>;
+    startMigration: handleUnaryCall<StartMigrationRequest, StartMigrationResponse>;
+    finishMigration: handleUnaryCall<FinishMigrationRequest, FinishMigrationResponse>;
+    rollbackMigration: handleUnaryCall<RollbackMigrationRequest, RollbackMigrationResponse>;
+    getMigrationStatus: handleUnaryCall<GetMigrationStatusRequest, GetMigrationStatusResponse>;
+    dataTransformation: handleBidiStreamingCall<DataTransformationRequest, DataToTransform>;
+}
+export interface ServiceClient extends Client {
+    registerMigration(request: RegisterMigrationRequest, callback: (error: ServiceError | null, response: RegisterMigrationResponse) => void): ClientUnaryCall;
+    registerMigration(request: RegisterMigrationRequest, metadata: Metadata, callback: (error: ServiceError | null, response: RegisterMigrationResponse) => void): ClientUnaryCall;
+    registerMigration(request: RegisterMigrationRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: RegisterMigrationResponse) => void): ClientUnaryCall;
+    startMigration(request: StartMigrationRequest, callback: (error: ServiceError | null, response: StartMigrationResponse) => void): ClientUnaryCall;
+    startMigration(request: StartMigrationRequest, metadata: Metadata, callback: (error: ServiceError | null, response: StartMigrationResponse) => void): ClientUnaryCall;
+    startMigration(request: StartMigrationRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: StartMigrationResponse) => void): ClientUnaryCall;
+    finishMigration(request: FinishMigrationRequest, callback: (error: ServiceError | null, response: FinishMigrationResponse) => void): ClientUnaryCall;
+    finishMigration(request: FinishMigrationRequest, metadata: Metadata, callback: (error: ServiceError | null, response: FinishMigrationResponse) => void): ClientUnaryCall;
+    finishMigration(request: FinishMigrationRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: FinishMigrationResponse) => void): ClientUnaryCall;
+    rollbackMigration(request: RollbackMigrationRequest, callback: (error: ServiceError | null, response: RollbackMigrationResponse) => void): ClientUnaryCall;
+    rollbackMigration(request: RollbackMigrationRequest, metadata: Metadata, callback: (error: ServiceError | null, response: RollbackMigrationResponse) => void): ClientUnaryCall;
+    rollbackMigration(request: RollbackMigrationRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: RollbackMigrationResponse) => void): ClientUnaryCall;
+    getMigrationStatus(request: GetMigrationStatusRequest, callback: (error: ServiceError | null, response: GetMigrationStatusResponse) => void): ClientUnaryCall;
+    getMigrationStatus(request: GetMigrationStatusRequest, metadata: Metadata, callback: (error: ServiceError | null, response: GetMigrationStatusResponse) => void): ClientUnaryCall;
+    getMigrationStatus(request: GetMigrationStatusRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: GetMigrationStatusResponse) => void): ClientUnaryCall;
+    dataTransformation(): ClientDuplexStream<DataTransformationRequest, DataToTransform>;
+    dataTransformation(options: Partial<CallOptions>): ClientDuplexStream<DataTransformationRequest, DataToTransform>;
+    dataTransformation(metadata: Metadata, options?: Partial<CallOptions>): ClientDuplexStream<DataTransformationRequest, DataToTransform>;
+}
+export declare const ServiceClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): ServiceClient;
+    service: typeof ServiceService;
+};

package/dist/freym/projections/management/service.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceClient = exports.ServiceService = exports.protobufPackage = void 0;
+const grpc_js_1 = require("@grpc/grpc-js");
+const data_transformation_1 = require("./data_transformation");
+const migration_1 = require("./migration");
+exports.protobufPackage = "freym.projections.management";
+exports.ServiceService = {
+    registerMigration: {
+        path: "/freym.projections.management.Service/RegisterMigration",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(migration_1.RegisterMigrationRequest.encode(value).finish()),
+        requestDeserialize: (value) => migration_1.RegisterMigrationRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(migration_1.RegisterMigrationResponse.encode(value).finish()),
+        responseDeserialize: (value) => migration_1.RegisterMigrationResponse.decode(value),
+    },
+    startMigration: {
+        path: "/freym.projections.management.Service/StartMigration",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(migration_1.StartMigrationRequest.encode(value).finish()),
+        requestDeserialize: (value) => migration_1.StartMigrationRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(migration_1.StartMigrationResponse.encode(value).finish()),
+        responseDeserialize: (value) => migration_1.StartMigrationResponse.decode(value),
+    },
+    finishMigration: {
+        path: "/freym.projections.management.Service/FinishMigration",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(migration_1.FinishMigrationRequest.encode(value).finish()),
+        requestDeserialize: (value) => migration_1.FinishMigrationRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(migration_1.FinishMigrationResponse.encode(value).finish()),
+        responseDeserialize: (value) => migration_1.FinishMigrationResponse.decode(value),
+    },
+    rollbackMigration: {
+        path: "/freym.projections.management.Service/RollbackMigration",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(migration_1.RollbackMigrationRequest.encode(value).finish()),
+        requestDeserialize: (value) => migration_1.RollbackMigrationRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(migration_1.RollbackMigrationResponse.encode(value).finish()),
+        responseDeserialize: (value) => migration_1.RollbackMigrationResponse.decode(value),
+    },
+    getMigrationStatus: {
+        path: "/freym.projections.management.Service/GetMigrationStatus",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(migration_1.GetMigrationStatusRequest.encode(value).finish()),
+        requestDeserialize: (value) => migration_1.GetMigrationStatusRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(migration_1.GetMigrationStatusResponse.encode(value).finish()),
+        responseDeserialize: (value) => migration_1.GetMigrationStatusResponse.decode(value),
+    },
+    dataTransformation: {
+        path: "/freym.projections.management.Service/DataTransformation",
+        requestStream: true,
+        responseStream: true,
+        requestSerialize: (value) => Buffer.from(data_transformation_1.DataTransformationRequest.encode(value).finish()),
+        requestDeserialize: (value) => data_transformation_1.DataTransformationRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(data_transformation_1.DataToTransform.encode(value).finish()),
+        responseDeserialize: (value) => data_transformation_1.DataToTransform.decode(value),
+    },
+};
+exports.ServiceClient = (0, grpc_js_1.makeGenericClientConstructor)(exports.ServiceService, "freym.projections.management.Service");

package/dist/freym/projections/management.d.ts

@@ -0,0 +1,3 @@
+export { ServiceClient, ServiceServer, ServiceService } from "./management/service";
+export { DataToTransform, DataToTransform_DataEntry, DataTransformationRequest, TransformData, TransformedData, TransformedData_DataEntry, } from "./management/data_transformation";
+export { CrudType, EnumType, FinishMigrationRequest, FinishMigrationResponse, GetMigrationStatusRequest, GetMigrationStatusResponse, NestedType, ProjectionType, RegisterMigrationRequest, RegisterMigrationResponse, RollbackMigrationRequest, RollbackMigrationResponse, StartMigrationRequest, StartMigrationResponse, TypeArgument, TypeDirective, TypeField, } from "./management/migration";

package/dist/freym/projections/management.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeField = exports.TypeDirective = exports.TypeArgument = exports.StartMigrationResponse = exports.StartMigrationRequest = exports.RollbackMigrationResponse = exports.RollbackMigrationRequest = exports.RegisterMigrationResponse = exports.RegisterMigrationRequest = exports.ProjectionType = exports.NestedType = exports.GetMigrationStatusResponse = exports.GetMigrationStatusRequest = exports.FinishMigrationResponse = exports.FinishMigrationRequest = exports.EnumType = exports.CrudType = exports.TransformedData_DataEntry = exports.TransformedData = exports.TransformData = exports.DataTransformationRequest = exports.DataToTransform_DataEntry = exports.DataToTransform = exports.ServiceService = exports.ServiceClient = void 0;
+var service_1 = require("./management/service");
+Object.defineProperty(exports, "ServiceClient", { enumerable: true, get: function () { return service_1.ServiceClient; } });
+Object.defineProperty(exports, "ServiceService", { enumerable: true, get: function () { return service_1.ServiceService; } });
+var data_transformation_1 = require("./management/data_transformation");
+Object.defineProperty(exports, "DataToTransform", { enumerable: true, get: function () { return data_transformation_1.DataToTransform; } });
+Object.defineProperty(exports, "DataToTransform_DataEntry", { enumerable: true, get: function () { return data_transformation_1.DataToTransform_DataEntry; } });
+Object.defineProperty(exports, "DataTransformationRequest", { enumerable: true, get: function () { return data_transformation_1.DataTransformationRequest; } });
+Object.defineProperty(exports, "TransformData", { enumerable: true, get: function () { return data_transformation_1.TransformData; } });
+Object.defineProperty(exports, "TransformedData", { enumerable: true, get: function () { return data_transformation_1.TransformedData; } });
+Object.defineProperty(exports, "TransformedData_DataEntry", { enumerable: true, get: function () { return data_transformation_1.TransformedData_DataEntry; } });
+var migration_1 = require("./management/migration");
+Object.defineProperty(exports, "CrudType", { enumerable: true, get: function () { return migration_1.CrudType; } });
+Object.defineProperty(exports, "EnumType", { enumerable: true, get: function () { return migration_1.EnumType; } });
+Object.defineProperty(exports, "FinishMigrationRequest", { enumerable: true, get: function () { return migration_1.FinishMigrationRequest; } });
+Object.defineProperty(exports, "FinishMigrationResponse", { enumerable: true, get: function () { return migration_1.FinishMigrationResponse; } });
+Object.defineProperty(exports, "GetMigrationStatusRequest", { enumerable: true, get: function () { return migration_1.GetMigrationStatusRequest; } });
+Object.defineProperty(exports, "GetMigrationStatusResponse", { enumerable: true, get: function () { return migration_1.GetMigrationStatusResponse; } });
+Object.defineProperty(exports, "NestedType", { enumerable: true, get: function () { return migration_1.NestedType; } });
+Object.defineProperty(exports, "ProjectionType", { enumerable: true, get: function () { return migration_1.ProjectionType; } });
+Object.defineProperty(exports, "RegisterMigrationRequest", { enumerable: true, get: function () { return migration_1.RegisterMigrationRequest; } });
+Object.defineProperty(exports, "RegisterMigrationResponse", { enumerable: true, get: function () { return migration_1.RegisterMigrationResponse; } });
+Object.defineProperty(exports, "RollbackMigrationRequest", { enumerable: true, get: function () { return migration_1.RollbackMigrationRequest; } });
+Object.defineProperty(exports, "RollbackMigrationResponse", { enumerable: true, get: function () { return migration_1.RollbackMigrationResponse; } });
+Object.defineProperty(exports, "StartMigrationRequest", { enumerable: true, get: function () { return migration_1.StartMigrationRequest; } });
+Object.defineProperty(exports, "StartMigrationResponse", { enumerable: true, get: function () { return migration_1.StartMigrationResponse; } });
+Object.defineProperty(exports, "TypeArgument", { enumerable: true, get: function () { return migration_1.TypeArgument; } });
+Object.defineProperty(exports, "TypeDirective", { enumerable: true, get: function () { return migration_1.TypeDirective; } });
+Object.defineProperty(exports, "TypeField", { enumerable: true, get: function () { return migration_1.TypeField; } });

package/dist/freym/streams/backchannel/broadcast.d.ts

@@ -0,0 +1,66 @@
+import _m0 from "protobufjs/minimal";
+import { Event } from "../clientchannel/event";
+export declare const protobufPackage = "freym.streams.backchannel";
+export interface BroadcastRequest {
+    tenantId: string;
+    topic: string;
+    broadcast: boolean;
+    event: Event | undefined;
+}
+export interface BroadcastResponse {
+    payload?: {
+        $case: "broadcastAck";
+        broadcastAck: BroadcastResponse_BroadcastAck;
+    } | {
+        $case: "broadcastNotAck";
+        broadcastNotAck: BroadcastResponse_BroadcastNotAck;
+    } | undefined;
+}
+export interface BroadcastResponse_BroadcastAck {
+}
+export interface BroadcastResponse_BroadcastNotAck {
+    reason: string;
+}
+export declare const BroadcastRequest: {
+    encode(message: BroadcastRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): BroadcastRequest;
+    fromJSON(object: any): BroadcastRequest;
+    toJSON(message: BroadcastRequest): unknown;
+    create(base?: DeepPartial<BroadcastRequest>): BroadcastRequest;
+    fromPartial(object: DeepPartial<BroadcastRequest>): BroadcastRequest;
+};
+export declare const BroadcastResponse: {
+    encode(message: BroadcastResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): BroadcastResponse;
+    fromJSON(object: any): BroadcastResponse;
+    toJSON(message: BroadcastResponse): unknown;
+    create(base?: DeepPartial<BroadcastResponse>): BroadcastResponse;
+    fromPartial(object: DeepPartial<BroadcastResponse>): BroadcastResponse;
+};
+export declare const BroadcastResponse_BroadcastAck: {
+    encode(_: BroadcastResponse_BroadcastAck, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): BroadcastResponse_BroadcastAck;
+    fromJSON(_: any): BroadcastResponse_BroadcastAck;
+    toJSON(_: BroadcastResponse_BroadcastAck): unknown;
+    create(base?: DeepPartial<BroadcastResponse_BroadcastAck>): BroadcastResponse_BroadcastAck;
+    fromPartial(_: DeepPartial<BroadcastResponse_BroadcastAck>): BroadcastResponse_BroadcastAck;
+};
+export declare const BroadcastResponse_BroadcastNotAck: {
+    encode(message: BroadcastResponse_BroadcastNotAck, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): BroadcastResponse_BroadcastNotAck;
+    fromJSON(object: any): BroadcastResponse_BroadcastNotAck;
+    toJSON(message: BroadcastResponse_BroadcastNotAck): unknown;
+    create(base?: DeepPartial<BroadcastResponse_BroadcastNotAck>): BroadcastResponse_BroadcastNotAck;
+    fromPartial(object: DeepPartial<BroadcastResponse_BroadcastNotAck>): BroadcastResponse_BroadcastNotAck;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    $case: string;
+} ? {
+    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
+} & {
+    $case: T["$case"];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};

package/dist/freym/streams/backchannel/broadcast.js

@@ -0,0 +1,292 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BroadcastResponse_BroadcastNotAck = exports.BroadcastResponse_BroadcastAck = exports.BroadcastResponse = exports.BroadcastRequest = exports.protobufPackage = void 0;
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const event_1 = require("../clientchannel/event");
+exports.protobufPackage = "freym.streams.backchannel";
+function createBaseBroadcastRequest() {
+    return { tenantId: "", topic: "", broadcast: false, event: undefined };
+}
+exports.BroadcastRequest = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.tenantId !== "") {
+            writer.uint32(10).string(message.tenantId);
+        }
+        if (message.topic !== "") {
+            writer.uint32(18).string(message.topic);
+        }
+        if (message.broadcast === true) {
+            writer.uint32(24).bool(message.broadcast);
+        }
+        if (message.event !== undefined) {
+            event_1.Event.encode(message.event, writer.uint32(34).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseBroadcastRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.tenantId = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.topic = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.broadcast = reader.bool();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.event = event_1.Event.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            tenantId: isSet(object.tenantId) ? String(object.tenantId) : "",
+            topic: isSet(object.topic) ? String(object.topic) : "",
+            broadcast: isSet(object.broadcast) ? Boolean(object.broadcast) : false,
+            event: isSet(object.event) ? event_1.Event.fromJSON(object.event) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.tenantId !== "") {
+            obj.tenantId = message.tenantId;
+        }
+        if (message.topic !== "") {
+            obj.topic = message.topic;
+        }
+        if (message.broadcast === true) {
+            obj.broadcast = message.broadcast;
+        }
+        if (message.event !== undefined) {
+            obj.event = event_1.Event.toJSON(message.event);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.BroadcastRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = createBaseBroadcastRequest();
+        message.tenantId = (_a = object.tenantId) !== null && _a !== void 0 ? _a : "";
+        message.topic = (_b = object.topic) !== null && _b !== void 0 ? _b : "";
+        message.broadcast = (_c = object.broadcast) !== null && _c !== void 0 ? _c : false;
+        message.event = (object.event !== undefined && object.event !== null) ? event_1.Event.fromPartial(object.event) : undefined;
+        return message;
+    },
+};
+function createBaseBroadcastResponse() {
+    return { payload: undefined };
+}
+exports.BroadcastResponse = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        var _a;
+        switch ((_a = message.payload) === null || _a === void 0 ? void 0 : _a.$case) {
+            case "broadcastAck":
+                exports.BroadcastResponse_BroadcastAck.encode(message.payload.broadcastAck, writer.uint32(10).fork()).ldelim();
+                break;
+            case "broadcastNotAck":
+                exports.BroadcastResponse_BroadcastNotAck.encode(message.payload.broadcastNotAck, writer.uint32(18).fork()).ldelim();
+                break;
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseBroadcastResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.payload = {
+                        $case: "broadcastAck",
+                        broadcastAck: exports.BroadcastResponse_BroadcastAck.decode(reader, reader.uint32()),
+                    };
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.payload = {
+                        $case: "broadcastNotAck",
+                        broadcastNotAck: exports.BroadcastResponse_BroadcastNotAck.decode(reader, reader.uint32()),
+                    };
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            payload: isSet(object.broadcastAck)
+                ? { $case: "broadcastAck", broadcastAck: exports.BroadcastResponse_BroadcastAck.fromJSON(object.broadcastAck) }
+                : isSet(object.broadcastNotAck)
+                    ? {
+                        $case: "broadcastNotAck",
+                        broadcastNotAck: exports.BroadcastResponse_BroadcastNotAck.fromJSON(object.broadcastNotAck),
+                    }
+                    : undefined,
+        };
+    },
+    toJSON(message) {
+        var _a, _b;
+        const obj = {};
+        if (((_a = message.payload) === null || _a === void 0 ? void 0 : _a.$case) === "broadcastAck") {
+            obj.broadcastAck = exports.BroadcastResponse_BroadcastAck.toJSON(message.payload.broadcastAck);
+        }
+        if (((_b = message.payload) === null || _b === void 0 ? void 0 : _b.$case) === "broadcastNotAck") {
+            obj.broadcastNotAck = exports.BroadcastResponse_BroadcastNotAck.toJSON(message.payload.broadcastNotAck);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.BroadcastResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b, _c, _d, _e, _f;
+        const message = createBaseBroadcastResponse();
+        if (((_a = object.payload) === null || _a === void 0 ? void 0 : _a.$case) === "broadcastAck" &&
+            ((_b = object.payload) === null || _b === void 0 ? void 0 : _b.broadcastAck) !== undefined &&
+            ((_c = object.payload) === null || _c === void 0 ? void 0 : _c.broadcastAck) !== null) {
+            message.payload = {
+                $case: "broadcastAck",
+                broadcastAck: exports.BroadcastResponse_BroadcastAck.fromPartial(object.payload.broadcastAck),
+            };
+        }
+        if (((_d = object.payload) === null || _d === void 0 ? void 0 : _d.$case) === "broadcastNotAck" &&
+            ((_e = object.payload) === null || _e === void 0 ? void 0 : _e.broadcastNotAck) !== undefined &&
+            ((_f = object.payload) === null || _f === void 0 ? void 0 : _f.broadcastNotAck) !== null) {
+            message.payload = {
+                $case: "broadcastNotAck",
+                broadcastNotAck: exports.BroadcastResponse_BroadcastNotAck.fromPartial(object.payload.broadcastNotAck),
+            };
+        }
+        return message;
+    },
+};
+function createBaseBroadcastResponse_BroadcastAck() {
+    return {};
+}
+exports.BroadcastResponse_BroadcastAck = {
+    encode(_, writer = minimal_1.default.Writer.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseBroadcastResponse_BroadcastAck();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(_) {
+        return {};
+    },
+    toJSON(_) {
+        const obj = {};
+        return obj;
+    },
+    create(base) {
+        return exports.BroadcastResponse_BroadcastAck.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(_) {
+        const message = createBaseBroadcastResponse_BroadcastAck();
+        return message;
+    },
+};
+function createBaseBroadcastResponse_BroadcastNotAck() {
+    return { reason: "" };
+}
+exports.BroadcastResponse_BroadcastNotAck = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.reason !== "") {
+            writer.uint32(10).string(message.reason);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseBroadcastResponse_BroadcastNotAck();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.reason = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { reason: isSet(object.reason) ? String(object.reason) : "" };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.reason !== "") {
+            obj.reason = message.reason;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.BroadcastResponse_BroadcastNotAck.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseBroadcastResponse_BroadcastNotAck();
+        message.reason = (_a = object.reason) !== null && _a !== void 0 ? _a : "";
+        return message;
+    },
+};
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/dist/freym/streams/backchannel/handled.d.ts

@@ -0,0 +1,37 @@
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "freym.streams.backchannel";
+export interface HandledRequest {
+    tenantId: string;
+    topic: string;
+    groupId: string;
+    eventId: string;
+}
+export interface HandledResponse {
+}
+export declare const HandledRequest: {
+    encode(message: HandledRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): HandledRequest;
+    fromJSON(object: any): HandledRequest;
+    toJSON(message: HandledRequest): unknown;
+    create(base?: DeepPartial<HandledRequest>): HandledRequest;
+    fromPartial(object: DeepPartial<HandledRequest>): HandledRequest;
+};
+export declare const HandledResponse: {
+    encode(_: HandledResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): HandledResponse;
+    fromJSON(_: any): HandledResponse;
+    toJSON(_: HandledResponse): unknown;
+    create(base?: DeepPartial<HandledResponse>): HandledResponse;
+    fromPartial(_: DeepPartial<HandledResponse>): HandledResponse;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    $case: string;
+} ? {
+    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
+} & {
+    $case: T["$case"];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};