@cratis/chronicle.contracts 0.0.0

package/generated/events.ts

@@ -0,0 +1,1191 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.6
+//   protoc               v7.34.1
+// source: events.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import {
+  type CallOptions,
+  type ChannelCredentials,
+  Client,
+  type ClientOptions,
+  type ClientReadableStream,
+  type ClientUnaryCall,
+  type handleServerStreamingCall,
+  type handleUnaryCall,
+  makeGenericClientConstructor,
+  type Metadata,
+  type ServiceError,
+  type UntypedServiceImplementation,
+} from "@grpc/grpc-js";
+import { Empty } from "./google/protobuf/empty";
+
+export const protobufPackage = "Cratis.Chronicle.Contracts.Events";
+
+export interface EventType {
+  Id: string;
+  Generation: number;
+  Tombstone: boolean;
+}
+
+export interface EventTypeGenerationDefinition {
+  Generation: number;
+  Schema: string;
+}
+
+export interface EventTypeMigrationDefinition {
+  FromGeneration: number;
+  ToGeneration: number;
+  Operations: EventTypeMigrationOperation[];
+  UpcastJmesPath: string;
+  DowncastJmesPath: string;
+}
+
+export interface EventTypeMigrationOperation {
+  Operation: string;
+  Details: string;
+}
+
+export interface EventTypeRegistration {
+  Type: EventType | undefined;
+  Schema: string;
+  Generations: EventTypeGenerationDefinition[];
+  Migrations: EventTypeMigrationDefinition[];
+}
+
+export interface GetAllEventTypesRequest {
+  EventStore: string;
+}
+
+export interface GetEventTypeGenerationsRequest {
+  EventStore: string;
+  EventTypeId: string;
+}
+
+export interface IEnumerableEventType {
+  items: EventType[];
+}
+
+export interface IEnumerableEventTypeRegistration {
+  items: EventTypeRegistration[];
+}
+
+export interface RegisterEventTypesRequest {
+  EventStore: string;
+  Types: EventTypeRegistration[];
+  DisableValidation: boolean;
+}
+
+export interface RegisterSingleEventTypeRequest {
+  EventStore: string;
+  Type: EventTypeRegistration | undefined;
+}
+
+function createBaseEventType(): EventType {
+  return { Id: "", Generation: 0, Tombstone: false };
+}
+
+export const EventType: MessageFns<EventType> = {
+  encode(message: EventType, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.Id !== "") {
+      writer.uint32(10).string(message.Id);
+    }
+    if (message.Generation !== 0) {
+      writer.uint32(16).uint32(message.Generation);
+    }
+    if (message.Tombstone !== false) {
+      writer.uint32(24).bool(message.Tombstone);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): EventType {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEventType();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.Id = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.Generation = reader.uint32();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.Tombstone = reader.bool();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: 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 createBaseEventTypeGenerationDefinition(): EventTypeGenerationDefinition {
+  return { Generation: 0, Schema: "" };
+}
+
+export const EventTypeGenerationDefinition: MessageFns<EventTypeGenerationDefinition> = {
+  encode(message: EventTypeGenerationDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.Generation !== 0) {
+      writer.uint32(8).uint32(message.Generation);
+    }
+    if (message.Schema !== "") {
+      writer.uint32(18).string(message.Schema);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): EventTypeGenerationDefinition {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEventTypeGenerationDefinition();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.Generation = reader.uint32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.Schema = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): EventTypeGenerationDefinition {
+    return {
+      Generation: isSet(object.Generation) ? globalThis.Number(object.Generation) : 0,
+      Schema: isSet(object.Schema) ? globalThis.String(object.Schema) : "",
+    };
+  },
+
+  toJSON(message: EventTypeGenerationDefinition): unknown {
+    const obj: any = {};
+    if (message.Generation !== 0) {
+      obj.Generation = Math.round(message.Generation);
+    }
+    if (message.Schema !== "") {
+      obj.Schema = message.Schema;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<EventTypeGenerationDefinition>): EventTypeGenerationDefinition {
+    return EventTypeGenerationDefinition.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<EventTypeGenerationDefinition>): EventTypeGenerationDefinition {
+    const message = createBaseEventTypeGenerationDefinition();
+    message.Generation = object.Generation ?? 0;
+    message.Schema = object.Schema ?? "";
+    return message;
+  },
+};
+
+function createBaseEventTypeMigrationDefinition(): EventTypeMigrationDefinition {
+  return { FromGeneration: 0, ToGeneration: 0, Operations: [], UpcastJmesPath: "", DowncastJmesPath: "" };
+}
+
+export const EventTypeMigrationDefinition: MessageFns<EventTypeMigrationDefinition> = {
+  encode(message: EventTypeMigrationDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.FromGeneration !== 0) {
+      writer.uint32(8).uint32(message.FromGeneration);
+    }
+    if (message.ToGeneration !== 0) {
+      writer.uint32(16).uint32(message.ToGeneration);
+    }
+    for (const v of message.Operations) {
+      EventTypeMigrationOperation.encode(v!, writer.uint32(26).fork()).join();
+    }
+    if (message.UpcastJmesPath !== "") {
+      writer.uint32(34).string(message.UpcastJmesPath);
+    }
+    if (message.DowncastJmesPath !== "") {
+      writer.uint32(42).string(message.DowncastJmesPath);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): EventTypeMigrationDefinition {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEventTypeMigrationDefinition();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.FromGeneration = reader.uint32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.ToGeneration = reader.uint32();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.Operations.push(EventTypeMigrationOperation.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.UpcastJmesPath = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.DowncastJmesPath = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): EventTypeMigrationDefinition {
+    return {
+      FromGeneration: isSet(object.FromGeneration) ? globalThis.Number(object.FromGeneration) : 0,
+      ToGeneration: isSet(object.ToGeneration) ? globalThis.Number(object.ToGeneration) : 0,
+      Operations: globalThis.Array.isArray(object?.Operations)
+        ? object.Operations.map((e: any) => EventTypeMigrationOperation.fromJSON(e))
+        : [],
+      UpcastJmesPath: isSet(object.UpcastJmesPath) ? globalThis.String(object.UpcastJmesPath) : "",
+      DowncastJmesPath: isSet(object.DowncastJmesPath) ? globalThis.String(object.DowncastJmesPath) : "",
+    };
+  },
+
+  toJSON(message: EventTypeMigrationDefinition): unknown {
+    const obj: any = {};
+    if (message.FromGeneration !== 0) {
+      obj.FromGeneration = Math.round(message.FromGeneration);
+    }
+    if (message.ToGeneration !== 0) {
+      obj.ToGeneration = Math.round(message.ToGeneration);
+    }
+    if (message.Operations?.length) {
+      obj.Operations = message.Operations.map((e) => EventTypeMigrationOperation.toJSON(e));
+    }
+    if (message.UpcastJmesPath !== "") {
+      obj.UpcastJmesPath = message.UpcastJmesPath;
+    }
+    if (message.DowncastJmesPath !== "") {
+      obj.DowncastJmesPath = message.DowncastJmesPath;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<EventTypeMigrationDefinition>): EventTypeMigrationDefinition {
+    return EventTypeMigrationDefinition.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<EventTypeMigrationDefinition>): EventTypeMigrationDefinition {
+    const message = createBaseEventTypeMigrationDefinition();
+    message.FromGeneration = object.FromGeneration ?? 0;
+    message.ToGeneration = object.ToGeneration ?? 0;
+    message.Operations = object.Operations?.map((e) => EventTypeMigrationOperation.fromPartial(e)) || [];
+    message.UpcastJmesPath = object.UpcastJmesPath ?? "";
+    message.DowncastJmesPath = object.DowncastJmesPath ?? "";
+    return message;
+  },
+};
+
+function createBaseEventTypeMigrationOperation(): EventTypeMigrationOperation {
+  return { Operation: "", Details: "" };
+}
+
+export const EventTypeMigrationOperation: MessageFns<EventTypeMigrationOperation> = {
+  encode(message: EventTypeMigrationOperation, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.Operation !== "") {
+      writer.uint32(10).string(message.Operation);
+    }
+    if (message.Details !== "") {
+      writer.uint32(18).string(message.Details);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): EventTypeMigrationOperation {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEventTypeMigrationOperation();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.Operation = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.Details = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): EventTypeMigrationOperation {
+    return {
+      Operation: isSet(object.Operation) ? globalThis.String(object.Operation) : "",
+      Details: isSet(object.Details) ? globalThis.String(object.Details) : "",
+    };
+  },
+
+  toJSON(message: EventTypeMigrationOperation): unknown {
+    const obj: any = {};
+    if (message.Operation !== "") {
+      obj.Operation = message.Operation;
+    }
+    if (message.Details !== "") {
+      obj.Details = message.Details;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<EventTypeMigrationOperation>): EventTypeMigrationOperation {
+    return EventTypeMigrationOperation.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<EventTypeMigrationOperation>): EventTypeMigrationOperation {
+    const message = createBaseEventTypeMigrationOperation();
+    message.Operation = object.Operation ?? "";
+    message.Details = object.Details ?? "";
+    return message;
+  },
+};
+
+function createBaseEventTypeRegistration(): EventTypeRegistration {
+  return { Type: undefined, Schema: "", Generations: [], Migrations: [] };
+}
+
+export const EventTypeRegistration: MessageFns<EventTypeRegistration> = {
+  encode(message: EventTypeRegistration, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.Type !== undefined) {
+      EventType.encode(message.Type, writer.uint32(10).fork()).join();
+    }
+    if (message.Schema !== "") {
+      writer.uint32(18).string(message.Schema);
+    }
+    for (const v of message.Generations) {
+      EventTypeGenerationDefinition.encode(v!, writer.uint32(26).fork()).join();
+    }
+    for (const v of message.Migrations) {
+      EventTypeMigrationDefinition.encode(v!, writer.uint32(34).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): EventTypeRegistration {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEventTypeRegistration();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.Type = EventType.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.Schema = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.Generations.push(EventTypeGenerationDefinition.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.Migrations.push(EventTypeMigrationDefinition.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): EventTypeRegistration {
+    return {
+      Type: isSet(object.Type) ? EventType.fromJSON(object.Type) : undefined,
+      Schema: isSet(object.Schema) ? globalThis.String(object.Schema) : "",
+      Generations: globalThis.Array.isArray(object?.Generations)
+        ? object.Generations.map((e: any) => EventTypeGenerationDefinition.fromJSON(e))
+        : [],
+      Migrations: globalThis.Array.isArray(object?.Migrations)
+        ? object.Migrations.map((e: any) => EventTypeMigrationDefinition.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: EventTypeRegistration): unknown {
+    const obj: any = {};
+    if (message.Type !== undefined) {
+      obj.Type = EventType.toJSON(message.Type);
+    }
+    if (message.Schema !== "") {
+      obj.Schema = message.Schema;
+    }
+    if (message.Generations?.length) {
+      obj.Generations = message.Generations.map((e) => EventTypeGenerationDefinition.toJSON(e));
+    }
+    if (message.Migrations?.length) {
+      obj.Migrations = message.Migrations.map((e) => EventTypeMigrationDefinition.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<EventTypeRegistration>): EventTypeRegistration {
+    return EventTypeRegistration.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<EventTypeRegistration>): EventTypeRegistration {
+    const message = createBaseEventTypeRegistration();
+    message.Type = (object.Type !== undefined && object.Type !== null) ? EventType.fromPartial(object.Type) : undefined;
+    message.Schema = object.Schema ?? "";
+    message.Generations = object.Generations?.map((e) => EventTypeGenerationDefinition.fromPartial(e)) || [];
+    message.Migrations = object.Migrations?.map((e) => EventTypeMigrationDefinition.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseGetAllEventTypesRequest(): GetAllEventTypesRequest {
+  return { EventStore: "" };
+}
+
+export const GetAllEventTypesRequest: MessageFns<GetAllEventTypesRequest> = {
+  encode(message: GetAllEventTypesRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.EventStore !== "") {
+      writer.uint32(10).string(message.EventStore);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetAllEventTypesRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetAllEventTypesRequest();
+    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;
+  },
+
+  fromJSON(object: any): GetAllEventTypesRequest {
+    return { EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "" };
+  },
+
+  toJSON(message: GetAllEventTypesRequest): unknown {
+    const obj: any = {};
+    if (message.EventStore !== "") {
+      obj.EventStore = message.EventStore;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetAllEventTypesRequest>): GetAllEventTypesRequest {
+    return GetAllEventTypesRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetAllEventTypesRequest>): GetAllEventTypesRequest {
+    const message = createBaseGetAllEventTypesRequest();
+    message.EventStore = object.EventStore ?? "";
+    return message;
+  },
+};
+
+function createBaseGetEventTypeGenerationsRequest(): GetEventTypeGenerationsRequest {
+  return { EventStore: "", EventTypeId: "" };
+}
+
+export const GetEventTypeGenerationsRequest: MessageFns<GetEventTypeGenerationsRequest> = {
+  encode(message: GetEventTypeGenerationsRequest, 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): GetEventTypeGenerationsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetEventTypeGenerationsRequest();
+    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;
+  },
+
+  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 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) {
+            break;
+          }
+
+          message.items.push(EventType.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  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: [] };
+}
+
+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;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): IEnumerableEventTypeRegistration {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    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) {
+            break;
+          }
+
+          message.items.push(EventTypeRegistration.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): IEnumerableEventTypeRegistration {
+    return {
+      items: globalThis.Array.isArray(object?.items)
+        ? object.items.map((e: any) => EventTypeRegistration.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: IEnumerableEventTypeRegistration): unknown {
+    const obj: any = {};
+    if (message.items?.length) {
+      obj.items = message.items.map((e) => EventTypeRegistration.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<IEnumerableEventTypeRegistration>): IEnumerableEventTypeRegistration {
+    return IEnumerableEventTypeRegistration.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<IEnumerableEventTypeRegistration>): IEnumerableEventTypeRegistration {
+    const message = createBaseIEnumerableEventTypeRegistration();
+    message.items = object.items?.map((e) => EventTypeRegistration.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseRegisterEventTypesRequest(): RegisterEventTypesRequest {
+  return { EventStore: "", Types: [], DisableValidation: false };
+}
+
+export const RegisterEventTypesRequest: MessageFns<RegisterEventTypesRequest> = {
+  encode(message: RegisterEventTypesRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.EventStore !== "") {
+      writer.uint32(10).string(message.EventStore);
+    }
+    for (const v of message.Types) {
+      EventTypeRegistration.encode(v!, writer.uint32(18).fork()).join();
+    }
+    if (message.DisableValidation !== false) {
+      writer.uint32(24).bool(message.DisableValidation);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): RegisterEventTypesRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRegisterEventTypesRequest();
+    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.Types.push(EventTypeRegistration.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.DisableValidation = reader.bool();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RegisterEventTypesRequest {
+    return {
+      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+      Types: globalThis.Array.isArray(object?.Types)
+        ? object.Types.map((e: any) => EventTypeRegistration.fromJSON(e))
+        : [],
+      DisableValidation: isSet(object.DisableValidation) ? globalThis.Boolean(object.DisableValidation) : false,
+    };
+  },
+
+  toJSON(message: RegisterEventTypesRequest): unknown {
+    const obj: any = {};
+    if (message.EventStore !== "") {
+      obj.EventStore = message.EventStore;
+    }
+    if (message.Types?.length) {
+      obj.Types = message.Types.map((e) => EventTypeRegistration.toJSON(e));
+    }
+    if (message.DisableValidation !== false) {
+      obj.DisableValidation = message.DisableValidation;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<RegisterEventTypesRequest>): RegisterEventTypesRequest {
+    return RegisterEventTypesRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<RegisterEventTypesRequest>): RegisterEventTypesRequest {
+    const message = createBaseRegisterEventTypesRequest();
+    message.EventStore = object.EventStore ?? "";
+    message.Types = object.Types?.map((e) => EventTypeRegistration.fromPartial(e)) || [];
+    message.DisableValidation = object.DisableValidation ?? false;
+    return message;
+  },
+};
+
+function createBaseRegisterSingleEventTypeRequest(): RegisterSingleEventTypeRequest {
+  return { EventStore: "", Type: undefined };
+}
+
+export const RegisterSingleEventTypeRequest: MessageFns<RegisterSingleEventTypeRequest> = {
+  encode(message: RegisterSingleEventTypeRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.EventStore !== "") {
+      writer.uint32(10).string(message.EventStore);
+    }
+    if (message.Type !== undefined) {
+      EventTypeRegistration.encode(message.Type, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): RegisterSingleEventTypeRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRegisterSingleEventTypeRequest();
+    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.Type = EventTypeRegistration.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RegisterSingleEventTypeRequest {
+    return {
+      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+      Type: isSet(object.Type) ? EventTypeRegistration.fromJSON(object.Type) : undefined,
+    };
+  },
+
+  toJSON(message: RegisterSingleEventTypeRequest): unknown {
+    const obj: any = {};
+    if (message.EventStore !== "") {
+      obj.EventStore = message.EventStore;
+    }
+    if (message.Type !== undefined) {
+      obj.Type = EventTypeRegistration.toJSON(message.Type);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<RegisterSingleEventTypeRequest>): RegisterSingleEventTypeRequest {
+    return RegisterSingleEventTypeRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<RegisterSingleEventTypeRequest>): RegisterSingleEventTypeRequest {
+    const message = createBaseRegisterSingleEventTypeRequest();
+    message.EventStore = object.EventStore ?? "";
+    message.Type = (object.Type !== undefined && object.Type !== null)
+      ? EventTypeRegistration.fromPartial(object.Type)
+      : undefined;
+    return message;
+  },
+};
+
+export type EventTypesService = typeof EventTypesService;
+export const EventTypesService = {
+  getAll: {
+    path: "/Cratis.Chronicle.Contracts.Events.EventTypes/GetAll" as const,
+    requestStream: false as const,
+    responseStream: false as const,
+    requestSerialize: (value: GetAllEventTypesRequest): Buffer =>
+      Buffer.from(GetAllEventTypesRequest.encode(value).finish()),
+    requestDeserialize: (value: Buffer): GetAllEventTypesRequest => GetAllEventTypesRequest.decode(value),
+    responseSerialize: (value: IEnumerableEventType): Buffer =>
+      Buffer.from(IEnumerableEventType.encode(value).finish()),
+    responseDeserialize: (value: Buffer): IEnumerableEventType => IEnumerableEventType.decode(value),
+  },
+  getAllGenerationsForEventType: {
+    path: "/Cratis.Chronicle.Contracts.Events.EventTypes/GetAllGenerationsForEventType" as const,
+    requestStream: false as const,
+    responseStream: false as const,
+    requestSerialize: (value: GetEventTypeGenerationsRequest): Buffer =>
+      Buffer.from(GetEventTypeGenerationsRequest.encode(value).finish()),
+    requestDeserialize: (value: Buffer): GetEventTypeGenerationsRequest => GetEventTypeGenerationsRequest.decode(value),
+    responseSerialize: (value: IEnumerableEventTypeRegistration): Buffer =>
+      Buffer.from(IEnumerableEventTypeRegistration.encode(value).finish()),
+    responseDeserialize: (value: Buffer): IEnumerableEventTypeRegistration =>
+      IEnumerableEventTypeRegistration.decode(value),
+  },
+  getAllRegistrations: {
+    path: "/Cratis.Chronicle.Contracts.Events.EventTypes/GetAllRegistrations" as const,
+    requestStream: false as const,
+    responseStream: false as const,
+    requestSerialize: (value: GetAllEventTypesRequest): Buffer =>
+      Buffer.from(GetAllEventTypesRequest.encode(value).finish()),
+    requestDeserialize: (value: Buffer): GetAllEventTypesRequest => GetAllEventTypesRequest.decode(value),
+    responseSerialize: (value: IEnumerableEventTypeRegistration): Buffer =>
+      Buffer.from(IEnumerableEventTypeRegistration.encode(value).finish()),
+    responseDeserialize: (value: Buffer): IEnumerableEventTypeRegistration =>
+      IEnumerableEventTypeRegistration.decode(value),
+  },
+  observeAllRegistrations: {
+    path: "/Cratis.Chronicle.Contracts.Events.EventTypes/ObserveAllRegistrations" as const,
+    requestStream: false as const,
+    responseStream: true as const,
+    requestSerialize: (value: GetAllEventTypesRequest): Buffer =>
+      Buffer.from(GetAllEventTypesRequest.encode(value).finish()),
+    requestDeserialize: (value: Buffer): GetAllEventTypesRequest => GetAllEventTypesRequest.decode(value),
+    responseSerialize: (value: IEnumerableEventTypeRegistration): Buffer =>
+      Buffer.from(IEnumerableEventTypeRegistration.encode(value).finish()),
+    responseDeserialize: (value: Buffer): IEnumerableEventTypeRegistration =>
+      IEnumerableEventTypeRegistration.decode(value),
+  },
+  register: {
+    path: "/Cratis.Chronicle.Contracts.Events.EventTypes/Register" as const,
+    requestStream: false as const,
+    responseStream: false as const,
+    requestSerialize: (value: RegisterEventTypesRequest): Buffer =>
+      Buffer.from(RegisterEventTypesRequest.encode(value).finish()),
+    requestDeserialize: (value: Buffer): RegisterEventTypesRequest => RegisterEventTypesRequest.decode(value),
+    responseSerialize: (value: Empty): Buffer => Buffer.from(Empty.encode(value).finish()),
+    responseDeserialize: (value: Buffer): Empty => Empty.decode(value),
+  },
+  registerSingle: {
+    path: "/Cratis.Chronicle.Contracts.Events.EventTypes/RegisterSingle" as const,
+    requestStream: false as const,
+    responseStream: false as const,
+    requestSerialize: (value: RegisterSingleEventTypeRequest): Buffer =>
+      Buffer.from(RegisterSingleEventTypeRequest.encode(value).finish()),
+    requestDeserialize: (value: Buffer): RegisterSingleEventTypeRequest => RegisterSingleEventTypeRequest.decode(value),
+    responseSerialize: (value: Empty): Buffer => Buffer.from(Empty.encode(value).finish()),
+    responseDeserialize: (value: Buffer): Empty => Empty.decode(value),
+  },
+} as const;
+
+export interface EventTypesServer extends UntypedServiceImplementation {
+  getAll: handleUnaryCall<GetAllEventTypesRequest, IEnumerableEventType>;
+  getAllGenerationsForEventType: handleUnaryCall<GetEventTypeGenerationsRequest, IEnumerableEventTypeRegistration>;
+  getAllRegistrations: handleUnaryCall<GetAllEventTypesRequest, IEnumerableEventTypeRegistration>;
+  observeAllRegistrations: handleServerStreamingCall<GetAllEventTypesRequest, IEnumerableEventTypeRegistration>;
+  register: handleUnaryCall<RegisterEventTypesRequest, Empty>;
+  registerSingle: handleUnaryCall<RegisterSingleEventTypeRequest, Empty>;
+}
+
+export interface EventTypesClient extends Client {
+  getAll(
+    request: GetAllEventTypesRequest,
+    callback: (error: ServiceError | null, response: IEnumerableEventType) => void,
+  ): ClientUnaryCall;
+  getAll(
+    request: GetAllEventTypesRequest,
+    metadata: Metadata,
+    callback: (error: ServiceError | null, response: IEnumerableEventType) => void,
+  ): ClientUnaryCall;
+  getAll(
+    request: GetAllEventTypesRequest,
+    metadata: Metadata,
+    options: Partial<CallOptions>,
+    callback: (error: ServiceError | null, response: IEnumerableEventType) => void,
+  ): ClientUnaryCall;
+  getAllGenerationsForEventType(
+    request: GetEventTypeGenerationsRequest,
+    callback: (error: ServiceError | null, response: IEnumerableEventTypeRegistration) => void,
+  ): ClientUnaryCall;
+  getAllGenerationsForEventType(
+    request: GetEventTypeGenerationsRequest,
+    metadata: Metadata,
+    callback: (error: ServiceError | null, response: IEnumerableEventTypeRegistration) => void,
+  ): ClientUnaryCall;
+  getAllGenerationsForEventType(
+    request: GetEventTypeGenerationsRequest,
+    metadata: Metadata,
+    options: Partial<CallOptions>,
+    callback: (error: ServiceError | null, response: IEnumerableEventTypeRegistration) => void,
+  ): ClientUnaryCall;
+  getAllRegistrations(
+    request: GetAllEventTypesRequest,
+    callback: (error: ServiceError | null, response: IEnumerableEventTypeRegistration) => void,
+  ): ClientUnaryCall;
+  getAllRegistrations(
+    request: GetAllEventTypesRequest,
+    metadata: Metadata,
+    callback: (error: ServiceError | null, response: IEnumerableEventTypeRegistration) => void,
+  ): ClientUnaryCall;
+  getAllRegistrations(
+    request: GetAllEventTypesRequest,
+    metadata: Metadata,
+    options: Partial<CallOptions>,
+    callback: (error: ServiceError | null, response: IEnumerableEventTypeRegistration) => void,
+  ): ClientUnaryCall;
+  observeAllRegistrations(
+    request: GetAllEventTypesRequest,
+    options?: Partial<CallOptions>,
+  ): ClientReadableStream<IEnumerableEventTypeRegistration>;
+  observeAllRegistrations(
+    request: GetAllEventTypesRequest,
+    metadata?: Metadata,
+    options?: Partial<CallOptions>,
+  ): ClientReadableStream<IEnumerableEventTypeRegistration>;
+  register(
+    request: RegisterEventTypesRequest,
+    callback: (error: ServiceError | null, response: Empty) => void,
+  ): ClientUnaryCall;
+  register(
+    request: RegisterEventTypesRequest,
+    metadata: Metadata,
+    callback: (error: ServiceError | null, response: Empty) => void,
+  ): ClientUnaryCall;
+  register(
+    request: RegisterEventTypesRequest,
+    metadata: Metadata,
+    options: Partial<CallOptions>,
+    callback: (error: ServiceError | null, response: Empty) => void,
+  ): ClientUnaryCall;
+  registerSingle(
+    request: RegisterSingleEventTypeRequest,
+    callback: (error: ServiceError | null, response: Empty) => void,
+  ): ClientUnaryCall;
+  registerSingle(
+    request: RegisterSingleEventTypeRequest,
+    metadata: Metadata,
+    callback: (error: ServiceError | null, response: Empty) => void,
+  ): ClientUnaryCall;
+  registerSingle(
+    request: RegisterSingleEventTypeRequest,
+    metadata: Metadata,
+    options: Partial<CallOptions>,
+    callback: (error: ServiceError | null, response: Empty) => void,
+  ): ClientUnaryCall;
+}
+
+export const EventTypesClient = makeGenericClientConstructor(
+  EventTypesService,
+  "Cratis.Chronicle.Contracts.Events.EventTypes",
+) as unknown as {
+  new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): EventTypesClient;
+  service: typeof EventTypesService;
+  serviceName: string;
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create(base?: DeepPartial<T>): T;
+  fromPartial(object: DeepPartial<T>): T;
+}