@fraym/proto 0.1.0

package/dist/freym/streams/clientchannel/service.js

@@ -0,0 +1,99 @@
+"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 event_1 = require("./event");
+const get_event_1 = require("./get_event");
+const get_events_from_start_1 = require("./get_events_from_start");
+const get_stream_1 = require("./get_stream");
+const introduce_gdpr_on_event_field_1 = require("./introduce_gdpr_on_event_field");
+const introduce_gdpr_on_field_1 = require("./introduce_gdpr_on_field");
+const invalidate_gdpr_1 = require("./invalidate_gdpr");
+const publish_1 = require("./publish");
+const snapshot_1 = require("./snapshot");
+const subscribe_1 = require("./subscribe");
+exports.protobufPackage = "freym.streams.clientchannel";
+exports.ServiceService = {
+    subscribe: {
+        path: "/freym.streams.clientchannel.Service/Subscribe",
+        requestStream: true,
+        responseStream: true,
+        requestSerialize: (value) => Buffer.from(subscribe_1.SubscribeRequest.encode(value).finish()),
+        requestDeserialize: (value) => subscribe_1.SubscribeRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(subscribe_1.SubscribeResponse.encode(value).finish()),
+        responseDeserialize: (value) => subscribe_1.SubscribeResponse.decode(value),
+    },
+    publish: {
+        path: "/freym.streams.clientchannel.Service/Publish",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(publish_1.PublishRequest.encode(value).finish()),
+        requestDeserialize: (value) => publish_1.PublishRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(publish_1.PublishResponse.encode(value).finish()),
+        responseDeserialize: (value) => publish_1.PublishResponse.decode(value),
+    },
+    getStream: {
+        path: "/freym.streams.clientchannel.Service/GetStream",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(get_stream_1.GetStreamRequest.encode(value).finish()),
+        requestDeserialize: (value) => get_stream_1.GetStreamRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(get_stream_1.GetStreamResponse.encode(value).finish()),
+        responseDeserialize: (value) => get_stream_1.GetStreamResponse.decode(value),
+    },
+    getEvent: {
+        path: "/freym.streams.clientchannel.Service/GetEvent",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(get_event_1.GetEventRequest.encode(value).finish()),
+        requestDeserialize: (value) => get_event_1.GetEventRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(event_1.PublishEventEnvelope.encode(value).finish()),
+        responseDeserialize: (value) => event_1.PublishEventEnvelope.decode(value),
+    },
+    getEventsFromStart: {
+        path: "/freym.streams.clientchannel.Service/GetEventsFromStart",
+        requestStream: false,
+        responseStream: true,
+        requestSerialize: (value) => Buffer.from(get_events_from_start_1.GetEventsFromStartRequest.encode(value).finish()),
+        requestDeserialize: (value) => get_events_from_start_1.GetEventsFromStartRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(event_1.PublishEventEnvelope.encode(value).finish()),
+        responseDeserialize: (value) => event_1.PublishEventEnvelope.decode(value),
+    },
+    introduceGdprOnField: {
+        path: "/freym.streams.clientchannel.Service/IntroduceGdprOnField",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(introduce_gdpr_on_field_1.IntroduceGdprOnFieldRequest.encode(value).finish()),
+        requestDeserialize: (value) => introduce_gdpr_on_field_1.IntroduceGdprOnFieldRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(introduce_gdpr_on_field_1.IntroduceGdprOnFieldResponse.encode(value).finish()),
+        responseDeserialize: (value) => introduce_gdpr_on_field_1.IntroduceGdprOnFieldResponse.decode(value),
+    },
+    introduceGdprOnEventField: {
+        path: "/freym.streams.clientchannel.Service/IntroduceGdprOnEventField",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(introduce_gdpr_on_event_field_1.IntroduceGdprOnEventFieldRequest.encode(value).finish()),
+        requestDeserialize: (value) => introduce_gdpr_on_event_field_1.IntroduceGdprOnEventFieldRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(introduce_gdpr_on_event_field_1.IntroduceGdprOnEventFieldResponse.encode(value).finish()),
+        responseDeserialize: (value) => introduce_gdpr_on_event_field_1.IntroduceGdprOnEventFieldResponse.decode(value),
+    },
+    invalidateGdpr: {
+        path: "/freym.streams.clientchannel.Service/InvalidateGdpr",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(invalidate_gdpr_1.InvalidateGdprRequest.encode(value).finish()),
+        requestDeserialize: (value) => invalidate_gdpr_1.InvalidateGdprRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(invalidate_gdpr_1.InvalidateGdprResponse.encode(value).finish()),
+        responseDeserialize: (value) => invalidate_gdpr_1.InvalidateGdprResponse.decode(value),
+    },
+    snapshot: {
+        path: "/freym.streams.clientchannel.Service/Snapshot",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(snapshot_1.SnapshotRequest.encode(value).finish()),
+        requestDeserialize: (value) => snapshot_1.SnapshotRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(snapshot_1.SnapshotResponse.encode(value).finish()),
+        responseDeserialize: (value) => snapshot_1.SnapshotResponse.decode(value),
+    },
+};
+exports.ServiceClient = (0, grpc_js_1.makeGenericClientConstructor)(exports.ServiceService, "freym.streams.clientchannel.Service");

package/dist/freym/streams/clientchannel/snapshot.d.ts

@@ -0,0 +1,35 @@
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "freym.streams.clientchannel";
+export interface SnapshotRequest {
+    topic: string;
+    toTime: string;
+}
+export interface SnapshotResponse {
+}
+export declare const SnapshotRequest: {
+    encode(message: SnapshotRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SnapshotRequest;
+    fromJSON(object: any): SnapshotRequest;
+    toJSON(message: SnapshotRequest): unknown;
+    create(base?: DeepPartial<SnapshotRequest>): SnapshotRequest;
+    fromPartial(object: DeepPartial<SnapshotRequest>): SnapshotRequest;
+};
+export declare const SnapshotResponse: {
+    encode(_: SnapshotResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SnapshotResponse;
+    fromJSON(_: any): SnapshotResponse;
+    toJSON(_: SnapshotResponse): unknown;
+    create(base?: DeepPartial<SnapshotResponse>): SnapshotResponse;
+    fromPartial(_: DeepPartial<SnapshotResponse>): SnapshotResponse;
+};
+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/clientchannel/snapshot.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapshotResponse = exports.SnapshotRequest = exports.protobufPackage = void 0;
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+exports.protobufPackage = "freym.streams.clientchannel";
+function createBaseSnapshotRequest() {
+    return { topic: "", toTime: "" };
+}
+exports.SnapshotRequest = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.topic !== "") {
+            writer.uint32(10).string(message.topic);
+        }
+        if (message.toTime !== "") {
+            writer.uint32(18).string(message.toTime);
+        }
+        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 = createBaseSnapshotRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.topic = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.toTime = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            topic: isSet(object.topic) ? String(object.topic) : "",
+            toTime: isSet(object.toTime) ? String(object.toTime) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.topic !== "") {
+            obj.topic = message.topic;
+        }
+        if (message.toTime !== "") {
+            obj.toTime = message.toTime;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.SnapshotRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = createBaseSnapshotRequest();
+        message.topic = (_a = object.topic) !== null && _a !== void 0 ? _a : "";
+        message.toTime = (_b = object.toTime) !== null && _b !== void 0 ? _b : "";
+        return message;
+    },
+};
+function createBaseSnapshotResponse() {
+    return {};
+}
+exports.SnapshotResponse = {
+    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 = createBaseSnapshotResponse();
+        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.SnapshotResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(_) {
+        const message = createBaseSnapshotResponse();
+        return message;
+    },
+};
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/dist/freym/streams/clientchannel/subscribe.d.ts

@@ -0,0 +1,189 @@
+import _m0 from "protobufjs/minimal";
+import { PublishEventEnvelope } from "./event";
+export declare const protobufPackage = "freym.streams.clientchannel";
+export interface SubscribeRequest {
+    payload?: {
+        $case: "init";
+        init: SubscribeRequest_InitAction;
+    } | {
+        $case: "subscribe";
+        subscribe: SubscribeRequest_SubscribeAction;
+    } | {
+        $case: "eventReceived";
+        eventReceived: SubscribeRequest_EventReceived;
+    } | {
+        $case: "eventNotReceived";
+        eventNotReceived: SubscribeRequest_EventNotReceived;
+    } | {
+        $case: "eventHandled";
+        eventHandled: SubscribeRequest_EventHandled;
+    } | {
+        $case: "eventNotHandled";
+        eventNotHandled: SubscribeRequest_EventNotHandled;
+    } | undefined;
+}
+export interface SubscribeRequest_InitAction {
+    groupId: string;
+    subscriberId: string;
+}
+export interface SubscribeRequest_SubscribeAction {
+    includedTopics: string[];
+    excludedTopics: string[];
+}
+export interface SubscribeRequest_EventReceived {
+    tenantId: string;
+    topic: string;
+    eventId: string;
+}
+export interface SubscribeRequest_EventNotReceived {
+    tenantId: string;
+    topic: string;
+    eventId: string;
+    reason: string;
+}
+export interface SubscribeRequest_EventHandled {
+    tenantId: string;
+    topic: string;
+    eventId: string;
+}
+export interface SubscribeRequest_EventNotHandled {
+    tenantId: string;
+    topic: string;
+    eventId: string;
+    reason: string;
+}
+export interface SubscribeResponse {
+    data?: {
+        $case: "event";
+        event: PublishEventEnvelope;
+    } | {
+        $case: "initAck";
+        initAck: SubscribeResponse_InitAck;
+    } | {
+        $case: "initNotAck";
+        initNotAck: SubscribeResponse_InitNotAck;
+    } | {
+        $case: "subscribeAck";
+        subscribeAck: SubscribeResponse_SubscribeAck;
+    } | {
+        $case: "subscribeNotAck";
+        subscribeNotAck: SubscribeResponse_SubscribeNotAck;
+    } | undefined;
+}
+export interface SubscribeResponse_InitAck {
+}
+export interface SubscribeResponse_InitNotAck {
+    reason: string;
+}
+export interface SubscribeResponse_SubscribeAck {
+}
+export interface SubscribeResponse_SubscribeNotAck {
+    reason: string;
+}
+export declare const SubscribeRequest: {
+    encode(message: SubscribeRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeRequest;
+    fromJSON(object: any): SubscribeRequest;
+    toJSON(message: SubscribeRequest): unknown;
+    create(base?: DeepPartial<SubscribeRequest>): SubscribeRequest;
+    fromPartial(object: DeepPartial<SubscribeRequest>): SubscribeRequest;
+};
+export declare const SubscribeRequest_InitAction: {
+    encode(message: SubscribeRequest_InitAction, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeRequest_InitAction;
+    fromJSON(object: any): SubscribeRequest_InitAction;
+    toJSON(message: SubscribeRequest_InitAction): unknown;
+    create(base?: DeepPartial<SubscribeRequest_InitAction>): SubscribeRequest_InitAction;
+    fromPartial(object: DeepPartial<SubscribeRequest_InitAction>): SubscribeRequest_InitAction;
+};
+export declare const SubscribeRequest_SubscribeAction: {
+    encode(message: SubscribeRequest_SubscribeAction, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeRequest_SubscribeAction;
+    fromJSON(object: any): SubscribeRequest_SubscribeAction;
+    toJSON(message: SubscribeRequest_SubscribeAction): unknown;
+    create(base?: DeepPartial<SubscribeRequest_SubscribeAction>): SubscribeRequest_SubscribeAction;
+    fromPartial(object: DeepPartial<SubscribeRequest_SubscribeAction>): SubscribeRequest_SubscribeAction;
+};
+export declare const SubscribeRequest_EventReceived: {
+    encode(message: SubscribeRequest_EventReceived, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeRequest_EventReceived;
+    fromJSON(object: any): SubscribeRequest_EventReceived;
+    toJSON(message: SubscribeRequest_EventReceived): unknown;
+    create(base?: DeepPartial<SubscribeRequest_EventReceived>): SubscribeRequest_EventReceived;
+    fromPartial(object: DeepPartial<SubscribeRequest_EventReceived>): SubscribeRequest_EventReceived;
+};
+export declare const SubscribeRequest_EventNotReceived: {
+    encode(message: SubscribeRequest_EventNotReceived, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeRequest_EventNotReceived;
+    fromJSON(object: any): SubscribeRequest_EventNotReceived;
+    toJSON(message: SubscribeRequest_EventNotReceived): unknown;
+    create(base?: DeepPartial<SubscribeRequest_EventNotReceived>): SubscribeRequest_EventNotReceived;
+    fromPartial(object: DeepPartial<SubscribeRequest_EventNotReceived>): SubscribeRequest_EventNotReceived;
+};
+export declare const SubscribeRequest_EventHandled: {
+    encode(message: SubscribeRequest_EventHandled, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeRequest_EventHandled;
+    fromJSON(object: any): SubscribeRequest_EventHandled;
+    toJSON(message: SubscribeRequest_EventHandled): unknown;
+    create(base?: DeepPartial<SubscribeRequest_EventHandled>): SubscribeRequest_EventHandled;
+    fromPartial(object: DeepPartial<SubscribeRequest_EventHandled>): SubscribeRequest_EventHandled;
+};
+export declare const SubscribeRequest_EventNotHandled: {
+    encode(message: SubscribeRequest_EventNotHandled, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeRequest_EventNotHandled;
+    fromJSON(object: any): SubscribeRequest_EventNotHandled;
+    toJSON(message: SubscribeRequest_EventNotHandled): unknown;
+    create(base?: DeepPartial<SubscribeRequest_EventNotHandled>): SubscribeRequest_EventNotHandled;
+    fromPartial(object: DeepPartial<SubscribeRequest_EventNotHandled>): SubscribeRequest_EventNotHandled;
+};
+export declare const SubscribeResponse: {
+    encode(message: SubscribeResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeResponse;
+    fromJSON(object: any): SubscribeResponse;
+    toJSON(message: SubscribeResponse): unknown;
+    create(base?: DeepPartial<SubscribeResponse>): SubscribeResponse;
+    fromPartial(object: DeepPartial<SubscribeResponse>): SubscribeResponse;
+};
+export declare const SubscribeResponse_InitAck: {
+    encode(_: SubscribeResponse_InitAck, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeResponse_InitAck;
+    fromJSON(_: any): SubscribeResponse_InitAck;
+    toJSON(_: SubscribeResponse_InitAck): unknown;
+    create(base?: DeepPartial<SubscribeResponse_InitAck>): SubscribeResponse_InitAck;
+    fromPartial(_: DeepPartial<SubscribeResponse_InitAck>): SubscribeResponse_InitAck;
+};
+export declare const SubscribeResponse_InitNotAck: {
+    encode(message: SubscribeResponse_InitNotAck, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeResponse_InitNotAck;
+    fromJSON(object: any): SubscribeResponse_InitNotAck;
+    toJSON(message: SubscribeResponse_InitNotAck): unknown;
+    create(base?: DeepPartial<SubscribeResponse_InitNotAck>): SubscribeResponse_InitNotAck;
+    fromPartial(object: DeepPartial<SubscribeResponse_InitNotAck>): SubscribeResponse_InitNotAck;
+};
+export declare const SubscribeResponse_SubscribeAck: {
+    encode(_: SubscribeResponse_SubscribeAck, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeResponse_SubscribeAck;
+    fromJSON(_: any): SubscribeResponse_SubscribeAck;
+    toJSON(_: SubscribeResponse_SubscribeAck): unknown;
+    create(base?: DeepPartial<SubscribeResponse_SubscribeAck>): SubscribeResponse_SubscribeAck;
+    fromPartial(_: DeepPartial<SubscribeResponse_SubscribeAck>): SubscribeResponse_SubscribeAck;
+};
+export declare const SubscribeResponse_SubscribeNotAck: {
+    encode(message: SubscribeResponse_SubscribeNotAck, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeResponse_SubscribeNotAck;
+    fromJSON(object: any): SubscribeResponse_SubscribeNotAck;
+    toJSON(message: SubscribeResponse_SubscribeNotAck): unknown;
+    create(base?: DeepPartial<SubscribeResponse_SubscribeNotAck>): SubscribeResponse_SubscribeNotAck;
+    fromPartial(object: DeepPartial<SubscribeResponse_SubscribeNotAck>): SubscribeResponse_SubscribeNotAck;
+};
+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 {};