@cratis/chronicle.contracts 19.121.1 → 19.123.0

package/dist/cjs/generated/observation_reactors.js

@@ -71,11 +71,61 @@ function eventObservationStateToJSON(object) {
             return "UNRECOGNIZED";
     }
 }
+exports.ObservationOrigin = void 0;
+(function (ObservationOrigin) {
+    ObservationOrigin[ObservationOrigin["Unknown"] = 0] = "Unknown";
+    ObservationOrigin[ObservationOrigin["Live"] = 1] = "Live";
+    ObservationOrigin[ObservationOrigin["CatchingUp"] = 2] = "CatchingUp";
+    ObservationOrigin[ObservationOrigin["Replaying"] = 3] = "Replaying";
+    ObservationOrigin[ObservationOrigin["Retrying"] = 4] = "Retrying";
+    ObservationOrigin[ObservationOrigin["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(exports.ObservationOrigin || (exports.ObservationOrigin = {}));
+function observationOriginFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "Unknown":
+            return exports.ObservationOrigin.Unknown;
+        case 1:
+        case "Live":
+            return exports.ObservationOrigin.Live;
+        case 2:
+        case "CatchingUp":
+            return exports.ObservationOrigin.CatchingUp;
+        case 3:
+        case "Replaying":
+            return exports.ObservationOrigin.Replaying;
+        case 4:
+        case "Retrying":
+            return exports.ObservationOrigin.Retrying;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return exports.ObservationOrigin.UNRECOGNIZED;
+    }
+}
+function observationOriginToJSON(object) {
+    switch (object) {
+        case exports.ObservationOrigin.Unknown:
+            return "Unknown";
+        case exports.ObservationOrigin.Live:
+            return "Live";
+        case exports.ObservationOrigin.CatchingUp:
+            return "CatchingUp";
+        case exports.ObservationOrigin.Replaying:
+            return "Replaying";
+        case exports.ObservationOrigin.Retrying:
+            return "Retrying";
+        case exports.ObservationOrigin.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
 exports.ObservationState = void 0;
 (function (ObservationState) {
     ObservationState[ObservationState["OBSERVATION_STATE_None"] = 0] = "OBSERVATION_STATE_None";
     ObservationState[ObservationState["Success"] = 1] = "Success";
     ObservationState[ObservationState["Failed"] = 2] = "Failed";
+    ObservationState[ObservationState["Deferred"] = 3] = "Deferred";
     ObservationState[ObservationState["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(exports.ObservationState || (exports.ObservationState = {}));
 function observationStateFromJSON(object) {
@@ -89,6 +139,9 @@ function observationStateFromJSON(object) {
         case 2:
         case "Failed":
             return exports.ObservationState.Failed;
+        case 3:
+        case "Deferred":
+            return exports.ObservationState.Deferred;
         case -1:
         case "UNRECOGNIZED":
         default:
@@ -103,6 +156,8 @@ function observationStateToJSON(object) {
             return "Success";
         case exports.ObservationState.Failed:
             return "Failed";
+        case exports.ObservationState.Deferred:
+            return "Deferred";
         case exports.ObservationState.UNRECOGNIZED:
         default:
             return "UNRECOGNIZED";
@@ -1255,7 +1310,15 @@ const EventTypeWithKeyExpression = {
     },
 };
 function createBaseEventsToObserve() {
-    return { Partition: "", Events: [], ReplayState: 0, DeliveryId: 0n, DeliverWithinMilliseconds: 0n };
+    return {
+        Partition: "",
+        Events: [],
+        ReplayState: 0,
+        DeliveryId: 0n,
+        DeliverWithinMilliseconds: 0n,
+        Partitions: [],
+        Origin: 0,
+    };
 }
 const EventsToObserve = {
     encode(message, writer = new wire.BinaryWriter()) {
@@ -1280,6 +1343,12 @@ const EventsToObserve = {
             }
             writer.uint32(40).uint64(message.DeliverWithinMilliseconds);
         }
+        for (const v of message.Partitions) {
+            PartitionEvents.encode(v, writer.uint32(50).fork()).join();
+        }
+        if (message.Origin !== 0) {
+            writer.uint32(56).int32(message.Origin);
+        }
         return writer;
     },
     decode(input, length) {
@@ -1330,6 +1399,20 @@ const EventsToObserve = {
                         message.DeliverWithinMilliseconds = reader.uint64();
                         continue;
                     }
+                    case 6: {
+                        if (tag !== 50) {
+                            break;
+                        }
+                        message.Partitions.push(PartitionEvents.decode(reader, reader.uint32()));
+                        continue;
+                    }
+                    case 7: {
+                        if (tag !== 56) {
+                            break;
+                        }
+                        message.Origin = reader.int32();
+                        continue;
+                    }
                 }
                 if ((tag & 7) === 4 || tag === 0) {
                     break;
@@ -1351,6 +1434,10 @@ const EventsToObserve = {
             DeliverWithinMilliseconds: isSet(object.DeliverWithinMilliseconds)
                 ? BigInt(object.DeliverWithinMilliseconds)
                 : 0n,
+            Partitions: globalThis.Array.isArray(object?.Partitions)
+                ? object.Partitions.map((e) => PartitionEvents.fromJSON(e))
+                : [],
+            Origin: isSet(object.Origin) ? observationOriginFromJSON(object.Origin) : 0,
         };
     },
     toJSON(message) {
@@ -1370,6 +1457,12 @@ const EventsToObserve = {
         if (message.DeliverWithinMilliseconds !== 0n) {
             obj.DeliverWithinMilliseconds = message.DeliverWithinMilliseconds.toString();
         }
+        if (message.Partitions?.length) {
+            obj.Partitions = message.Partitions.map((e) => PartitionEvents.toJSON(e));
+        }
+        if (message.Origin !== 0) {
+            obj.Origin = observationOriginToJSON(message.Origin);
+        }
         return obj;
     },
     create(base) {
@@ -1387,6 +1480,8 @@ const EventsToObserve = {
             (object.DeliverWithinMilliseconds !== undefined && object.DeliverWithinMilliseconds !== null)
                 ? BigInt(object.DeliverWithinMilliseconds)
                 : 0n;
+        message.Partitions = object.Partitions?.map((e) => PartitionEvents.fromPartial(e)) || [];
+        message.Origin = object.Origin ?? 0;
         return message;
     },
 };
@@ -1926,6 +2021,369 @@ const OneOfRegisterReactorReactorResult = {
         return message;
     },
 };
+function createBasePageDelivery() {
+    return { Enabled: false, MaxEventsPerPage: 0, MaxBytesPerPage: 0, MaxDelayMilliseconds: 0 };
+}
+const PageDelivery = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Enabled !== false) {
+            writer.uint32(8).bool(message.Enabled);
+        }
+        if (message.MaxEventsPerPage !== 0) {
+            writer.uint32(16).uint32(message.MaxEventsPerPage);
+        }
+        if (message.MaxBytesPerPage !== 0) {
+            writer.uint32(24).uint32(message.MaxBytesPerPage);
+        }
+        if (message.MaxDelayMilliseconds !== 0) {
+            writer.uint32(32).uint32(message.MaxDelayMilliseconds);
+        }
+        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 = createBasePageDelivery();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 8) {
+                            break;
+                        }
+                        message.Enabled = reader.bool();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 16) {
+                            break;
+                        }
+                        message.MaxEventsPerPage = reader.uint32();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 24) {
+                            break;
+                        }
+                        message.MaxBytesPerPage = reader.uint32();
+                        continue;
+                    }
+                    case 4: {
+                        if (tag !== 32) {
+                            break;
+                        }
+                        message.MaxDelayMilliseconds = reader.uint32();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            Enabled: isSet(object.Enabled) ? globalThis.Boolean(object.Enabled) : false,
+            MaxEventsPerPage: isSet(object.MaxEventsPerPage) ? globalThis.Number(object.MaxEventsPerPage) : 0,
+            MaxBytesPerPage: isSet(object.MaxBytesPerPage) ? globalThis.Number(object.MaxBytesPerPage) : 0,
+            MaxDelayMilliseconds: isSet(object.MaxDelayMilliseconds) ? globalThis.Number(object.MaxDelayMilliseconds) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Enabled !== false) {
+            obj.Enabled = message.Enabled;
+        }
+        if (message.MaxEventsPerPage !== 0) {
+            obj.MaxEventsPerPage = Math.round(message.MaxEventsPerPage);
+        }
+        if (message.MaxBytesPerPage !== 0) {
+            obj.MaxBytesPerPage = Math.round(message.MaxBytesPerPage);
+        }
+        if (message.MaxDelayMilliseconds !== 0) {
+            obj.MaxDelayMilliseconds = Math.round(message.MaxDelayMilliseconds);
+        }
+        return obj;
+    },
+    create(base) {
+        return PageDelivery.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBasePageDelivery();
+        message.Enabled = object.Enabled ?? false;
+        message.MaxEventsPerPage = object.MaxEventsPerPage ?? 0;
+        message.MaxBytesPerPage = object.MaxBytesPerPage ?? 0;
+        message.MaxDelayMilliseconds = object.MaxDelayMilliseconds ?? 0;
+        return message;
+    },
+};
+function createBasePartitionEvents() {
+    return { Partition: "", Events: [] };
+}
+const PartitionEvents = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Partition !== "") {
+            writer.uint32(10).string(message.Partition);
+        }
+        for (const v of message.Events) {
+            AppendedEvent.encode(v, 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 = createBasePartitionEvents();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.Partition = reader.string();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 18) {
+                            break;
+                        }
+                        message.Events.push(AppendedEvent.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 {
+            Partition: isSet(object.Partition) ? globalThis.String(object.Partition) : "",
+            Events: globalThis.Array.isArray(object?.Events) ? object.Events.map((e) => AppendedEvent.fromJSON(e)) : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Partition !== "") {
+            obj.Partition = message.Partition;
+        }
+        if (message.Events?.length) {
+            obj.Events = message.Events.map((e) => AppendedEvent.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return PartitionEvents.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBasePartitionEvents();
+        message.Partition = object.Partition ?? "";
+        message.Events = object.Events?.map((e) => AppendedEvent.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBasePartitionResult() {
+    return {
+        Partition: "",
+        State: 0,
+        LastSuccessfulObservation: 0n,
+        ExceptionMessages: [],
+        ExceptionStackTrace: "",
+        RetryAfterMilliseconds: 0n,
+        ReadModelState: "",
+    };
+}
+const PartitionResult = {
+    encode(message, writer = new wire.BinaryWriter()) {
+        if (message.Partition !== "") {
+            writer.uint32(10).string(message.Partition);
+        }
+        if (message.State !== 0) {
+            writer.uint32(16).int32(message.State);
+        }
+        if (message.LastSuccessfulObservation !== 0n) {
+            if (BigInt.asUintN(64, message.LastSuccessfulObservation) !== message.LastSuccessfulObservation) {
+                throw new globalThis.Error("value provided for field message.LastSuccessfulObservation of type uint64 too large");
+            }
+            writer.uint32(24).uint64(message.LastSuccessfulObservation);
+        }
+        for (const v of message.ExceptionMessages) {
+            writer.uint32(34).string(v);
+        }
+        if (message.ExceptionStackTrace !== "") {
+            writer.uint32(42).string(message.ExceptionStackTrace);
+        }
+        if (message.RetryAfterMilliseconds !== 0n) {
+            if (BigInt.asUintN(64, message.RetryAfterMilliseconds) !== message.RetryAfterMilliseconds) {
+                throw new globalThis.Error("value provided for field message.RetryAfterMilliseconds of type uint64 too large");
+            }
+            writer.uint32(48).uint64(message.RetryAfterMilliseconds);
+        }
+        if (message.ReadModelState !== "") {
+            writer.uint32(58).string(message.ReadModelState);
+        }
+        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 = createBasePartitionResult();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1: {
+                        if (tag !== 10) {
+                            break;
+                        }
+                        message.Partition = reader.string();
+                        continue;
+                    }
+                    case 2: {
+                        if (tag !== 16) {
+                            break;
+                        }
+                        message.State = reader.int32();
+                        continue;
+                    }
+                    case 3: {
+                        if (tag !== 24) {
+                            break;
+                        }
+                        message.LastSuccessfulObservation = reader.uint64();
+                        continue;
+                    }
+                    case 4: {
+                        if (tag !== 34) {
+                            break;
+                        }
+                        message.ExceptionMessages.push(reader.string());
+                        continue;
+                    }
+                    case 5: {
+                        if (tag !== 42) {
+                            break;
+                        }
+                        message.ExceptionStackTrace = reader.string();
+                        continue;
+                    }
+                    case 6: {
+                        if (tag !== 48) {
+                            break;
+                        }
+                        message.RetryAfterMilliseconds = reader.uint64();
+                        continue;
+                    }
+                    case 7: {
+                        if (tag !== 58) {
+                            break;
+                        }
+                        message.ReadModelState = reader.string();
+                        continue;
+                    }
+                }
+                if ((tag & 7) === 4 || tag === 0) {
+                    break;
+                }
+                reader.skip(tag & 7);
+            }
+            return message;
+        }
+        finally {
+            reader.__tsProtoDecodeDepth = previousRecursionDepth;
+        }
+    },
+    fromJSON(object) {
+        return {
+            Partition: isSet(object.Partition) ? globalThis.String(object.Partition) : "",
+            State: isSet(object.State) ? observationStateFromJSON(object.State) : 0,
+            LastSuccessfulObservation: isSet(object.LastSuccessfulObservation)
+                ? BigInt(object.LastSuccessfulObservation)
+                : 0n,
+            ExceptionMessages: globalThis.Array.isArray(object?.ExceptionMessages)
+                ? object.ExceptionMessages.map((e) => globalThis.String(e))
+                : [],
+            ExceptionStackTrace: isSet(object.ExceptionStackTrace) ? globalThis.String(object.ExceptionStackTrace) : "",
+            RetryAfterMilliseconds: isSet(object.RetryAfterMilliseconds) ? BigInt(object.RetryAfterMilliseconds) : 0n,
+            ReadModelState: isSet(object.ReadModelState) ? globalThis.String(object.ReadModelState) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Partition !== "") {
+            obj.Partition = message.Partition;
+        }
+        if (message.State !== 0) {
+            obj.State = observationStateToJSON(message.State);
+        }
+        if (message.LastSuccessfulObservation !== 0n) {
+            obj.LastSuccessfulObservation = message.LastSuccessfulObservation.toString();
+        }
+        if (message.ExceptionMessages?.length) {
+            obj.ExceptionMessages = message.ExceptionMessages;
+        }
+        if (message.ExceptionStackTrace !== "") {
+            obj.ExceptionStackTrace = message.ExceptionStackTrace;
+        }
+        if (message.RetryAfterMilliseconds !== 0n) {
+            obj.RetryAfterMilliseconds = message.RetryAfterMilliseconds.toString();
+        }
+        if (message.ReadModelState !== "") {
+            obj.ReadModelState = message.ReadModelState;
+        }
+        return obj;
+    },
+    create(base) {
+        return PartitionResult.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBasePartitionResult();
+        message.Partition = object.Partition ?? "";
+        message.State = object.State ?? 0;
+        message.LastSuccessfulObservation =
+            (object.LastSuccessfulObservation !== undefined && object.LastSuccessfulObservation !== null)
+                ? BigInt(object.LastSuccessfulObservation)
+                : 0n;
+        message.ExceptionMessages = object.ExceptionMessages?.map((e) => e) || [];
+        message.ExceptionStackTrace = object.ExceptionStackTrace ?? "";
+        message.RetryAfterMilliseconds =
+            (object.RetryAfterMilliseconds !== undefined && object.RetryAfterMilliseconds !== null)
+                ? BigInt(object.RetryAfterMilliseconds)
+                : 0n;
+        message.ReadModelState = object.ReadModelState ?? "";
+        return message;
+    },
+};
 function createBaseReactorDefinition() {
     return {
         ReactorId: "",
@@ -2196,6 +2654,8 @@ function createBaseReactorResult() {
         ExceptionMessages: [],
         ExceptionStackTrace: "",
         DeliveryId: 0n,
+        RetryAfterMilliseconds: 0n,
+        Partitions: [],
     };
 }
 const ReactorResult = {
@@ -2224,6 +2684,15 @@ const ReactorResult = {
             }
             writer.uint32(48).uint64(message.DeliveryId);
         }
+        if (message.RetryAfterMilliseconds !== 0n) {
+            if (BigInt.asUintN(64, message.RetryAfterMilliseconds) !== message.RetryAfterMilliseconds) {
+                throw new globalThis.Error("value provided for field message.RetryAfterMilliseconds of type uint64 too large");
+            }
+            writer.uint32(56).uint64(message.RetryAfterMilliseconds);
+        }
+        for (const v of message.Partitions) {
+            PartitionResult.encode(v, writer.uint32(66).fork()).join();
+        }
         return writer;
     },
     decode(input, length) {
@@ -2281,6 +2750,20 @@ const ReactorResult = {
                         message.DeliveryId = reader.uint64();
                         continue;
                     }
+                    case 7: {
+                        if (tag !== 56) {
+                            break;
+                        }
+                        message.RetryAfterMilliseconds = reader.uint64();
+                        continue;
+                    }
+                    case 8: {
+                        if (tag !== 66) {
+                            break;
+                        }
+                        message.Partitions.push(PartitionResult.decode(reader, reader.uint32()));
+                        continue;
+                    }
                 }
                 if ((tag & 7) === 4 || tag === 0) {
                     break;
@@ -2305,6 +2788,10 @@ const ReactorResult = {
                 : [],
             ExceptionStackTrace: isSet(object.ExceptionStackTrace) ? globalThis.String(object.ExceptionStackTrace) : "",
             DeliveryId: isSet(object.DeliveryId) ? BigInt(object.DeliveryId) : 0n,
+            RetryAfterMilliseconds: isSet(object.RetryAfterMilliseconds) ? BigInt(object.RetryAfterMilliseconds) : 0n,
+            Partitions: globalThis.Array.isArray(object?.Partitions)
+                ? object.Partitions.map((e) => PartitionResult.fromJSON(e))
+                : [],
         };
     },
     toJSON(message) {
@@ -2327,6 +2814,12 @@ const ReactorResult = {
         if (message.DeliveryId !== 0n) {
             obj.DeliveryId = message.DeliveryId.toString();
         }
+        if (message.RetryAfterMilliseconds !== 0n) {
+            obj.RetryAfterMilliseconds = message.RetryAfterMilliseconds.toString();
+        }
+        if (message.Partitions?.length) {
+            obj.Partitions = message.Partitions.map((e) => PartitionResult.toJSON(e));
+        }
         return obj;
     },
     create(base) {
@@ -2345,11 +2838,16 @@ const ReactorResult = {
         message.DeliveryId = (object.DeliveryId !== undefined && object.DeliveryId !== null)
             ? BigInt(object.DeliveryId)
             : 0n;
+        message.RetryAfterMilliseconds =
+            (object.RetryAfterMilliseconds !== undefined && object.RetryAfterMilliseconds !== null)
+                ? BigInt(object.RetryAfterMilliseconds)
+                : 0n;
+        message.Partitions = object.Partitions?.map((e) => PartitionResult.fromPartial(e)) || [];
         return message;
     },
 };
 function createBaseRegisterReactor() {
-    return { ConnectionId: "", EventStore: "", Namespace: "", Reactor: undefined };
+    return { ConnectionId: "", EventStore: "", Namespace: "", Reactor: undefined, PageDelivery: undefined };
 }
 const RegisterReactor = {
     encode(message, writer = new wire.BinaryWriter()) {
@@ -2365,6 +2863,9 @@ const RegisterReactor = {
         if (message.Reactor !== undefined) {
             ReactorDefinition.encode(message.Reactor, writer.uint32(34).fork()).join();
         }
+        if (message.PageDelivery !== undefined) {
+            PageDelivery.encode(message.PageDelivery, writer.uint32(42).fork()).join();
+        }
         return writer;
     },
     decode(input, length) {
@@ -2408,6 +2909,13 @@ const RegisterReactor = {
                         message.Reactor = ReactorDefinition.decode(reader, reader.uint32());
                         continue;
                     }
+                    case 5: {
+                        if (tag !== 42) {
+                            break;
+                        }
+                        message.PageDelivery = PageDelivery.decode(reader, reader.uint32());
+                        continue;
+                    }
                 }
                 if ((tag & 7) === 4 || tag === 0) {
                     break;
@@ -2426,6 +2934,7 @@ const RegisterReactor = {
             EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
             Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
             Reactor: isSet(object.Reactor) ? ReactorDefinition.fromJSON(object.Reactor) : undefined,
+            PageDelivery: isSet(object.PageDelivery) ? PageDelivery.fromJSON(object.PageDelivery) : undefined,
         };
     },
     toJSON(message) {
@@ -2442,6 +2951,9 @@ const RegisterReactor = {
         if (message.Reactor !== undefined) {
             obj.Reactor = ReactorDefinition.toJSON(message.Reactor);
         }
+        if (message.PageDelivery !== undefined) {
+            obj.PageDelivery = PageDelivery.toJSON(message.PageDelivery);
+        }
         return obj;
     },
     create(base) {
@@ -2455,6 +2967,9 @@ const RegisterReactor = {
         message.Reactor = (object.Reactor !== undefined && object.Reactor !== null)
             ? ReactorDefinition.fromPartial(object.Reactor)
             : undefined;
+        message.PageDelivery = (object.PageDelivery !== undefined && object.PageDelivery !== null)
+            ? PageDelivery.fromPartial(object.PageDelivery)
+            : undefined;
         return message;
     },
 };
@@ -2563,6 +3078,9 @@ exports.Identity = Identity;
 exports.NamedTag = NamedTag;
 exports.ObserverFilters = ObserverFilters;
 exports.OneOfRegisterReactorReactorResult = OneOfRegisterReactorReactorResult;
+exports.PageDelivery = PageDelivery;
+exports.PartitionEvents = PartitionEvents;
+exports.PartitionResult = PartitionResult;
 exports.ReactorDefinition = ReactorDefinition;
 exports.ReactorMessage = ReactorMessage;
 exports.ReactorResult = ReactorResult;
@@ -2573,6 +3091,8 @@ exports.eventGenerationDeliveryFromJSON = eventGenerationDeliveryFromJSON;
 exports.eventGenerationDeliveryToJSON = eventGenerationDeliveryToJSON;
 exports.eventObservationStateFromJSON = eventObservationStateFromJSON;
 exports.eventObservationStateToJSON = eventObservationStateToJSON;
+exports.observationOriginFromJSON = observationOriginFromJSON;
+exports.observationOriginToJSON = observationOriginToJSON;
 exports.observationStateFromJSON = observationStateFromJSON;
 exports.observationStateToJSON = observationStateToJSON;
 exports.replayStateFromJSON = replayStateFromJSON;