@cratis/chronicle.contracts 17.0.0 → 17.0.1

package/generated/{events.ts → eventtypes.ts}

@@ -2,14 +2,164 @@
 // versions:
 //   protoc-gen-ts_proto  v2.12.1
 //   protoc               v5.28.3
-// source: events.proto
+// source: eventtypes.proto
 
 /* eslint-disable */
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
 import type { CallContext, CallOptions } from "nice-grpc-common";
-import { Empty } from "./google/protobuf/empty";
+import { Guid } from "./protobuf-net/bcl";
 
-export const protobufPackage = "Cratis.Chronicle.Contracts.Events";
+export const protobufPackage = "Cratis.Chronicle.Contracts.EventTypes";
+
+export enum EventTypeOwner {
+  None = 0,
+  Client = 1,
+  Server = 2,
+  UNRECOGNIZED = -1,
+}
+
+export function eventTypeOwnerFromJSON(object: any): EventTypeOwner {
+  switch (object) {
+    case 0:
+    case "None":
+      return EventTypeOwner.None;
+    case 1:
+    case "Client":
+      return EventTypeOwner.Client;
+    case 2:
+    case "Server":
+      return EventTypeOwner.Server;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return EventTypeOwner.UNRECOGNIZED;
+  }
+}
+
+export function eventTypeOwnerToJSON(object: EventTypeOwner): string {
+  switch (object) {
+    case EventTypeOwner.None:
+      return "None";
+    case EventTypeOwner.Client:
+      return "Client";
+    case EventTypeOwner.Server:
+      return "Server";
+    case EventTypeOwner.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+export enum EventTypeSource {
+  EVENT_TYPE_SOURCE_Unknown = 0,
+  Code = 1,
+  User = 2,
+  UNRECOGNIZED = -1,
+}
+
+export function eventTypeSourceFromJSON(object: any): EventTypeSource {
+  switch (object) {
+    case 0:
+    case "EVENT_TYPE_SOURCE_Unknown":
+      return EventTypeSource.EVENT_TYPE_SOURCE_Unknown;
+    case 1:
+    case "Code":
+      return EventTypeSource.Code;
+    case 2:
+    case "User":
+      return EventTypeSource.User;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return EventTypeSource.UNRECOGNIZED;
+  }
+}
+
+export function eventTypeSourceToJSON(object: EventTypeSource): string {
+  switch (object) {
+    case EventTypeSource.EVENT_TYPE_SOURCE_Unknown:
+      return "EVENT_TYPE_SOURCE_Unknown";
+    case EventTypeSource.Code:
+      return "Code";
+    case EventTypeSource.User:
+      return "User";
+    case EventTypeSource.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+export enum ValidationResultSeverity {
+  VALIDATION_RESULT_SEVERITY_Unknown = 0,
+  Information = 1,
+  Warning = 2,
+  Error = 3,
+  UNRECOGNIZED = -1,
+}
+
+export function validationResultSeverityFromJSON(object: any): ValidationResultSeverity {
+  switch (object) {
+    case 0:
+    case "VALIDATION_RESULT_SEVERITY_Unknown":
+      return ValidationResultSeverity.VALIDATION_RESULT_SEVERITY_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: ValidationResultSeverity): string {
+  switch (object) {
+    case ValidationResultSeverity.VALIDATION_RESULT_SEVERITY_Unknown:
+      return "VALIDATION_RESULT_SEVERITY_Unknown";
+    case ValidationResultSeverity.Information:
+      return "Information";
+    case ValidationResultSeverity.Warning:
+      return "Warning";
+    case ValidationResultSeverity.Error:
+      return "Error";
+    case ValidationResultSeverity.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+export interface AllEventTypeGenerationsRequest {
+  EventStore: string;
+  EventTypeId: string;
+}
+
+export interface AllEventTypesRequest {
+  EventStore: string;
+}
+
+export interface CommandResult {
+  /** default value could not be applied: 00000000-0000-0000-0000-000000000000 */
+  CorrelationId:
+    | Guid
+    | undefined;
+  /** default value could not be applied: True */
+  IsAuthorized: boolean;
+  ValidationResults: ValidationResult[];
+  ExceptionMessages: string[];
+  ExceptionStackTrace: string;
+  AuthorizationFailureReason: string;
+}
+
+export interface CreateEventTypeRequest {
+  EventStore: string;
+  Name: string;
+}
 
 export interface EventType {
   Id: string;
@@ -17,6 +167,14 @@ export interface EventType {
   Tombstone: boolean;
 }
 
+export interface EventTypeDetailsResponse {
+  Type: EventType | undefined;
+  Owner: EventTypeOwner;
+  Source: EventTypeSource;
+  Schema: string;
+  Id: string;
+}
+
 export interface EventTypeGenerationDefinition {
   Generation: number;
   Schema: string;
@@ -43,21 +201,21 @@ export interface EventTypeRegistration {
   EventStore: string;
 }
 
-export interface GetAllEventTypesRequest {
-  EventStore: string;
-}
-
-export interface GetEventTypeGenerationsRequest {
+export interface ObserveEventTypesRequest {
   EventStore: string;
-  EventTypeId: string;
-}
-
-export interface IEnumerableEventType {
-  items: EventType[];
 }
 
-export interface IEnumerableEventTypeRegistration {
-  items: EventTypeRegistration[];
+export interface QueryResultIEnumerableEventTypeDetailsResponse {
+  /** default value could not be applied: 00000000-0000-0000-0000-000000000000 */
+  CorrelationId:
+    | Guid
+    | undefined;
+  /** default value could not be applied: True */
+  IsAuthorized: boolean;
+  ValidationResults: ValidationResult[];
+  ExceptionMessages: string[];
+  ExceptionStackTrace: string;
+  Data: EventTypeDetailsResponse[];
 }
 
 export interface RegisterEventTypesRequest {
@@ -71,6 +229,414 @@ export interface RegisterSingleEventTypeRequest {
   Type: EventTypeRegistration | undefined;
 }
 
+export interface ValidationResult {
+  /** default value could not be applied: Error */
+  Severity: ValidationResultSeverity;
+  Message: string;
+  Members: string[];
+}
+
+function createBaseAllEventTypeGenerationsRequest(): AllEventTypeGenerationsRequest {
+  return { EventStore: "", EventTypeId: "" };
+}
+
+export const AllEventTypeGenerationsRequest: MessageFns<AllEventTypeGenerationsRequest> = {
+  encode(message: AllEventTypeGenerationsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.EventStore !== "") {
+      writer.uint32(10).string(message.EventStore);
+    }
+    if (message.EventTypeId !== "") {
+      writer.uint32(18).string(message.EventTypeId);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): AllEventTypeGenerationsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__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 as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): AllEventTypeGenerationsRequest {
+    return {
+      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+      EventTypeId: isSet(object.EventTypeId) ? globalThis.String(object.EventTypeId) : "",
+    };
+  },
+
+  toJSON(message: AllEventTypeGenerationsRequest): unknown {
+    const obj: any = {};
+    if (message.EventStore !== "") {
+      obj.EventStore = message.EventStore;
+    }
+    if (message.EventTypeId !== "") {
+      obj.EventTypeId = message.EventTypeId;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<AllEventTypeGenerationsRequest>): AllEventTypeGenerationsRequest {
+    return AllEventTypeGenerationsRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<AllEventTypeGenerationsRequest>): AllEventTypeGenerationsRequest {
+    const message = createBaseAllEventTypeGenerationsRequest();
+    message.EventStore = object.EventStore ?? "";
+    message.EventTypeId = object.EventTypeId ?? "";
+    return message;
+  },
+};
+
+function createBaseAllEventTypesRequest(): AllEventTypesRequest {
+  return { EventStore: "" };
+}
+
+export const AllEventTypesRequest: MessageFns<AllEventTypesRequest> = {
+  encode(message: AllEventTypesRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.EventStore !== "") {
+      writer.uint32(10).string(message.EventStore);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): AllEventTypesRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__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 as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): AllEventTypesRequest {
+    return { EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "" };
+  },
+
+  toJSON(message: AllEventTypesRequest): unknown {
+    const obj: any = {};
+    if (message.EventStore !== "") {
+      obj.EventStore = message.EventStore;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<AllEventTypesRequest>): AllEventTypesRequest {
+    return AllEventTypesRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<AllEventTypesRequest>): AllEventTypesRequest {
+    const message = createBaseAllEventTypesRequest();
+    message.EventStore = object.EventStore ?? "";
+    return message;
+  },
+};
+
+function createBaseCommandResult(): CommandResult {
+  return {
+    CorrelationId: undefined,
+    IsAuthorized: false,
+    ValidationResults: [],
+    ExceptionMessages: [],
+    ExceptionStackTrace: "",
+    AuthorizationFailureReason: "",
+  };
+}
+
+export const CommandResult: MessageFns<CommandResult> = {
+  encode(message: CommandResult, writer: BinaryWriter = new BinaryWriter()): 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: BinaryReader | Uint8Array, length?: number): CommandResult {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__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 as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): CommandResult {
+    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: any) => ValidationResult.fromJSON(e))
+        : [],
+      ExceptionMessages: globalThis.Array.isArray(object?.ExceptionMessages)
+        ? object.ExceptionMessages.map((e: any) => globalThis.String(e))
+        : [],
+      ExceptionStackTrace: isSet(object.ExceptionStackTrace) ? globalThis.String(object.ExceptionStackTrace) : "",
+      AuthorizationFailureReason: isSet(object.AuthorizationFailureReason)
+        ? globalThis.String(object.AuthorizationFailureReason)
+        : "",
+    };
+  },
+
+  toJSON(message: CommandResult): unknown {
+    const obj: any = {};
+    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?: DeepPartial<CommandResult>): CommandResult {
+    return CommandResult.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<CommandResult>): CommandResult {
+    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 createBaseCreateEventTypeRequest(): CreateEventTypeRequest {
+  return { EventStore: "", Name: "" };
+}
+
+export const CreateEventTypeRequest: MessageFns<CreateEventTypeRequest> = {
+  encode(message: CreateEventTypeRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.EventStore !== "") {
+      writer.uint32(10).string(message.EventStore);
+    }
+    if (message.Name !== "") {
+      writer.uint32(18).string(message.Name);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CreateEventTypeRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__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 as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): CreateEventTypeRequest {
+    return {
+      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+      Name: isSet(object.Name) ? globalThis.String(object.Name) : "",
+    };
+  },
+
+  toJSON(message: CreateEventTypeRequest): unknown {
+    const obj: any = {};
+    if (message.EventStore !== "") {
+      obj.EventStore = message.EventStore;
+    }
+    if (message.Name !== "") {
+      obj.Name = message.Name;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<CreateEventTypeRequest>): CreateEventTypeRequest {
+    return CreateEventTypeRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<CreateEventTypeRequest>): CreateEventTypeRequest {
+    const message = createBaseCreateEventTypeRequest();
+    message.EventStore = object.EventStore ?? "";
+    message.Name = object.Name ?? "";
+    return message;
+  },
+};
+
 function createBaseEventType(): EventType {
   return { Id: "", Generation: 0, Tombstone: false };
 }
@@ -83,13 +649,120 @@ export const EventType: MessageFns<EventType> = {
     if (message.Generation !== 0) {
       writer.uint32(16).uint32(message.Generation);
     }
-    if (message.Tombstone !== false) {
-      writer.uint32(24).bool(message.Tombstone);
+    if (message.Tombstone !== false) {
+      writer.uint32(24).bool(message.Tombstone);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): EventType {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__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 as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): EventType {
+    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: EventType): unknown {
+    const obj: any = {};
+    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?: DeepPartial<EventType>): EventType {
+    return EventType.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<EventType>): EventType {
+    const message = createBaseEventType();
+    message.Id = object.Id ?? "";
+    message.Generation = object.Generation ?? 0;
+    message.Tombstone = object.Tombstone ?? false;
+    return message;
+  },
+};
+
+function createBaseEventTypeDetailsResponse(): EventTypeDetailsResponse {
+  return { Type: undefined, Owner: 0, Source: 0, Schema: "", Id: "" };
+}
+
+export const EventTypeDetailsResponse: MessageFns<EventTypeDetailsResponse> = {
+  encode(message: EventTypeDetailsResponse, writer: BinaryWriter = new BinaryWriter()): 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.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;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): EventType {
+  decode(input: BinaryReader | Uint8Array, length?: number): EventTypeDetailsResponse {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -98,7 +771,7 @@ export const EventType: MessageFns<EventType> = {
     (reader as any).__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) {
@@ -107,7 +780,7 @@ export const EventType: MessageFns<EventType> = {
               break;
             }
 
-            message.Id = reader.string();
+            message.Type = EventType.decode(reader, reader.uint32());
             continue;
           }
           case 2: {
@@ -115,7 +788,7 @@ export const EventType: MessageFns<EventType> = {
               break;
             }
 
-            message.Generation = reader.uint32();
+            message.Owner = reader.int32() as any;
             continue;
           }
           case 3: {
@@ -123,7 +796,23 @@ export const EventType: MessageFns<EventType> = {
               break;
             }
 
-            message.Tombstone = reader.bool();
+            message.Source = reader.int32() as any;
+            continue;
+          }
+          case 4: {
+            if (tag !== 34) {
+              break;
+            }
+
+            message.Schema = reader.string();
+            continue;
+          }
+          case 5: {
+            if (tag !== 42) {
+              break;
+            }
+
+            message.Id = reader.string();
             continue;
           }
         }
@@ -138,36 +827,46 @@ export const EventType: MessageFns<EventType> = {
     }
   },
 
-  fromJSON(object: any): EventType {
+  fromJSON(object: any): EventTypeDetailsResponse {
     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: EventType): unknown {
+  toJSON(message: EventTypeDetailsResponse): unknown {
     const obj: any = {};
-    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?: DeepPartial<EventType>): EventType {
-    return EventType.fromPartial(base ?? {});
+  create(base?: DeepPartial<EventTypeDetailsResponse>): EventTypeDetailsResponse {
+    return EventTypeDetailsResponse.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<EventType>): EventType {
-    const message = createBaseEventType();
+  fromPartial(object: DeepPartial<EventTypeDetailsResponse>): EventTypeDetailsResponse {
+    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;
   },
 };
@@ -614,19 +1313,19 @@ export const EventTypeRegistration: MessageFns<EventTypeRegistration> = {
   },
 };
 
-function createBaseGetAllEventTypesRequest(): GetAllEventTypesRequest {
+function createBaseObserveEventTypesRequest(): ObserveEventTypesRequest {
   return { EventStore: "" };
 }
 
-export const GetAllEventTypesRequest: MessageFns<GetAllEventTypesRequest> = {
-  encode(message: GetAllEventTypesRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const ObserveEventTypesRequest: MessageFns<ObserveEventTypesRequest> = {
+  encode(message: ObserveEventTypesRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.EventStore !== "") {
       writer.uint32(10).string(message.EventStore);
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): GetAllEventTypesRequest {
+  decode(input: BinaryReader | Uint8Array, length?: number): ObserveEventTypesRequest {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -635,7 +1334,7 @@ export const GetAllEventTypesRequest: MessageFns<GetAllEventTypesRequest> = {
     (reader as any).__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) {
@@ -659,11 +1358,11 @@ export const GetAllEventTypesRequest: MessageFns<GetAllEventTypesRequest> = {
     }
   },
 
-  fromJSON(object: any): GetAllEventTypesRequest {
+  fromJSON(object: any): ObserveEventTypesRequest {
     return { EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "" };
   },
 
-  toJSON(message: GetAllEventTypesRequest): unknown {
+  toJSON(message: ObserveEventTypesRequest): unknown {
     const obj: any = {};
     if (message.EventStore !== "") {
       obj.EventStore = message.EventStore;
@@ -671,32 +1370,56 @@ export const GetAllEventTypesRequest: MessageFns<GetAllEventTypesRequest> = {
     return obj;
   },
 
-  create(base?: DeepPartial<GetAllEventTypesRequest>): GetAllEventTypesRequest {
-    return GetAllEventTypesRequest.fromPartial(base ?? {});
+  create(base?: DeepPartial<ObserveEventTypesRequest>): ObserveEventTypesRequest {
+    return ObserveEventTypesRequest.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<GetAllEventTypesRequest>): GetAllEventTypesRequest {
-    const message = createBaseGetAllEventTypesRequest();
+  fromPartial(object: DeepPartial<ObserveEventTypesRequest>): ObserveEventTypesRequest {
+    const message = createBaseObserveEventTypesRequest();
     message.EventStore = object.EventStore ?? "";
     return message;
   },
 };
 
-function createBaseGetEventTypeGenerationsRequest(): GetEventTypeGenerationsRequest {
-  return { EventStore: "", EventTypeId: "" };
+function createBaseQueryResultIEnumerableEventTypeDetailsResponse(): QueryResultIEnumerableEventTypeDetailsResponse {
+  return {
+    CorrelationId: undefined,
+    IsAuthorized: false,
+    ValidationResults: [],
+    ExceptionMessages: [],
+    ExceptionStackTrace: "",
+    Data: [],
+  };
 }
 
-export const GetEventTypeGenerationsRequest: MessageFns<GetEventTypeGenerationsRequest> = {
-  encode(message: GetEventTypeGenerationsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.EventStore !== "") {
-      writer.uint32(10).string(message.EventStore);
+export const QueryResultIEnumerableEventTypeDetailsResponse: MessageFns<
+  QueryResultIEnumerableEventTypeDetailsResponse
+> = {
+  encode(
+    message: QueryResultIEnumerableEventTypeDetailsResponse,
+    writer: BinaryWriter = new BinaryWriter(),
+  ): BinaryWriter {
+    if (message.CorrelationId !== undefined) {
+      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;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): GetEventTypeGenerationsRequest {
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryResultIEnumerableEventTypeDetailsResponse {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -705,7 +1428,7 @@ export const GetEventTypeGenerationsRequest: MessageFns<GetEventTypeGenerationsR
     (reader as any).__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) {
@@ -714,158 +1437,47 @@ export const GetEventTypeGenerationsRequest: MessageFns<GetEventTypeGenerationsR
               break;
             }
 
-            message.EventStore = reader.string();
+            message.CorrelationId = 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 as any).__tsProtoDecodeDepth = previousRecursionDepth;
-    }
-  },
-
-  fromJSON(object: any): GetEventTypeGenerationsRequest {
-    return {
-      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
-      EventTypeId: isSet(object.EventTypeId) ? globalThis.String(object.EventTypeId) : "",
-    };
-  },
-
-  toJSON(message: GetEventTypeGenerationsRequest): unknown {
-    const obj: any = {};
-    if (message.EventStore !== "") {
-      obj.EventStore = message.EventStore;
-    }
-    if (message.EventTypeId !== "") {
-      obj.EventTypeId = message.EventTypeId;
-    }
-    return obj;
-  },
-
-  create(base?: DeepPartial<GetEventTypeGenerationsRequest>): GetEventTypeGenerationsRequest {
-    return GetEventTypeGenerationsRequest.fromPartial(base ?? {});
-  },
-  fromPartial(object: DeepPartial<GetEventTypeGenerationsRequest>): GetEventTypeGenerationsRequest {
-    const message = createBaseGetEventTypeGenerationsRequest();
-    message.EventStore = object.EventStore ?? "";
-    message.EventTypeId = object.EventTypeId ?? "";
-    return message;
-  },
-};
-
-function createBaseIEnumerableEventType(): IEnumerableEventType {
-  return { items: [] };
-}
-
-export const IEnumerableEventType: MessageFns<IEnumerableEventType> = {
-  encode(message: IEnumerableEventType, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    for (const v of message.items) {
-      EventType.encode(v!, writer.uint32(10).fork()).join();
-    }
-    return writer;
-  },
-
-  decode(input: BinaryReader | Uint8Array, length?: number): IEnumerableEventType {
-    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
-    if (previousRecursionDepth >= 100) {
-      throw new globalThis.Error("protobuf decode recursion limit exceeded");
-    }
-    (reader as any).__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 as any).__tsProtoDecodeDepth = previousRecursionDepth;
-    }
-  },
-
-  fromJSON(object: any): IEnumerableEventType {
-    return {
-      items: globalThis.Array.isArray(object?.items) ? object.items.map((e: any) => EventType.fromJSON(e)) : [],
-    };
-  },
-
-  toJSON(message: IEnumerableEventType): unknown {
-    const obj: any = {};
-    if (message.items?.length) {
-      obj.items = message.items.map((e) => EventType.toJSON(e));
-    }
-    return obj;
-  },
-
-  create(base?: DeepPartial<IEnumerableEventType>): IEnumerableEventType {
-    return IEnumerableEventType.fromPartial(base ?? {});
-  },
-  fromPartial(object: DeepPartial<IEnumerableEventType>): IEnumerableEventType {
-    const message = createBaseIEnumerableEventType();
-    message.items = object.items?.map((e) => EventType.fromPartial(e)) || [];
-    return message;
-  },
-};
-
-function createBaseIEnumerableEventTypeRegistration(): IEnumerableEventTypeRegistration {
-  return { items: [] };
-}
+          case 4: {
+            if (tag !== 34) {
+              break;
+            }
 
-export const IEnumerableEventTypeRegistration: MessageFns<IEnumerableEventTypeRegistration> = {
-  encode(message: IEnumerableEventTypeRegistration, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    for (const v of message.items) {
-      EventTypeRegistration.encode(v!, writer.uint32(10).fork()).join();
-    }
-    return writer;
-  },
+            message.ExceptionMessages.push(reader.string());
+            continue;
+          }
+          case 5: {
+            if (tag !== 42) {
+              break;
+            }
 
-  decode(input: BinaryReader | Uint8Array, length?: number): IEnumerableEventTypeRegistration {
-    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
-    if (previousRecursionDepth >= 100) {
-      throw new globalThis.Error("protobuf decode recursion limit exceeded");
-    }
-    (reader as any).__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) {
+            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;
           }
         }
@@ -880,28 +1492,63 @@ export const IEnumerableEventTypeRegistration: MessageFns<IEnumerableEventTypeRe
     }
   },
 
-  fromJSON(object: any): IEnumerableEventTypeRegistration {
+  fromJSON(object: any): QueryResultIEnumerableEventTypeDetailsResponse {
     return {
-      items: globalThis.Array.isArray(object?.items)
-        ? object.items.map((e: any) => EventTypeRegistration.fromJSON(e))
+      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: any) => ValidationResult.fromJSON(e))
+        : [],
+      ExceptionMessages: globalThis.Array.isArray(object?.ExceptionMessages)
+        ? object.ExceptionMessages.map((e: any) => globalThis.String(e))
+        : [],
+      ExceptionStackTrace: isSet(object.ExceptionStackTrace) ? globalThis.String(object.ExceptionStackTrace) : "",
+      Data: globalThis.Array.isArray(object?.Data)
+        ? object.Data.map((e: any) => EventTypeDetailsResponse.fromJSON(e))
         : [],
     };
   },
 
-  toJSON(message: IEnumerableEventTypeRegistration): unknown {
+  toJSON(message: QueryResultIEnumerableEventTypeDetailsResponse): unknown {
     const obj: any = {};
-    if (message.items?.length) {
-      obj.items = message.items.map((e) => EventTypeRegistration.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) => EventTypeDetailsResponse.toJSON(e));
     }
     return obj;
   },
 
-  create(base?: DeepPartial<IEnumerableEventTypeRegistration>): IEnumerableEventTypeRegistration {
-    return IEnumerableEventTypeRegistration.fromPartial(base ?? {});
+  create(
+    base?: DeepPartial<QueryResultIEnumerableEventTypeDetailsResponse>,
+  ): QueryResultIEnumerableEventTypeDetailsResponse {
+    return QueryResultIEnumerableEventTypeDetailsResponse.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<IEnumerableEventTypeRegistration>): IEnumerableEventTypeRegistration {
-    const message = createBaseIEnumerableEventTypeRegistration();
-    message.items = object.items?.map((e) => EventTypeRegistration.fromPartial(e)) || [];
+  fromPartial(
+    object: DeepPartial<QueryResultIEnumerableEventTypeDetailsResponse>,
+  ): QueryResultIEnumerableEventTypeDetailsResponse {
+    const message = createBaseQueryResultIEnumerableEventTypeDetailsResponse();
+    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) => EventTypeDetailsResponse.fromPartial(e)) || [];
     return message;
   },
 };
@@ -1096,56 +1743,160 @@ export const RegisterSingleEventTypeRequest: MessageFns<RegisterSingleEventTypeR
   },
 };
 
+function createBaseValidationResult(): ValidationResult {
+  return { Severity: 0, Message: "", Members: [] };
+}
+
+export const ValidationResult: MessageFns<ValidationResult> = {
+  encode(message: ValidationResult, writer: BinaryWriter = new BinaryWriter()): 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: BinaryReader | Uint8Array, length?: number): ValidationResult {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__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() as any;
+            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 as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): ValidationResult {
+    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: any) => globalThis.String(e)) : [],
+    };
+  },
+
+  toJSON(message: ValidationResult): unknown {
+    const obj: any = {};
+    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?: DeepPartial<ValidationResult>): ValidationResult {
+    return ValidationResult.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ValidationResult>): ValidationResult {
+    const message = createBaseValidationResult();
+    message.Severity = object.Severity ?? 0;
+    message.Message = object.Message ?? "";
+    message.Members = object.Members?.map((e) => e) || [];
+    return message;
+  },
+};
+
 export type EventTypesDefinition = typeof EventTypesDefinition;
 export const EventTypesDefinition = {
   name: "EventTypes",
-  fullName: "Cratis.Chronicle.Contracts.Events.EventTypes",
+  fullName: "Cratis.Chronicle.Contracts.EventTypes.EventTypes",
   methods: {
-    getAll: {
-      name: "GetAll",
-      requestType: GetAllEventTypesRequest as typeof GetAllEventTypesRequest,
+    allEventTypeGenerations: {
+      name: "AllEventTypeGenerations",
+      requestType: AllEventTypeGenerationsRequest as typeof AllEventTypeGenerationsRequest,
       requestStream: false,
-      responseType: IEnumerableEventType as typeof IEnumerableEventType,
+      responseType:
+        QueryResultIEnumerableEventTypeDetailsResponse as typeof QueryResultIEnumerableEventTypeDetailsResponse,
       responseStream: false,
       options: {},
     },
-    getAllGenerationsForEventType: {
-      name: "GetAllGenerationsForEventType",
-      requestType: GetEventTypeGenerationsRequest as typeof GetEventTypeGenerationsRequest,
+    allEventTypes: {
+      name: "AllEventTypes",
+      requestType: AllEventTypesRequest as typeof AllEventTypesRequest,
       requestStream: false,
-      responseType: IEnumerableEventTypeRegistration as typeof IEnumerableEventTypeRegistration,
+      responseType:
+        QueryResultIEnumerableEventTypeDetailsResponse as typeof QueryResultIEnumerableEventTypeDetailsResponse,
       responseStream: false,
       options: {},
     },
-    getAllRegistrations: {
-      name: "GetAllRegistrations",
-      requestType: GetAllEventTypesRequest as typeof GetAllEventTypesRequest,
+    createEventType: {
+      name: "CreateEventType",
+      requestType: CreateEventTypeRequest as typeof CreateEventTypeRequest,
       requestStream: false,
-      responseType: IEnumerableEventTypeRegistration as typeof IEnumerableEventTypeRegistration,
+      responseType: CommandResult as typeof CommandResult,
       responseStream: false,
       options: {},
     },
-    observeAllRegistrations: {
-      name: "ObserveAllRegistrations",
-      requestType: GetAllEventTypesRequest as typeof GetAllEventTypesRequest,
+    observeEventTypes: {
+      name: "ObserveEventTypes",
+      requestType: ObserveEventTypesRequest as typeof ObserveEventTypesRequest,
       requestStream: false,
-      responseType: IEnumerableEventTypeRegistration as typeof IEnumerableEventTypeRegistration,
+      responseType:
+        QueryResultIEnumerableEventTypeDetailsResponse as typeof QueryResultIEnumerableEventTypeDetailsResponse,
       responseStream: true,
       options: {},
     },
-    register: {
-      name: "Register",
+    registerEventTypes: {
+      name: "RegisterEventTypes",
       requestType: RegisterEventTypesRequest as typeof RegisterEventTypesRequest,
       requestStream: false,
-      responseType: Empty as typeof Empty,
+      responseType: CommandResult as typeof CommandResult,
       responseStream: false,
       options: {},
     },
-    registerSingle: {
-      name: "RegisterSingle",
+    registerSingleEventType: {
+      name: "RegisterSingleEventType",
       requestType: RegisterSingleEventTypeRequest as typeof RegisterSingleEventTypeRequest,
       requestStream: false,
-      responseType: Empty as typeof Empty,
+      responseType: CommandResult as typeof CommandResult,
       responseStream: false,
       options: {},
     },
@@ -1153,51 +1904,57 @@ export const EventTypesDefinition = {
 } as const;
 
 export interface EventTypesServiceImplementation<CallContextExt = {}> {
-  getAll(
-    request: GetAllEventTypesRequest,
+  allEventTypeGenerations(
+    request: AllEventTypeGenerationsRequest,
     context: CallContext & CallContextExt,
-  ): Promise<DeepPartial<IEnumerableEventType>>;
-  getAllGenerationsForEventType(
-    request: GetEventTypeGenerationsRequest,
+  ): Promise<DeepPartial<QueryResultIEnumerableEventTypeDetailsResponse>>;
+  allEventTypes(
+    request: AllEventTypesRequest,
     context: CallContext & CallContextExt,
-  ): Promise<DeepPartial<IEnumerableEventTypeRegistration>>;
-  getAllRegistrations(
-    request: GetAllEventTypesRequest,
+  ): Promise<DeepPartial<QueryResultIEnumerableEventTypeDetailsResponse>>;
+  createEventType(
+    request: CreateEventTypeRequest,
     context: CallContext & CallContextExt,
-  ): Promise<DeepPartial<IEnumerableEventTypeRegistration>>;
-  observeAllRegistrations(
-    request: GetAllEventTypesRequest,
+  ): Promise<DeepPartial<CommandResult>>;
+  observeEventTypes(
+    request: ObserveEventTypesRequest,
     context: CallContext & CallContextExt,
-  ): ServerStreamingMethodResult<DeepPartial<IEnumerableEventTypeRegistration>>;
-  register(request: RegisterEventTypesRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Empty>>;
-  registerSingle(
+  ): ServerStreamingMethodResult<DeepPartial<QueryResultIEnumerableEventTypeDetailsResponse>>;
+  registerEventTypes(
+    request: RegisterEventTypesRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<CommandResult>>;
+  registerSingleEventType(
     request: RegisterSingleEventTypeRequest,
     context: CallContext & CallContextExt,
-  ): Promise<DeepPartial<Empty>>;
+  ): Promise<DeepPartial<CommandResult>>;
 }
 
 export interface EventTypesClient<CallOptionsExt = {}> {
-  getAll(
-    request: DeepPartial<GetAllEventTypesRequest>,
+  allEventTypeGenerations(
+    request: DeepPartial<AllEventTypeGenerationsRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<QueryResultIEnumerableEventTypeDetailsResponse>;
+  allEventTypes(
+    request: DeepPartial<AllEventTypesRequest>,
     options?: CallOptions & CallOptionsExt,
-  ): Promise<IEnumerableEventType>;
-  getAllGenerationsForEventType(
-    request: DeepPartial<GetEventTypeGenerationsRequest>,
+  ): Promise<QueryResultIEnumerableEventTypeDetailsResponse>;
+  createEventType(
+    request: DeepPartial<CreateEventTypeRequest>,
     options?: CallOptions & CallOptionsExt,
-  ): Promise<IEnumerableEventTypeRegistration>;
-  getAllRegistrations(
-    request: DeepPartial<GetAllEventTypesRequest>,
+  ): Promise<CommandResult>;
+  observeEventTypes(
+    request: DeepPartial<ObserveEventTypesRequest>,
     options?: CallOptions & CallOptionsExt,
-  ): Promise<IEnumerableEventTypeRegistration>;
-  observeAllRegistrations(
-    request: DeepPartial<GetAllEventTypesRequest>,
+  ): AsyncIterable<QueryResultIEnumerableEventTypeDetailsResponse>;
+  registerEventTypes(
+    request: DeepPartial<RegisterEventTypesRequest>,
     options?: CallOptions & CallOptionsExt,
-  ): AsyncIterable<IEnumerableEventTypeRegistration>;
-  register(request: DeepPartial<RegisterEventTypesRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
-  registerSingle(
+  ): Promise<CommandResult>;
+  registerSingleEventType(
     request: DeepPartial<RegisterSingleEventTypeRequest>,
     options?: CallOptions & CallOptionsExt,
-  ): Promise<Empty>;
+  ): Promise<CommandResult>;
 }
 
 type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;