@cratis/chronicle.contracts 19.121.1 → 19.123.0

package/generated/observation_reactors.ts

@@ -85,10 +85,62 @@ export function eventObservationStateToJSON(object: EventObservationState): stri
   }
 }
 
+export enum ObservationOrigin {
+  Unknown = 0,
+  Live = 1,
+  CatchingUp = 2,
+  Replaying = 3,
+  Retrying = 4,
+  UNRECOGNIZED = -1,
+}
+
+export function observationOriginFromJSON(object: any): ObservationOrigin {
+  switch (object) {
+    case 0:
+    case "Unknown":
+      return ObservationOrigin.Unknown;
+    case 1:
+    case "Live":
+      return ObservationOrigin.Live;
+    case 2:
+    case "CatchingUp":
+      return ObservationOrigin.CatchingUp;
+    case 3:
+    case "Replaying":
+      return ObservationOrigin.Replaying;
+    case 4:
+    case "Retrying":
+      return ObservationOrigin.Retrying;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return ObservationOrigin.UNRECOGNIZED;
+  }
+}
+
+export function observationOriginToJSON(object: ObservationOrigin): string {
+  switch (object) {
+    case ObservationOrigin.Unknown:
+      return "Unknown";
+    case ObservationOrigin.Live:
+      return "Live";
+    case ObservationOrigin.CatchingUp:
+      return "CatchingUp";
+    case ObservationOrigin.Replaying:
+      return "Replaying";
+    case ObservationOrigin.Retrying:
+      return "Retrying";
+    case ObservationOrigin.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
 export enum ObservationState {
   OBSERVATION_STATE_None = 0,
   Success = 1,
   Failed = 2,
+  Deferred = 3,
   UNRECOGNIZED = -1,
 }
 
@@ -103,6 +155,9 @@ export function observationStateFromJSON(object: any): ObservationState {
     case 2:
     case "Failed":
       return ObservationState.Failed;
+    case 3:
+    case "Deferred":
+      return ObservationState.Deferred;
     case -1:
     case "UNRECOGNIZED":
     default:
@@ -118,6 +173,8 @@ export function observationStateToJSON(object: ObservationState): string {
       return "Success";
     case ObservationState.Failed:
       return "Failed";
+    case ObservationState.Deferred:
+      return "Deferred";
     case ObservationState.UNRECOGNIZED:
     default:
       return "UNRECOGNIZED";
@@ -247,6 +304,8 @@ export interface EventsToObserve {
   ReplayState: ReplayState;
   DeliveryId: bigint;
   DeliverWithinMilliseconds: bigint;
+  Partitions: PartitionEvents[];
+  Origin: ObservationOrigin;
 }
 
 export interface HasReactorRequest {
@@ -284,6 +343,28 @@ export interface OneOfRegisterReactorReactorResult {
   Value1: ReactorResult | undefined;
 }
 
+export interface PageDelivery {
+  Enabled: boolean;
+  MaxEventsPerPage: number;
+  MaxBytesPerPage: number;
+  MaxDelayMilliseconds: number;
+}
+
+export interface PartitionEvents {
+  Partition: string;
+  Events: AppendedEvent[];
+}
+
+export interface PartitionResult {
+  Partition: string;
+  State: ObservationState;
+  LastSuccessfulObservation: bigint;
+  ExceptionMessages: string[];
+  ExceptionStackTrace: string;
+  RetryAfterMilliseconds: bigint;
+  ReadModelState: string;
+}
+
 export interface ReactorDefinition {
   ReactorId: string;
   EventSequenceId: string;
@@ -308,6 +389,8 @@ export interface ReactorResult {
   ExceptionMessages: string[];
   ExceptionStackTrace: string;
   DeliveryId: bigint;
+  RetryAfterMilliseconds: bigint;
+  Partitions: PartitionResult[];
 }
 
 export interface RegisterReactor {
@@ -315,6 +398,7 @@ export interface RegisterReactor {
   EventStore: string;
   Namespace: string;
   Reactor: ReactorDefinition | undefined;
+  PageDelivery: PageDelivery | undefined;
 }
 
 /** Represents a DateTimeOffset value as an ISO 8601 string (e.g., "2024-01-15T12:30:00.0000000+02:00"). */
@@ -1510,7 +1594,15 @@ export const EventTypeWithKeyExpression: MessageFns<EventTypeWithKeyExpression>
 };
 
 function createBaseEventsToObserve(): EventsToObserve {
-  return { Partition: "", Events: [], ReplayState: 0, DeliveryId: 0n, DeliverWithinMilliseconds: 0n };
+  return {
+    Partition: "",
+    Events: [],
+    ReplayState: 0,
+    DeliveryId: 0n,
+    DeliverWithinMilliseconds: 0n,
+    Partitions: [],
+    Origin: 0,
+  };
 }
 
 export const EventsToObserve: MessageFns<EventsToObserve> = {
@@ -1538,6 +1630,12 @@ export const EventsToObserve: MessageFns<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;
   },
 
@@ -1594,6 +1692,22 @@ export const EventsToObserve: MessageFns<EventsToObserve> = {
             message.DeliverWithinMilliseconds = reader.uint64() as bigint;
             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() as any;
+            continue;
+          }
         }
         if ((tag & 7) === 4 || tag === 0) {
           break;
@@ -1615,6 +1729,10 @@ export const EventsToObserve: MessageFns<EventsToObserve> = {
       DeliverWithinMilliseconds: isSet(object.DeliverWithinMilliseconds)
         ? BigInt(object.DeliverWithinMilliseconds)
         : 0n,
+      Partitions: globalThis.Array.isArray(object?.Partitions)
+        ? object.Partitions.map((e: any) => PartitionEvents.fromJSON(e))
+        : [],
+      Origin: isSet(object.Origin) ? observationOriginFromJSON(object.Origin) : 0,
     };
   },
 
@@ -1635,6 +1753,12 @@ export const EventsToObserve: MessageFns<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;
   },
 
@@ -1653,6 +1777,8 @@ export const EventsToObserve: MessageFns<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;
   },
 };
@@ -2239,6 +2365,399 @@ export const OneOfRegisterReactorReactorResult: MessageFns<OneOfRegisterReactorR
   },
 };
 
+function createBasePageDelivery(): PageDelivery {
+  return { Enabled: false, MaxEventsPerPage: 0, MaxBytesPerPage: 0, MaxDelayMilliseconds: 0 };
+}
+
+export const PageDelivery: MessageFns<PageDelivery> = {
+  encode(message: PageDelivery, writer: BinaryWriter = new BinaryWriter()): 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: BinaryReader | Uint8Array, length?: number): PageDelivery {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__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 as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): PageDelivery {
+    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: PageDelivery): unknown {
+    const obj: any = {};
+    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?: DeepPartial<PageDelivery>): PageDelivery {
+    return PageDelivery.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<PageDelivery>): PageDelivery {
+    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(): PartitionEvents {
+  return { Partition: "", Events: [] };
+}
+
+export const PartitionEvents: MessageFns<PartitionEvents> = {
+  encode(message: PartitionEvents, writer: BinaryWriter = new BinaryWriter()): 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: BinaryReader | Uint8Array, length?: number): PartitionEvents {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__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 as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): PartitionEvents {
+    return {
+      Partition: isSet(object.Partition) ? globalThis.String(object.Partition) : "",
+      Events: globalThis.Array.isArray(object?.Events) ? object.Events.map((e: any) => AppendedEvent.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: PartitionEvents): unknown {
+    const obj: any = {};
+    if (message.Partition !== "") {
+      obj.Partition = message.Partition;
+    }
+    if (message.Events?.length) {
+      obj.Events = message.Events.map((e) => AppendedEvent.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<PartitionEvents>): PartitionEvents {
+    return PartitionEvents.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<PartitionEvents>): PartitionEvents {
+    const message = createBasePartitionEvents();
+    message.Partition = object.Partition ?? "";
+    message.Events = object.Events?.map((e) => AppendedEvent.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBasePartitionResult(): PartitionResult {
+  return {
+    Partition: "",
+    State: 0,
+    LastSuccessfulObservation: 0n,
+    ExceptionMessages: [],
+    ExceptionStackTrace: "",
+    RetryAfterMilliseconds: 0n,
+    ReadModelState: "",
+  };
+}
+
+export const PartitionResult: MessageFns<PartitionResult> = {
+  encode(message: PartitionResult, writer: BinaryWriter = new BinaryWriter()): 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: BinaryReader | Uint8Array, length?: number): PartitionResult {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__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() as any;
+            continue;
+          }
+          case 3: {
+            if (tag !== 24) {
+              break;
+            }
+
+            message.LastSuccessfulObservation = reader.uint64() as bigint;
+            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() as bigint;
+            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 as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): PartitionResult {
+    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: any) => 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: PartitionResult): unknown {
+    const obj: any = {};
+    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?: DeepPartial<PartitionResult>): PartitionResult {
+    return PartitionResult.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<PartitionResult>): PartitionResult {
+    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(): ReactorDefinition {
   return {
     ReactorId: "",
@@ -2529,6 +3048,8 @@ function createBaseReactorResult(): ReactorResult {
     ExceptionMessages: [],
     ExceptionStackTrace: "",
     DeliveryId: 0n,
+    RetryAfterMilliseconds: 0n,
+    Partitions: [],
   };
 }
 
@@ -2560,6 +3081,15 @@ export const ReactorResult: MessageFns<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;
   },
 
@@ -2624,6 +3154,22 @@ export const ReactorResult: MessageFns<ReactorResult> = {
             message.DeliveryId = reader.uint64() as bigint;
             continue;
           }
+          case 7: {
+            if (tag !== 56) {
+              break;
+            }
+
+            message.RetryAfterMilliseconds = reader.uint64() as bigint;
+            continue;
+          }
+          case 8: {
+            if (tag !== 66) {
+              break;
+            }
+
+            message.Partitions.push(PartitionResult.decode(reader, reader.uint32()));
+            continue;
+          }
         }
         if ((tag & 7) === 4 || tag === 0) {
           break;
@@ -2648,6 +3194,10 @@ export const ReactorResult: MessageFns<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: any) => PartitionResult.fromJSON(e))
+        : [],
     };
   },
 
@@ -2671,6 +3221,12 @@ export const ReactorResult: MessageFns<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;
   },
 
@@ -2690,12 +3246,17 @@ export const ReactorResult: MessageFns<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(): RegisterReactor {
-  return { ConnectionId: "", EventStore: "", Namespace: "", Reactor: undefined };
+  return { ConnectionId: "", EventStore: "", Namespace: "", Reactor: undefined, PageDelivery: undefined };
 }
 
 export const RegisterReactor: MessageFns<RegisterReactor> = {
@@ -2712,6 +3273,9 @@ export const RegisterReactor: MessageFns<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;
   },
 
@@ -2760,6 +3324,14 @@ export const RegisterReactor: MessageFns<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;
@@ -2778,6 +3350,7 @@ export const RegisterReactor: MessageFns<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,
     };
   },
 
@@ -2795,6 +3368,9 @@ export const RegisterReactor: MessageFns<RegisterReactor> = {
     if (message.Reactor !== undefined) {
       obj.Reactor = ReactorDefinition.toJSON(message.Reactor);
     }
+    if (message.PageDelivery !== undefined) {
+      obj.PageDelivery = PageDelivery.toJSON(message.PageDelivery);
+    }
     return obj;
   },
 
@@ -2809,6 +3385,9 @@ export const RegisterReactor: MessageFns<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;
   },
 };