@cratis/chronicle.contracts 18.0.0 → 18.1.1

package/dist/cjs/generated/sequencequeries.js

@@ -0,0 +1,1182 @@
+'use strict';
+
+var wire = require('@bufbuild/protobuf/wire');
+var empty = require('./google/protobuf/empty.js');
+
+exports.SequenceQueryScope = void 0;
+(function (SequenceQueryScope) {
+    SequenceQueryScope[SequenceQueryScope["User"] = 0] = "User";
+    SequenceQueryScope[SequenceQueryScope["Everyone"] = 1] = "Everyone";
+    SequenceQueryScope[SequenceQueryScope["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(exports.SequenceQueryScope || (exports.SequenceQueryScope = {}));
+function sequenceQueryScopeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "User":
+            return exports.SequenceQueryScope.User;
+        case 1:
+        case "Everyone":
+            return exports.SequenceQueryScope.Everyone;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return exports.SequenceQueryScope.UNRECOGNIZED;
+    }
+}
+function sequenceQueryScopeToJSON(object) {
+    switch (object) {
+        case exports.SequenceQueryScope.User:
+            return "User";
+        case exports.SequenceQueryScope.Everyone:
+            return "Everyone";
+        case exports.SequenceQueryScope.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.SequenceQuerySortBy = void 0;
+(function (SequenceQuerySortBy) {
+    SequenceQuerySortBy[SequenceQuerySortBy["SequenceNumber"] = 0] = "SequenceNumber";
+    SequenceQuerySortBy[SequenceQuerySortBy["Occurred"] = 1] = "Occurred";
+    SequenceQuerySortBy[SequenceQuerySortBy["EventType"] = 2] = "EventType";
+    SequenceQuerySortBy[SequenceQuerySortBy["EventSourceId"] = 3] = "EventSourceId";
+    SequenceQuerySortBy[SequenceQuerySortBy["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(exports.SequenceQuerySortBy || (exports.SequenceQuerySortBy = {}));
+function sequenceQuerySortByFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "SequenceNumber":
+            return exports.SequenceQuerySortBy.SequenceNumber;
+        case 1:
+        case "Occurred":
+            return exports.SequenceQuerySortBy.Occurred;
+        case 2:
+        case "EventType":
+            return exports.SequenceQuerySortBy.EventType;
+        case 3:
+        case "EventSourceId":
+            return exports.SequenceQuerySortBy.EventSourceId;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return exports.SequenceQuerySortBy.UNRECOGNIZED;
+    }
+}
+function sequenceQuerySortByToJSON(object) {
+    switch (object) {
+        case exports.SequenceQuerySortBy.SequenceNumber:
+            return "SequenceNumber";
+        case exports.SequenceQuerySortBy.Occurred:
+            return "Occurred";
+        case exports.SequenceQuerySortBy.EventType:
+            return "EventType";
+        case exports.SequenceQuerySortBy.EventSourceId:
+            return "EventSourceId";
+        case exports.SequenceQuerySortBy.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseDateTimeOffset() {
+    return {};
+}
+const DateTimeOffset = {
+    encode(_, writer = new wire.BinaryWriter()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseDateTimeOffset();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(_) {
+        return {};
+    },
+    toJSON(_) {
+        const obj = {};
+        return obj;
+    },
+    create(base) {
+        return DateTimeOffset.fromPartial(base ?? {});
+    },
+    fromPartial(_) {
+        const message = createBaseDateTimeOffset();
+        return message;
+    },
+};
+function createBaseDeleteSequenceQueryFolderRequest() {
+    return { EventStore: "", Id: "" };
+}
+const DeleteSequenceQueryFolderRequest = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        if (message.Id !== "") {
+            writer.uint32(18).string(message.Id);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseDeleteSequenceQueryFolderRequest();
+            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.Id = reader.string();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+            Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.Id !== "") {
+            obj.Id = message.Id;
+        }
+        return obj;
+    },
+    create(base) {
+        return DeleteSequenceQueryFolderRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseDeleteSequenceQueryFolderRequest();
+        message.EventStore = object.EventStore ?? "";
+        message.Id = object.Id ?? "";
+        return message;
+    },
+};
+function createBaseDeleteSequenceQueryRequest() {
+    return { EventStore: "", Id: "" };
+}
+const DeleteSequenceQueryRequest = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        if (message.Id !== "") {
+            writer.uint32(18).string(message.Id);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseDeleteSequenceQueryRequest();
+            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.Id = reader.string();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+            Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.Id !== "") {
+            obj.Id = message.Id;
+        }
+        return obj;
+    },
+    create(base) {
+        return DeleteSequenceQueryRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseDeleteSequenceQueryRequest();
+        message.EventStore = object.EventStore ?? "";
+        message.Id = object.Id ?? "";
+        return message;
+    },
+};
+function createBaseGetSequenceQueriesRequest() {
+    return { EventStore: "", Owner: "" };
+}
+const GetSequenceQueriesRequest = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        if (message.Owner !== "") {
+            writer.uint32(18).string(message.Owner);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseGetSequenceQueriesRequest();
+            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.Owner = reader.string();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+            Owner: isSet(object.Owner) ? globalThis.String(object.Owner) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.Owner !== "") {
+            obj.Owner = message.Owner;
+        }
+        return obj;
+    },
+    create(base) {
+        return GetSequenceQueriesRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGetSequenceQueriesRequest();
+        message.EventStore = object.EventStore ?? "";
+        message.Owner = object.Owner ?? "";
+        return message;
+    },
+};
+function createBaseIEnumerableSequenceQueryDefinition() {
+    return { items: [] };
+}
+const IEnumerableSequenceQueryDefinition = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        for (const v of message.items) {
+            SequenceQueryDefinition.encode(v, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseIEnumerableSequenceQueryDefinition();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.items.push(SequenceQueryDefinition.decode(reader, reader.uint32()));
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            items: globalThis.Array.isArray(object?.items)
+                ? object.items.map((e) => SequenceQueryDefinition.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.items?.length) {
+            obj.items = message.items.map((e) => SequenceQueryDefinition.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return IEnumerableSequenceQueryDefinition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseIEnumerableSequenceQueryDefinition();
+        message.items = object.items?.map((e) => SequenceQueryDefinition.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseIEnumerableSequenceQueryFolderDefinition() {
+    return { items: [] };
+}
+const IEnumerableSequenceQueryFolderDefinition = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        for (const v of message.items) {
+            SequenceQueryFolderDefinition.encode(v, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseIEnumerableSequenceQueryFolderDefinition();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.items.push(SequenceQueryFolderDefinition.decode(reader, reader.uint32()));
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            items: globalThis.Array.isArray(object?.items)
+                ? object.items.map((e) => SequenceQueryFolderDefinition.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.items?.length) {
+            obj.items = message.items.map((e) => SequenceQueryFolderDefinition.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return IEnumerableSequenceQueryFolderDefinition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseIEnumerableSequenceQueryFolderDefinition();
+        message.items = object.items?.map((e) => SequenceQueryFolderDefinition.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseSaveSequenceQueryFolderRequest() {
+    return { EventStore: "", Folder: undefined };
+}
+const SaveSequenceQueryFolderRequest = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        if (message.Folder !== undefined) {
+            SequenceQueryFolderDefinition.encode(message.Folder, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseSaveSequenceQueryFolderRequest();
+            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.Folder = SequenceQueryFolderDefinition.decode(reader, reader.uint32());
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+            Folder: isSet(object.Folder) ? SequenceQueryFolderDefinition.fromJSON(object.Folder) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.Folder !== undefined) {
+            obj.Folder = SequenceQueryFolderDefinition.toJSON(message.Folder);
+        }
+        return obj;
+    },
+    create(base) {
+        return SaveSequenceQueryFolderRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSaveSequenceQueryFolderRequest();
+        message.EventStore = object.EventStore ?? "";
+        message.Folder = (object.Folder !== undefined && object.Folder !== null)
+            ? SequenceQueryFolderDefinition.fromPartial(object.Folder)
+            : undefined;
+        return message;
+    },
+};
+function createBaseSaveSequenceQueryRequest() {
+    return { EventStore: "", Query: undefined };
+}
+const SaveSequenceQueryRequest = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        if (message.Query !== undefined) {
+            SequenceQueryDefinition.encode(message.Query, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseSaveSequenceQueryRequest();
+            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.Query = SequenceQueryDefinition.decode(reader, reader.uint32());
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+            Query: isSet(object.Query) ? SequenceQueryDefinition.fromJSON(object.Query) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.Query !== undefined) {
+            obj.Query = SequenceQueryDefinition.toJSON(message.Query);
+        }
+        return obj;
+    },
+    create(base) {
+        return SaveSequenceQueryRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSaveSequenceQueryRequest();
+        message.EventStore = object.EventStore ?? "";
+        message.Query = (object.Query !== undefined && object.Query !== null)
+            ? SequenceQueryDefinition.fromPartial(object.Query)
+            : undefined;
+        return message;
+    },
+};
+function createBaseSequenceQueryDefinition() {
+    return {
+        Id: "",
+        Name: "",
+        Scope: 0,
+        Owner: "",
+        Namespace: "",
+        EventSequenceId: "",
+        EventSourceId: "",
+        EventTypes: [],
+        Tags: [],
+        OccurredFrom: undefined,
+        OccurredTo: undefined,
+        Descending: false,
+        Folder: "",
+        EventSourceType: "",
+        EventStreamType: "",
+        CorrelationId: "",
+        SortBy: 0,
+    };
+}
+const SequenceQueryDefinition = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Id !== "") {
+            writer.uint32(10).string(message.Id);
+        }
+        if (message.Name !== "") {
+            writer.uint32(18).string(message.Name);
+        }
+        if (message.Scope !== 0) {
+            writer.uint32(24).int32(message.Scope);
+        }
+        if (message.Owner !== "") {
+            writer.uint32(34).string(message.Owner);
+        }
+        if (message.Namespace !== "") {
+            writer.uint32(42).string(message.Namespace);
+        }
+        if (message.EventSequenceId !== "") {
+            writer.uint32(50).string(message.EventSequenceId);
+        }
+        if (message.EventSourceId !== "") {
+            writer.uint32(58).string(message.EventSourceId);
+        }
+        for (const v of message.EventTypes) {
+            writer.uint32(66).string(v);
+        }
+        for (const v of message.Tags) {
+            writer.uint32(74).string(v);
+        }
+        if (message.OccurredFrom !== undefined) {
+            DateTimeOffset.encode(message.OccurredFrom, writer.uint32(82).fork()).join();
+        }
+        if (message.OccurredTo !== undefined) {
+            DateTimeOffset.encode(message.OccurredTo, writer.uint32(90).fork()).join();
+        }
+        if (message.Descending !== false) {
+            writer.uint32(96).bool(message.Descending);
+        }
+        if (message.Folder !== "") {
+            writer.uint32(106).string(message.Folder);
+        }
+        if (message.EventSourceType !== "") {
+            writer.uint32(114).string(message.EventSourceType);
+        }
+        if (message.EventStreamType !== "") {
+            writer.uint32(122).string(message.EventStreamType);
+        }
+        if (message.CorrelationId !== "") {
+            writer.uint32(130).string(message.CorrelationId);
+        }
+        if (message.SortBy !== 0) {
+            writer.uint32(136).int32(message.SortBy);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseSequenceQueryDefinition();
+            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 !== 18) {
+                            break;
+                        }
+                        message.Name = reader.string();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 24) {
+                            break;
+                        }
+                        message.Scope = reader.int32();
+                        continue;
+                    }
+                    case 4: {
+                        if (tag !== 34) {
+                            break;
+                        }
+                        message.Owner = reader.string();
+                        continue;
+                    }
+                    case 5: {
+                        if (tag !== 42) {
+                            break;
+                        }
+                        message.Namespace = reader.string();
+                        continue;
+                    }
+                    case 6: {
+                        if (tag !== 50) {
+                            break;
+                        }
+                        message.EventSequenceId = reader.string();
+                        continue;
+                    }
+                    case 7: {
+                        if (tag !== 58) {
+                            break;
+                        }
+                        message.EventSourceId = reader.string();
+                        continue;
+                    }
+                    case 8: {
+                        if (tag !== 66) {
+                            break;
+                        }
+                        message.EventTypes.push(reader.string());
+                        continue;
+                    }
+                    case 9: {
+                        if (tag !== 74) {
+                            break;
+                        }
+                        message.Tags.push(reader.string());
+                        continue;
+                    }
+                    case 10: {
+                        if (tag !== 82) {
+                            break;
+                        }
+                        message.OccurredFrom = DateTimeOffset.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 11: {
+                        if (tag !== 90) {
+                            break;
+                        }
+                        message.OccurredTo = DateTimeOffset.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 12: {
+                        if (tag !== 96) {
+                            break;
+                        }
+                        message.Descending = reader.bool();
+                        continue;
+                    }
+                    case 13: {
+                        if (tag !== 106) {
+                            break;
+                        }
+                        message.Folder = reader.string();
+                        continue;
+                    }
+                    case 14: {
+                        if (tag !== 114) {
+                            break;
+                        }
+                        message.EventSourceType = reader.string();
+                        continue;
+                    }
+                    case 15: {
+                        if (tag !== 122) {
+                            break;
+                        }
+                        message.EventStreamType = reader.string();
+                        continue;
+                    }
+                    case 16: {
+                        if (tag !== 130) {
+                            break;
+                        }
+                        message.CorrelationId = reader.string();
+                        continue;
+                    }
+                    case 17: {
+                        if (tag !== 136) {
+                            break;
+                        }
+                        message.SortBy = reader.int32();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
+            Name: isSet(object.Name) ? globalThis.String(object.Name) : "",
+            Scope: isSet(object.Scope) ? sequenceQueryScopeFromJSON(object.Scope) : 0,
+            Owner: isSet(object.Owner) ? globalThis.String(object.Owner) : "",
+            Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
+            EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
+            EventSourceId: isSet(object.EventSourceId) ? globalThis.String(object.EventSourceId) : "",
+            EventTypes: globalThis.Array.isArray(object?.EventTypes)
+                ? object.EventTypes.map((e) => globalThis.String(e))
+                : [],
+            Tags: globalThis.Array.isArray(object?.Tags) ? object.Tags.map((e) => globalThis.String(e)) : [],
+            OccurredFrom: isSet(object.OccurredFrom) ? DateTimeOffset.fromJSON(object.OccurredFrom) : undefined,
+            OccurredTo: isSet(object.OccurredTo) ? DateTimeOffset.fromJSON(object.OccurredTo) : undefined,
+            Descending: isSet(object.Descending) ? globalThis.Boolean(object.Descending) : false,
+            Folder: isSet(object.Folder) ? globalThis.String(object.Folder) : "",
+            EventSourceType: isSet(object.EventSourceType) ? globalThis.String(object.EventSourceType) : "",
+            EventStreamType: isSet(object.EventStreamType) ? globalThis.String(object.EventStreamType) : "",
+            CorrelationId: isSet(object.CorrelationId) ? globalThis.String(object.CorrelationId) : "",
+            SortBy: isSet(object.SortBy) ? sequenceQuerySortByFromJSON(object.SortBy) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Id !== "") {
+            obj.Id = message.Id;
+        }
+        if (message.Name !== "") {
+            obj.Name = message.Name;
+        }
+        if (message.Scope !== 0) {
+            obj.Scope = sequenceQueryScopeToJSON(message.Scope);
+        }
+        if (message.Owner !== "") {
+            obj.Owner = message.Owner;
+        }
+        if (message.Namespace !== "") {
+            obj.Namespace = message.Namespace;
+        }
+        if (message.EventSequenceId !== "") {
+            obj.EventSequenceId = message.EventSequenceId;
+        }
+        if (message.EventSourceId !== "") {
+            obj.EventSourceId = message.EventSourceId;
+        }
+        if (message.EventTypes?.length) {
+            obj.EventTypes = message.EventTypes;
+        }
+        if (message.Tags?.length) {
+            obj.Tags = message.Tags;
+        }
+        if (message.OccurredFrom !== undefined) {
+            obj.OccurredFrom = DateTimeOffset.toJSON(message.OccurredFrom);
+        }
+        if (message.OccurredTo !== undefined) {
+            obj.OccurredTo = DateTimeOffset.toJSON(message.OccurredTo);
+        }
+        if (message.Descending !== false) {
+            obj.Descending = message.Descending;
+        }
+        if (message.Folder !== "") {
+            obj.Folder = message.Folder;
+        }
+        if (message.EventSourceType !== "") {
+            obj.EventSourceType = message.EventSourceType;
+        }
+        if (message.EventStreamType !== "") {
+            obj.EventStreamType = message.EventStreamType;
+        }
+        if (message.CorrelationId !== "") {
+            obj.CorrelationId = message.CorrelationId;
+        }
+        if (message.SortBy !== 0) {
+            obj.SortBy = sequenceQuerySortByToJSON(message.SortBy);
+        }
+        return obj;
+    },
+    create(base) {
+        return SequenceQueryDefinition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSequenceQueryDefinition();
+        message.Id = object.Id ?? "";
+        message.Name = object.Name ?? "";
+        message.Scope = object.Scope ?? 0;
+        message.Owner = object.Owner ?? "";
+        message.Namespace = object.Namespace ?? "";
+        message.EventSequenceId = object.EventSequenceId ?? "";
+        message.EventSourceId = object.EventSourceId ?? "";
+        message.EventTypes = object.EventTypes?.map((e) => e) || [];
+        message.Tags = object.Tags?.map((e) => e) || [];
+        message.OccurredFrom = (object.OccurredFrom !== undefined && object.OccurredFrom !== null)
+            ? DateTimeOffset.fromPartial(object.OccurredFrom)
+            : undefined;
+        message.OccurredTo = (object.OccurredTo !== undefined && object.OccurredTo !== null)
+            ? DateTimeOffset.fromPartial(object.OccurredTo)
+            : undefined;
+        message.Descending = object.Descending ?? false;
+        message.Folder = object.Folder ?? "";
+        message.EventSourceType = object.EventSourceType ?? "";
+        message.EventStreamType = object.EventStreamType ?? "";
+        message.CorrelationId = object.CorrelationId ?? "";
+        message.SortBy = object.SortBy ?? 0;
+        return message;
+    },
+};
+function createBaseSequenceQueryFolderDefinition() {
+    return { Id: "", Scope: 0, Owner: "", Namespace: "", Path: "" };
+}
+const SequenceQueryFolderDefinition = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Id !== "") {
+            writer.uint32(10).string(message.Id);
+        }
+        if (message.Scope !== 0) {
+            writer.uint32(16).int32(message.Scope);
+        }
+        if (message.Owner !== "") {
+            writer.uint32(26).string(message.Owner);
+        }
+        if (message.Namespace !== "") {
+            writer.uint32(34).string(message.Namespace);
+        }
+        if (message.Path !== "") {
+            writer.uint32(42).string(message.Path);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+        const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
+        if (previousRecursionDepth >= 100) {
+            throw new globalThis.Error("protobuf decode recursion limit exceeded");
+        }
+        reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
+        try {
+            const end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBaseSequenceQueryFolderDefinition();
+            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.Scope = reader.int32();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.Owner = reader.string();
+                        continue;
+                    }
+                    case 4: {
+                        if (tag !== 34) {
+                            break;
+                        }
+                        message.Namespace = reader.string();
+                        continue;
+                    }
+                    case 5: {
+                        if (tag !== 42) {
+                            break;
+                        }
+                        message.Path = reader.string();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
+            Scope: isSet(object.Scope) ? sequenceQueryScopeFromJSON(object.Scope) : 0,
+            Owner: isSet(object.Owner) ? globalThis.String(object.Owner) : "",
+            Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
+            Path: isSet(object.Path) ? globalThis.String(object.Path) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Id !== "") {
+            obj.Id = message.Id;
+        }
+        if (message.Scope !== 0) {
+            obj.Scope = sequenceQueryScopeToJSON(message.Scope);
+        }
+        if (message.Owner !== "") {
+            obj.Owner = message.Owner;
+        }
+        if (message.Namespace !== "") {
+            obj.Namespace = message.Namespace;
+        }
+        if (message.Path !== "") {
+            obj.Path = message.Path;
+        }
+        return obj;
+    },
+    create(base) {
+        return SequenceQueryFolderDefinition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSequenceQueryFolderDefinition();
+        message.Id = object.Id ?? "";
+        message.Scope = object.Scope ?? 0;
+        message.Owner = object.Owner ?? "";
+        message.Namespace = object.Namespace ?? "";
+        message.Path = object.Path ?? "";
+        return message;
+    },
+};
+const SequenceQueriesDefinition = {
+    name: "SequenceQueries",
+    fullName: "Cratis.Chronicle.Contracts.SequenceQueries.SequenceQueries",
+    methods: {
+        delete: {
+            name: "Delete",
+            requestType: DeleteSequenceQueryRequest,
+            requestStream: false,
+            responseType: empty.Empty,
+            responseStream: false,
+            options: {},
+        },
+        deleteFolder: {
+            name: "DeleteFolder",
+            requestType: DeleteSequenceQueryFolderRequest,
+            requestStream: false,
+            responseType: empty.Empty,
+            responseStream: false,
+            options: {},
+        },
+        getSequenceQueries: {
+            name: "GetSequenceQueries",
+            requestType: GetSequenceQueriesRequest,
+            requestStream: false,
+            responseType: IEnumerableSequenceQueryDefinition,
+            responseStream: false,
+            options: {},
+        },
+        getSequenceQueryFolders: {
+            name: "GetSequenceQueryFolders",
+            requestType: GetSequenceQueriesRequest,
+            requestStream: false,
+            responseType: IEnumerableSequenceQueryFolderDefinition,
+            responseStream: false,
+            options: {},
+        },
+        observeSequenceQueries: {
+            name: "ObserveSequenceQueries",
+            requestType: GetSequenceQueriesRequest,
+            requestStream: false,
+            responseType: IEnumerableSequenceQueryDefinition,
+            responseStream: true,
+            options: {},
+        },
+        save: {
+            name: "Save",
+            requestType: SaveSequenceQueryRequest,
+            requestStream: false,
+            responseType: empty.Empty,
+            responseStream: false,
+            options: {},
+        },
+        saveFolder: {
+            name: "SaveFolder",
+            requestType: SaveSequenceQueryFolderRequest,
+            requestStream: false,
+            responseType: empty.Empty,
+            responseStream: false,
+            options: {},
+        },
+    },
+};
+function isSet(value) {
+    return value !== null && value !== undefined;
+}
+
+exports.DateTimeOffset = DateTimeOffset;
+exports.DeleteSequenceQueryFolderRequest = DeleteSequenceQueryFolderRequest;
+exports.DeleteSequenceQueryRequest = DeleteSequenceQueryRequest;
+exports.GetSequenceQueriesRequest = GetSequenceQueriesRequest;
+exports.IEnumerableSequenceQueryDefinition = IEnumerableSequenceQueryDefinition;
+exports.IEnumerableSequenceQueryFolderDefinition = IEnumerableSequenceQueryFolderDefinition;
+exports.SaveSequenceQueryFolderRequest = SaveSequenceQueryFolderRequest;
+exports.SaveSequenceQueryRequest = SaveSequenceQueryRequest;
+exports.SequenceQueriesDefinition = SequenceQueriesDefinition;
+exports.SequenceQueryDefinition = SequenceQueryDefinition;
+exports.SequenceQueryFolderDefinition = SequenceQueryFolderDefinition;
+exports.sequenceQueryScopeFromJSON = sequenceQueryScopeFromJSON;
+exports.sequenceQueryScopeToJSON = sequenceQueryScopeToJSON;
+exports.sequenceQuerySortByFromJSON = sequenceQuerySortByFromJSON;
+exports.sequenceQuerySortByToJSON = sequenceQuerySortByToJSON;
+//# sourceMappingURL=sequencequeries.js.map