@cratis/chronicle.contracts 16.45.3 → 17.0.1

package/dist/cjs/generated/{events.js → eventtypes.js}

@@ -1,8 +1,495 @@
 'use strict';
 
 var wire = require('@bufbuild/protobuf/wire');
-var empty = require('./google/protobuf/empty.js');
+var bcl = require('./protobuf-net/bcl.js');
 
+exports.EventTypeOwner = void 0;
+(function (EventTypeOwner) {
+    EventTypeOwner[EventTypeOwner["None"] = 0] = "None";
+    EventTypeOwner[EventTypeOwner["Client"] = 1] = "Client";
+    EventTypeOwner[EventTypeOwner["Server"] = 2] = "Server";
+    EventTypeOwner[EventTypeOwner["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(exports.EventTypeOwner || (exports.EventTypeOwner = {}));
+function eventTypeOwnerFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "None":
+            return exports.EventTypeOwner.None;
+        case 1:
+        case "Client":
+            return exports.EventTypeOwner.Client;
+        case 2:
+        case "Server":
+            return exports.EventTypeOwner.Server;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return exports.EventTypeOwner.UNRECOGNIZED;
+    }
+}
+function eventTypeOwnerToJSON(object) {
+    switch (object) {
+        case exports.EventTypeOwner.None:
+            return "None";
+        case exports.EventTypeOwner.Client:
+            return "Client";
+        case exports.EventTypeOwner.Server:
+            return "Server";
+        case exports.EventTypeOwner.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.EventTypeSource = void 0;
+(function (EventTypeSource) {
+    EventTypeSource[EventTypeSource["EVENT_TYPE_SOURCE_Unknown"] = 0] = "EVENT_TYPE_SOURCE_Unknown";
+    EventTypeSource[EventTypeSource["Code"] = 1] = "Code";
+    EventTypeSource[EventTypeSource["User"] = 2] = "User";
+    EventTypeSource[EventTypeSource["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(exports.EventTypeSource || (exports.EventTypeSource = {}));
+function eventTypeSourceFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "EVENT_TYPE_SOURCE_Unknown":
+            return exports.EventTypeSource.EVENT_TYPE_SOURCE_Unknown;
+        case 1:
+        case "Code":
+            return exports.EventTypeSource.Code;
+        case 2:
+        case "User":
+            return exports.EventTypeSource.User;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return exports.EventTypeSource.UNRECOGNIZED;
+    }
+}
+function eventTypeSourceToJSON(object) {
+    switch (object) {
+        case exports.EventTypeSource.EVENT_TYPE_SOURCE_Unknown:
+            return "EVENT_TYPE_SOURCE_Unknown";
+        case exports.EventTypeSource.Code:
+            return "Code";
+        case exports.EventTypeSource.User:
+            return "User";
+        case exports.EventTypeSource.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.ValidationResultSeverity = void 0;
+(function (ValidationResultSeverity) {
+    ValidationResultSeverity[ValidationResultSeverity["VALIDATION_RESULT_SEVERITY_Unknown"] = 0] = "VALIDATION_RESULT_SEVERITY_Unknown";
+    ValidationResultSeverity[ValidationResultSeverity["Information"] = 1] = "Information";
+    ValidationResultSeverity[ValidationResultSeverity["Warning"] = 2] = "Warning";
+    ValidationResultSeverity[ValidationResultSeverity["Error"] = 3] = "Error";
+    ValidationResultSeverity[ValidationResultSeverity["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(exports.ValidationResultSeverity || (exports.ValidationResultSeverity = {}));
+function validationResultSeverityFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "VALIDATION_RESULT_SEVERITY_Unknown":
+            return exports.ValidationResultSeverity.VALIDATION_RESULT_SEVERITY_Unknown;
+        case 1:
+        case "Information":
+            return exports.ValidationResultSeverity.Information;
+        case 2:
+        case "Warning":
+            return exports.ValidationResultSeverity.Warning;
+        case 3:
+        case "Error":
+            return exports.ValidationResultSeverity.Error;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return exports.ValidationResultSeverity.UNRECOGNIZED;
+    }
+}
+function validationResultSeverityToJSON(object) {
+    switch (object) {
+        case exports.ValidationResultSeverity.VALIDATION_RESULT_SEVERITY_Unknown:
+            return "VALIDATION_RESULT_SEVERITY_Unknown";
+        case exports.ValidationResultSeverity.Information:
+            return "Information";
+        case exports.ValidationResultSeverity.Warning:
+            return "Warning";
+        case exports.ValidationResultSeverity.Error:
+            return "Error";
+        case exports.ValidationResultSeverity.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseAllEventTypeGenerationsRequest() {
+    return { EventStore: "", EventTypeId: "" };
+}
+const AllEventTypeGenerationsRequest = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        if (message.EventTypeId !== "") {
+            writer.uint32(18).string(message.EventTypeId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseAllEventTypeGenerationsRequest();
+            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.EventTypeId = 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) : "",
+            EventTypeId: isSet(object.EventTypeId) ? globalThis.String(object.EventTypeId) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.EventTypeId !== "") {
+            obj.EventTypeId = message.EventTypeId;
+        }
+        return obj;
+    },
+    create(base) {
+        return AllEventTypeGenerationsRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseAllEventTypeGenerationsRequest();
+        message.EventStore = object.EventStore ?? "";
+        message.EventTypeId = object.EventTypeId ?? "";
+        return message;
+    },
+};
+function createBaseAllEventTypesRequest() {
+    return { EventStore: "" };
+}
+const AllEventTypesRequest = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseAllEventTypesRequest();
+            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 AllEventTypesRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseAllEventTypesRequest();
+        message.EventStore = object.EventStore ?? "";
+        return message;
+    },
+};
+function createBaseCommandResult() {
+    return {
+        CorrelationId: undefined,
+        IsAuthorized: false,
+        ValidationResults: [],
+        ExceptionMessages: [],
+        ExceptionStackTrace: "",
+        AuthorizationFailureReason: "",
+    };
+}
+const CommandResult = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.CorrelationId !== undefined) {
+            bcl.Guid.encode(message.CorrelationId, writer.uint32(10).fork()).join();
+        }
+        if (message.IsAuthorized !== false) {
+            writer.uint32(16).bool(message.IsAuthorized);
+        }
+        for (const v of message.ValidationResults) {
+            ValidationResult.encode(v, writer.uint32(26).fork()).join();
+        }
+        for (const v of message.ExceptionMessages) {
+            writer.uint32(34).string(v);
+        }
+        if (message.ExceptionStackTrace !== "") {
+            writer.uint32(42).string(message.ExceptionStackTrace);
+        }
+        if (message.AuthorizationFailureReason !== "") {
+            writer.uint32(50).string(message.AuthorizationFailureReason);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseCommandResult();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.CorrelationId = bcl.Guid.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 16) {
+                            break;
+                        }
+                        message.IsAuthorized = reader.bool();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.ValidationResults.push(ValidationResult.decode(reader, reader.uint32()));
+                        continue;
+                    }
+                    case 4: {
+                        if (tag !== 34) {
+                            break;
+                        }
+                        message.ExceptionMessages.push(reader.string());
+                        continue;
+                    }
+                    case 5: {
+                        if (tag !== 42) {
+                            break;
+                        }
+                        message.ExceptionStackTrace = reader.string();
+                        continue;
+                    }
+                    case 6: {
+                        if (tag !== 50) {
+                            break;
+                        }
+                        message.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) ? bcl.Guid.fromJSON(object.CorrelationId) : undefined,
+            IsAuthorized: isSet(object.IsAuthorized) ? globalThis.Boolean(object.IsAuthorized) : false,
+            ValidationResults: globalThis.Array.isArray(object?.ValidationResults)
+                ? object.ValidationResults.map((e) => ValidationResult.fromJSON(e))
+                : [],
+            ExceptionMessages: globalThis.Array.isArray(object?.ExceptionMessages)
+                ? object.ExceptionMessages.map((e) => globalThis.String(e))
+                : [],
+            ExceptionStackTrace: isSet(object.ExceptionStackTrace) ? globalThis.String(object.ExceptionStackTrace) : "",
+            AuthorizationFailureReason: isSet(object.AuthorizationFailureReason)
+                ? globalThis.String(object.AuthorizationFailureReason)
+                : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.CorrelationId !== undefined) {
+            obj.CorrelationId = bcl.Guid.toJSON(message.CorrelationId);
+        }
+        if (message.IsAuthorized !== false) {
+            obj.IsAuthorized = message.IsAuthorized;
+        }
+        if (message.ValidationResults?.length) {
+            obj.ValidationResults = message.ValidationResults.map((e) => ValidationResult.toJSON(e));
+        }
+        if (message.ExceptionMessages?.length) {
+            obj.ExceptionMessages = message.ExceptionMessages;
+        }
+        if (message.ExceptionStackTrace !== "") {
+            obj.ExceptionStackTrace = message.ExceptionStackTrace;
+        }
+        if (message.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)
+            ? bcl.Guid.fromPartial(object.CorrelationId)
+            : undefined;
+        message.IsAuthorized = object.IsAuthorized ?? false;
+        message.ValidationResults = object.ValidationResults?.map((e) => ValidationResult.fromPartial(e)) || [];
+        message.ExceptionMessages = object.ExceptionMessages?.map((e) => e) || [];
+        message.ExceptionStackTrace = object.ExceptionStackTrace ?? "";
+        message.AuthorizationFailureReason = object.AuthorizationFailureReason ?? "";
+        return message;
+    },
+};
+function createBaseCreateEventTypeRequest() {
+    return { EventStore: "", Name: "" };
+}
+const CreateEventTypeRequest = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        if (message.Name !== "") {
+            writer.uint32(18).string(message.Name);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseCreateEventTypeRequest();
+            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.Name = 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) : "",
+            Name: isSet(object.Name) ? globalThis.String(object.Name) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.Name !== "") {
+            obj.Name = message.Name;
+        }
+        return obj;
+    },
+    create(base) {
+        return CreateEventTypeRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseCreateEventTypeRequest();
+        message.EventStore = object.EventStore ?? "";
+        message.Name = object.Name ?? "";
+        return message;
+    },
+};
 function createBaseEventType() {
     return { Id: "", Generation: 0, Tombstone: false };
 }
@@ -11,11 +498,110 @@ const EventType = {
         if (message.Id !== "") {
             writer.uint32(10).string(message.Id);
         }
-        if (message.Generation !== 0) {
-            writer.uint32(16).uint32(message.Generation);
+        if (message.Generation !== 0) {
+            writer.uint32(16).uint32(message.Generation);
+        }
+        if (message.Tombstone !== false) {
+            writer.uint32(24).bool(message.Tombstone);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const 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 createBaseEventTypeDetailsResponse() {
+    return { Type: undefined, Owner: 0, Source: 0, Schema: "", Id: "" };
+}
+const EventTypeDetailsResponse = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Type !== undefined) {
+            EventType.encode(message.Type, writer.uint32(10).fork()).join();
+        }
+        if (message.Owner !== 0) {
+            writer.uint32(16).int32(message.Owner);
         }
-        if (message.Tombstone !== false) {
-            writer.uint32(24).bool(message.Tombstone);
+        if (message.Source !== 0) {
+            writer.uint32(24).int32(message.Source);
+        }
+        if (message.Schema !== "") {
+            writer.uint32(34).string(message.Schema);
+        }
+        if (message.Id !== "") {
+            writer.uint32(42).string(message.Id);
         }
         return writer;
     },
@@ -28,7 +614,7 @@ const EventType = {
         reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
         try {
             const end = length === undefined ? reader.len : reader.pos + length;
-            const message = createBaseEventType();
+            const message = createBaseEventTypeDetailsResponse();
             while (reader.pos < end) {
                 const tag = reader.uint32();
                 switch (tag >>> 3) {
@@ -36,21 +622,35 @@ const EventType = {
                         if (tag !== 10) {
                             break;
                         }
-                        message.Id = reader.string();
+                        message.Type = EventType.decode(reader, reader.uint32());
                         continue;
                     }
                     case 2: {
                         if (tag !== 16) {
                             break;
                         }
-                        message.Generation = reader.uint32();
+                        message.Owner = reader.int32();
                         continue;
                     }
                     case 3: {
                         if (tag !== 24) {
                             break;
                         }
-                        message.Tombstone = reader.bool();
+                        message.Source = reader.int32();
+                        continue;
+                    }
+                    case 4: {
+                        if (tag !== 34) {
+                            break;
+                        }
+                        message.Schema = reader.string();
+                        continue;
+                    }
+                    case 5: {
+                        if (tag !== 42) {
+                            break;
+                        }
+                        message.Id = reader.string();
                         continue;
                     }
                 }
@@ -67,32 +667,42 @@ const EventType = {
     },
     fromJSON(object) {
         return {
+            Type: isSet(object.Type) ? EventType.fromJSON(object.Type) : undefined,
+            Owner: isSet(object.Owner) ? eventTypeOwnerFromJSON(object.Owner) : 0,
+            Source: isSet(object.Source) ? eventTypeSourceFromJSON(object.Source) : 0,
+            Schema: isSet(object.Schema) ? globalThis.String(object.Schema) : "",
             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.Type !== undefined) {
+            obj.Type = EventType.toJSON(message.Type);
         }
-        if (message.Generation !== 0) {
-            obj.Generation = Math.round(message.Generation);
+        if (message.Owner !== 0) {
+            obj.Owner = eventTypeOwnerToJSON(message.Owner);
         }
-        if (message.Tombstone !== false) {
-            obj.Tombstone = message.Tombstone;
+        if (message.Source !== 0) {
+            obj.Source = eventTypeSourceToJSON(message.Source);
+        }
+        if (message.Schema !== "") {
+            obj.Schema = message.Schema;
+        }
+        if (message.Id !== "") {
+            obj.Id = message.Id;
         }
         return obj;
     },
     create(base) {
-        return EventType.fromPartial(base ?? {});
+        return EventTypeDetailsResponse.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        const message = createBaseEventType();
+        const message = createBaseEventTypeDetailsResponse();
+        message.Type = (object.Type !== undefined && object.Type !== null) ? EventType.fromPartial(object.Type) : undefined;
+        message.Owner = object.Owner ?? 0;
+        message.Source = object.Source ?? 0;
+        message.Schema = object.Schema ?? "";
         message.Id = object.Id ?? "";
-        message.Generation = object.Generation ?? 0;
-        message.Tombstone = object.Tombstone ?? false;
         return message;
     },
 };
@@ -504,10 +1114,10 @@ const EventTypeRegistration = {
         return message;
     },
 };
-function createBaseGetAllEventTypesRequest() {
+function createBaseObserveEventTypesRequest() {
     return { EventStore: "" };
 }
-const GetAllEventTypesRequest = {
+const ObserveEventTypesRequest = {
     encode(message, writer = new wire.BinaryWriter()) {
         if (message.EventStore !== "") {
             writer.uint32(10).string(message.EventStore);
@@ -523,7 +1133,7 @@ const GetAllEventTypesRequest = {
         reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
         try {
             const end = length === undefined ? reader.len : reader.pos + length;
-            const message = createBaseGetAllEventTypesRequest();
+            const message = createBaseObserveEventTypesRequest();
             while (reader.pos < end) {
                 const tag = reader.uint32();
                 switch (tag >>> 3) {
@@ -557,24 +1167,43 @@ const GetAllEventTypesRequest = {
         return obj;
     },
     create(base) {
-        return GetAllEventTypesRequest.fromPartial(base ?? {});
+        return ObserveEventTypesRequest.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        const message = createBaseGetAllEventTypesRequest();
+        const message = createBaseObserveEventTypesRequest();
         message.EventStore = object.EventStore ?? "";
         return message;
     },
 };
-function createBaseGetEventTypeGenerationsRequest() {
-    return { EventStore: "", EventTypeId: "" };
+function createBaseQueryResultIEnumerableEventTypeDetailsResponse() {
+    return {
+        CorrelationId: undefined,
+        IsAuthorized: false,
+        ValidationResults: [],
+        ExceptionMessages: [],
+        ExceptionStackTrace: "",
+        Data: [],
+    };
 }
-const GetEventTypeGenerationsRequest = {
+const QueryResultIEnumerableEventTypeDetailsResponse = {
     encode(message, writer = new wire.BinaryWriter()) {
-        if (message.EventStore !== "") {
-            writer.uint32(10).string(message.EventStore);
+        if (message.CorrelationId !== undefined) {
+            bcl.Guid.encode(message.CorrelationId, writer.uint32(10).fork()).join();
         }
-        if (message.EventTypeId !== "") {
-            writer.uint32(18).string(message.EventTypeId);
+        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) {
+            EventTypeDetailsResponse.encode(v, writer.uint32(50).fork()).join();
         }
         return writer;
     },
@@ -587,7 +1216,7 @@ const GetEventTypeGenerationsRequest = {
         reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
         try {
             const end = length === undefined ? reader.len : reader.pos + length;
-            const message = createBaseGetEventTypeGenerationsRequest();
+            const message = createBaseQueryResultIEnumerableEventTypeDetailsResponse();
             while (reader.pos < end) {
                 const tag = reader.uint32();
                 switch (tag >>> 3) {
@@ -595,145 +1224,42 @@ const GetEventTypeGenerationsRequest = {
                         if (tag !== 10) {
                             break;
                         }
-                        message.EventStore = reader.string();
+                        message.CorrelationId = bcl.Guid.decode(reader, reader.uint32());
                         continue;
                     }
                     case 2: {
-                        if (tag !== 18) {
+                        if (tag !== 16) {
                             break;
                         }
-                        message.EventTypeId = reader.string();
+                        message.IsAuthorized = reader.bool();
                         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) : "",
-            EventTypeId: isSet(object.EventTypeId) ? globalThis.String(object.EventTypeId) : "",
-        };
-    },
-    toJSON(message) {
-        const obj = {};
-        if (message.EventStore !== "") {
-            obj.EventStore = message.EventStore;
-        }
-        if (message.EventTypeId !== "") {
-            obj.EventTypeId = message.EventTypeId;
-        }
-        return obj;
-    },
-    create(base) {
-        return GetEventTypeGenerationsRequest.fromPartial(base ?? {});
-    },
-    fromPartial(object) {
-        const message = createBaseGetEventTypeGenerationsRequest();
-        message.EventStore = object.EventStore ?? "";
-        message.EventTypeId = object.EventTypeId ?? "";
-        return message;
-    },
-};
-function createBaseIEnumerableEventType() {
-    return { items: [] };
-}
-const IEnumerableEventType = {
-    encode(message, writer = new wire.BinaryWriter()) {
-        for (const v of message.items) {
-            EventType.encode(v, writer.uint32(10).fork()).join();
-        }
-        return writer;
-    },
-    decode(input, length) {
-        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
-        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
-        if (previousRecursionDepth >= 100) {
-            throw new globalThis.Error("protobuf decode recursion limit exceeded");
-        }
-        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
-        try {
-            const end = length === undefined ? reader.len : reader.pos + length;
-            const message = createBaseIEnumerableEventType();
-            while (reader.pos < end) {
-                const tag = reader.uint32();
-                switch (tag >>> 3) {
-                    case 1: {
-                        if (tag !== 10) {
+                    case 3: {
+                        if (tag !== 26) {
                             break;
                         }
-                        message.items.push(EventType.decode(reader, reader.uint32()));
+                        message.ValidationResults.push(ValidationResult.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 {
-            items: globalThis.Array.isArray(object?.items) ? object.items.map((e) => EventType.fromJSON(e)) : [],
-        };
-    },
-    toJSON(message) {
-        const obj = {};
-        if (message.items?.length) {
-            obj.items = message.items.map((e) => EventType.toJSON(e));
-        }
-        return obj;
-    },
-    create(base) {
-        return IEnumerableEventType.fromPartial(base ?? {});
-    },
-    fromPartial(object) {
-        const message = createBaseIEnumerableEventType();
-        message.items = object.items?.map((e) => EventType.fromPartial(e)) || [];
-        return message;
-    },
-};
-function createBaseIEnumerableEventTypeRegistration() {
-    return { items: [] };
-}
-const IEnumerableEventTypeRegistration = {
-    encode(message, writer = new wire.BinaryWriter()) {
-        for (const v of message.items) {
-            EventTypeRegistration.encode(v, writer.uint32(10).fork()).join();
-        }
-        return writer;
-    },
-    decode(input, length) {
-        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
-        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
-        if (previousRecursionDepth >= 100) {
-            throw new globalThis.Error("protobuf decode recursion limit exceeded");
-        }
-        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
-        try {
-            const end = length === undefined ? reader.len : reader.pos + length;
-            const message = createBaseIEnumerableEventTypeRegistration();
-            while (reader.pos < end) {
-                const tag = reader.uint32();
-                switch (tag >>> 3) {
-                    case 1: {
-                        if (tag !== 10) {
+                    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.items.push(EventTypeRegistration.decode(reader, reader.uint32()));
+                        message.Data.push(EventTypeDetailsResponse.decode(reader, reader.uint32()));
                         continue;
                     }
                 }
@@ -750,24 +1276,55 @@ const IEnumerableEventTypeRegistration = {
     },
     fromJSON(object) {
         return {
-            items: globalThis.Array.isArray(object?.items)
-                ? object.items.map((e) => EventTypeRegistration.fromJSON(e))
+            CorrelationId: isSet(object.CorrelationId) ? bcl.Guid.fromJSON(object.CorrelationId) : undefined,
+            IsAuthorized: isSet(object.IsAuthorized) ? globalThis.Boolean(object.IsAuthorized) : false,
+            ValidationResults: globalThis.Array.isArray(object?.ValidationResults)
+                ? object.ValidationResults.map((e) => ValidationResult.fromJSON(e))
+                : [],
+            ExceptionMessages: globalThis.Array.isArray(object?.ExceptionMessages)
+                ? object.ExceptionMessages.map((e) => globalThis.String(e))
+                : [],
+            ExceptionStackTrace: isSet(object.ExceptionStackTrace) ? globalThis.String(object.ExceptionStackTrace) : "",
+            Data: globalThis.Array.isArray(object?.Data)
+                ? object.Data.map((e) => EventTypeDetailsResponse.fromJSON(e))
                 : [],
         };
     },
     toJSON(message) {
         const obj = {};
-        if (message.items?.length) {
-            obj.items = message.items.map((e) => EventTypeRegistration.toJSON(e));
+        if (message.CorrelationId !== undefined) {
+            obj.CorrelationId = bcl.Guid.toJSON(message.CorrelationId);
+        }
+        if (message.IsAuthorized !== false) {
+            obj.IsAuthorized = message.IsAuthorized;
+        }
+        if (message.ValidationResults?.length) {
+            obj.ValidationResults = message.ValidationResults.map((e) => ValidationResult.toJSON(e));
+        }
+        if (message.ExceptionMessages?.length) {
+            obj.ExceptionMessages = message.ExceptionMessages;
+        }
+        if (message.ExceptionStackTrace !== "") {
+            obj.ExceptionStackTrace = message.ExceptionStackTrace;
+        }
+        if (message.Data?.length) {
+            obj.Data = message.Data.map((e) => EventTypeDetailsResponse.toJSON(e));
         }
         return obj;
     },
     create(base) {
-        return IEnumerableEventTypeRegistration.fromPartial(base ?? {});
+        return QueryResultIEnumerableEventTypeDetailsResponse.fromPartial(base ?? {});
     },
     fromPartial(object) {
-        const message = createBaseIEnumerableEventTypeRegistration();
-        message.items = object.items?.map((e) => EventTypeRegistration.fromPartial(e)) || [];
+        const message = createBaseQueryResultIEnumerableEventTypeDetailsResponse();
+        message.CorrelationId = (object.CorrelationId !== undefined && object.CorrelationId !== null)
+            ? bcl.Guid.fromPartial(object.CorrelationId)
+            : undefined;
+        message.IsAuthorized = object.IsAuthorized ?? false;
+        message.ValidationResults = object.ValidationResults?.map((e) => ValidationResult.fromPartial(e)) || [];
+        message.ExceptionMessages = object.ExceptionMessages?.map((e) => e) || [];
+        message.ExceptionStackTrace = object.ExceptionStackTrace ?? "";
+        message.Data = object.Data?.map((e) => EventTypeDetailsResponse.fromPartial(e)) || [];
         return message;
     },
 };
@@ -946,55 +1503,148 @@ const RegisterSingleEventTypeRequest = {
         return message;
     },
 };
+function createBaseValidationResult() {
+    return { Severity: 0, Message: "", Members: [] };
+}
+const ValidationResult = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Severity !== 0) {
+            writer.uint32(8).int32(message.Severity);
+        }
+        if (message.Message !== "") {
+            writer.uint32(18).string(message.Message);
+        }
+        for (const v of message.Members) {
+            writer.uint32(26).string(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseValidationResult();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 8) {
+                            break;
+                        }
+                        message.Severity = reader.int32();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 18) {
+                            break;
+                        }
+                        message.Message = reader.string();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.Members.push(reader.string());
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            Severity: isSet(object.Severity) ? validationResultSeverityFromJSON(object.Severity) : 0,
+            Message: isSet(object.Message) ? globalThis.String(object.Message) : "",
+            Members: globalThis.Array.isArray(object?.Members) ? object.Members.map((e) => globalThis.String(e)) : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Severity !== 0) {
+            obj.Severity = validationResultSeverityToJSON(message.Severity);
+        }
+        if (message.Message !== "") {
+            obj.Message = message.Message;
+        }
+        if (message.Members?.length) {
+            obj.Members = message.Members;
+        }
+        return obj;
+    },
+    create(base) {
+        return ValidationResult.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseValidationResult();
+        message.Severity = object.Severity ?? 0;
+        message.Message = object.Message ?? "";
+        message.Members = object.Members?.map((e) => e) || [];
+        return message;
+    },
+};
 const EventTypesDefinition = {
     name: "EventTypes",
-    fullName: "Cratis.Chronicle.Contracts.Events.EventTypes",
+    fullName: "Cratis.Chronicle.Contracts.EventTypes.EventTypes",
     methods: {
-        getAll: {
-            name: "GetAll",
-            requestType: GetAllEventTypesRequest,
+        allEventTypeGenerations: {
+            name: "AllEventTypeGenerations",
+            requestType: AllEventTypeGenerationsRequest,
             requestStream: false,
-            responseType: IEnumerableEventType,
+            responseType: QueryResultIEnumerableEventTypeDetailsResponse,
             responseStream: false,
             options: {},
         },
-        getAllGenerationsForEventType: {
-            name: "GetAllGenerationsForEventType",
-            requestType: GetEventTypeGenerationsRequest,
+        allEventTypes: {
+            name: "AllEventTypes",
+            requestType: AllEventTypesRequest,
             requestStream: false,
-            responseType: IEnumerableEventTypeRegistration,
+            responseType: QueryResultIEnumerableEventTypeDetailsResponse,
             responseStream: false,
             options: {},
         },
-        getAllRegistrations: {
-            name: "GetAllRegistrations",
-            requestType: GetAllEventTypesRequest,
+        createEventType: {
+            name: "CreateEventType",
+            requestType: CreateEventTypeRequest,
             requestStream: false,
-            responseType: IEnumerableEventTypeRegistration,
+            responseType: CommandResult,
             responseStream: false,
             options: {},
         },
-        observeAllRegistrations: {
-            name: "ObserveAllRegistrations",
-            requestType: GetAllEventTypesRequest,
+        observeEventTypes: {
+            name: "ObserveEventTypes",
+            requestType: ObserveEventTypesRequest,
             requestStream: false,
-            responseType: IEnumerableEventTypeRegistration,
+            responseType: QueryResultIEnumerableEventTypeDetailsResponse,
             responseStream: true,
             options: {},
         },
-        register: {
-            name: "Register",
+        registerEventTypes: {
+            name: "RegisterEventTypes",
             requestType: RegisterEventTypesRequest,
             requestStream: false,
-            responseType: empty.Empty,
+            responseType: CommandResult,
             responseStream: false,
             options: {},
         },
-        registerSingle: {
-            name: "RegisterSingle",
+        registerSingleEventType: {
+            name: "RegisterSingleEventType",
             requestType: RegisterSingleEventTypeRequest,
             requestStream: false,
-            responseType: empty.Empty,
+            responseType: CommandResult,
             responseStream: false,
             options: {},
         },
@@ -1004,16 +1654,26 @@ function isSet(value) {
     return value !== null && value !== undefined;
 }
 
+exports.AllEventTypeGenerationsRequest = AllEventTypeGenerationsRequest;
+exports.AllEventTypesRequest = AllEventTypesRequest;
+exports.CommandResult = CommandResult;
+exports.CreateEventTypeRequest = CreateEventTypeRequest;
 exports.EventType = EventType;
+exports.EventTypeDetailsResponse = EventTypeDetailsResponse;
 exports.EventTypeGenerationDefinition = EventTypeGenerationDefinition;
 exports.EventTypeMigrationDefinition = EventTypeMigrationDefinition;
 exports.EventTypeMigrationOperation = EventTypeMigrationOperation;
 exports.EventTypeRegistration = EventTypeRegistration;
 exports.EventTypesDefinition = EventTypesDefinition;
-exports.GetAllEventTypesRequest = GetAllEventTypesRequest;
-exports.GetEventTypeGenerationsRequest = GetEventTypeGenerationsRequest;
-exports.IEnumerableEventType = IEnumerableEventType;
-exports.IEnumerableEventTypeRegistration = IEnumerableEventTypeRegistration;
+exports.ObserveEventTypesRequest = ObserveEventTypesRequest;
+exports.QueryResultIEnumerableEventTypeDetailsResponse = QueryResultIEnumerableEventTypeDetailsResponse;
 exports.RegisterEventTypesRequest = RegisterEventTypesRequest;
 exports.RegisterSingleEventTypeRequest = RegisterSingleEventTypeRequest;
-//# sourceMappingURL=events.js.map
+exports.ValidationResult = ValidationResult;
+exports.eventTypeOwnerFromJSON = eventTypeOwnerFromJSON;
+exports.eventTypeOwnerToJSON = eventTypeOwnerToJSON;
+exports.eventTypeSourceFromJSON = eventTypeSourceFromJSON;
+exports.eventTypeSourceToJSON = eventTypeSourceToJSON;
+exports.validationResultSeverityFromJSON = validationResultSeverityFromJSON;
+exports.validationResultSeverityToJSON = validationResultSeverityToJSON;
+//# sourceMappingURL=eventtypes.js.map