@cratis/chronicle.contracts 0.0.0

package/dist/cjs/generated/observation.js

@@ -0,0 +1,1573 @@
+'use strict';
+
+var wire = require('@bufbuild/protobuf/wire');
+var grpc = require('@grpc/grpc-js');
+var empty = require('./google/protobuf/empty.js');
+var bcl = require('./protobuf-net/bcl.js');
+
+exports.ObserverOwner = void 0;
+(function (ObserverOwner) {
+    ObserverOwner[ObserverOwner["None"] = 0] = "None";
+    ObserverOwner[ObserverOwner["Client"] = 1] = "Client";
+    ObserverOwner[ObserverOwner["Kernel"] = 2] = "Kernel";
+    ObserverOwner[ObserverOwner["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(exports.ObserverOwner || (exports.ObserverOwner = {}));
+function observerOwnerFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "None":
+            return exports.ObserverOwner.None;
+        case 1:
+        case "Client":
+            return exports.ObserverOwner.Client;
+        case 2:
+        case "Kernel":
+            return exports.ObserverOwner.Kernel;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return exports.ObserverOwner.UNRECOGNIZED;
+    }
+}
+function observerOwnerToJSON(object) {
+    switch (object) {
+        case exports.ObserverOwner.None:
+            return "None";
+        case exports.ObserverOwner.Client:
+            return "Client";
+        case exports.ObserverOwner.Kernel:
+            return "Kernel";
+        case exports.ObserverOwner.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.ObserverRunningState = void 0;
+(function (ObserverRunningState) {
+    ObserverRunningState[ObserverRunningState["OBSERVER_RUNNING_STATE_Unknown"] = 0] = "OBSERVER_RUNNING_STATE_Unknown";
+    ObserverRunningState[ObserverRunningState["Active"] = 1] = "Active";
+    ObserverRunningState[ObserverRunningState["Suspended"] = 2] = "Suspended";
+    ObserverRunningState[ObserverRunningState["Replaying"] = 3] = "Replaying";
+    ObserverRunningState[ObserverRunningState["Disconnected"] = 4] = "Disconnected";
+    ObserverRunningState[ObserverRunningState["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(exports.ObserverRunningState || (exports.ObserverRunningState = {}));
+function observerRunningStateFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "OBSERVER_RUNNING_STATE_Unknown":
+            return exports.ObserverRunningState.OBSERVER_RUNNING_STATE_Unknown;
+        case 1:
+        case "Active":
+            return exports.ObserverRunningState.Active;
+        case 2:
+        case "Suspended":
+            return exports.ObserverRunningState.Suspended;
+        case 3:
+        case "Replaying":
+            return exports.ObserverRunningState.Replaying;
+        case 4:
+        case "Disconnected":
+            return exports.ObserverRunningState.Disconnected;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return exports.ObserverRunningState.UNRECOGNIZED;
+    }
+}
+function observerRunningStateToJSON(object) {
+    switch (object) {
+        case exports.ObserverRunningState.OBSERVER_RUNNING_STATE_Unknown:
+            return "OBSERVER_RUNNING_STATE_Unknown";
+        case exports.ObserverRunningState.Active:
+            return "Active";
+        case exports.ObserverRunningState.Suspended:
+            return "Suspended";
+        case exports.ObserverRunningState.Replaying:
+            return "Replaying";
+        case exports.ObserverRunningState.Disconnected:
+            return "Disconnected";
+        case exports.ObserverRunningState.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.ObserverType = void 0;
+(function (ObserverType) {
+    ObserverType[ObserverType["OBSERVER_TYPE_Unknown"] = 0] = "OBSERVER_TYPE_Unknown";
+    ObserverType[ObserverType["Reactor"] = 1] = "Reactor";
+    ObserverType[ObserverType["Projection"] = 2] = "Projection";
+    ObserverType[ObserverType["Reducer"] = 3] = "Reducer";
+    ObserverType[ObserverType["External"] = 4] = "External";
+    ObserverType[ObserverType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(exports.ObserverType || (exports.ObserverType = {}));
+function observerTypeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "OBSERVER_TYPE_Unknown":
+            return exports.ObserverType.OBSERVER_TYPE_Unknown;
+        case 1:
+        case "Reactor":
+            return exports.ObserverType.Reactor;
+        case 2:
+        case "Projection":
+            return exports.ObserverType.Projection;
+        case 3:
+        case "Reducer":
+            return exports.ObserverType.Reducer;
+        case 4:
+        case "External":
+            return exports.ObserverType.External;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return exports.ObserverType.UNRECOGNIZED;
+    }
+}
+function observerTypeToJSON(object) {
+    switch (object) {
+        case exports.ObserverType.OBSERVER_TYPE_Unknown:
+            return "OBSERVER_TYPE_Unknown";
+        case exports.ObserverType.Reactor:
+            return "Reactor";
+        case exports.ObserverType.Projection:
+            return "Projection";
+        case exports.ObserverType.Reducer:
+            return "Reducer";
+        case exports.ObserverType.External:
+            return "External";
+        case exports.ObserverType.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseAllObserversRequest() {
+    return { EventStore: "", Namespace: "" };
+}
+const AllObserversRequest = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        if (message.Namespace !== "") {
+            writer.uint32(18).string(message.Namespace);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseAllObserversRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.EventStore = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.Namespace = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+            Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.Namespace !== "") {
+            obj.Namespace = message.Namespace;
+        }
+        return obj;
+    },
+    create(base) {
+        return AllObserversRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseAllObserversRequest();
+        message.EventStore = object.EventStore ?? "";
+        message.Namespace = object.Namespace ?? "";
+        return message;
+    },
+};
+function createBaseEventType() {
+    return { Id: "", Generation: 0, Tombstone: false };
+}
+const EventType = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Id !== "") {
+            writer.uint32(10).string(message.Id);
+        }
+        if (message.Generation !== 0) {
+            writer.uint32(16).uint32(message.Generation);
+        }
+        if (message.Tombstone !== false) {
+            writer.uint32(24).bool(message.Tombstone);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseEventType();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.Id = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.Generation = reader.uint32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.Tombstone = reader.bool();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
+            Generation: isSet(object.Generation) ? globalThis.Number(object.Generation) : 0,
+            Tombstone: isSet(object.Tombstone) ? globalThis.Boolean(object.Tombstone) : false,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Id !== "") {
+            obj.Id = message.Id;
+        }
+        if (message.Generation !== 0) {
+            obj.Generation = Math.round(message.Generation);
+        }
+        if (message.Tombstone !== false) {
+            obj.Tombstone = message.Tombstone;
+        }
+        return obj;
+    },
+    create(base) {
+        return EventType.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseEventType();
+        message.Id = object.Id ?? "";
+        message.Generation = object.Generation ?? 0;
+        message.Tombstone = object.Tombstone ?? false;
+        return message;
+    },
+};
+function createBaseFailedPartition() {
+    return { Id: undefined, ObserverId: "", Partition: "", Attempts: [] };
+}
+const FailedPartition = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Id !== undefined) {
+            bcl.Guid.encode(message.Id, writer.uint32(10).fork()).join();
+        }
+        if (message.ObserverId !== "") {
+            writer.uint32(18).string(message.ObserverId);
+        }
+        if (message.Partition !== "") {
+            writer.uint32(26).string(message.Partition);
+        }
+        for (const v of message.Attempts) {
+            FailedPartitionAttempt.encode(v, writer.uint32(34).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseFailedPartition();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.Id = bcl.Guid.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.ObserverId = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.Partition = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.Attempts.push(FailedPartitionAttempt.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            Id: isSet(object.Id) ? bcl.Guid.fromJSON(object.Id) : undefined,
+            ObserverId: isSet(object.ObserverId) ? globalThis.String(object.ObserverId) : "",
+            Partition: isSet(object.Partition) ? globalThis.String(object.Partition) : "",
+            Attempts: globalThis.Array.isArray(object?.Attempts)
+                ? object.Attempts.map((e) => FailedPartitionAttempt.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Id !== undefined) {
+            obj.Id = bcl.Guid.toJSON(message.Id);
+        }
+        if (message.ObserverId !== "") {
+            obj.ObserverId = message.ObserverId;
+        }
+        if (message.Partition !== "") {
+            obj.Partition = message.Partition;
+        }
+        if (message.Attempts?.length) {
+            obj.Attempts = message.Attempts.map((e) => FailedPartitionAttempt.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return FailedPartition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseFailedPartition();
+        message.Id = (object.Id !== undefined && object.Id !== null) ? bcl.Guid.fromPartial(object.Id) : undefined;
+        message.ObserverId = object.ObserverId ?? "";
+        message.Partition = object.Partition ?? "";
+        message.Attempts = object.Attempts?.map((e) => FailedPartitionAttempt.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseFailedPartitionAttempt() {
+    return { Occurred: undefined, SequenceNumber: 0, Messages: [], StackTrace: "" };
+}
+const FailedPartitionAttempt = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Occurred !== undefined) {
+            SerializableDateTimeOffset.encode(message.Occurred, writer.uint32(10).fork()).join();
+        }
+        if (message.SequenceNumber !== 0) {
+            writer.uint32(16).uint64(message.SequenceNumber);
+        }
+        for (const v of message.Messages) {
+            writer.uint32(26).string(v);
+        }
+        if (message.StackTrace !== "") {
+            writer.uint32(34).string(message.StackTrace);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseFailedPartitionAttempt();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.Occurred = SerializableDateTimeOffset.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.SequenceNumber = longToNumber(reader.uint64());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.Messages.push(reader.string());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.StackTrace = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            Occurred: isSet(object.Occurred) ? SerializableDateTimeOffset.fromJSON(object.Occurred) : undefined,
+            SequenceNumber: isSet(object.SequenceNumber) ? globalThis.Number(object.SequenceNumber) : 0,
+            Messages: globalThis.Array.isArray(object?.Messages) ? object.Messages.map((e) => globalThis.String(e)) : [],
+            StackTrace: isSet(object.StackTrace) ? globalThis.String(object.StackTrace) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Occurred !== undefined) {
+            obj.Occurred = SerializableDateTimeOffset.toJSON(message.Occurred);
+        }
+        if (message.SequenceNumber !== 0) {
+            obj.SequenceNumber = Math.round(message.SequenceNumber);
+        }
+        if (message.Messages?.length) {
+            obj.Messages = message.Messages;
+        }
+        if (message.StackTrace !== "") {
+            obj.StackTrace = message.StackTrace;
+        }
+        return obj;
+    },
+    create(base) {
+        return FailedPartitionAttempt.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseFailedPartitionAttempt();
+        message.Occurred = (object.Occurred !== undefined && object.Occurred !== null)
+            ? SerializableDateTimeOffset.fromPartial(object.Occurred)
+            : undefined;
+        message.SequenceNumber = object.SequenceNumber ?? 0;
+        message.Messages = object.Messages?.map((e) => e) || [];
+        message.StackTrace = object.StackTrace ?? "";
+        return message;
+    },
+};
+function createBaseGetFailedPartitionsRequest() {
+    return { EventStore: "", Namespace: "", ObserverId: "" };
+}
+const GetFailedPartitionsRequest = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        if (message.Namespace !== "") {
+            writer.uint32(18).string(message.Namespace);
+        }
+        if (message.ObserverId !== "") {
+            writer.uint32(26).string(message.ObserverId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGetFailedPartitionsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.EventStore = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.Namespace = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.ObserverId = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+            Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
+            ObserverId: isSet(object.ObserverId) ? globalThis.String(object.ObserverId) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.Namespace !== "") {
+            obj.Namespace = message.Namespace;
+        }
+        if (message.ObserverId !== "") {
+            obj.ObserverId = message.ObserverId;
+        }
+        return obj;
+    },
+    create(base) {
+        return GetFailedPartitionsRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGetFailedPartitionsRequest();
+        message.EventStore = object.EventStore ?? "";
+        message.Namespace = object.Namespace ?? "";
+        message.ObserverId = object.ObserverId ?? "";
+        return message;
+    },
+};
+function createBaseGetObserverInformationRequest() {
+    return { EventStore: "", Namespace: "", ObserverId: "", EventSequenceId: "" };
+}
+const GetObserverInformationRequest = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        if (message.Namespace !== "") {
+            writer.uint32(18).string(message.Namespace);
+        }
+        if (message.ObserverId !== "") {
+            writer.uint32(26).string(message.ObserverId);
+        }
+        if (message.EventSequenceId !== "") {
+            writer.uint32(34).string(message.EventSequenceId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGetObserverInformationRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.EventStore = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.Namespace = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.ObserverId = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.EventSequenceId = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+            Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
+            ObserverId: isSet(object.ObserverId) ? globalThis.String(object.ObserverId) : "",
+            EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.Namespace !== "") {
+            obj.Namespace = message.Namespace;
+        }
+        if (message.ObserverId !== "") {
+            obj.ObserverId = message.ObserverId;
+        }
+        if (message.EventSequenceId !== "") {
+            obj.EventSequenceId = message.EventSequenceId;
+        }
+        return obj;
+    },
+    create(base) {
+        return GetObserverInformationRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGetObserverInformationRequest();
+        message.EventStore = object.EventStore ?? "";
+        message.Namespace = object.Namespace ?? "";
+        message.ObserverId = object.ObserverId ?? "";
+        message.EventSequenceId = object.EventSequenceId ?? "";
+        return message;
+    },
+};
+function createBaseGetReplayableObserversForEventTypesRequest() {
+    return { EventStore: "", Namespace: "", EventTypes: [] };
+}
+const GetReplayableObserversForEventTypesRequest = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        if (message.Namespace !== "") {
+            writer.uint32(18).string(message.Namespace);
+        }
+        for (const v of message.EventTypes) {
+            EventType.encode(v, writer.uint32(26).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGetReplayableObserversForEventTypesRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.EventStore = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.Namespace = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.EventTypes.push(EventType.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+            Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
+            EventTypes: globalThis.Array.isArray(object?.EventTypes)
+                ? object.EventTypes.map((e) => EventType.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.Namespace !== "") {
+            obj.Namespace = message.Namespace;
+        }
+        if (message.EventTypes?.length) {
+            obj.EventTypes = message.EventTypes.map((e) => EventType.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return GetReplayableObserversForEventTypesRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGetReplayableObserversForEventTypesRequest();
+        message.EventStore = object.EventStore ?? "";
+        message.Namespace = object.Namespace ?? "";
+        message.EventTypes = object.EventTypes?.map((e) => EventType.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseIEnumerableFailedPartition() {
+    return { items: [] };
+}
+const IEnumerableFailedPartition = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        for (const v of message.items) {
+            FailedPartition.encode(v, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseIEnumerableFailedPartition();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.items.push(FailedPartition.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            items: globalThis.Array.isArray(object?.items) ? object.items.map((e) => FailedPartition.fromJSON(e)) : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.items?.length) {
+            obj.items = message.items.map((e) => FailedPartition.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return IEnumerableFailedPartition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseIEnumerableFailedPartition();
+        message.items = object.items?.map((e) => FailedPartition.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseIEnumerableObserverInformation() {
+    return { items: [] };
+}
+const IEnumerableObserverInformation = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        for (const v of message.items) {
+            ObserverInformation.encode(v, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseIEnumerableObserverInformation();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.items.push(ObserverInformation.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            items: globalThis.Array.isArray(object?.items)
+                ? object.items.map((e) => ObserverInformation.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.items?.length) {
+            obj.items = message.items.map((e) => ObserverInformation.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return IEnumerableObserverInformation.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseIEnumerableObserverInformation();
+        message.items = object.items?.map((e) => ObserverInformation.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseObserverInformation() {
+    return {
+        Id: "",
+        EventSequenceId: "",
+        Type: 0,
+        Owner: 0,
+        EventTypes: [],
+        NextEventSequenceNumber: 0,
+        LastHandledEventSequenceNumber: 0,
+        RunningState: 0,
+        IsSubscribed: false,
+        IsReplayable: false,
+    };
+}
+const ObserverInformation = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Id !== "") {
+            writer.uint32(10).string(message.Id);
+        }
+        if (message.EventSequenceId !== "") {
+            writer.uint32(18).string(message.EventSequenceId);
+        }
+        if (message.Type !== 0) {
+            writer.uint32(24).int32(message.Type);
+        }
+        if (message.Owner !== 0) {
+            writer.uint32(32).int32(message.Owner);
+        }
+        for (const v of message.EventTypes) {
+            EventType.encode(v, writer.uint32(42).fork()).join();
+        }
+        if (message.NextEventSequenceNumber !== 0) {
+            writer.uint32(48).uint64(message.NextEventSequenceNumber);
+        }
+        if (message.LastHandledEventSequenceNumber !== 0) {
+            writer.uint32(56).uint64(message.LastHandledEventSequenceNumber);
+        }
+        if (message.RunningState !== 0) {
+            writer.uint32(64).int32(message.RunningState);
+        }
+        if (message.IsSubscribed !== false) {
+            writer.uint32(72).bool(message.IsSubscribed);
+        }
+        if (message.IsReplayable !== false) {
+            writer.uint32(80).bool(message.IsReplayable);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseObserverInformation();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.Id = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.EventSequenceId = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.Type = reader.int32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.Owner = reader.int32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.EventTypes.push(EventType.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 48) {
+                        break;
+                    }
+                    message.NextEventSequenceNumber = longToNumber(reader.uint64());
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 56) {
+                        break;
+                    }
+                    message.LastHandledEventSequenceNumber = longToNumber(reader.uint64());
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 64) {
+                        break;
+                    }
+                    message.RunningState = reader.int32();
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 72) {
+                        break;
+                    }
+                    message.IsSubscribed = reader.bool();
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 80) {
+                        break;
+                    }
+                    message.IsReplayable = reader.bool();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
+            EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
+            Type: isSet(object.Type) ? observerTypeFromJSON(object.Type) : 0,
+            Owner: isSet(object.Owner) ? observerOwnerFromJSON(object.Owner) : 0,
+            EventTypes: globalThis.Array.isArray(object?.EventTypes)
+                ? object.EventTypes.map((e) => EventType.fromJSON(e))
+                : [],
+            NextEventSequenceNumber: isSet(object.NextEventSequenceNumber)
+                ? globalThis.Number(object.NextEventSequenceNumber)
+                : 0,
+            LastHandledEventSequenceNumber: isSet(object.LastHandledEventSequenceNumber)
+                ? globalThis.Number(object.LastHandledEventSequenceNumber)
+                : 0,
+            RunningState: isSet(object.RunningState) ? observerRunningStateFromJSON(object.RunningState) : 0,
+            IsSubscribed: isSet(object.IsSubscribed) ? globalThis.Boolean(object.IsSubscribed) : false,
+            IsReplayable: isSet(object.IsReplayable) ? globalThis.Boolean(object.IsReplayable) : false,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Id !== "") {
+            obj.Id = message.Id;
+        }
+        if (message.EventSequenceId !== "") {
+            obj.EventSequenceId = message.EventSequenceId;
+        }
+        if (message.Type !== 0) {
+            obj.Type = observerTypeToJSON(message.Type);
+        }
+        if (message.Owner !== 0) {
+            obj.Owner = observerOwnerToJSON(message.Owner);
+        }
+        if (message.EventTypes?.length) {
+            obj.EventTypes = message.EventTypes.map((e) => EventType.toJSON(e));
+        }
+        if (message.NextEventSequenceNumber !== 0) {
+            obj.NextEventSequenceNumber = Math.round(message.NextEventSequenceNumber);
+        }
+        if (message.LastHandledEventSequenceNumber !== 0) {
+            obj.LastHandledEventSequenceNumber = Math.round(message.LastHandledEventSequenceNumber);
+        }
+        if (message.RunningState !== 0) {
+            obj.RunningState = observerRunningStateToJSON(message.RunningState);
+        }
+        if (message.IsSubscribed !== false) {
+            obj.IsSubscribed = message.IsSubscribed;
+        }
+        if (message.IsReplayable !== false) {
+            obj.IsReplayable = message.IsReplayable;
+        }
+        return obj;
+    },
+    create(base) {
+        return ObserverInformation.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseObserverInformation();
+        message.Id = object.Id ?? "";
+        message.EventSequenceId = object.EventSequenceId ?? "";
+        message.Type = object.Type ?? 0;
+        message.Owner = object.Owner ?? 0;
+        message.EventTypes = object.EventTypes?.map((e) => EventType.fromPartial(e)) || [];
+        message.NextEventSequenceNumber = object.NextEventSequenceNumber ?? 0;
+        message.LastHandledEventSequenceNumber = object.LastHandledEventSequenceNumber ?? 0;
+        message.RunningState = object.RunningState ?? 0;
+        message.IsSubscribed = object.IsSubscribed ?? false;
+        message.IsReplayable = object.IsReplayable ?? false;
+        return message;
+    },
+};
+function createBaseReplay() {
+    return { EventStore: "", Namespace: "", ObserverId: "", EventSequenceId: "" };
+}
+const Replay = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        if (message.Namespace !== "") {
+            writer.uint32(18).string(message.Namespace);
+        }
+        if (message.ObserverId !== "") {
+            writer.uint32(26).string(message.ObserverId);
+        }
+        if (message.EventSequenceId !== "") {
+            writer.uint32(34).string(message.EventSequenceId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseReplay();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.EventStore = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.Namespace = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.ObserverId = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.EventSequenceId = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+            Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
+            ObserverId: isSet(object.ObserverId) ? globalThis.String(object.ObserverId) : "",
+            EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.Namespace !== "") {
+            obj.Namespace = message.Namespace;
+        }
+        if (message.ObserverId !== "") {
+            obj.ObserverId = message.ObserverId;
+        }
+        if (message.EventSequenceId !== "") {
+            obj.EventSequenceId = message.EventSequenceId;
+        }
+        return obj;
+    },
+    create(base) {
+        return Replay.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseReplay();
+        message.EventStore = object.EventStore ?? "";
+        message.Namespace = object.Namespace ?? "";
+        message.ObserverId = object.ObserverId ?? "";
+        message.EventSequenceId = object.EventSequenceId ?? "";
+        return message;
+    },
+};
+function createBaseReplayPartition() {
+    return { EventStore: "", Namespace: "", ObserverId: "", EventSequenceId: "", Partition: "" };
+}
+const ReplayPartition = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        if (message.Namespace !== "") {
+            writer.uint32(18).string(message.Namespace);
+        }
+        if (message.ObserverId !== "") {
+            writer.uint32(26).string(message.ObserverId);
+        }
+        if (message.EventSequenceId !== "") {
+            writer.uint32(34).string(message.EventSequenceId);
+        }
+        if (message.Partition !== "") {
+            writer.uint32(42).string(message.Partition);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseReplayPartition();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.EventStore = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.Namespace = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.ObserverId = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.EventSequenceId = reader.string();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.Partition = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+            Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
+            ObserverId: isSet(object.ObserverId) ? globalThis.String(object.ObserverId) : "",
+            EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
+            Partition: isSet(object.Partition) ? globalThis.String(object.Partition) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.Namespace !== "") {
+            obj.Namespace = message.Namespace;
+        }
+        if (message.ObserverId !== "") {
+            obj.ObserverId = message.ObserverId;
+        }
+        if (message.EventSequenceId !== "") {
+            obj.EventSequenceId = message.EventSequenceId;
+        }
+        if (message.Partition !== "") {
+            obj.Partition = message.Partition;
+        }
+        return obj;
+    },
+    create(base) {
+        return ReplayPartition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseReplayPartition();
+        message.EventStore = object.EventStore ?? "";
+        message.Namespace = object.Namespace ?? "";
+        message.ObserverId = object.ObserverId ?? "";
+        message.EventSequenceId = object.EventSequenceId ?? "";
+        message.Partition = object.Partition ?? "";
+        return message;
+    },
+};
+function createBaseRetryPartition() {
+    return { EventStore: "", Namespace: "", ObserverId: "", EventSequenceId: "", Partition: "" };
+}
+const RetryPartition = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        if (message.Namespace !== "") {
+            writer.uint32(18).string(message.Namespace);
+        }
+        if (message.ObserverId !== "") {
+            writer.uint32(26).string(message.ObserverId);
+        }
+        if (message.EventSequenceId !== "") {
+            writer.uint32(34).string(message.EventSequenceId);
+        }
+        if (message.Partition !== "") {
+            writer.uint32(42).string(message.Partition);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRetryPartition();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.EventStore = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.Namespace = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.ObserverId = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.EventSequenceId = reader.string();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.Partition = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+            Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
+            ObserverId: isSet(object.ObserverId) ? globalThis.String(object.ObserverId) : "",
+            EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
+            Partition: isSet(object.Partition) ? globalThis.String(object.Partition) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.Namespace !== "") {
+            obj.Namespace = message.Namespace;
+        }
+        if (message.ObserverId !== "") {
+            obj.ObserverId = message.ObserverId;
+        }
+        if (message.EventSequenceId !== "") {
+            obj.EventSequenceId = message.EventSequenceId;
+        }
+        if (message.Partition !== "") {
+            obj.Partition = message.Partition;
+        }
+        return obj;
+    },
+    create(base) {
+        return RetryPartition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseRetryPartition();
+        message.EventStore = object.EventStore ?? "";
+        message.Namespace = object.Namespace ?? "";
+        message.ObserverId = object.ObserverId ?? "";
+        message.EventSequenceId = object.EventSequenceId ?? "";
+        message.Partition = object.Partition ?? "";
+        return message;
+    },
+};
+function createBaseSerializableDateTimeOffset() {
+    return { Value: "" };
+}
+const SerializableDateTimeOffset = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Value !== "") {
+            writer.uint32(10).string(message.Value);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSerializableDateTimeOffset();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.Value = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { Value: isSet(object.Value) ? globalThis.String(object.Value) : "" };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Value !== "") {
+            obj.Value = message.Value;
+        }
+        return obj;
+    },
+    create(base) {
+        return SerializableDateTimeOffset.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSerializableDateTimeOffset();
+        message.Value = object.Value ?? "";
+        return message;
+    },
+};
+const FailedPartitionsService = {
+    getFailedPartitions: {
+        path: "/Cratis.Chronicle.Contracts.Observation.FailedPartitions/GetFailedPartitions",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GetFailedPartitionsRequest.encode(value).finish()),
+        requestDeserialize: (value) => GetFailedPartitionsRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(IEnumerableFailedPartition.encode(value).finish()),
+        responseDeserialize: (value) => IEnumerableFailedPartition.decode(value),
+    },
+    observeFailedPartitions: {
+        path: "/Cratis.Chronicle.Contracts.Observation.FailedPartitions/ObserveFailedPartitions",
+        requestStream: false,
+        responseStream: true,
+        requestSerialize: (value) => Buffer.from(GetFailedPartitionsRequest.encode(value).finish()),
+        requestDeserialize: (value) => GetFailedPartitionsRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(IEnumerableFailedPartition.encode(value).finish()),
+        responseDeserialize: (value) => IEnumerableFailedPartition.decode(value),
+    },
+};
+const FailedPartitionsClient = grpc.makeGenericClientConstructor(FailedPartitionsService, "Cratis.Chronicle.Contracts.Observation.FailedPartitions");
+const ObserversService = {
+    getObserverInformation: {
+        path: "/Cratis.Chronicle.Contracts.Observation.Observers/GetObserverInformation",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GetObserverInformationRequest.encode(value).finish()),
+        requestDeserialize: (value) => GetObserverInformationRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(ObserverInformation.encode(value).finish()),
+        responseDeserialize: (value) => ObserverInformation.decode(value),
+    },
+    getObservers: {
+        path: "/Cratis.Chronicle.Contracts.Observation.Observers/GetObservers",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(AllObserversRequest.encode(value).finish()),
+        requestDeserialize: (value) => AllObserversRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(IEnumerableObserverInformation.encode(value).finish()),
+        responseDeserialize: (value) => IEnumerableObserverInformation.decode(value),
+    },
+    getReplayableObserversForEventTypes: {
+        path: "/Cratis.Chronicle.Contracts.Observation.Observers/GetReplayableObserversForEventTypes",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GetReplayableObserversForEventTypesRequest.encode(value).finish()),
+        requestDeserialize: (value) => GetReplayableObserversForEventTypesRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(IEnumerableObserverInformation.encode(value).finish()),
+        responseDeserialize: (value) => IEnumerableObserverInformation.decode(value),
+    },
+    observeObservers: {
+        path: "/Cratis.Chronicle.Contracts.Observation.Observers/ObserveObservers",
+        requestStream: false,
+        responseStream: true,
+        requestSerialize: (value) => Buffer.from(AllObserversRequest.encode(value).finish()),
+        requestDeserialize: (value) => AllObserversRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(IEnumerableObserverInformation.encode(value).finish()),
+        responseDeserialize: (value) => IEnumerableObserverInformation.decode(value),
+    },
+    replay: {
+        path: "/Cratis.Chronicle.Contracts.Observation.Observers/Replay",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(Replay.encode(value).finish()),
+        requestDeserialize: (value) => Replay.decode(value),
+        responseSerialize: (value) => Buffer.from(empty.Empty.encode(value).finish()),
+        responseDeserialize: (value) => empty.Empty.decode(value),
+    },
+    replayPartition: {
+        path: "/Cratis.Chronicle.Contracts.Observation.Observers/ReplayPartition",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(ReplayPartition.encode(value).finish()),
+        requestDeserialize: (value) => ReplayPartition.decode(value),
+        responseSerialize: (value) => Buffer.from(empty.Empty.encode(value).finish()),
+        responseDeserialize: (value) => empty.Empty.decode(value),
+    },
+    retryPartition: {
+        path: "/Cratis.Chronicle.Contracts.Observation.Observers/RetryPartition",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(RetryPartition.encode(value).finish()),
+        requestDeserialize: (value) => RetryPartition.decode(value),
+        responseSerialize: (value) => Buffer.from(empty.Empty.encode(value).finish()),
+        responseDeserialize: (value) => empty.Empty.decode(value),
+    },
+};
+const ObserversClient = grpc.makeGenericClientConstructor(ObserversService, "Cratis.Chronicle.Contracts.Observation.Observers");
+function longToNumber(int64) {
+    const num = globalThis.Number(int64.toString());
+    if (num > globalThis.Number.MAX_SAFE_INTEGER) {
+        throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+    }
+    if (num < globalThis.Number.MIN_SAFE_INTEGER) {
+        throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
+    }
+    return num;
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}
+
+exports.AllObserversRequest = AllObserversRequest;
+exports.EventType = EventType;
+exports.FailedPartition = FailedPartition;
+exports.FailedPartitionAttempt = FailedPartitionAttempt;
+exports.FailedPartitionsClient = FailedPartitionsClient;
+exports.FailedPartitionsService = FailedPartitionsService;
+exports.GetFailedPartitionsRequest = GetFailedPartitionsRequest;
+exports.GetObserverInformationRequest = GetObserverInformationRequest;
+exports.GetReplayableObserversForEventTypesRequest = GetReplayableObserversForEventTypesRequest;
+exports.IEnumerableFailedPartition = IEnumerableFailedPartition;
+exports.IEnumerableObserverInformation = IEnumerableObserverInformation;
+exports.ObserverInformation = ObserverInformation;
+exports.ObserversClient = ObserversClient;
+exports.ObserversService = ObserversService;
+exports.Replay = Replay;
+exports.ReplayPartition = ReplayPartition;
+exports.RetryPartition = RetryPartition;
+exports.SerializableDateTimeOffset = SerializableDateTimeOffset;
+exports.observerOwnerFromJSON = observerOwnerFromJSON;
+exports.observerOwnerToJSON = observerOwnerToJSON;
+exports.observerRunningStateFromJSON = observerRunningStateFromJSON;
+exports.observerRunningStateToJSON = observerRunningStateToJSON;
+exports.observerTypeFromJSON = observerTypeFromJSON;
+exports.observerTypeToJSON = observerTypeToJSON;
+//# sourceMappingURL=observation.js.map