@cratis/chronicle.contracts 19.31.11 → 19.32.1

package/dist/cjs/generated/alerts.js

@@ -0,0 +1,2113 @@
+'use strict';
+
+var wire = require('@bufbuild/protobuf/wire');
+var bcl = require('./protobuf-net/bcl.js');
+
+const protobufPackage = "Cratis.Chronicle.Contracts.Alerts";
+exports.AlertIncidentsReadinessState = void 0;
+(function (AlertIncidentsReadinessState) {
+    AlertIncidentsReadinessState[AlertIncidentsReadinessState["CatchingUp"] = 0] = "CatchingUp";
+    AlertIncidentsReadinessState[AlertIncidentsReadinessState["Ready"] = 1] = "Ready";
+    AlertIncidentsReadinessState[AlertIncidentsReadinessState["Degraded"] = 2] = "Degraded";
+    AlertIncidentsReadinessState[AlertIncidentsReadinessState["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(exports.AlertIncidentsReadinessState || (exports.AlertIncidentsReadinessState = {}));
+function alertIncidentsReadinessStateFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "CatchingUp":
+            return exports.AlertIncidentsReadinessState.CatchingUp;
+        case 1:
+        case "Ready":
+            return exports.AlertIncidentsReadinessState.Ready;
+        case 2:
+        case "Degraded":
+            return exports.AlertIncidentsReadinessState.Degraded;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return exports.AlertIncidentsReadinessState.UNRECOGNIZED;
+    }
+}
+function alertIncidentsReadinessStateToJSON(object) {
+    switch (object) {
+        case exports.AlertIncidentsReadinessState.CatchingUp:
+            return "CatchingUp";
+        case exports.AlertIncidentsReadinessState.Ready:
+            return "Ready";
+        case exports.AlertIncidentsReadinessState.Degraded:
+            return "Degraded";
+        case exports.AlertIncidentsReadinessState.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.AlertSeverity = void 0;
+(function (AlertSeverity) {
+    AlertSeverity[AlertSeverity["ALERT_SEVERITY_Warning"] = 0] = "ALERT_SEVERITY_Warning";
+    AlertSeverity[AlertSeverity["Critical"] = 1] = "Critical";
+    AlertSeverity[AlertSeverity["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(exports.AlertSeverity || (exports.AlertSeverity = {}));
+function alertSeverityFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "ALERT_SEVERITY_Warning":
+            return exports.AlertSeverity.ALERT_SEVERITY_Warning;
+        case 1:
+        case "Critical":
+            return exports.AlertSeverity.Critical;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return exports.AlertSeverity.UNRECOGNIZED;
+    }
+}
+function alertSeverityToJSON(object) {
+    switch (object) {
+        case exports.AlertSeverity.ALERT_SEVERITY_Warning:
+            return "ALERT_SEVERITY_Warning";
+        case exports.AlertSeverity.Critical:
+            return "Critical";
+        case exports.AlertSeverity.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.FailureKind = void 0;
+(function (FailureKind) {
+    FailureKind[FailureKind["FAILURE_KIND_Unknown"] = 0] = "FAILURE_KIND_Unknown";
+    FailureKind[FailureKind["Handling"] = 1] = "Handling";
+    FailureKind[FailureKind["Timeout"] = 2] = "Timeout";
+    FailureKind[FailureKind["Disconnected"] = 3] = "Disconnected";
+    FailureKind[FailureKind["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(exports.FailureKind || (exports.FailureKind = {}));
+function failureKindFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "FAILURE_KIND_Unknown":
+            return exports.FailureKind.FAILURE_KIND_Unknown;
+        case 1:
+        case "Handling":
+            return exports.FailureKind.Handling;
+        case 2:
+        case "Timeout":
+            return exports.FailureKind.Timeout;
+        case 3:
+        case "Disconnected":
+            return exports.FailureKind.Disconnected;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return exports.FailureKind.UNRECOGNIZED;
+    }
+}
+function failureKindToJSON(object) {
+    switch (object) {
+        case exports.FailureKind.FAILURE_KIND_Unknown:
+            return "FAILURE_KIND_Unknown";
+        case exports.FailureKind.Handling:
+            return "Handling";
+        case exports.FailureKind.Timeout:
+            return "Timeout";
+        case exports.FailureKind.Disconnected:
+            return "Disconnected";
+        case exports.FailureKind.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.ValidationResultSeverity = void 0;
+(function (ValidationResultSeverity) {
+    ValidationResultSeverity[ValidationResultSeverity["VALIDATION_RESULT_SEVERITY_Unknown"] = 0] = "VALIDATION_RESULT_SEVERITY_Unknown";
+    ValidationResultSeverity[ValidationResultSeverity["Information"] = 1] = "Information";
+    ValidationResultSeverity[ValidationResultSeverity["VALIDATION_RESULT_SEVERITY_Warning"] = 2] = "VALIDATION_RESULT_SEVERITY_Warning";
+    ValidationResultSeverity[ValidationResultSeverity["Error"] = 3] = "Error";
+    ValidationResultSeverity[ValidationResultSeverity["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(exports.ValidationResultSeverity || (exports.ValidationResultSeverity = {}));
+function validationResultSeverityFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "VALIDATION_RESULT_SEVERITY_Unknown":
+            return exports.ValidationResultSeverity.VALIDATION_RESULT_SEVERITY_Unknown;
+        case 1:
+        case "Information":
+            return exports.ValidationResultSeverity.Information;
+        case 2:
+        case "VALIDATION_RESULT_SEVERITY_Warning":
+            return exports.ValidationResultSeverity.VALIDATION_RESULT_SEVERITY_Warning;
+        case 3:
+        case "Error":
+            return exports.ValidationResultSeverity.Error;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return exports.ValidationResultSeverity.UNRECOGNIZED;
+    }
+}
+function validationResultSeverityToJSON(object) {
+    switch (object) {
+        case exports.ValidationResultSeverity.VALIDATION_RESULT_SEVERITY_Unknown:
+            return "VALIDATION_RESULT_SEVERITY_Unknown";
+        case exports.ValidationResultSeverity.Information:
+            return "Information";
+        case exports.ValidationResultSeverity.VALIDATION_RESULT_SEVERITY_Warning:
+            return "VALIDATION_RESULT_SEVERITY_Warning";
+        case exports.ValidationResultSeverity.Error:
+            return "Error";
+        case exports.ValidationResultSeverity.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseAlertEvidence() {
+    return { AttemptCount: 0, FirstFailure: undefined, LastFailure: undefined, FailureKind: 0, Message: "" };
+}
+const AlertEvidence = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.AttemptCount !== 0) {
+            writer.uint32(8).int32(message.AttemptCount);
+        }
+        if (message.FirstFailure !== undefined) {
+            SerializableDateTimeOffset.encode(message.FirstFailure, writer.uint32(18).fork()).join();
+        }
+        if (message.LastFailure !== undefined) {
+            SerializableDateTimeOffset.encode(message.LastFailure, writer.uint32(26).fork()).join();
+        }
+        if (message.FailureKind !== 0) {
+            writer.uint32(32).int32(message.FailureKind);
+        }
+        if (message.Message !== "") {
+            writer.uint32(42).string(message.Message);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseAlertEvidence();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 8) {
+                            break;
+                        }
+                        message.AttemptCount = reader.int32();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 18) {
+                            break;
+                        }
+                        message.FirstFailure = SerializableDateTimeOffset.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.LastFailure = SerializableDateTimeOffset.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 4: {
+                        if (tag !== 32) {
+                            break;
+                        }
+                        message.FailureKind = reader.int32();
+                        continue;
+                    }
+                    case 5: {
+                        if (tag !== 42) {
+                            break;
+                        }
+                        message.Message = reader.string();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            AttemptCount: isSet(object.AttemptCount) ? globalThis.Number(object.AttemptCount) : 0,
+            FirstFailure: isSet(object.FirstFailure) ? SerializableDateTimeOffset.fromJSON(object.FirstFailure) : undefined,
+            LastFailure: isSet(object.LastFailure) ? SerializableDateTimeOffset.fromJSON(object.LastFailure) : undefined,
+            FailureKind: isSet(object.FailureKind) ? failureKindFromJSON(object.FailureKind) : 0,
+            Message: isSet(object.Message) ? globalThis.String(object.Message) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.AttemptCount !== 0) {
+            obj.AttemptCount = Math.round(message.AttemptCount);
+        }
+        if (message.FirstFailure !== undefined) {
+            obj.FirstFailure = SerializableDateTimeOffset.toJSON(message.FirstFailure);
+        }
+        if (message.LastFailure !== undefined) {
+            obj.LastFailure = SerializableDateTimeOffset.toJSON(message.LastFailure);
+        }
+        if (message.FailureKind !== 0) {
+            obj.FailureKind = failureKindToJSON(message.FailureKind);
+        }
+        if (message.Message !== "") {
+            obj.Message = message.Message;
+        }
+        return obj;
+    },
+    create(base) {
+        return AlertEvidence.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseAlertEvidence();
+        message.AttemptCount = object.AttemptCount ?? 0;
+        message.FirstFailure = (object.FirstFailure !== undefined && object.FirstFailure !== null)
+            ? SerializableDateTimeOffset.fromPartial(object.FirstFailure)
+            : undefined;
+        message.LastFailure = (object.LastFailure !== undefined && object.LastFailure !== null)
+            ? SerializableDateTimeOffset.fromPartial(object.LastFailure)
+            : undefined;
+        message.FailureKind = object.FailureKind ?? 0;
+        message.Message = object.Message ?? "";
+        return message;
+    },
+};
+function createBaseAlertIncidentContinuation() {
+    return { RaisedSequenceNumber: 0n, IncidentId: undefined };
+}
+const AlertIncidentContinuation = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.RaisedSequenceNumber !== 0n) {
+            if (BigInt.asUintN(64, message.RaisedSequenceNumber) !== message.RaisedSequenceNumber) {
+                throw new globalThis.Error("value provided for field message.RaisedSequenceNumber of type uint64 too large");
+            }
+            writer.uint32(8).uint64(message.RaisedSequenceNumber);
+        }
+        if (message.IncidentId !== undefined) {
+            bcl.Guid.encode(message.IncidentId, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseAlertIncidentContinuation();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 8) {
+                            break;
+                        }
+                        message.RaisedSequenceNumber = reader.uint64();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 18) {
+                            break;
+                        }
+                        message.IncidentId = bcl.Guid.decode(reader, reader.uint32());
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            RaisedSequenceNumber: isSet(object.RaisedSequenceNumber) ? BigInt(object.RaisedSequenceNumber) : 0n,
+            IncidentId: isSet(object.IncidentId) ? bcl.Guid.fromJSON(object.IncidentId) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.RaisedSequenceNumber !== 0n) {
+            obj.RaisedSequenceNumber = message.RaisedSequenceNumber.toString();
+        }
+        if (message.IncidentId !== undefined) {
+            obj.IncidentId = bcl.Guid.toJSON(message.IncidentId);
+        }
+        return obj;
+    },
+    create(base) {
+        return AlertIncidentContinuation.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseAlertIncidentContinuation();
+        message.RaisedSequenceNumber = (object.RaisedSequenceNumber !== undefined && object.RaisedSequenceNumber !== null)
+            ? BigInt(object.RaisedSequenceNumber)
+            : 0n;
+        message.IncidentId = (object.IncidentId !== undefined && object.IncidentId !== null)
+            ? bcl.Guid.fromPartial(object.IncidentId)
+            : undefined;
+        return message;
+    },
+};
+function createBaseAlertIncidentCountDetails() {
+    return { Namespace: "", Condition: "", Severity: 0, Count: 0n };
+}
+const AlertIncidentCountDetails = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Namespace !== "") {
+            writer.uint32(10).string(message.Namespace);
+        }
+        if (message.Condition !== "") {
+            writer.uint32(18).string(message.Condition);
+        }
+        if (message.Severity !== 0) {
+            writer.uint32(24).int32(message.Severity);
+        }
+        if (message.Count !== 0n) {
+            if (BigInt.asIntN(64, message.Count) !== message.Count) {
+                throw new globalThis.Error("value provided for field message.Count of type int64 too large");
+            }
+            writer.uint32(32).int64(message.Count);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseAlertIncidentCountDetails();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.Namespace = reader.string();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 18) {
+                            break;
+                        }
+                        message.Condition = reader.string();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 24) {
+                            break;
+                        }
+                        message.Severity = reader.int32();
+                        continue;
+                    }
+                    case 4: {
+                        if (tag !== 32) {
+                            break;
+                        }
+                        message.Count = reader.int64();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
+            Condition: isSet(object.Condition) ? globalThis.String(object.Condition) : "",
+            Severity: isSet(object.Severity) ? alertSeverityFromJSON(object.Severity) : 0,
+            Count: isSet(object.Count) ? BigInt(object.Count) : 0n,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Namespace !== "") {
+            obj.Namespace = message.Namespace;
+        }
+        if (message.Condition !== "") {
+            obj.Condition = message.Condition;
+        }
+        if (message.Severity !== 0) {
+            obj.Severity = alertSeverityToJSON(message.Severity);
+        }
+        if (message.Count !== 0n) {
+            obj.Count = message.Count.toString();
+        }
+        return obj;
+    },
+    create(base) {
+        return AlertIncidentCountDetails.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseAlertIncidentCountDetails();
+        message.Namespace = object.Namespace ?? "";
+        message.Condition = object.Condition ?? "";
+        message.Severity = object.Severity ?? 0;
+        message.Count = (object.Count !== undefined && object.Count !== null) ? BigInt(object.Count) : 0n;
+        return message;
+    },
+};
+function createBaseAlertIncidentDetails() {
+    return {
+        Id: undefined,
+        Target: undefined,
+        Condition: "",
+        Severity: 0,
+        Evidence: undefined,
+        RaisedAt: undefined,
+        LastChangedAt: undefined,
+        RaisedSequenceNumber: 0n,
+        LastTransitionSequenceNumber: 0n,
+    };
+}
+const AlertIncidentDetails = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Id !== undefined) {
+            bcl.Guid.encode(message.Id, writer.uint32(10).fork()).join();
+        }
+        if (message.Target !== undefined) {
+            AlertTarget.encode(message.Target, writer.uint32(18).fork()).join();
+        }
+        if (message.Condition !== "") {
+            writer.uint32(26).string(message.Condition);
+        }
+        if (message.Severity !== 0) {
+            writer.uint32(32).int32(message.Severity);
+        }
+        if (message.Evidence !== undefined) {
+            AlertEvidence.encode(message.Evidence, writer.uint32(42).fork()).join();
+        }
+        if (message.RaisedAt !== undefined) {
+            SerializableDateTimeOffset.encode(message.RaisedAt, writer.uint32(50).fork()).join();
+        }
+        if (message.LastChangedAt !== undefined) {
+            SerializableDateTimeOffset.encode(message.LastChangedAt, writer.uint32(58).fork()).join();
+        }
+        if (message.RaisedSequenceNumber !== 0n) {
+            if (BigInt.asUintN(64, message.RaisedSequenceNumber) !== message.RaisedSequenceNumber) {
+                throw new globalThis.Error("value provided for field message.RaisedSequenceNumber of type uint64 too large");
+            }
+            writer.uint32(64).uint64(message.RaisedSequenceNumber);
+        }
+        if (message.LastTransitionSequenceNumber !== 0n) {
+            if (BigInt.asUintN(64, message.LastTransitionSequenceNumber) !== message.LastTransitionSequenceNumber) {
+                throw new globalThis.Error("value provided for field message.LastTransitionSequenceNumber of type uint64 too large");
+            }
+            writer.uint32(72).uint64(message.LastTransitionSequenceNumber);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseAlertIncidentDetails();
+            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.Target = AlertTarget.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.Condition = reader.string();
+                        continue;
+                    }
+                    case 4: {
+                        if (tag !== 32) {
+                            break;
+                        }
+                        message.Severity = reader.int32();
+                        continue;
+                    }
+                    case 5: {
+                        if (tag !== 42) {
+                            break;
+                        }
+                        message.Evidence = AlertEvidence.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 6: {
+                        if (tag !== 50) {
+                            break;
+                        }
+                        message.RaisedAt = SerializableDateTimeOffset.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 7: {
+                        if (tag !== 58) {
+                            break;
+                        }
+                        message.LastChangedAt = SerializableDateTimeOffset.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 8: {
+                        if (tag !== 64) {
+                            break;
+                        }
+                        message.RaisedSequenceNumber = reader.uint64();
+                        continue;
+                    }
+                    case 9: {
+                        if (tag !== 72) {
+                            break;
+                        }
+                        message.LastTransitionSequenceNumber = reader.uint64();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            Id: isSet(object.Id) ? bcl.Guid.fromJSON(object.Id) : undefined,
+            Target: isSet(object.Target) ? AlertTarget.fromJSON(object.Target) : undefined,
+            Condition: isSet(object.Condition) ? globalThis.String(object.Condition) : "",
+            Severity: isSet(object.Severity) ? alertSeverityFromJSON(object.Severity) : 0,
+            Evidence: isSet(object.Evidence) ? AlertEvidence.fromJSON(object.Evidence) : undefined,
+            RaisedAt: isSet(object.RaisedAt) ? SerializableDateTimeOffset.fromJSON(object.RaisedAt) : undefined,
+            LastChangedAt: isSet(object.LastChangedAt)
+                ? SerializableDateTimeOffset.fromJSON(object.LastChangedAt)
+                : undefined,
+            RaisedSequenceNumber: isSet(object.RaisedSequenceNumber) ? BigInt(object.RaisedSequenceNumber) : 0n,
+            LastTransitionSequenceNumber: isSet(object.LastTransitionSequenceNumber)
+                ? BigInt(object.LastTransitionSequenceNumber)
+                : 0n,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Id !== undefined) {
+            obj.Id = bcl.Guid.toJSON(message.Id);
+        }
+        if (message.Target !== undefined) {
+            obj.Target = AlertTarget.toJSON(message.Target);
+        }
+        if (message.Condition !== "") {
+            obj.Condition = message.Condition;
+        }
+        if (message.Severity !== 0) {
+            obj.Severity = alertSeverityToJSON(message.Severity);
+        }
+        if (message.Evidence !== undefined) {
+            obj.Evidence = AlertEvidence.toJSON(message.Evidence);
+        }
+        if (message.RaisedAt !== undefined) {
+            obj.RaisedAt = SerializableDateTimeOffset.toJSON(message.RaisedAt);
+        }
+        if (message.LastChangedAt !== undefined) {
+            obj.LastChangedAt = SerializableDateTimeOffset.toJSON(message.LastChangedAt);
+        }
+        if (message.RaisedSequenceNumber !== 0n) {
+            obj.RaisedSequenceNumber = message.RaisedSequenceNumber.toString();
+        }
+        if (message.LastTransitionSequenceNumber !== 0n) {
+            obj.LastTransitionSequenceNumber = message.LastTransitionSequenceNumber.toString();
+        }
+        return obj;
+    },
+    create(base) {
+        return AlertIncidentDetails.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseAlertIncidentDetails();
+        message.Id = (object.Id !== undefined && object.Id !== null) ? bcl.Guid.fromPartial(object.Id) : undefined;
+        message.Target = (object.Target !== undefined && object.Target !== null)
+            ? AlertTarget.fromPartial(object.Target)
+            : undefined;
+        message.Condition = object.Condition ?? "";
+        message.Severity = object.Severity ?? 0;
+        message.Evidence = (object.Evidence !== undefined && object.Evidence !== null)
+            ? AlertEvidence.fromPartial(object.Evidence)
+            : undefined;
+        message.RaisedAt = (object.RaisedAt !== undefined && object.RaisedAt !== null)
+            ? SerializableDateTimeOffset.fromPartial(object.RaisedAt)
+            : undefined;
+        message.LastChangedAt = (object.LastChangedAt !== undefined && object.LastChangedAt !== null)
+            ? SerializableDateTimeOffset.fromPartial(object.LastChangedAt)
+            : undefined;
+        message.RaisedSequenceNumber = (object.RaisedSequenceNumber !== undefined && object.RaisedSequenceNumber !== null)
+            ? BigInt(object.RaisedSequenceNumber)
+            : 0n;
+        message.LastTransitionSequenceNumber =
+            (object.LastTransitionSequenceNumber !== undefined && object.LastTransitionSequenceNumber !== null)
+                ? BigInt(object.LastTransitionSequenceNumber)
+                : 0n;
+        return message;
+    },
+};
+function createBaseAlertIncidentLookupResponse() {
+    return { Status: 0, Incident: undefined };
+}
+const AlertIncidentLookupResponse = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Status !== 0) {
+            writer.uint32(8).int32(message.Status);
+        }
+        if (message.Incident !== undefined) {
+            AlertIncidentDetails.encode(message.Incident, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseAlertIncidentLookupResponse();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 8) {
+                            break;
+                        }
+                        message.Status = reader.int32();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 18) {
+                            break;
+                        }
+                        message.Incident = AlertIncidentDetails.decode(reader, reader.uint32());
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            Status: isSet(object.Status) ? alertIncidentsReadinessStateFromJSON(object.Status) : 0,
+            Incident: isSet(object.Incident) ? AlertIncidentDetails.fromJSON(object.Incident) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Status !== 0) {
+            obj.Status = alertIncidentsReadinessStateToJSON(message.Status);
+        }
+        if (message.Incident !== undefined) {
+            obj.Incident = AlertIncidentDetails.toJSON(message.Incident);
+        }
+        return obj;
+    },
+    create(base) {
+        return AlertIncidentLookupResponse.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseAlertIncidentLookupResponse();
+        message.Status = object.Status ?? 0;
+        message.Incident = (object.Incident !== undefined && object.Incident !== null)
+            ? AlertIncidentDetails.fromPartial(object.Incident)
+            : undefined;
+        return message;
+    },
+};
+function createBaseAlertIncidentPageResponse() {
+    return { Status: 0, Items: [], Next: undefined };
+}
+const AlertIncidentPageResponse = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Status !== 0) {
+            writer.uint32(8).int32(message.Status);
+        }
+        for (const v of message.Items) {
+            AlertIncidentDetails.encode(v, writer.uint32(18).fork()).join();
+        }
+        if (message.Next !== undefined) {
+            AlertIncidentContinuation.encode(message.Next, writer.uint32(26).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseAlertIncidentPageResponse();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 8) {
+                            break;
+                        }
+                        message.Status = reader.int32();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 18) {
+                            break;
+                        }
+                        message.Items.push(AlertIncidentDetails.decode(reader, reader.uint32()));
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.Next = AlertIncidentContinuation.decode(reader, reader.uint32());
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            Status: isSet(object.Status) ? alertIncidentsReadinessStateFromJSON(object.Status) : 0,
+            Items: globalThis.Array.isArray(object?.Items)
+                ? object.Items.map((e) => AlertIncidentDetails.fromJSON(e))
+                : [],
+            Next: isSet(object.Next) ? AlertIncidentContinuation.fromJSON(object.Next) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Status !== 0) {
+            obj.Status = alertIncidentsReadinessStateToJSON(message.Status);
+        }
+        if (message.Items?.length) {
+            obj.Items = message.Items.map((e) => AlertIncidentDetails.toJSON(e));
+        }
+        if (message.Next !== undefined) {
+            obj.Next = AlertIncidentContinuation.toJSON(message.Next);
+        }
+        return obj;
+    },
+    create(base) {
+        return AlertIncidentPageResponse.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseAlertIncidentPageResponse();
+        message.Status = object.Status ?? 0;
+        message.Items = object.Items?.map((e) => AlertIncidentDetails.fromPartial(e)) || [];
+        message.Next = (object.Next !== undefined && object.Next !== null)
+            ? AlertIncidentContinuation.fromPartial(object.Next)
+            : undefined;
+        return message;
+    },
+};
+function createBaseAlertIncidentSummaryResponse() {
+    return { Status: 0, Counts: [] };
+}
+const AlertIncidentSummaryResponse = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Status !== 0) {
+            writer.uint32(8).int32(message.Status);
+        }
+        for (const v of message.Counts) {
+            AlertIncidentCountDetails.encode(v, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseAlertIncidentSummaryResponse();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 8) {
+                            break;
+                        }
+                        message.Status = reader.int32();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 18) {
+                            break;
+                        }
+                        message.Counts.push(AlertIncidentCountDetails.decode(reader, reader.uint32()));
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            Status: isSet(object.Status) ? alertIncidentsReadinessStateFromJSON(object.Status) : 0,
+            Counts: globalThis.Array.isArray(object?.Counts)
+                ? object.Counts.map((e) => AlertIncidentCountDetails.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Status !== 0) {
+            obj.Status = alertIncidentsReadinessStateToJSON(message.Status);
+        }
+        if (message.Counts?.length) {
+            obj.Counts = message.Counts.map((e) => AlertIncidentCountDetails.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return AlertIncidentSummaryResponse.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseAlertIncidentSummaryResponse();
+        message.Status = object.Status ?? 0;
+        message.Counts = object.Counts?.map((e) => AlertIncidentCountDetails.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseAlertTarget() {
+    return { EventStore: "", Namespace: "", ObserverId: "", EventSequenceId: "", Partition: "" };
+}
+const AlertTarget = {
+    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 previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseAlertTarget();
+            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;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    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 AlertTarget.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseAlertTarget();
+        message.EventStore = object.EventStore ?? "";
+        message.Namespace = object.Namespace ?? "";
+        message.ObserverId = object.ObserverId ?? "";
+        message.EventSequenceId = object.EventSequenceId ?? "";
+        message.Partition = object.Partition ?? "";
+        return message;
+    },
+};
+function createBaseGetOpenIncidentCountsRequest() {
+    return { EventStore: "", Namespace: "" };
+}
+const GetOpenIncidentCountsRequest = {
+    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 previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseGetOpenIncidentCountsRequest();
+            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;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    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 GetOpenIncidentCountsRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGetOpenIncidentCountsRequest();
+        message.EventStore = object.EventStore ?? "";
+        message.Namespace = object.Namespace ?? "";
+        return message;
+    },
+};
+function createBaseGetOpenIncidentRequest() {
+    return { EventStore: "", IncidentId: undefined, Namespace: "" };
+}
+const GetOpenIncidentRequest = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        if (message.IncidentId !== undefined) {
+            bcl.Guid.encode(message.IncidentId, writer.uint32(18).fork()).join();
+        }
+        if (message.Namespace !== "") {
+            writer.uint32(26).string(message.Namespace);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseGetOpenIncidentRequest();
+            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.IncidentId = bcl.Guid.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.Namespace = reader.string();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+            IncidentId: isSet(object.IncidentId) ? bcl.Guid.fromJSON(object.IncidentId) : undefined,
+            Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.IncidentId !== undefined) {
+            obj.IncidentId = bcl.Guid.toJSON(message.IncidentId);
+        }
+        if (message.Namespace !== "") {
+            obj.Namespace = message.Namespace;
+        }
+        return obj;
+    },
+    create(base) {
+        return GetOpenIncidentRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGetOpenIncidentRequest();
+        message.EventStore = object.EventStore ?? "";
+        message.IncidentId = (object.IncidentId !== undefined && object.IncidentId !== null)
+            ? bcl.Guid.fromPartial(object.IncidentId)
+            : undefined;
+        message.Namespace = object.Namespace ?? "";
+        return message;
+    },
+};
+function createBaseGetOpenIncidentsRequest() {
+    return {
+        EventStore: "",
+        Namespace: "",
+        ObserverId: "",
+        Condition: "",
+        MinimumSeverity: 0,
+        Limit: 0,
+        AfterRaisedSequenceNumber: 0n,
+        AfterIncidentId: undefined,
+    };
+}
+const GetOpenIncidentsRequest = {
+    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.Condition !== "") {
+            writer.uint32(34).string(message.Condition);
+        }
+        if (message.MinimumSeverity !== 0) {
+            writer.uint32(40).int32(message.MinimumSeverity);
+        }
+        if (message.Limit !== 0) {
+            writer.uint32(48).int32(message.Limit);
+        }
+        if (message.AfterRaisedSequenceNumber !== 0n) {
+            if (BigInt.asUintN(64, message.AfterRaisedSequenceNumber) !== message.AfterRaisedSequenceNumber) {
+                throw new globalThis.Error("value provided for field message.AfterRaisedSequenceNumber of type uint64 too large");
+            }
+            writer.uint32(56).uint64(message.AfterRaisedSequenceNumber);
+        }
+        if (message.AfterIncidentId !== undefined) {
+            bcl.Guid.encode(message.AfterIncidentId, writer.uint32(66).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseGetOpenIncidentsRequest();
+            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.Condition = reader.string();
+                        continue;
+                    }
+                    case 5: {
+                        if (tag !== 40) {
+                            break;
+                        }
+                        message.MinimumSeverity = reader.int32();
+                        continue;
+                    }
+                    case 6: {
+                        if (tag !== 48) {
+                            break;
+                        }
+                        message.Limit = reader.int32();
+                        continue;
+                    }
+                    case 7: {
+                        if (tag !== 56) {
+                            break;
+                        }
+                        message.AfterRaisedSequenceNumber = reader.uint64();
+                        continue;
+                    }
+                    case 8: {
+                        if (tag !== 66) {
+                            break;
+                        }
+                        message.AfterIncidentId = bcl.Guid.decode(reader, reader.uint32());
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    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) : "",
+            Condition: isSet(object.Condition) ? globalThis.String(object.Condition) : "",
+            MinimumSeverity: isSet(object.MinimumSeverity) ? alertSeverityFromJSON(object.MinimumSeverity) : 0,
+            Limit: isSet(object.Limit) ? globalThis.Number(object.Limit) : 0,
+            AfterRaisedSequenceNumber: isSet(object.AfterRaisedSequenceNumber)
+                ? BigInt(object.AfterRaisedSequenceNumber)
+                : 0n,
+            AfterIncidentId: isSet(object.AfterIncidentId) ? bcl.Guid.fromJSON(object.AfterIncidentId) : undefined,
+        };
+    },
+    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.Condition !== "") {
+            obj.Condition = message.Condition;
+        }
+        if (message.MinimumSeverity !== 0) {
+            obj.MinimumSeverity = alertSeverityToJSON(message.MinimumSeverity);
+        }
+        if (message.Limit !== 0) {
+            obj.Limit = Math.round(message.Limit);
+        }
+        if (message.AfterRaisedSequenceNumber !== 0n) {
+            obj.AfterRaisedSequenceNumber = message.AfterRaisedSequenceNumber.toString();
+        }
+        if (message.AfterIncidentId !== undefined) {
+            obj.AfterIncidentId = bcl.Guid.toJSON(message.AfterIncidentId);
+        }
+        return obj;
+    },
+    create(base) {
+        return GetOpenIncidentsRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGetOpenIncidentsRequest();
+        message.EventStore = object.EventStore ?? "";
+        message.Namespace = object.Namespace ?? "";
+        message.ObserverId = object.ObserverId ?? "";
+        message.Condition = object.Condition ?? "";
+        message.MinimumSeverity = object.MinimumSeverity ?? 0;
+        message.Limit = object.Limit ?? 0;
+        message.AfterRaisedSequenceNumber =
+            (object.AfterRaisedSequenceNumber !== undefined && object.AfterRaisedSequenceNumber !== null)
+                ? BigInt(object.AfterRaisedSequenceNumber)
+                : 0n;
+        message.AfterIncidentId = (object.AfterIncidentId !== undefined && object.AfterIncidentId !== null)
+            ? bcl.Guid.fromPartial(object.AfterIncidentId)
+            : undefined;
+        return message;
+    },
+};
+function createBaseQueryResultAlertIncidentLookupResponse() {
+    return {
+        CorrelationId: undefined,
+        IsAuthorized: false,
+        ValidationResults: [],
+        ExceptionMessages: [],
+        ExceptionStackTrace: "",
+        Data: undefined,
+    };
+}
+const QueryResultAlertIncidentLookupResponse = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.CorrelationId !== undefined) {
+            bcl.Guid.encode(message.CorrelationId, writer.uint32(10).fork()).join();
+        }
+        if (message.IsAuthorized !== false) {
+            writer.uint32(16).bool(message.IsAuthorized);
+        }
+        for (const v of message.ValidationResults) {
+            ValidationResult.encode(v, writer.uint32(26).fork()).join();
+        }
+        for (const v of message.ExceptionMessages) {
+            writer.uint32(34).string(v);
+        }
+        if (message.ExceptionStackTrace !== "") {
+            writer.uint32(42).string(message.ExceptionStackTrace);
+        }
+        if (message.Data !== undefined) {
+            AlertIncidentLookupResponse.encode(message.Data, writer.uint32(50).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseQueryResultAlertIncidentLookupResponse();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.CorrelationId = bcl.Guid.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 16) {
+                            break;
+                        }
+                        message.IsAuthorized = reader.bool();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.ValidationResults.push(ValidationResult.decode(reader, reader.uint32()));
+                        continue;
+                    }
+                    case 4: {
+                        if (tag !== 34) {
+                            break;
+                        }
+                        message.ExceptionMessages.push(reader.string());
+                        continue;
+                    }
+                    case 5: {
+                        if (tag !== 42) {
+                            break;
+                        }
+                        message.ExceptionStackTrace = reader.string();
+                        continue;
+                    }
+                    case 6: {
+                        if (tag !== 50) {
+                            break;
+                        }
+                        message.Data = AlertIncidentLookupResponse.decode(reader, reader.uint32());
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            CorrelationId: isSet(object.CorrelationId) ? bcl.Guid.fromJSON(object.CorrelationId) : undefined,
+            IsAuthorized: isSet(object.IsAuthorized) ? globalThis.Boolean(object.IsAuthorized) : false,
+            ValidationResults: globalThis.Array.isArray(object?.ValidationResults)
+                ? object.ValidationResults.map((e) => ValidationResult.fromJSON(e))
+                : [],
+            ExceptionMessages: globalThis.Array.isArray(object?.ExceptionMessages)
+                ? object.ExceptionMessages.map((e) => globalThis.String(e))
+                : [],
+            ExceptionStackTrace: isSet(object.ExceptionStackTrace) ? globalThis.String(object.ExceptionStackTrace) : "",
+            Data: isSet(object.Data) ? AlertIncidentLookupResponse.fromJSON(object.Data) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.CorrelationId !== undefined) {
+            obj.CorrelationId = bcl.Guid.toJSON(message.CorrelationId);
+        }
+        if (message.IsAuthorized !== false) {
+            obj.IsAuthorized = message.IsAuthorized;
+        }
+        if (message.ValidationResults?.length) {
+            obj.ValidationResults = message.ValidationResults.map((e) => ValidationResult.toJSON(e));
+        }
+        if (message.ExceptionMessages?.length) {
+            obj.ExceptionMessages = message.ExceptionMessages;
+        }
+        if (message.ExceptionStackTrace !== "") {
+            obj.ExceptionStackTrace = message.ExceptionStackTrace;
+        }
+        if (message.Data !== undefined) {
+            obj.Data = AlertIncidentLookupResponse.toJSON(message.Data);
+        }
+        return obj;
+    },
+    create(base) {
+        return QueryResultAlertIncidentLookupResponse.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseQueryResultAlertIncidentLookupResponse();
+        message.CorrelationId = (object.CorrelationId !== undefined && object.CorrelationId !== null)
+            ? bcl.Guid.fromPartial(object.CorrelationId)
+            : undefined;
+        message.IsAuthorized = object.IsAuthorized ?? false;
+        message.ValidationResults = object.ValidationResults?.map((e) => ValidationResult.fromPartial(e)) || [];
+        message.ExceptionMessages = object.ExceptionMessages?.map((e) => e) || [];
+        message.ExceptionStackTrace = object.ExceptionStackTrace ?? "";
+        message.Data = (object.Data !== undefined && object.Data !== null)
+            ? AlertIncidentLookupResponse.fromPartial(object.Data)
+            : undefined;
+        return message;
+    },
+};
+function createBaseQueryResultAlertIncidentPageResponse() {
+    return {
+        CorrelationId: undefined,
+        IsAuthorized: false,
+        ValidationResults: [],
+        ExceptionMessages: [],
+        ExceptionStackTrace: "",
+        Data: undefined,
+    };
+}
+const QueryResultAlertIncidentPageResponse = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.CorrelationId !== undefined) {
+            bcl.Guid.encode(message.CorrelationId, writer.uint32(10).fork()).join();
+        }
+        if (message.IsAuthorized !== false) {
+            writer.uint32(16).bool(message.IsAuthorized);
+        }
+        for (const v of message.ValidationResults) {
+            ValidationResult.encode(v, writer.uint32(26).fork()).join();
+        }
+        for (const v of message.ExceptionMessages) {
+            writer.uint32(34).string(v);
+        }
+        if (message.ExceptionStackTrace !== "") {
+            writer.uint32(42).string(message.ExceptionStackTrace);
+        }
+        if (message.Data !== undefined) {
+            AlertIncidentPageResponse.encode(message.Data, writer.uint32(50).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseQueryResultAlertIncidentPageResponse();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.CorrelationId = bcl.Guid.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 16) {
+                            break;
+                        }
+                        message.IsAuthorized = reader.bool();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.ValidationResults.push(ValidationResult.decode(reader, reader.uint32()));
+                        continue;
+                    }
+                    case 4: {
+                        if (tag !== 34) {
+                            break;
+                        }
+                        message.ExceptionMessages.push(reader.string());
+                        continue;
+                    }
+                    case 5: {
+                        if (tag !== 42) {
+                            break;
+                        }
+                        message.ExceptionStackTrace = reader.string();
+                        continue;
+                    }
+                    case 6: {
+                        if (tag !== 50) {
+                            break;
+                        }
+                        message.Data = AlertIncidentPageResponse.decode(reader, reader.uint32());
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            CorrelationId: isSet(object.CorrelationId) ? bcl.Guid.fromJSON(object.CorrelationId) : undefined,
+            IsAuthorized: isSet(object.IsAuthorized) ? globalThis.Boolean(object.IsAuthorized) : false,
+            ValidationResults: globalThis.Array.isArray(object?.ValidationResults)
+                ? object.ValidationResults.map((e) => ValidationResult.fromJSON(e))
+                : [],
+            ExceptionMessages: globalThis.Array.isArray(object?.ExceptionMessages)
+                ? object.ExceptionMessages.map((e) => globalThis.String(e))
+                : [],
+            ExceptionStackTrace: isSet(object.ExceptionStackTrace) ? globalThis.String(object.ExceptionStackTrace) : "",
+            Data: isSet(object.Data) ? AlertIncidentPageResponse.fromJSON(object.Data) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.CorrelationId !== undefined) {
+            obj.CorrelationId = bcl.Guid.toJSON(message.CorrelationId);
+        }
+        if (message.IsAuthorized !== false) {
+            obj.IsAuthorized = message.IsAuthorized;
+        }
+        if (message.ValidationResults?.length) {
+            obj.ValidationResults = message.ValidationResults.map((e) => ValidationResult.toJSON(e));
+        }
+        if (message.ExceptionMessages?.length) {
+            obj.ExceptionMessages = message.ExceptionMessages;
+        }
+        if (message.ExceptionStackTrace !== "") {
+            obj.ExceptionStackTrace = message.ExceptionStackTrace;
+        }
+        if (message.Data !== undefined) {
+            obj.Data = AlertIncidentPageResponse.toJSON(message.Data);
+        }
+        return obj;
+    },
+    create(base) {
+        return QueryResultAlertIncidentPageResponse.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseQueryResultAlertIncidentPageResponse();
+        message.CorrelationId = (object.CorrelationId !== undefined && object.CorrelationId !== null)
+            ? bcl.Guid.fromPartial(object.CorrelationId)
+            : undefined;
+        message.IsAuthorized = object.IsAuthorized ?? false;
+        message.ValidationResults = object.ValidationResults?.map((e) => ValidationResult.fromPartial(e)) || [];
+        message.ExceptionMessages = object.ExceptionMessages?.map((e) => e) || [];
+        message.ExceptionStackTrace = object.ExceptionStackTrace ?? "";
+        message.Data = (object.Data !== undefined && object.Data !== null)
+            ? AlertIncidentPageResponse.fromPartial(object.Data)
+            : undefined;
+        return message;
+    },
+};
+function createBaseQueryResultAlertIncidentSummaryResponse() {
+    return {
+        CorrelationId: undefined,
+        IsAuthorized: false,
+        ValidationResults: [],
+        ExceptionMessages: [],
+        ExceptionStackTrace: "",
+        Data: undefined,
+    };
+}
+const QueryResultAlertIncidentSummaryResponse = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.CorrelationId !== undefined) {
+            bcl.Guid.encode(message.CorrelationId, writer.uint32(10).fork()).join();
+        }
+        if (message.IsAuthorized !== false) {
+            writer.uint32(16).bool(message.IsAuthorized);
+        }
+        for (const v of message.ValidationResults) {
+            ValidationResult.encode(v, writer.uint32(26).fork()).join();
+        }
+        for (const v of message.ExceptionMessages) {
+            writer.uint32(34).string(v);
+        }
+        if (message.ExceptionStackTrace !== "") {
+            writer.uint32(42).string(message.ExceptionStackTrace);
+        }
+        if (message.Data !== undefined) {
+            AlertIncidentSummaryResponse.encode(message.Data, writer.uint32(50).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseQueryResultAlertIncidentSummaryResponse();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.CorrelationId = bcl.Guid.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 16) {
+                            break;
+                        }
+                        message.IsAuthorized = reader.bool();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.ValidationResults.push(ValidationResult.decode(reader, reader.uint32()));
+                        continue;
+                    }
+                    case 4: {
+                        if (tag !== 34) {
+                            break;
+                        }
+                        message.ExceptionMessages.push(reader.string());
+                        continue;
+                    }
+                    case 5: {
+                        if (tag !== 42) {
+                            break;
+                        }
+                        message.ExceptionStackTrace = reader.string();
+                        continue;
+                    }
+                    case 6: {
+                        if (tag !== 50) {
+                            break;
+                        }
+                        message.Data = AlertIncidentSummaryResponse.decode(reader, reader.uint32());
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            CorrelationId: isSet(object.CorrelationId) ? bcl.Guid.fromJSON(object.CorrelationId) : undefined,
+            IsAuthorized: isSet(object.IsAuthorized) ? globalThis.Boolean(object.IsAuthorized) : false,
+            ValidationResults: globalThis.Array.isArray(object?.ValidationResults)
+                ? object.ValidationResults.map((e) => ValidationResult.fromJSON(e))
+                : [],
+            ExceptionMessages: globalThis.Array.isArray(object?.ExceptionMessages)
+                ? object.ExceptionMessages.map((e) => globalThis.String(e))
+                : [],
+            ExceptionStackTrace: isSet(object.ExceptionStackTrace) ? globalThis.String(object.ExceptionStackTrace) : "",
+            Data: isSet(object.Data) ? AlertIncidentSummaryResponse.fromJSON(object.Data) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.CorrelationId !== undefined) {
+            obj.CorrelationId = bcl.Guid.toJSON(message.CorrelationId);
+        }
+        if (message.IsAuthorized !== false) {
+            obj.IsAuthorized = message.IsAuthorized;
+        }
+        if (message.ValidationResults?.length) {
+            obj.ValidationResults = message.ValidationResults.map((e) => ValidationResult.toJSON(e));
+        }
+        if (message.ExceptionMessages?.length) {
+            obj.ExceptionMessages = message.ExceptionMessages;
+        }
+        if (message.ExceptionStackTrace !== "") {
+            obj.ExceptionStackTrace = message.ExceptionStackTrace;
+        }
+        if (message.Data !== undefined) {
+            obj.Data = AlertIncidentSummaryResponse.toJSON(message.Data);
+        }
+        return obj;
+    },
+    create(base) {
+        return QueryResultAlertIncidentSummaryResponse.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseQueryResultAlertIncidentSummaryResponse();
+        message.CorrelationId = (object.CorrelationId !== undefined && object.CorrelationId !== null)
+            ? bcl.Guid.fromPartial(object.CorrelationId)
+            : undefined;
+        message.IsAuthorized = object.IsAuthorized ?? false;
+        message.ValidationResults = object.ValidationResults?.map((e) => ValidationResult.fromPartial(e)) || [];
+        message.ExceptionMessages = object.ExceptionMessages?.map((e) => e) || [];
+        message.ExceptionStackTrace = object.ExceptionStackTrace ?? "";
+        message.Data = (object.Data !== undefined && object.Data !== null)
+            ? AlertIncidentSummaryResponse.fromPartial(object.Data)
+            : undefined;
+        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 previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            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;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    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;
+    },
+};
+function createBaseValidationResult() {
+    return { Severity: 0, Message: "", Members: [] };
+}
+const ValidationResult = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Severity !== 0) {
+            writer.uint32(8).int32(message.Severity);
+        }
+        if (message.Message !== "") {
+            writer.uint32(18).string(message.Message);
+        }
+        for (const v of message.Members) {
+            writer.uint32(26).string(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseValidationResult();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 8) {
+                            break;
+                        }
+                        message.Severity = reader.int32();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 18) {
+                            break;
+                        }
+                        message.Message = reader.string();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.Members.push(reader.string());
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            Severity: isSet(object.Severity) ? validationResultSeverityFromJSON(object.Severity) : 0,
+            Message: isSet(object.Message) ? globalThis.String(object.Message) : "",
+            Members: globalThis.Array.isArray(object?.Members) ? object.Members.map((e) => globalThis.String(e)) : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Severity !== 0) {
+            obj.Severity = validationResultSeverityToJSON(message.Severity);
+        }
+        if (message.Message !== "") {
+            obj.Message = message.Message;
+        }
+        if (message.Members?.length) {
+            obj.Members = message.Members;
+        }
+        return obj;
+    },
+    create(base) {
+        return ValidationResult.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseValidationResult();
+        message.Severity = object.Severity ?? 0;
+        message.Message = object.Message ?? "";
+        message.Members = object.Members?.map((e) => e) || [];
+        return message;
+    },
+};
+const AlertsDefinition = {
+    name: "Alerts",
+    fullName: "Cratis.Chronicle.Contracts.Alerts.Alerts",
+    methods: {
+        getOpenIncident: {
+            name: "GetOpenIncident",
+            requestType: GetOpenIncidentRequest,
+            requestStream: false,
+            responseType: QueryResultAlertIncidentLookupResponse,
+            responseStream: false,
+            options: {},
+        },
+        getOpenIncidentCounts: {
+            name: "GetOpenIncidentCounts",
+            requestType: GetOpenIncidentCountsRequest,
+            requestStream: false,
+            responseType: QueryResultAlertIncidentSummaryResponse,
+            responseStream: false,
+            options: {},
+        },
+        getOpenIncidents: {
+            name: "GetOpenIncidents",
+            requestType: GetOpenIncidentsRequest,
+            requestStream: false,
+            responseType: QueryResultAlertIncidentPageResponse,
+            responseStream: false,
+            options: {},
+        },
+    },
+};
+function isSet(value) {
+    return value !== null && value !== undefined;
+}
+
+exports.AlertEvidence = AlertEvidence;
+exports.AlertIncidentContinuation = AlertIncidentContinuation;
+exports.AlertIncidentCountDetails = AlertIncidentCountDetails;
+exports.AlertIncidentDetails = AlertIncidentDetails;
+exports.AlertIncidentLookupResponse = AlertIncidentLookupResponse;
+exports.AlertIncidentPageResponse = AlertIncidentPageResponse;
+exports.AlertIncidentSummaryResponse = AlertIncidentSummaryResponse;
+exports.AlertTarget = AlertTarget;
+exports.AlertsDefinition = AlertsDefinition;
+exports.GetOpenIncidentCountsRequest = GetOpenIncidentCountsRequest;
+exports.GetOpenIncidentRequest = GetOpenIncidentRequest;
+exports.GetOpenIncidentsRequest = GetOpenIncidentsRequest;
+exports.QueryResultAlertIncidentLookupResponse = QueryResultAlertIncidentLookupResponse;
+exports.QueryResultAlertIncidentPageResponse = QueryResultAlertIncidentPageResponse;
+exports.QueryResultAlertIncidentSummaryResponse = QueryResultAlertIncidentSummaryResponse;
+exports.SerializableDateTimeOffset = SerializableDateTimeOffset;
+exports.ValidationResult = ValidationResult;
+exports.alertIncidentsReadinessStateFromJSON = alertIncidentsReadinessStateFromJSON;
+exports.alertIncidentsReadinessStateToJSON = alertIncidentsReadinessStateToJSON;
+exports.alertSeverityFromJSON = alertSeverityFromJSON;
+exports.alertSeverityToJSON = alertSeverityToJSON;
+exports.failureKindFromJSON = failureKindFromJSON;
+exports.failureKindToJSON = failureKindToJSON;
+exports.protobufPackage = protobufPackage;
+exports.validationResultSeverityFromJSON = validationResultSeverityFromJSON;
+exports.validationResultSeverityToJSON = validationResultSeverityToJSON;
+//# sourceMappingURL=alerts.js.map