@cratis/chronicle.contracts 19.121.1 → 19.123.0

package/generated/observation_reducers.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";
@@ -265,6 +322,23 @@ export interface OneOfRegisterReducerReducerResult {
   Value1: ReducerResult | undefined;
 }
 
+export interface PageDelivery {
+  Enabled: boolean;
+  MaxEventsPerPage: number;
+  MaxBytesPerPage: number;
+  MaxDelayMilliseconds: number;
+}
+
+export interface PartitionResult {
+  Partition: string;
+  State: ObservationState;
+  LastSuccessfulObservation: bigint;
+  ExceptionMessages: string[];
+  ExceptionStackTrace: string;
+  RetryAfterMilliseconds: bigint;
+  ReadModelState: string;
+}
+
 export interface ReduceOperationMessage {
   Partition: string;
   InitialState: string;
@@ -272,6 +346,8 @@ export interface ReduceOperationMessage {
   ReplayState: ReplayState;
   DeliveryId: bigint;
   DeliverWithinMilliseconds: bigint;
+  Partitions: ReducerPartition[];
+  Origin: ObservationOrigin;
 }
 
 export interface ReducerDefinition {
@@ -290,6 +366,12 @@ export interface ReducerMessage {
   Content: OneOfRegisterReducerReducerResult | undefined;
 }
 
+export interface ReducerPartition {
+  Partition: string;
+  InitialState: string;
+  Events: AppendedEvent[];
+}
+
 export interface ReducerResult {
   Partition: string;
   State: ObservationState;
@@ -298,6 +380,8 @@ export interface ReducerResult {
   ExceptionStackTrace: string;
   ReadModelState: string;
   DeliveryId: bigint;
+  RetryAfterMilliseconds: bigint;
+  Partitions: PartitionResult[];
 }
 
 export interface RegisterReducer {
@@ -305,6 +389,7 @@ export interface RegisterReducer {
   EventStore: string;
   Namespace: string;
   Reducer: ReducerDefinition | undefined;
+  PageDelivery: PageDelivery | undefined;
 }
 
 /** Represents a DateTimeOffset value as an ISO 8601 string (e.g., "2024-01-15T12:30:00.0000000+02:00"). */
@@ -1895,8 +1980,325 @@ export const OneOfRegisterReducerReducerResult: MessageFns<OneOfRegisterReducerR
   },
 };
 
+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 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 createBaseReduceOperationMessage(): ReduceOperationMessage {
-  return { Partition: "", InitialState: "", Events: [], ReplayState: 0, DeliveryId: 0n, DeliverWithinMilliseconds: 0n };
+  return {
+    Partition: "",
+    InitialState: "",
+    Events: [],
+    ReplayState: 0,
+    DeliveryId: 0n,
+    DeliverWithinMilliseconds: 0n,
+    Partitions: [],
+    Origin: 0,
+  };
 }
 
 export const ReduceOperationMessage: MessageFns<ReduceOperationMessage> = {
@@ -1927,6 +2329,12 @@ export const ReduceOperationMessage: MessageFns<ReduceOperationMessage> = {
       }
       writer.uint32(48).uint64(message.DeliverWithinMilliseconds);
     }
+    for (const v of message.Partitions) {
+      ReducerPartition.encode(v!, writer.uint32(58).fork()).join();
+    }
+    if (message.Origin !== 0) {
+      writer.uint32(64).int32(message.Origin);
+    }
     return writer;
   },
 
@@ -1991,6 +2399,22 @@ export const ReduceOperationMessage: MessageFns<ReduceOperationMessage> = {
             message.DeliverWithinMilliseconds = reader.uint64() as bigint;
             continue;
           }
+          case 7: {
+            if (tag !== 58) {
+              break;
+            }
+
+            message.Partitions.push(ReducerPartition.decode(reader, reader.uint32()));
+            continue;
+          }
+          case 8: {
+            if (tag !== 64) {
+              break;
+            }
+
+            message.Origin = reader.int32() as any;
+            continue;
+          }
         }
         if ((tag & 7) === 4 || tag === 0) {
           break;
@@ -2013,6 +2437,10 @@ export const ReduceOperationMessage: MessageFns<ReduceOperationMessage> = {
       DeliverWithinMilliseconds: isSet(object.DeliverWithinMilliseconds)
         ? BigInt(object.DeliverWithinMilliseconds)
         : 0n,
+      Partitions: globalThis.Array.isArray(object?.Partitions)
+        ? object.Partitions.map((e: any) => ReducerPartition.fromJSON(e))
+        : [],
+      Origin: isSet(object.Origin) ? observationOriginFromJSON(object.Origin) : 0,
     };
   },
 
@@ -2036,6 +2464,12 @@ export const ReduceOperationMessage: MessageFns<ReduceOperationMessage> = {
     if (message.DeliverWithinMilliseconds !== 0n) {
       obj.DeliverWithinMilliseconds = message.DeliverWithinMilliseconds.toString();
     }
+    if (message.Partitions?.length) {
+      obj.Partitions = message.Partitions.map((e) => ReducerPartition.toJSON(e));
+    }
+    if (message.Origin !== 0) {
+      obj.Origin = observationOriginToJSON(message.Origin);
+    }
     return obj;
   },
 
@@ -2055,6 +2489,8 @@ export const ReduceOperationMessage: MessageFns<ReduceOperationMessage> = {
       (object.DeliverWithinMilliseconds !== undefined && object.DeliverWithinMilliseconds !== null)
         ? BigInt(object.DeliverWithinMilliseconds)
         : 0n;
+    message.Partitions = object.Partitions?.map((e) => ReducerPartition.fromPartial(e)) || [];
+    message.Origin = object.Origin ?? 0;
     return message;
   },
 };
@@ -2341,6 +2777,107 @@ export const ReducerMessage: MessageFns<ReducerMessage> = {
   },
 };
 
+function createBaseReducerPartition(): ReducerPartition {
+  return { Partition: "", InitialState: "", Events: [] };
+}
+
+export const ReducerPartition: MessageFns<ReducerPartition> = {
+  encode(message: ReducerPartition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.Partition !== "") {
+      writer.uint32(10).string(message.Partition);
+    }
+    if (message.InitialState !== "") {
+      writer.uint32(18).string(message.InitialState);
+    }
+    for (const v of message.Events) {
+      AppendedEvent.encode(v!, writer.uint32(26).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ReducerPartition {
+    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 = createBaseReducerPartition();
+      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.InitialState = reader.string();
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              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): ReducerPartition {
+    return {
+      Partition: isSet(object.Partition) ? globalThis.String(object.Partition) : "",
+      InitialState: isSet(object.InitialState) ? globalThis.String(object.InitialState) : "",
+      Events: globalThis.Array.isArray(object?.Events) ? object.Events.map((e: any) => AppendedEvent.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: ReducerPartition): unknown {
+    const obj: any = {};
+    if (message.Partition !== "") {
+      obj.Partition = message.Partition;
+    }
+    if (message.InitialState !== "") {
+      obj.InitialState = message.InitialState;
+    }
+    if (message.Events?.length) {
+      obj.Events = message.Events.map((e) => AppendedEvent.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<ReducerPartition>): ReducerPartition {
+    return ReducerPartition.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ReducerPartition>): ReducerPartition {
+    const message = createBaseReducerPartition();
+    message.Partition = object.Partition ?? "";
+    message.InitialState = object.InitialState ?? "";
+    message.Events = object.Events?.map((e) => AppendedEvent.fromPartial(e)) || [];
+    return message;
+  },
+};
+
 function createBaseReducerResult(): ReducerResult {
   return {
     Partition: "",
@@ -2350,6 +2887,8 @@ function createBaseReducerResult(): ReducerResult {
     ExceptionStackTrace: "",
     ReadModelState: "",
     DeliveryId: 0n,
+    RetryAfterMilliseconds: 0n,
+    Partitions: [],
   };
 }
 
@@ -2384,6 +2923,15 @@ export const ReducerResult: MessageFns<ReducerResult> = {
       }
       writer.uint32(56).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(64).uint64(message.RetryAfterMilliseconds);
+    }
+    for (const v of message.Partitions) {
+      PartitionResult.encode(v!, writer.uint32(74).fork()).join();
+    }
     return writer;
   },
 
@@ -2456,6 +3004,22 @@ export const ReducerResult: MessageFns<ReducerResult> = {
             message.DeliveryId = reader.uint64() as bigint;
             continue;
           }
+          case 8: {
+            if (tag !== 64) {
+              break;
+            }
+
+            message.RetryAfterMilliseconds = reader.uint64() as bigint;
+            continue;
+          }
+          case 9: {
+            if (tag !== 74) {
+              break;
+            }
+
+            message.Partitions.push(PartitionResult.decode(reader, reader.uint32()));
+            continue;
+          }
         }
         if ((tag & 7) === 4 || tag === 0) {
           break;
@@ -2481,6 +3045,10 @@ export const ReducerResult: MessageFns<ReducerResult> = {
       ExceptionStackTrace: isSet(object.ExceptionStackTrace) ? globalThis.String(object.ExceptionStackTrace) : "",
       ReadModelState: isSet(object.ReadModelState) ? globalThis.String(object.ReadModelState) : "",
       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))
+        : [],
     };
   },
 
@@ -2507,6 +3075,12 @@ export const ReducerResult: MessageFns<ReducerResult> = {
     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;
   },
 
@@ -2527,12 +3101,17 @@ export const ReducerResult: MessageFns<ReducerResult> = {
     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 createBaseRegisterReducer(): RegisterReducer {
-  return { ConnectionId: "", EventStore: "", Namespace: "", Reducer: undefined };
+  return { ConnectionId: "", EventStore: "", Namespace: "", Reducer: undefined, PageDelivery: undefined };
 }
 
 export const RegisterReducer: MessageFns<RegisterReducer> = {
@@ -2549,6 +3128,9 @@ export const RegisterReducer: MessageFns<RegisterReducer> = {
     if (message.Reducer !== undefined) {
       ReducerDefinition.encode(message.Reducer, writer.uint32(34).fork()).join();
     }
+    if (message.PageDelivery !== undefined) {
+      PageDelivery.encode(message.PageDelivery, writer.uint32(42).fork()).join();
+    }
     return writer;
   },
 
@@ -2597,6 +3179,14 @@ export const RegisterReducer: MessageFns<RegisterReducer> = {
             message.Reducer = ReducerDefinition.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;
@@ -2615,6 +3205,7 @@ export const RegisterReducer: MessageFns<RegisterReducer> = {
       EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
       Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
       Reducer: isSet(object.Reducer) ? ReducerDefinition.fromJSON(object.Reducer) : undefined,
+      PageDelivery: isSet(object.PageDelivery) ? PageDelivery.fromJSON(object.PageDelivery) : undefined,
     };
   },
 
@@ -2632,6 +3223,9 @@ export const RegisterReducer: MessageFns<RegisterReducer> = {
     if (message.Reducer !== undefined) {
       obj.Reducer = ReducerDefinition.toJSON(message.Reducer);
     }
+    if (message.PageDelivery !== undefined) {
+      obj.PageDelivery = PageDelivery.toJSON(message.PageDelivery);
+    }
     return obj;
   },
 
@@ -2646,6 +3240,9 @@ export const RegisterReducer: MessageFns<RegisterReducer> = {
     message.Reducer = (object.Reducer !== undefined && object.Reducer !== null)
       ? ReducerDefinition.fromPartial(object.Reducer)
       : undefined;
+    message.PageDelivery = (object.PageDelivery !== undefined && object.PageDelivery !== null)
+      ? PageDelivery.fromPartial(object.PageDelivery)
+      : undefined;
     return message;
   },
 };