@cratis/chronicle.contracts 0.0.0

package/dist/cjs/generated/events.js

@@ -0,0 +1,899 @@
+'use strict';
+
+var wire = require('@bufbuild/protobuf/wire');
+var grpc = require('@grpc/grpc-js');
+var empty = require('./google/protobuf/empty.js');
+
+function createBaseEventType() {
+    return { Id: "", Generation: 0, Tombstone: false };
+}
+const EventType = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Id !== "") {
+            writer.uint32(10).string(message.Id);
+        }
+        if (message.Generation !== 0) {
+            writer.uint32(16).uint32(message.Generation);
+        }
+        if (message.Tombstone !== false) {
+            writer.uint32(24).bool(message.Tombstone);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.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) {
+        return {
+            Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
+            Generation: isSet(object.Generation) ? globalThis.Number(object.Generation) : 0,
+            Tombstone: isSet(object.Tombstone) ? globalThis.Boolean(object.Tombstone) : false,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Id !== "") {
+            obj.Id = message.Id;
+        }
+        if (message.Generation !== 0) {
+            obj.Generation = Math.round(message.Generation);
+        }
+        if (message.Tombstone !== false) {
+            obj.Tombstone = message.Tombstone;
+        }
+        return obj;
+    },
+    create(base) {
+        return EventType.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseEventType();
+        message.Id = object.Id ?? "";
+        message.Generation = object.Generation ?? 0;
+        message.Tombstone = object.Tombstone ?? false;
+        return message;
+    },
+};
+function createBaseEventTypeGenerationDefinition() {
+    return { Generation: 0, Schema: "" };
+}
+const EventTypeGenerationDefinition = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Generation !== 0) {
+            writer.uint32(8).uint32(message.Generation);
+        }
+        if (message.Schema !== "") {
+            writer.uint32(18).string(message.Schema);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.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) {
+        return {
+            Generation: isSet(object.Generation) ? globalThis.Number(object.Generation) : 0,
+            Schema: isSet(object.Schema) ? globalThis.String(object.Schema) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Generation !== 0) {
+            obj.Generation = Math.round(message.Generation);
+        }
+        if (message.Schema !== "") {
+            obj.Schema = message.Schema;
+        }
+        return obj;
+    },
+    create(base) {
+        return EventTypeGenerationDefinition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseEventTypeGenerationDefinition();
+        message.Generation = object.Generation ?? 0;
+        message.Schema = object.Schema ?? "";
+        return message;
+    },
+};
+function createBaseEventTypeMigrationDefinition() {
+    return { FromGeneration: 0, ToGeneration: 0, Operations: [], UpcastJmesPath: "", DowncastJmesPath: "" };
+}
+const EventTypeMigrationDefinition = {
+    encode(message, writer = new wire.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, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.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) {
+        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) => EventTypeMigrationOperation.fromJSON(e))
+                : [],
+            UpcastJmesPath: isSet(object.UpcastJmesPath) ? globalThis.String(object.UpcastJmesPath) : "",
+            DowncastJmesPath: isSet(object.DowncastJmesPath) ? globalThis.String(object.DowncastJmesPath) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        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) {
+        return EventTypeMigrationDefinition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        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() {
+    return { Operation: "", Details: "" };
+}
+const EventTypeMigrationOperation = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Operation !== "") {
+            writer.uint32(10).string(message.Operation);
+        }
+        if (message.Details !== "") {
+            writer.uint32(18).string(message.Details);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.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) {
+        return {
+            Operation: isSet(object.Operation) ? globalThis.String(object.Operation) : "",
+            Details: isSet(object.Details) ? globalThis.String(object.Details) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Operation !== "") {
+            obj.Operation = message.Operation;
+        }
+        if (message.Details !== "") {
+            obj.Details = message.Details;
+        }
+        return obj;
+    },
+    create(base) {
+        return EventTypeMigrationOperation.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseEventTypeMigrationOperation();
+        message.Operation = object.Operation ?? "";
+        message.Details = object.Details ?? "";
+        return message;
+    },
+};
+function createBaseEventTypeRegistration() {
+    return { Type: undefined, Schema: "", Generations: [], Migrations: [] };
+}
+const EventTypeRegistration = {
+    encode(message, writer = new wire.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, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.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) {
+        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) => EventTypeGenerationDefinition.fromJSON(e))
+                : [],
+            Migrations: globalThis.Array.isArray(object?.Migrations)
+                ? object.Migrations.map((e) => EventTypeMigrationDefinition.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        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) {
+        return EventTypeRegistration.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        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() {
+    return { EventStore: "" };
+}
+const GetAllEventTypesRequest = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const 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) {
+        return { EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "" };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        return obj;
+    },
+    create(base) {
+        return GetAllEventTypesRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGetAllEventTypesRequest();
+        message.EventStore = object.EventStore ?? "";
+        return message;
+    },
+};
+function createBaseGetEventTypeGenerationsRequest() {
+    return { EventStore: "", EventTypeId: "" };
+}
+const GetEventTypeGenerationsRequest = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        if (message.EventTypeId !== "") {
+            writer.uint32(18).string(message.EventTypeId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const 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) {
+        return {
+            EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+            EventTypeId: isSet(object.EventTypeId) ? globalThis.String(object.EventTypeId) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.EventTypeId !== "") {
+            obj.EventTypeId = message.EventTypeId;
+        }
+        return obj;
+    },
+    create(base) {
+        return GetEventTypeGenerationsRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGetEventTypeGenerationsRequest();
+        message.EventStore = object.EventStore ?? "";
+        message.EventTypeId = object.EventTypeId ?? "";
+        return message;
+    },
+};
+function createBaseIEnumerableEventType() {
+    return { items: [] };
+}
+const IEnumerableEventType = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        for (const v of message.items) {
+            EventType.encode(v, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const 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) {
+        return {
+            items: globalThis.Array.isArray(object?.items) ? object.items.map((e) => EventType.fromJSON(e)) : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.items?.length) {
+            obj.items = message.items.map((e) => EventType.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return IEnumerableEventType.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseIEnumerableEventType();
+        message.items = object.items?.map((e) => EventType.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseIEnumerableEventTypeRegistration() {
+    return { items: [] };
+}
+const IEnumerableEventTypeRegistration = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        for (const v of message.items) {
+            EventTypeRegistration.encode(v, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const 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) {
+        return {
+            items: globalThis.Array.isArray(object?.items)
+                ? object.items.map((e) => EventTypeRegistration.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.items?.length) {
+            obj.items = message.items.map((e) => EventTypeRegistration.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return IEnumerableEventTypeRegistration.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseIEnumerableEventTypeRegistration();
+        message.items = object.items?.map((e) => EventTypeRegistration.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseRegisterEventTypesRequest() {
+    return { EventStore: "", Types: [], DisableValidation: false };
+}
+const RegisterEventTypesRequest = {
+    encode(message, writer = new wire.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, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.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) {
+        return {
+            EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+            Types: globalThis.Array.isArray(object?.Types)
+                ? object.Types.map((e) => EventTypeRegistration.fromJSON(e))
+                : [],
+            DisableValidation: isSet(object.DisableValidation) ? globalThis.Boolean(object.DisableValidation) : false,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        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) {
+        return RegisterEventTypesRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        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() {
+    return { EventStore: "", Type: undefined };
+}
+const RegisterSingleEventTypeRequest = {
+    encode(message, writer = new wire.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, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.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) {
+        return {
+            EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+            Type: isSet(object.Type) ? EventTypeRegistration.fromJSON(object.Type) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.Type !== undefined) {
+            obj.Type = EventTypeRegistration.toJSON(message.Type);
+        }
+        return obj;
+    },
+    create(base) {
+        return RegisterSingleEventTypeRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseRegisterSingleEventTypeRequest();
+        message.EventStore = object.EventStore ?? "";
+        message.Type = (object.Type !== undefined && object.Type !== null)
+            ? EventTypeRegistration.fromPartial(object.Type)
+            : undefined;
+        return message;
+    },
+};
+const EventTypesService = {
+    getAll: {
+        path: "/Cratis.Chronicle.Contracts.Events.EventTypes/GetAll",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GetAllEventTypesRequest.encode(value).finish()),
+        requestDeserialize: (value) => GetAllEventTypesRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(IEnumerableEventType.encode(value).finish()),
+        responseDeserialize: (value) => IEnumerableEventType.decode(value),
+    },
+    getAllGenerationsForEventType: {
+        path: "/Cratis.Chronicle.Contracts.Events.EventTypes/GetAllGenerationsForEventType",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GetEventTypeGenerationsRequest.encode(value).finish()),
+        requestDeserialize: (value) => GetEventTypeGenerationsRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(IEnumerableEventTypeRegistration.encode(value).finish()),
+        responseDeserialize: (value) => IEnumerableEventTypeRegistration.decode(value),
+    },
+    getAllRegistrations: {
+        path: "/Cratis.Chronicle.Contracts.Events.EventTypes/GetAllRegistrations",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GetAllEventTypesRequest.encode(value).finish()),
+        requestDeserialize: (value) => GetAllEventTypesRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(IEnumerableEventTypeRegistration.encode(value).finish()),
+        responseDeserialize: (value) => IEnumerableEventTypeRegistration.decode(value),
+    },
+    observeAllRegistrations: {
+        path: "/Cratis.Chronicle.Contracts.Events.EventTypes/ObserveAllRegistrations",
+        requestStream: false,
+        responseStream: true,
+        requestSerialize: (value) => Buffer.from(GetAllEventTypesRequest.encode(value).finish()),
+        requestDeserialize: (value) => GetAllEventTypesRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(IEnumerableEventTypeRegistration.encode(value).finish()),
+        responseDeserialize: (value) => IEnumerableEventTypeRegistration.decode(value),
+    },
+    register: {
+        path: "/Cratis.Chronicle.Contracts.Events.EventTypes/Register",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(RegisterEventTypesRequest.encode(value).finish()),
+        requestDeserialize: (value) => RegisterEventTypesRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(empty.Empty.encode(value).finish()),
+        responseDeserialize: (value) => empty.Empty.decode(value),
+    },
+    registerSingle: {
+        path: "/Cratis.Chronicle.Contracts.Events.EventTypes/RegisterSingle",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(RegisterSingleEventTypeRequest.encode(value).finish()),
+        requestDeserialize: (value) => RegisterSingleEventTypeRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(empty.Empty.encode(value).finish()),
+        responseDeserialize: (value) => empty.Empty.decode(value),
+    },
+};
+const EventTypesClient = grpc.makeGenericClientConstructor(EventTypesService, "Cratis.Chronicle.Contracts.Events.EventTypes");
+function isSet(value) {
+    return value !== null && value !== undefined;
+}
+
+exports.EventType = EventType;
+exports.EventTypeGenerationDefinition = EventTypeGenerationDefinition;
+exports.EventTypeMigrationDefinition = EventTypeMigrationDefinition;
+exports.EventTypeMigrationOperation = EventTypeMigrationOperation;
+exports.EventTypeRegistration = EventTypeRegistration;
+exports.EventTypesClient = EventTypesClient;
+exports.EventTypesService = EventTypesService;
+exports.GetAllEventTypesRequest = GetAllEventTypesRequest;
+exports.GetEventTypeGenerationsRequest = GetEventTypeGenerationsRequest;
+exports.IEnumerableEventType = IEnumerableEventType;
+exports.IEnumerableEventTypeRegistration = IEnumerableEventTypeRegistration;
+exports.RegisterEventTypesRequest = RegisterEventTypesRequest;
+exports.RegisterSingleEventTypeRequest = RegisterSingleEventTypeRequest;
+//# sourceMappingURL=events.js.map