@cratis/chronicle.contracts 16.45.3 → 17.0.1

package/dist/generated/captures.js

@@ -1,5 +1,5 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
-import { Empty } from "./google/protobuf/empty";
+import { Guid } from "./protobuf-net/bcl";
 export const protobufPackage = "Cratis.Chronicle.Contracts.Captures";
 export var CaptureStatus;
 (function (CaptureStatus) {
@@ -32,10 +32,90 @@ export function captureStatusToJSON(object) {
             return "UNRECOGNIZED";
     }
 }
-function createBaseCapture() {
+export var EventObservationState;
+(function (EventObservationState) {
+    EventObservationState[EventObservationState["None"] = 0] = "None";
+    EventObservationState[EventObservationState["Initial"] = 1] = "Initial";
+    EventObservationState[EventObservationState["Replay"] = 2] = "Replay";
+    EventObservationState[EventObservationState["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(EventObservationState || (EventObservationState = {}));
+export function eventObservationStateFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "None":
+            return EventObservationState.None;
+        case 1:
+        case "Initial":
+            return EventObservationState.Initial;
+        case 2:
+        case "Replay":
+            return EventObservationState.Replay;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return EventObservationState.UNRECOGNIZED;
+    }
+}
+export function eventObservationStateToJSON(object) {
+    switch (object) {
+        case EventObservationState.None:
+            return "None";
+        case EventObservationState.Initial:
+            return "Initial";
+        case EventObservationState.Replay:
+            return "Replay";
+        case EventObservationState.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+export var ValidationResultSeverity;
+(function (ValidationResultSeverity) {
+    ValidationResultSeverity[ValidationResultSeverity["Unknown"] = 0] = "Unknown";
+    ValidationResultSeverity[ValidationResultSeverity["Information"] = 1] = "Information";
+    ValidationResultSeverity[ValidationResultSeverity["Warning"] = 2] = "Warning";
+    ValidationResultSeverity[ValidationResultSeverity["Error"] = 3] = "Error";
+    ValidationResultSeverity[ValidationResultSeverity["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ValidationResultSeverity || (ValidationResultSeverity = {}));
+export function validationResultSeverityFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "Unknown":
+            return ValidationResultSeverity.Unknown;
+        case 1:
+        case "Information":
+            return ValidationResultSeverity.Information;
+        case 2:
+        case "Warning":
+            return ValidationResultSeverity.Warning;
+        case 3:
+        case "Error":
+            return ValidationResultSeverity.Error;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ValidationResultSeverity.UNRECOGNIZED;
+    }
+}
+export function validationResultSeverityToJSON(object) {
+    switch (object) {
+        case ValidationResultSeverity.Unknown:
+            return "Unknown";
+        case ValidationResultSeverity.Information:
+            return "Information";
+        case ValidationResultSeverity.Warning:
+            return "Warning";
+        case ValidationResultSeverity.Error:
+            return "Error";
+        case ValidationResultSeverity.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseCaptureDetailsResponse() {
     return { Id: "", Name: "", Declaration: "", Status: 0 };
 }
-export const Capture = {
+export const CaptureDetailsResponse = {
     encode(message, writer = new BinaryWriter()) {
         if (message.Id !== "") {
             writer.uint32(10).string(message.Id);
@@ -60,7 +140,7 @@ export const Capture = {
         reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
         try {
             const end = length === undefined ? reader.len : reader.pos + length;
-            const message = createBaseCapture();
+            const message = createBaseCaptureDetailsResponse();
             while (reader.pos < end) {
                 const tag = reader.uint32();
                 switch (tag >>> 3) {
@@ -129,10 +209,10 @@ export const Capture = {
         return obj;
     },
     create(base) {
-        return Capture.fromPartial(base ?? {});
+        return CaptureDetailsResponse.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        const message = createBaseCapture();
+        const message = createBaseCaptureDetailsResponse();
         message.Id = object.Id ?? "";
         message.Name = object.Name ?? "";
         message.Declaration = object.Declaration ?? "";
@@ -233,16 +313,1727 @@ export const CaptureValidationMessage = {
         return message;
     },
 };
-function createBaseDeleteCapture() {
-    return { EventStore: "", Id: "" };
+function createBaseCapturedEventResponse() {
+    return { Context: undefined, Content: "", Id: "" };
+}
+export const CapturedEventResponse = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.Context !== undefined) {
+            EventContext.encode(message.Context, writer.uint32(10).fork()).join();
+        }
+        if (message.Content !== "") {
+            writer.uint32(18).string(message.Content);
+        }
+        if (message.Id !== "") {
+            writer.uint32(26).string(message.Id);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new 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 = createBaseCapturedEventResponse();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.Context = EventContext.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 18) {
+                            break;
+                        }
+                        message.Content = reader.string();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.Id = reader.string();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            Context: isSet(object.Context) ? EventContext.fromJSON(object.Context) : undefined,
+            Content: isSet(object.Content) ? globalThis.String(object.Content) : "",
+            Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Context !== undefined) {
+            obj.Context = EventContext.toJSON(message.Context);
+        }
+        if (message.Content !== "") {
+            obj.Content = message.Content;
+        }
+        if (message.Id !== "") {
+            obj.Id = message.Id;
+        }
+        return obj;
+    },
+    create(base) {
+        return CapturedEventResponse.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseCapturedEventResponse();
+        message.Context = (object.Context !== undefined && object.Context !== null)
+            ? EventContext.fromPartial(object.Context)
+            : undefined;
+        message.Content = object.Content ?? "";
+        message.Id = object.Id ?? "";
+        return message;
+    },
+};
+function createBaseCapturedEventsRequest() {
+    return { EventStore: "", CaptureName: "", Namespace: "", MaxEvents: 0 };
 }
-export const DeleteCapture = {
+export const CapturedEventsRequest = {
     encode(message, writer = new BinaryWriter()) {
         if (message.EventStore !== "") {
             writer.uint32(10).string(message.EventStore);
         }
-        if (message.Id !== "") {
-            writer.uint32(18).string(message.Id);
+        if (message.CaptureName !== "") {
+            writer.uint32(18).string(message.CaptureName);
+        }
+        if (message.Namespace !== "") {
+            writer.uint32(26).string(message.Namespace);
+        }
+        if (message.MaxEvents !== 0) {
+            writer.uint32(32).int32(message.MaxEvents);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new 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 = createBaseCapturedEventsRequest();
+            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.CaptureName = reader.string();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.Namespace = reader.string();
+                        continue;
+                    }
+                    case 4: {
+                        if (tag !== 32) {
+                            break;
+                        }
+                        message.MaxEvents = reader.int32();
+                        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) : "",
+            CaptureName: isSet(object.CaptureName) ? globalThis.String(object.CaptureName) : "",
+            Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
+            MaxEvents: isSet(object.MaxEvents) ? globalThis.Number(object.MaxEvents) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.CaptureName !== "") {
+            obj.CaptureName = message.CaptureName;
+        }
+        if (message.Namespace !== "") {
+            obj.Namespace = message.Namespace;
+        }
+        if (message.MaxEvents !== 0) {
+            obj.MaxEvents = Math.round(message.MaxEvents);
+        }
+        return obj;
+    },
+    create(base) {
+        return CapturedEventsRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseCapturedEventsRequest();
+        message.EventStore = object.EventStore ?? "";
+        message.CaptureName = object.CaptureName ?? "";
+        message.Namespace = object.Namespace ?? "";
+        message.MaxEvents = object.MaxEvents ?? 0;
+        return message;
+    },
+};
+function createBaseCausation() {
+    return { Occurred: undefined, Type: "", Properties: {} };
+}
+export const Causation = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.Occurred !== undefined) {
+            SerializableDateTimeOffset.encode(message.Occurred, writer.uint32(10).fork()).join();
+        }
+        if (message.Type !== "") {
+            writer.uint32(18).string(message.Type);
+        }
+        globalThis.Object.entries(message.Properties).forEach(([key, value]) => {
+            Causation_PropertiesEntry.encode({ key: key, value }, writer.uint32(26).fork()).join();
+        });
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new 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 = createBaseCausation();
+            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 !== 18) {
+                            break;
+                        }
+                        message.Type = reader.string();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        const entry3 = Causation_PropertiesEntry.decode(reader, reader.uint32());
+                        if (entry3.value !== undefined) {
+                            message.Properties[entry3.key] = entry3.value;
+                        }
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            Occurred: isSet(object.Occurred) ? SerializableDateTimeOffset.fromJSON(object.Occurred) : undefined,
+            Type: isSet(object.Type) ? globalThis.String(object.Type) : "",
+            Properties: isObject(object.Properties)
+                ? globalThis.Object.entries(object.Properties).reduce((acc, [key, value]) => {
+                    globalThis.Object.defineProperty(acc, key, {
+                        value: globalThis.String(value),
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                    });
+                    return acc;
+                }, {})
+                : {},
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Occurred !== undefined) {
+            obj.Occurred = SerializableDateTimeOffset.toJSON(message.Occurred);
+        }
+        if (message.Type !== "") {
+            obj.Type = message.Type;
+        }
+        if (message.Properties) {
+            const entries = globalThis.Object.entries(message.Properties);
+            if (entries.length > 0) {
+                obj.Properties = {};
+                entries.forEach(([k, v]) => {
+                    obj.Properties[k] = v;
+                });
+            }
+        }
+        return obj;
+    },
+    create(base) {
+        return Causation.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseCausation();
+        message.Occurred = (object.Occurred !== undefined && object.Occurred !== null)
+            ? SerializableDateTimeOffset.fromPartial(object.Occurred)
+            : undefined;
+        message.Type = object.Type ?? "";
+        message.Properties = globalThis.Object.entries(object.Properties ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = globalThis.String(value);
+            }
+            return acc;
+        }, {});
+        return message;
+    },
+};
+function createBaseCausation_PropertiesEntry() {
+    return { key: "", value: "" };
+}
+export const Causation_PropertiesEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== "") {
+            writer.uint32(18).string(message.value);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new 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 = createBaseCausation_PropertiesEntry();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.key = reader.string();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 18) {
+                            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 {
+            key: isSet(object.key) ? globalThis.String(object.key) : "",
+            value: isSet(object.value) ? globalThis.String(object.value) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.key !== "") {
+            obj.key = message.key;
+        }
+        if (message.value !== "") {
+            obj.value = message.value;
+        }
+        return obj;
+    },
+    create(base) {
+        return Causation_PropertiesEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseCausation_PropertiesEntry();
+        message.key = object.key ?? "";
+        message.value = object.value ?? "";
+        return message;
+    },
+};
+function createBaseCommandResult() {
+    return {
+        CorrelationId: undefined,
+        IsAuthorized: false,
+        ValidationResults: [],
+        ExceptionMessages: [],
+        ExceptionStackTrace: "",
+        AuthorizationFailureReason: "",
+    };
+}
+export const CommandResult = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.CorrelationId !== undefined) {
+            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.AuthorizationFailureReason !== "") {
+            writer.uint32(50).string(message.AuthorizationFailureReason);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new 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 = createBaseCommandResult();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.CorrelationId = 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.AuthorizationFailureReason = reader.string();
+                        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) ? 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) : "",
+            AuthorizationFailureReason: isSet(object.AuthorizationFailureReason)
+                ? globalThis.String(object.AuthorizationFailureReason)
+                : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.CorrelationId !== undefined) {
+            obj.CorrelationId = 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.AuthorizationFailureReason !== "") {
+            obj.AuthorizationFailureReason = message.AuthorizationFailureReason;
+        }
+        return obj;
+    },
+    create(base) {
+        return CommandResult.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseCommandResult();
+        message.CorrelationId = (object.CorrelationId !== undefined && object.CorrelationId !== null)
+            ? 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.AuthorizationFailureReason = object.AuthorizationFailureReason ?? "";
+        return message;
+    },
+};
+function createBaseCommandResultSaveCaptureResponse() {
+    return {
+        CorrelationId: undefined,
+        IsAuthorized: false,
+        ValidationResults: [],
+        ExceptionMessages: [],
+        ExceptionStackTrace: "",
+        AuthorizationFailureReason: "",
+        Response: undefined,
+    };
+}
+export const CommandResultSaveCaptureResponse = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.CorrelationId !== undefined) {
+            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.AuthorizationFailureReason !== "") {
+            writer.uint32(50).string(message.AuthorizationFailureReason);
+        }
+        if (message.Response !== undefined) {
+            SaveCaptureResponse.encode(message.Response, writer.uint32(58).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new 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 = createBaseCommandResultSaveCaptureResponse();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.CorrelationId = 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.AuthorizationFailureReason = reader.string();
+                        continue;
+                    }
+                    case 7: {
+                        if (tag !== 58) {
+                            break;
+                        }
+                        message.Response = SaveCaptureResponse.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) ? 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) : "",
+            AuthorizationFailureReason: isSet(object.AuthorizationFailureReason)
+                ? globalThis.String(object.AuthorizationFailureReason)
+                : "",
+            Response: isSet(object.Response) ? SaveCaptureResponse.fromJSON(object.Response) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.CorrelationId !== undefined) {
+            obj.CorrelationId = 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.AuthorizationFailureReason !== "") {
+            obj.AuthorizationFailureReason = message.AuthorizationFailureReason;
+        }
+        if (message.Response !== undefined) {
+            obj.Response = SaveCaptureResponse.toJSON(message.Response);
+        }
+        return obj;
+    },
+    create(base) {
+        return CommandResultSaveCaptureResponse.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseCommandResultSaveCaptureResponse();
+        message.CorrelationId = (object.CorrelationId !== undefined && object.CorrelationId !== null)
+            ? 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.AuthorizationFailureReason = object.AuthorizationFailureReason ?? "";
+        message.Response = (object.Response !== undefined && object.Response !== null)
+            ? SaveCaptureResponse.fromPartial(object.Response)
+            : undefined;
+        return message;
+    },
+};
+function createBaseCommandResultStartCaptureResponse() {
+    return {
+        CorrelationId: undefined,
+        IsAuthorized: false,
+        ValidationResults: [],
+        ExceptionMessages: [],
+        ExceptionStackTrace: "",
+        AuthorizationFailureReason: "",
+        Response: undefined,
+    };
+}
+export const CommandResultStartCaptureResponse = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.CorrelationId !== undefined) {
+            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.AuthorizationFailureReason !== "") {
+            writer.uint32(50).string(message.AuthorizationFailureReason);
+        }
+        if (message.Response !== undefined) {
+            StartCaptureResponse.encode(message.Response, writer.uint32(58).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new 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 = createBaseCommandResultStartCaptureResponse();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.CorrelationId = 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.AuthorizationFailureReason = reader.string();
+                        continue;
+                    }
+                    case 7: {
+                        if (tag !== 58) {
+                            break;
+                        }
+                        message.Response = StartCaptureResponse.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) ? 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) : "",
+            AuthorizationFailureReason: isSet(object.AuthorizationFailureReason)
+                ? globalThis.String(object.AuthorizationFailureReason)
+                : "",
+            Response: isSet(object.Response) ? StartCaptureResponse.fromJSON(object.Response) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.CorrelationId !== undefined) {
+            obj.CorrelationId = 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.AuthorizationFailureReason !== "") {
+            obj.AuthorizationFailureReason = message.AuthorizationFailureReason;
+        }
+        if (message.Response !== undefined) {
+            obj.Response = StartCaptureResponse.toJSON(message.Response);
+        }
+        return obj;
+    },
+    create(base) {
+        return CommandResultStartCaptureResponse.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseCommandResultStartCaptureResponse();
+        message.CorrelationId = (object.CorrelationId !== undefined && object.CorrelationId !== null)
+            ? 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.AuthorizationFailureReason = object.AuthorizationFailureReason ?? "";
+        message.Response = (object.Response !== undefined && object.Response !== null)
+            ? StartCaptureResponse.fromPartial(object.Response)
+            : undefined;
+        return message;
+    },
+};
+function createBaseCommandResultValidateCaptureDeclarationResponse() {
+    return {
+        CorrelationId: undefined,
+        IsAuthorized: false,
+        ValidationResults: [],
+        ExceptionMessages: [],
+        ExceptionStackTrace: "",
+        AuthorizationFailureReason: "",
+        Response: undefined,
+    };
+}
+export const CommandResultValidateCaptureDeclarationResponse = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.CorrelationId !== undefined) {
+            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.AuthorizationFailureReason !== "") {
+            writer.uint32(50).string(message.AuthorizationFailureReason);
+        }
+        if (message.Response !== undefined) {
+            ValidateCaptureDeclarationResponse.encode(message.Response, writer.uint32(58).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new 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 = createBaseCommandResultValidateCaptureDeclarationResponse();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.CorrelationId = 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.AuthorizationFailureReason = reader.string();
+                        continue;
+                    }
+                    case 7: {
+                        if (tag !== 58) {
+                            break;
+                        }
+                        message.Response = ValidateCaptureDeclarationResponse.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) ? 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) : "",
+            AuthorizationFailureReason: isSet(object.AuthorizationFailureReason)
+                ? globalThis.String(object.AuthorizationFailureReason)
+                : "",
+            Response: isSet(object.Response) ? ValidateCaptureDeclarationResponse.fromJSON(object.Response) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.CorrelationId !== undefined) {
+            obj.CorrelationId = 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.AuthorizationFailureReason !== "") {
+            obj.AuthorizationFailureReason = message.AuthorizationFailureReason;
+        }
+        if (message.Response !== undefined) {
+            obj.Response = ValidateCaptureDeclarationResponse.toJSON(message.Response);
+        }
+        return obj;
+    },
+    create(base) {
+        return CommandResultValidateCaptureDeclarationResponse.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseCommandResultValidateCaptureDeclarationResponse();
+        message.CorrelationId = (object.CorrelationId !== undefined && object.CorrelationId !== null)
+            ? 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.AuthorizationFailureReason = object.AuthorizationFailureReason ?? "";
+        message.Response = (object.Response !== undefined && object.Response !== null)
+            ? ValidateCaptureDeclarationResponse.fromPartial(object.Response)
+            : undefined;
+        return message;
+    },
+};
+function createBaseDeleteCaptureRequest() {
+    return { EventStore: "", CaptureId: undefined };
+}
+export const DeleteCaptureRequest = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        if (message.CaptureId !== undefined) {
+            Guid.encode(message.CaptureId, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new 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 = createBaseDeleteCaptureRequest();
+            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.CaptureId = 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) : "",
+            CaptureId: isSet(object.CaptureId) ? Guid.fromJSON(object.CaptureId) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.CaptureId !== undefined) {
+            obj.CaptureId = Guid.toJSON(message.CaptureId);
+        }
+        return obj;
+    },
+    create(base) {
+        return DeleteCaptureRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseDeleteCaptureRequest();
+        message.EventStore = object.EventStore ?? "";
+        message.CaptureId = (object.CaptureId !== undefined && object.CaptureId !== null)
+            ? Guid.fromPartial(object.CaptureId)
+            : undefined;
+        return message;
+    },
+};
+function createBaseEventContext() {
+    return {
+        EventType: undefined,
+        EventSourceType: "",
+        EventSourceId: "",
+        SequenceNumber: 0n,
+        EventStreamType: "",
+        EventStreamId: "",
+        Occurred: undefined,
+        EventStore: "",
+        Namespace: "",
+        CorrelationId: undefined,
+        Causation: [],
+        CausedBy: undefined,
+        ObservationState: 0,
+        Tags: [],
+        Hash: "",
+    };
+}
+export const EventContext = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.EventType !== undefined) {
+            EventType.encode(message.EventType, writer.uint32(10).fork()).join();
+        }
+        if (message.EventSourceType !== "") {
+            writer.uint32(18).string(message.EventSourceType);
+        }
+        if (message.EventSourceId !== "") {
+            writer.uint32(26).string(message.EventSourceId);
+        }
+        if (message.SequenceNumber !== 0n) {
+            if (BigInt.asUintN(64, message.SequenceNumber) !== message.SequenceNumber) {
+                throw new globalThis.Error("value provided for field message.SequenceNumber of type uint64 too large");
+            }
+            writer.uint32(32).uint64(message.SequenceNumber);
+        }
+        if (message.EventStreamType !== "") {
+            writer.uint32(42).string(message.EventStreamType);
+        }
+        if (message.EventStreamId !== "") {
+            writer.uint32(50).string(message.EventStreamId);
+        }
+        if (message.Occurred !== undefined) {
+            SerializableDateTimeOffset.encode(message.Occurred, writer.uint32(58).fork()).join();
+        }
+        if (message.EventStore !== "") {
+            writer.uint32(66).string(message.EventStore);
+        }
+        if (message.Namespace !== "") {
+            writer.uint32(74).string(message.Namespace);
+        }
+        if (message.CorrelationId !== undefined) {
+            Guid.encode(message.CorrelationId, writer.uint32(82).fork()).join();
+        }
+        for (const v of message.Causation) {
+            Causation.encode(v, writer.uint32(90).fork()).join();
+        }
+        if (message.CausedBy !== undefined) {
+            Identity.encode(message.CausedBy, writer.uint32(98).fork()).join();
+        }
+        if (message.ObservationState !== 0) {
+            writer.uint32(104).int32(message.ObservationState);
+        }
+        for (const v of message.Tags) {
+            writer.uint32(114).string(v);
+        }
+        if (message.Hash !== "") {
+            writer.uint32(122).string(message.Hash);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new 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 = createBaseEventContext();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.EventType = EventType.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 18) {
+                            break;
+                        }
+                        message.EventSourceType = reader.string();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.EventSourceId = reader.string();
+                        continue;
+                    }
+                    case 4: {
+                        if (tag !== 32) {
+                            break;
+                        }
+                        message.SequenceNumber = reader.uint64();
+                        continue;
+                    }
+                    case 5: {
+                        if (tag !== 42) {
+                            break;
+                        }
+                        message.EventStreamType = reader.string();
+                        continue;
+                    }
+                    case 6: {
+                        if (tag !== 50) {
+                            break;
+                        }
+                        message.EventStreamId = reader.string();
+                        continue;
+                    }
+                    case 7: {
+                        if (tag !== 58) {
+                            break;
+                        }
+                        message.Occurred = SerializableDateTimeOffset.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 8: {
+                        if (tag !== 66) {
+                            break;
+                        }
+                        message.EventStore = reader.string();
+                        continue;
+                    }
+                    case 9: {
+                        if (tag !== 74) {
+                            break;
+                        }
+                        message.Namespace = reader.string();
+                        continue;
+                    }
+                    case 10: {
+                        if (tag !== 82) {
+                            break;
+                        }
+                        message.CorrelationId = Guid.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 11: {
+                        if (tag !== 90) {
+                            break;
+                        }
+                        message.Causation.push(Causation.decode(reader, reader.uint32()));
+                        continue;
+                    }
+                    case 12: {
+                        if (tag !== 98) {
+                            break;
+                        }
+                        message.CausedBy = Identity.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 13: {
+                        if (tag !== 104) {
+                            break;
+                        }
+                        message.ObservationState = reader.int32();
+                        continue;
+                    }
+                    case 14: {
+                        if (tag !== 114) {
+                            break;
+                        }
+                        message.Tags.push(reader.string());
+                        continue;
+                    }
+                    case 15: {
+                        if (tag !== 122) {
+                            break;
+                        }
+                        message.Hash = reader.string();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            EventType: isSet(object.EventType) ? EventType.fromJSON(object.EventType) : undefined,
+            EventSourceType: isSet(object.EventSourceType) ? globalThis.String(object.EventSourceType) : "",
+            EventSourceId: isSet(object.EventSourceId) ? globalThis.String(object.EventSourceId) : "",
+            SequenceNumber: isSet(object.SequenceNumber) ? BigInt(object.SequenceNumber) : 0n,
+            EventStreamType: isSet(object.EventStreamType) ? globalThis.String(object.EventStreamType) : "",
+            EventStreamId: isSet(object.EventStreamId) ? globalThis.String(object.EventStreamId) : "",
+            Occurred: isSet(object.Occurred) ? SerializableDateTimeOffset.fromJSON(object.Occurred) : undefined,
+            EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+            Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
+            CorrelationId: isSet(object.CorrelationId) ? Guid.fromJSON(object.CorrelationId) : undefined,
+            Causation: globalThis.Array.isArray(object?.Causation)
+                ? object.Causation.map((e) => Causation.fromJSON(e))
+                : [],
+            CausedBy: isSet(object.CausedBy) ? Identity.fromJSON(object.CausedBy) : undefined,
+            ObservationState: isSet(object.ObservationState) ? eventObservationStateFromJSON(object.ObservationState) : 0,
+            Tags: globalThis.Array.isArray(object?.Tags) ? object.Tags.map((e) => globalThis.String(e)) : [],
+            Hash: isSet(object.Hash) ? globalThis.String(object.Hash) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventType !== undefined) {
+            obj.EventType = EventType.toJSON(message.EventType);
+        }
+        if (message.EventSourceType !== "") {
+            obj.EventSourceType = message.EventSourceType;
+        }
+        if (message.EventSourceId !== "") {
+            obj.EventSourceId = message.EventSourceId;
+        }
+        if (message.SequenceNumber !== 0n) {
+            obj.SequenceNumber = message.SequenceNumber.toString();
+        }
+        if (message.EventStreamType !== "") {
+            obj.EventStreamType = message.EventStreamType;
+        }
+        if (message.EventStreamId !== "") {
+            obj.EventStreamId = message.EventStreamId;
+        }
+        if (message.Occurred !== undefined) {
+            obj.Occurred = SerializableDateTimeOffset.toJSON(message.Occurred);
+        }
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.Namespace !== "") {
+            obj.Namespace = message.Namespace;
+        }
+        if (message.CorrelationId !== undefined) {
+            obj.CorrelationId = Guid.toJSON(message.CorrelationId);
+        }
+        if (message.Causation?.length) {
+            obj.Causation = message.Causation.map((e) => Causation.toJSON(e));
+        }
+        if (message.CausedBy !== undefined) {
+            obj.CausedBy = Identity.toJSON(message.CausedBy);
+        }
+        if (message.ObservationState !== 0) {
+            obj.ObservationState = eventObservationStateToJSON(message.ObservationState);
+        }
+        if (message.Tags?.length) {
+            obj.Tags = message.Tags;
+        }
+        if (message.Hash !== "") {
+            obj.Hash = message.Hash;
+        }
+        return obj;
+    },
+    create(base) {
+        return EventContext.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseEventContext();
+        message.EventType = (object.EventType !== undefined && object.EventType !== null)
+            ? EventType.fromPartial(object.EventType)
+            : undefined;
+        message.EventSourceType = object.EventSourceType ?? "";
+        message.EventSourceId = object.EventSourceId ?? "";
+        message.SequenceNumber = (object.SequenceNumber !== undefined && object.SequenceNumber !== null)
+            ? BigInt(object.SequenceNumber)
+            : 0n;
+        message.EventStreamType = object.EventStreamType ?? "";
+        message.EventStreamId = object.EventStreamId ?? "";
+        message.Occurred = (object.Occurred !== undefined && object.Occurred !== null)
+            ? SerializableDateTimeOffset.fromPartial(object.Occurred)
+            : undefined;
+        message.EventStore = object.EventStore ?? "";
+        message.Namespace = object.Namespace ?? "";
+        message.CorrelationId = (object.CorrelationId !== undefined && object.CorrelationId !== null)
+            ? Guid.fromPartial(object.CorrelationId)
+            : undefined;
+        message.Causation = object.Causation?.map((e) => Causation.fromPartial(e)) || [];
+        message.CausedBy = (object.CausedBy !== undefined && object.CausedBy !== null)
+            ? Identity.fromPartial(object.CausedBy)
+            : undefined;
+        message.ObservationState = object.ObservationState ?? 0;
+        message.Tags = object.Tags?.map((e) => e) || [];
+        message.Hash = object.Hash ?? "";
+        return message;
+    },
+};
+function createBaseEventType() {
+    return { Id: "", Generation: 0, Tombstone: false };
+}
+export const EventType = {
+    encode(message, writer = new 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 BinaryReader ? input : new 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 = 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;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    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 createBaseGetCapturesRequest() {
+    return { EventStore: "" };
+}
+export const GetCapturesRequest = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new 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 = createBaseGetCapturesRequest();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.EventStore = 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) : "" };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        return obj;
+    },
+    create(base) {
+        return GetCapturesRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGetCapturesRequest();
+        message.EventStore = object.EventStore ?? "";
+        return message;
+    },
+};
+function createBaseIdentity() {
+    return { Subject: "", Name: "", UserName: "", OnBehalfOf: undefined };
+}
+export const Identity = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.Subject !== "") {
+            writer.uint32(10).string(message.Subject);
+        }
+        if (message.Name !== "") {
+            writer.uint32(18).string(message.Name);
+        }
+        if (message.UserName !== "") {
+            writer.uint32(26).string(message.UserName);
+        }
+        if (message.OnBehalfOf !== undefined) {
+            Identity.encode(message.OnBehalfOf, writer.uint32(34).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new 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 = createBaseIdentity();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.Subject = reader.string();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 18) {
+                            break;
+                        }
+                        message.Name = reader.string();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.UserName = reader.string();
+                        continue;
+                    }
+                    case 4: {
+                        if (tag !== 34) {
+                            break;
+                        }
+                        message.OnBehalfOf = Identity.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 {
+            Subject: isSet(object.Subject) ? globalThis.String(object.Subject) : "",
+            Name: isSet(object.Name) ? globalThis.String(object.Name) : "",
+            UserName: isSet(object.UserName) ? globalThis.String(object.UserName) : "",
+            OnBehalfOf: isSet(object.OnBehalfOf) ? Identity.fromJSON(object.OnBehalfOf) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Subject !== "") {
+            obj.Subject = message.Subject;
+        }
+        if (message.Name !== "") {
+            obj.Name = message.Name;
+        }
+        if (message.UserName !== "") {
+            obj.UserName = message.UserName;
+        }
+        if (message.OnBehalfOf !== undefined) {
+            obj.OnBehalfOf = Identity.toJSON(message.OnBehalfOf);
+        }
+        return obj;
+    },
+    create(base) {
+        return Identity.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseIdentity();
+        message.Subject = object.Subject ?? "";
+        message.Name = object.Name ?? "";
+        message.UserName = object.UserName ?? "";
+        message.OnBehalfOf = (object.OnBehalfOf !== undefined && object.OnBehalfOf !== null)
+            ? Identity.fromPartial(object.OnBehalfOf)
+            : undefined;
+        return message;
+    },
+};
+function createBaseObserveCapturesRequest() {
+    return { EventStore: "" };
+}
+export const ObserveCapturesRequest = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
         }
         return writer;
     },
@@ -255,7 +2046,7 @@ export const DeleteCapture = {
         reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
         try {
             const end = length === undefined ? reader.len : reader.pos + length;
-            const message = createBaseDeleteCapture();
+            const message = createBaseObserveCapturesRequest();
             while (reader.pos < end) {
                 const tag = reader.uint32();
                 switch (tag >>> 3) {
@@ -266,13 +2057,6 @@ export const DeleteCapture = {
                         message.EventStore = reader.string();
                         continue;
                     }
-                    case 2: {
-                        if (tag !== 18) {
-                            break;
-                        }
-                        message.Id = reader.string();
-                        continue;
-                    }
                 }
                 if ((tag & 7) === 4 || tag === 0) {
                     break;
@@ -286,38 +2070,53 @@ export const DeleteCapture = {
         }
     },
     fromJSON(object) {
-        return {
-            EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
-            Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
-        };
+        return { EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "" };
     },
     toJSON(message) {
         const obj = {};
         if (message.EventStore !== "") {
             obj.EventStore = message.EventStore;
         }
-        if (message.Id !== "") {
-            obj.Id = message.Id;
-        }
         return obj;
     },
     create(base) {
-        return DeleteCapture.fromPartial(base ?? {});
+        return ObserveCapturesRequest.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        const message = createBaseDeleteCapture();
+        const message = createBaseObserveCapturesRequest();
         message.EventStore = object.EventStore ?? "";
-        message.Id = object.Id ?? "";
         return message;
     },
 };
-function createBaseGetCapturesRequest() {
-    return { EventStore: "" };
+function createBaseQueryResultIEnumerableCaptureDetailsResponse() {
+    return {
+        CorrelationId: undefined,
+        IsAuthorized: false,
+        ValidationResults: [],
+        ExceptionMessages: [],
+        ExceptionStackTrace: "",
+        Data: [],
+    };
 }
-export const GetCapturesRequest = {
+export const QueryResultIEnumerableCaptureDetailsResponse = {
     encode(message, writer = new BinaryWriter()) {
-        if (message.EventStore !== "") {
-            writer.uint32(10).string(message.EventStore);
+        if (message.CorrelationId !== undefined) {
+            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);
+        }
+        for (const v of message.Data) {
+            CaptureDetailsResponse.encode(v, writer.uint32(50).fork()).join();
         }
         return writer;
     },
@@ -330,7 +2129,7 @@ export const GetCapturesRequest = {
         reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
         try {
             const end = length === undefined ? reader.len : reader.pos + length;
-            const message = createBaseGetCapturesRequest();
+            const message = createBaseQueryResultIEnumerableCaptureDetailsResponse();
             while (reader.pos < end) {
                 const tag = reader.uint32();
                 switch (tag >>> 3) {
@@ -338,7 +2137,42 @@ export const GetCapturesRequest = {
                         if (tag !== 10) {
                             break;
                         }
-                        message.EventStore = reader.string();
+                        message.CorrelationId = 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.push(CaptureDetailsResponse.decode(reader, reader.uint32()));
                         continue;
                     }
                 }
@@ -354,31 +2188,88 @@ export const GetCapturesRequest = {
         }
     },
     fromJSON(object) {
-        return { EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "" };
+        return {
+            CorrelationId: isSet(object.CorrelationId) ? 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: globalThis.Array.isArray(object?.Data)
+                ? object.Data.map((e) => CaptureDetailsResponse.fromJSON(e))
+                : [],
+        };
     },
     toJSON(message) {
         const obj = {};
-        if (message.EventStore !== "") {
-            obj.EventStore = message.EventStore;
+        if (message.CorrelationId !== undefined) {
+            obj.CorrelationId = 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?.length) {
+            obj.Data = message.Data.map((e) => CaptureDetailsResponse.toJSON(e));
         }
         return obj;
     },
     create(base) {
-        return GetCapturesRequest.fromPartial(base ?? {});
+        return QueryResultIEnumerableCaptureDetailsResponse.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        const message = createBaseGetCapturesRequest();
-        message.EventStore = object.EventStore ?? "";
+        const message = createBaseQueryResultIEnumerableCaptureDetailsResponse();
+        message.CorrelationId = (object.CorrelationId !== undefined && object.CorrelationId !== null)
+            ? 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?.map((e) => CaptureDetailsResponse.fromPartial(e)) || [];
         return message;
     },
 };
-function createBaseIEnumerableCapture() {
-    return { items: [] };
+function createBaseQueryResultIEnumerableCapturedEventResponse() {
+    return {
+        CorrelationId: undefined,
+        IsAuthorized: false,
+        ValidationResults: [],
+        ExceptionMessages: [],
+        ExceptionStackTrace: "",
+        Data: [],
+    };
 }
-export const IEnumerableCapture = {
+export const QueryResultIEnumerableCapturedEventResponse = {
     encode(message, writer = new BinaryWriter()) {
-        for (const v of message.items) {
-            Capture.encode(v, writer.uint32(10).fork()).join();
+        if (message.CorrelationId !== undefined) {
+            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);
+        }
+        for (const v of message.Data) {
+            CapturedEventResponse.encode(v, writer.uint32(50).fork()).join();
         }
         return writer;
     },
@@ -391,7 +2282,7 @@ export const IEnumerableCapture = {
         reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
         try {
             const end = length === undefined ? reader.len : reader.pos + length;
-            const message = createBaseIEnumerableCapture();
+            const message = createBaseQueryResultIEnumerableCapturedEventResponse();
             while (reader.pos < end) {
                 const tag = reader.uint32();
                 switch (tag >>> 3) {
@@ -399,7 +2290,42 @@ export const IEnumerableCapture = {
                         if (tag !== 10) {
                             break;
                         }
-                        message.items.push(Capture.decode(reader, reader.uint32()));
+                        message.CorrelationId = 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.push(CapturedEventResponse.decode(reader, reader.uint32()));
                         continue;
                     }
                 }
@@ -415,34 +2341,69 @@ export const IEnumerableCapture = {
         }
     },
     fromJSON(object) {
-        return { items: globalThis.Array.isArray(object?.items) ? object.items.map((e) => Capture.fromJSON(e)) : [] };
+        return {
+            CorrelationId: isSet(object.CorrelationId) ? 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: globalThis.Array.isArray(object?.Data)
+                ? object.Data.map((e) => CapturedEventResponse.fromJSON(e))
+                : [],
+        };
     },
     toJSON(message) {
         const obj = {};
-        if (message.items?.length) {
-            obj.items = message.items.map((e) => Capture.toJSON(e));
+        if (message.CorrelationId !== undefined) {
+            obj.CorrelationId = 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?.length) {
+            obj.Data = message.Data.map((e) => CapturedEventResponse.toJSON(e));
         }
         return obj;
     },
     create(base) {
-        return IEnumerableCapture.fromPartial(base ?? {});
+        return QueryResultIEnumerableCapturedEventResponse.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        const message = createBaseIEnumerableCapture();
-        message.items = object.items?.map((e) => Capture.fromPartial(e)) || [];
+        const message = createBaseQueryResultIEnumerableCapturedEventResponse();
+        message.CorrelationId = (object.CorrelationId !== undefined && object.CorrelationId !== null)
+            ? 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?.map((e) => CapturedEventResponse.fromPartial(e)) || [];
         return message;
     },
 };
-function createBaseSaveCapture() {
-    return { EventStore: "", Id: "", Declaration: "" };
+function createBaseSaveCaptureRequest() {
+    return { EventStore: "", Id: undefined, Declaration: "" };
 }
-export const SaveCapture = {
+export const SaveCaptureRequest = {
     encode(message, writer = new BinaryWriter()) {
         if (message.EventStore !== "") {
             writer.uint32(10).string(message.EventStore);
         }
-        if (message.Id !== "") {
-            writer.uint32(18).string(message.Id);
+        if (message.Id !== undefined) {
+            Guid.encode(message.Id, writer.uint32(18).fork()).join();
         }
         if (message.Declaration !== "") {
             writer.uint32(26).string(message.Declaration);
@@ -458,7 +2419,7 @@ export const SaveCapture = {
         reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
         try {
             const end = length === undefined ? reader.len : reader.pos + length;
-            const message = createBaseSaveCapture();
+            const message = createBaseSaveCaptureRequest();
             while (reader.pos < end) {
                 const tag = reader.uint32();
                 switch (tag >>> 3) {
@@ -473,7 +2434,7 @@ export const SaveCapture = {
                         if (tag !== 18) {
                             break;
                         }
-                        message.Id = reader.string();
+                        message.Id = Guid.decode(reader, reader.uint32());
                         continue;
                     }
                     case 3: {
@@ -498,7 +2459,7 @@ export const SaveCapture = {
     fromJSON(object) {
         return {
             EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
-            Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
+            Id: isSet(object.Id) ? Guid.fromJSON(object.Id) : undefined,
             Declaration: isSet(object.Declaration) ? globalThis.String(object.Declaration) : "",
         };
     },
@@ -507,8 +2468,8 @@ export const SaveCapture = {
         if (message.EventStore !== "") {
             obj.EventStore = message.EventStore;
         }
-        if (message.Id !== "") {
-            obj.Id = message.Id;
+        if (message.Id !== undefined) {
+            obj.Id = Guid.toJSON(message.Id);
         }
         if (message.Declaration !== "") {
             obj.Declaration = message.Declaration;
@@ -516,12 +2477,12 @@ export const SaveCapture = {
         return obj;
     },
     create(base) {
-        return SaveCapture.fromPartial(base ?? {});
+        return SaveCaptureRequest.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        const message = createBaseSaveCapture();
+        const message = createBaseSaveCaptureRequest();
         message.EventStore = object.EventStore ?? "";
-        message.Id = object.Id ?? "";
+        message.Id = (object.Id !== undefined && object.Id !== null) ? Guid.fromPartial(object.Id) : undefined;
         message.Declaration = object.Declaration ?? "";
         return message;
     },
@@ -532,7 +2493,7 @@ function createBaseSaveCaptureResponse() {
 export const SaveCaptureResponse = {
     encode(message, writer = new BinaryWriter()) {
         if (message.Capture !== undefined) {
-            Capture.encode(message.Capture, writer.uint32(10).fork()).join();
+            CaptureDetailsResponse.encode(message.Capture, writer.uint32(10).fork()).join();
         }
         for (const v of message.Messages) {
             CaptureValidationMessage.encode(v, writer.uint32(18).fork()).join();
@@ -556,7 +2517,7 @@ export const SaveCaptureResponse = {
                         if (tag !== 10) {
                             break;
                         }
-                        message.Capture = Capture.decode(reader, reader.uint32());
+                        message.Capture = CaptureDetailsResponse.decode(reader, reader.uint32());
                         continue;
                     }
                     case 2: {
@@ -580,7 +2541,7 @@ export const SaveCaptureResponse = {
     },
     fromJSON(object) {
         return {
-            Capture: isSet(object.Capture) ? Capture.fromJSON(object.Capture) : undefined,
+            Capture: isSet(object.Capture) ? CaptureDetailsResponse.fromJSON(object.Capture) : undefined,
             Messages: globalThis.Array.isArray(object?.Messages)
                 ? object.Messages.map((e) => CaptureValidationMessage.fromJSON(e))
                 : [],
@@ -589,7 +2550,7 @@ export const SaveCaptureResponse = {
     toJSON(message) {
         const obj = {};
         if (message.Capture !== undefined) {
-            obj.Capture = Capture.toJSON(message.Capture);
+            obj.Capture = CaptureDetailsResponse.toJSON(message.Capture);
         }
         if (message.Messages?.length) {
             obj.Messages = message.Messages.map((e) => CaptureValidationMessage.toJSON(e));
@@ -602,22 +2563,83 @@ export const SaveCaptureResponse = {
     fromPartial(object) {
         const message = createBaseSaveCaptureResponse();
         message.Capture = (object.Capture !== undefined && object.Capture !== null)
-            ? Capture.fromPartial(object.Capture)
+            ? CaptureDetailsResponse.fromPartial(object.Capture)
             : undefined;
         message.Messages = object.Messages?.map((e) => CaptureValidationMessage.fromPartial(e)) || [];
         return message;
     },
 };
-function createBaseStartCapture() {
-    return { EventStore: "", Id: "" };
+function createBaseSerializableDateTimeOffset() {
+    return { Value: "" };
+}
+export const SerializableDateTimeOffset = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.Value !== "") {
+            writer.uint32(10).string(message.Value);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new 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 createBaseStartCaptureRequest() {
+    return { EventStore: "", CaptureId: undefined };
 }
-export const StartCapture = {
+export const StartCaptureRequest = {
     encode(message, writer = new BinaryWriter()) {
         if (message.EventStore !== "") {
             writer.uint32(10).string(message.EventStore);
         }
-        if (message.Id !== "") {
-            writer.uint32(18).string(message.Id);
+        if (message.CaptureId !== undefined) {
+            Guid.encode(message.CaptureId, writer.uint32(18).fork()).join();
         }
         return writer;
     },
@@ -630,7 +2652,7 @@ export const StartCapture = {
         reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
         try {
             const end = length === undefined ? reader.len : reader.pos + length;
-            const message = createBaseStartCapture();
+            const message = createBaseStartCaptureRequest();
             while (reader.pos < end) {
                 const tag = reader.uint32();
                 switch (tag >>> 3) {
@@ -645,7 +2667,7 @@ export const StartCapture = {
                         if (tag !== 18) {
                             break;
                         }
-                        message.Id = reader.string();
+                        message.CaptureId = Guid.decode(reader, reader.uint32());
                         continue;
                     }
                 }
@@ -663,7 +2685,7 @@ export const StartCapture = {
     fromJSON(object) {
         return {
             EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
-            Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
+            CaptureId: isSet(object.CaptureId) ? Guid.fromJSON(object.CaptureId) : undefined,
         };
     },
     toJSON(message) {
@@ -671,18 +2693,20 @@ export const StartCapture = {
         if (message.EventStore !== "") {
             obj.EventStore = message.EventStore;
         }
-        if (message.Id !== "") {
-            obj.Id = message.Id;
+        if (message.CaptureId !== undefined) {
+            obj.CaptureId = Guid.toJSON(message.CaptureId);
         }
         return obj;
     },
     create(base) {
-        return StartCapture.fromPartial(base ?? {});
+        return StartCaptureRequest.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        const message = createBaseStartCapture();
+        const message = createBaseStartCaptureRequest();
         message.EventStore = object.EventStore ?? "";
-        message.Id = object.Id ?? "";
+        message.CaptureId = (object.CaptureId !== undefined && object.CaptureId !== null)
+            ? Guid.fromPartial(object.CaptureId)
+            : undefined;
         return message;
     },
 };
@@ -751,16 +2775,16 @@ export const StartCaptureResponse = {
         return message;
     },
 };
-function createBaseStopCapture() {
-    return { EventStore: "", Id: "" };
+function createBaseStopCaptureRequest() {
+    return { EventStore: "", CaptureId: undefined };
 }
-export const StopCapture = {
+export const StopCaptureRequest = {
     encode(message, writer = new BinaryWriter()) {
         if (message.EventStore !== "") {
             writer.uint32(10).string(message.EventStore);
         }
-        if (message.Id !== "") {
-            writer.uint32(18).string(message.Id);
+        if (message.CaptureId !== undefined) {
+            Guid.encode(message.CaptureId, writer.uint32(18).fork()).join();
         }
         return writer;
     },
@@ -773,7 +2797,7 @@ export const StopCapture = {
         reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
         try {
             const end = length === undefined ? reader.len : reader.pos + length;
-            const message = createBaseStopCapture();
+            const message = createBaseStopCaptureRequest();
             while (reader.pos < end) {
                 const tag = reader.uint32();
                 switch (tag >>> 3) {
@@ -788,7 +2812,7 @@ export const StopCapture = {
                         if (tag !== 18) {
                             break;
                         }
-                        message.Id = reader.string();
+                        message.CaptureId = Guid.decode(reader, reader.uint32());
                         continue;
                     }
                 }
@@ -806,7 +2830,7 @@ export const StopCapture = {
     fromJSON(object) {
         return {
             EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
-            Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
+            CaptureId: isSet(object.CaptureId) ? Guid.fromJSON(object.CaptureId) : undefined,
         };
     },
     toJSON(message) {
@@ -814,25 +2838,27 @@ export const StopCapture = {
         if (message.EventStore !== "") {
             obj.EventStore = message.EventStore;
         }
-        if (message.Id !== "") {
-            obj.Id = message.Id;
+        if (message.CaptureId !== undefined) {
+            obj.CaptureId = Guid.toJSON(message.CaptureId);
         }
         return obj;
     },
     create(base) {
-        return StopCapture.fromPartial(base ?? {});
+        return StopCaptureRequest.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        const message = createBaseStopCapture();
+        const message = createBaseStopCaptureRequest();
         message.EventStore = object.EventStore ?? "";
-        message.Id = object.Id ?? "";
+        message.CaptureId = (object.CaptureId !== undefined && object.CaptureId !== null)
+            ? Guid.fromPartial(object.CaptureId)
+            : undefined;
         return message;
     },
 };
-function createBaseValidateCaptureDeclaration() {
+function createBaseValidateCaptureDeclarationRequest() {
     return { EventStore: "", Declaration: "" };
 }
-export const ValidateCaptureDeclaration = {
+export const ValidateCaptureDeclarationRequest = {
     encode(message, writer = new BinaryWriter()) {
         if (message.EventStore !== "") {
             writer.uint32(10).string(message.EventStore);
@@ -851,7 +2877,7 @@ export const ValidateCaptureDeclaration = {
         reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
         try {
             const end = length === undefined ? reader.len : reader.pos + length;
-            const message = createBaseValidateCaptureDeclaration();
+            const message = createBaseValidateCaptureDeclarationRequest();
             while (reader.pos < end) {
                 const tag = reader.uint32();
                 switch (tag >>> 3) {
@@ -898,10 +2924,10 @@ export const ValidateCaptureDeclaration = {
         return obj;
     },
     create(base) {
-        return ValidateCaptureDeclaration.fromPartial(base ?? {});
+        return ValidateCaptureDeclarationRequest.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        const message = createBaseValidateCaptureDeclaration();
+        const message = createBaseValidateCaptureDeclarationRequest();
         message.EventStore = object.EventStore ?? "";
         message.Declaration = object.Declaration ?? "";
         return message;
@@ -972,15 +2998,116 @@ export const ValidateCaptureDeclarationResponse = {
         return message;
     },
 };
+function createBaseValidationResult() {
+    return { Severity: 0, Message: "", Members: [] };
+}
+export const ValidationResult = {
+    encode(message, writer = new 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 BinaryReader ? input : new 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;
+    },
+};
 export const CapturesDefinition = {
     name: "Captures",
     fullName: "Cratis.Chronicle.Contracts.Captures.Captures",
     methods: {
-        delete: {
-            name: "Delete",
-            requestType: DeleteCapture,
+        capturedEvents: {
+            name: "CapturedEvents",
+            requestType: CapturedEventsRequest,
+            requestStream: false,
+            responseType: QueryResultIEnumerableCapturedEventResponse,
+            responseStream: false,
+            options: {},
+        },
+        deleteCapture: {
+            name: "DeleteCapture",
+            requestType: DeleteCaptureRequest,
             requestStream: false,
-            responseType: Empty,
+            responseType: CommandResult,
             responseStream: false,
             options: {},
         },
@@ -988,52 +3115,55 @@ export const CapturesDefinition = {
             name: "GetCaptures",
             requestType: GetCapturesRequest,
             requestStream: false,
-            responseType: IEnumerableCapture,
+            responseType: QueryResultIEnumerableCaptureDetailsResponse,
             responseStream: false,
             options: {},
         },
         observeCaptures: {
             name: "ObserveCaptures",
-            requestType: GetCapturesRequest,
+            requestType: ObserveCapturesRequest,
             requestStream: false,
-            responseType: IEnumerableCapture,
+            responseType: QueryResultIEnumerableCaptureDetailsResponse,
             responseStream: true,
             options: {},
         },
-        save: {
-            name: "Save",
-            requestType: SaveCapture,
+        saveCapture: {
+            name: "SaveCapture",
+            requestType: SaveCaptureRequest,
             requestStream: false,
-            responseType: SaveCaptureResponse,
+            responseType: CommandResultSaveCaptureResponse,
             responseStream: false,
             options: {},
         },
-        start: {
-            name: "Start",
-            requestType: StartCapture,
+        startCapture: {
+            name: "StartCapture",
+            requestType: StartCaptureRequest,
             requestStream: false,
-            responseType: StartCaptureResponse,
+            responseType: CommandResultStartCaptureResponse,
             responseStream: false,
             options: {},
         },
-        stop: {
-            name: "Stop",
-            requestType: StopCapture,
+        stopCapture: {
+            name: "StopCapture",
+            requestType: StopCaptureRequest,
             requestStream: false,
-            responseType: Empty,
+            responseType: CommandResult,
             responseStream: false,
             options: {},
         },
-        validateDeclaration: {
-            name: "ValidateDeclaration",
-            requestType: ValidateCaptureDeclaration,
+        validateCaptureDeclaration: {
+            name: "ValidateCaptureDeclaration",
+            requestType: ValidateCaptureDeclarationRequest,
             requestStream: false,
-            responseType: ValidateCaptureDeclarationResponse,
+            responseType: CommandResultValidateCaptureDeclarationResponse,
             responseStream: false,
             options: {},
         },
     },
 };
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
 function isSet(value) {
     return value !== null && value !== undefined;
 }