@cratis/chronicle.contracts 19.123.1 → 19.125.0

package/dist/generated/sequences.js

@@ -6847,6 +6847,246 @@ export const CommandResultVerifyContentResponse = {
         return message;
     },
 };
+function createBaseCompensateRequest() {
+    return {
+        EventStore: "",
+        Namespace: "",
+        EventSequenceId: "",
+        CompensationFor: 0n,
+        EventType: undefined,
+        Content: "",
+        CorrelationId: undefined,
+        Tags: [],
+        Occurred: undefined,
+        Causation: [],
+        CausedBy: undefined,
+    };
+}
+export const CompensateRequest = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        if (message.Namespace !== "") {
+            writer.uint32(18).string(message.Namespace);
+        }
+        if (message.EventSequenceId !== "") {
+            writer.uint32(26).string(message.EventSequenceId);
+        }
+        if (message.CompensationFor !== 0n) {
+            if (BigInt.asUintN(64, message.CompensationFor) !== message.CompensationFor) {
+                throw new globalThis.Error("value provided for field message.CompensationFor of type uint64 too large");
+            }
+            writer.uint32(32).uint64(message.CompensationFor);
+        }
+        if (message.EventType !== undefined) {
+            EventType.encode(message.EventType, writer.uint32(42).fork()).join();
+        }
+        if (message.Content !== "") {
+            writer.uint32(50).string(message.Content);
+        }
+        if (message.CorrelationId !== undefined) {
+            Guid.encode(message.CorrelationId, writer.uint32(58).fork()).join();
+        }
+        for (const v of message.Tags) {
+            writer.uint32(66).string(v);
+        }
+        if (message.Occurred !== undefined) {
+            SerializableDateTimeOffset.encode(message.Occurred, writer.uint32(74).fork()).join();
+        }
+        for (const v of message.Causation) {
+            Causation.encode(v, writer.uint32(82).fork()).join();
+        }
+        if (message.CausedBy !== undefined) {
+            Identity.encode(message.CausedBy, writer.uint32(90).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new 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 = createBaseCompensateRequest();
+            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.Namespace = reader.string();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 26) {
+                            break;
+                        }
+                        message.EventSequenceId = reader.string();
+                        continue;
+                    }
+                    case 4: {
+                        if (tag !== 32) {
+                            break;
+                        }
+                        message.CompensationFor = reader.uint64();
+                        continue;
+                    }
+                    case 5: {
+                        if (tag !== 42) {
+                            break;
+                        }
+                        message.EventType = EventType.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 6: {
+                        if (tag !== 50) {
+                            break;
+                        }
+                        message.Content = reader.string();
+                        continue;
+                    }
+                    case 7: {
+                        if (tag !== 58) {
+                            break;
+                        }
+                        message.CorrelationId = Guid.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 8: {
+                        if (tag !== 66) {
+                            break;
+                        }
+                        message.Tags.push(reader.string());
+                        continue;
+                    }
+                    case 9: {
+                        if (tag !== 74) {
+                            break;
+                        }
+                        message.Occurred = SerializableDateTimeOffset.decode(reader, reader.uint32());
+                        continue;
+                    }
+                    case 10: {
+                        if (tag !== 82) {
+                            break;
+                        }
+                        message.Causation.push(Causation.decode(reader, reader.uint32()));
+                        continue;
+                    }
+                    case 11: {
+                        if (tag !== 90) {
+                            break;
+                        }
+                        message.CausedBy = Identity.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) : "",
+            Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
+            EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
+            CompensationFor: isSet(object.CompensationFor) ? BigInt(object.CompensationFor) : 0n,
+            EventType: isSet(object.EventType) ? EventType.fromJSON(object.EventType) : undefined,
+            Content: isSet(object.Content) ? globalThis.String(object.Content) : "",
+            CorrelationId: isSet(object.CorrelationId) ? Guid.fromJSON(object.CorrelationId) : undefined,
+            Tags: globalThis.Array.isArray(object?.Tags) ? object.Tags.map((e) => globalThis.String(e)) : [],
+            Occurred: isSet(object.Occurred) ? SerializableDateTimeOffset.fromJSON(object.Occurred) : undefined,
+            Causation: globalThis.Array.isArray(object?.Causation)
+                ? object.Causation.map((e) => Causation.fromJSON(e))
+                : [],
+            CausedBy: isSet(object.CausedBy) ? Identity.fromJSON(object.CausedBy) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.Namespace !== "") {
+            obj.Namespace = message.Namespace;
+        }
+        if (message.EventSequenceId !== "") {
+            obj.EventSequenceId = message.EventSequenceId;
+        }
+        if (message.CompensationFor !== 0n) {
+            obj.CompensationFor = message.CompensationFor.toString();
+        }
+        if (message.EventType !== undefined) {
+            obj.EventType = EventType.toJSON(message.EventType);
+        }
+        if (message.Content !== "") {
+            obj.Content = message.Content;
+        }
+        if (message.CorrelationId !== undefined) {
+            obj.CorrelationId = Guid.toJSON(message.CorrelationId);
+        }
+        if (message.Tags?.length) {
+            obj.Tags = message.Tags;
+        }
+        if (message.Occurred !== undefined) {
+            obj.Occurred = SerializableDateTimeOffset.toJSON(message.Occurred);
+        }
+        if (message.Causation?.length) {
+            obj.Causation = message.Causation.map((e) => Causation.toJSON(e));
+        }
+        if (message.CausedBy !== undefined) {
+            obj.CausedBy = Identity.toJSON(message.CausedBy);
+        }
+        return obj;
+    },
+    create(base) {
+        return CompensateRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseCompensateRequest();
+        message.EventStore = object.EventStore ?? "";
+        message.Namespace = object.Namespace ?? "";
+        message.EventSequenceId = object.EventSequenceId ?? "";
+        message.CompensationFor = (object.CompensationFor !== undefined && object.CompensationFor !== null)
+            ? BigInt(object.CompensationFor)
+            : 0n;
+        message.EventType = (object.EventType !== undefined && object.EventType !== null)
+            ? EventType.fromPartial(object.EventType)
+            : undefined;
+        message.Content = object.Content ?? "";
+        message.CorrelationId = (object.CorrelationId !== undefined && object.CorrelationId !== null)
+            ? Guid.fromPartial(object.CorrelationId)
+            : undefined;
+        message.Tags = object.Tags?.map((e) => e) || [];
+        message.Occurred = (object.Occurred !== undefined && object.Occurred !== null)
+            ? SerializableDateTimeOffset.fromPartial(object.Occurred)
+            : undefined;
+        message.Causation = object.Causation?.map((e) => Causation.fromPartial(e)) || [];
+        message.CausedBy = (object.CausedBy !== undefined && object.CausedBy !== null)
+            ? Identity.fromPartial(object.CausedBy)
+            : undefined;
+        return message;
+    },
+};
 function createBaseCompleteStreamRequest() {
     return { EventStore: "", Namespace: "", EventSequenceId: "", EventStreamType: "", EventStreamId: "" };
 }
@@ -8446,6 +8686,7 @@ function createBaseEventContext() {
         Subject: "",
         NamedTags: [],
         EventSource: "",
+        CompensationFor: 0n,
     };
 }
 export const EventContext = {
@@ -8501,6 +8742,12 @@ export const EventContext = {
         if (message.EventSource !== "") {
             writer.uint32(130).string(message.EventSource);
         }
+        if (message.CompensationFor !== 0n) {
+            if (BigInt.asUintN(64, message.CompensationFor) !== message.CompensationFor) {
+                throw new globalThis.Error("value provided for field message.CompensationFor of type uint64 too large");
+            }
+            writer.uint32(136).uint64(message.CompensationFor);
+        }
         return writer;
     },
     decode(input, length) {
@@ -8628,6 +8875,13 @@ export const EventContext = {
                         message.EventSource = reader.string();
                         continue;
                     }
+                    case 17: {
+                        if (tag !== 136) {
+                            break;
+                        }
+                        message.CompensationFor = reader.uint64();
+                        continue;
+                    }
                 }
                 if ((tag & 7) === 4 || tag === 0) {
                     break;
@@ -8662,6 +8916,7 @@ export const EventContext = {
                 ? object.NamedTags.map((e) => NamedTag.fromJSON(e))
                 : [],
             EventSource: isSet(object.EventSource) ? globalThis.String(object.EventSource) : "",
+            CompensationFor: isSet(object.CompensationFor) ? BigInt(object.CompensationFor) : 0n,
         };
     },
     toJSON(message) {
@@ -8714,6 +8969,9 @@ export const EventContext = {
         if (message.EventSource !== "") {
             obj.EventSource = message.EventSource;
         }
+        if (message.CompensationFor !== 0n) {
+            obj.CompensationFor = message.CompensationFor.toString();
+        }
         return obj;
     },
     create(base) {
@@ -8747,6 +9005,9 @@ export const EventContext = {
         message.Subject = object.Subject ?? "";
         message.NamedTags = object.NamedTags?.map((e) => NamedTag.fromPartial(e)) || [];
         message.EventSource = object.EventSource ?? "";
+        message.CompensationFor = (object.CompensationFor !== undefined && object.CompensationFor !== null)
+            ? BigInt(object.CompensationFor)
+            : 0n;
         return message;
     },
 };
@@ -17264,6 +17525,14 @@ export const EventSequencesDefinition = {
             responseStream: false,
             options: {},
         },
+        compensate: {
+            name: "Compensate",
+            requestType: CompensateRequest,
+            requestStream: false,
+            responseType: CommandResultAppendResponse,
+            responseStream: false,
+            options: {},
+        },
         completeStream: {
             name: "CompleteStream",
             requestType: CompleteStreamRequest,