@cratis/chronicle.contracts 19.114.2 → 19.115.1

package/generated/sequences.ts

@@ -984,6 +984,7 @@ export interface ConcurrencyScope {
   EventSourceType: string;
   EventTypes: EventType[];
   ExpectsNoMatchingEvent: boolean;
+  MutationEpoch: bigint;
 }
 
 export interface ConcurrencyViolation {
@@ -1119,8 +1120,14 @@ export interface EventSequenceNamesResponse {
   Name: string;
 }
 
+export interface EventSequencePageResponse {
+  Events: AppendedEventResponse[];
+  Next: bigint;
+}
+
 export interface EventSequenceTailResponse {
   SequenceNumber: bigint;
+  MutationEpoch: bigint;
 }
 
 export interface EventSourceConcurrencyScope {
@@ -1264,6 +1271,22 @@ export interface NamedTagQueryCriterion {
   AnyValue: boolean;
 }
 
+export interface PageRequest {
+  EventStore: string;
+  Namespace: string;
+  EventSequenceId: string;
+  From: bigint;
+  Count: number;
+  Backward: boolean;
+  Until: bigint;
+  EventSourceId: string;
+  EventSourceType: string;
+  EventStreamType: string;
+  EventStreamId: string;
+  EventTypeIds: string;
+  Tags: string;
+}
+
 export interface ParseResolutionRequest {
   Resolution: string;
 }
@@ -1297,6 +1320,16 @@ export interface QueryEventsWithNamedTagsRequest {
   OccurredTo: SerializableDateTimeOffset | undefined;
 }
 
+export interface QueryResultEventSequencePageResponse {
+  /** default value could not be applied: 00000000-0000-0000-0000-000000000000 */
+  CorrelationId: Guid | undefined;
+  IsAuthorized: boolean;
+  ValidationResults: ValidationResult[];
+  ExceptionMessages: string[];
+  ExceptionStackTrace: string;
+  Data: EventSequencePageResponse | undefined;
+}
+
 export interface QueryResultEventSequenceTailResponse {
   /** default value could not be applied: 00000000-0000-0000-0000-000000000000 */
   CorrelationId: Guid | undefined;
@@ -1520,6 +1553,7 @@ export interface TailSequenceNumberRequest {
   EventSourceType: string;
   EventStreamId: string;
   EventStreamType: string;
+  IncludeMutationEpoch: boolean;
 }
 
 export interface ValidationResult {
@@ -8546,6 +8580,7 @@ function createBaseConcurrencyScope(): ConcurrencyScope {
     EventSourceType: "",
     EventTypes: [],
     ExpectsNoMatchingEvent: false,
+    MutationEpoch: 0n,
   };
 }
 
@@ -8575,6 +8610,12 @@ export const ConcurrencyScope: MessageFns<ConcurrencyScope> = {
     if (message.ExpectsNoMatchingEvent !== false) {
       writer.uint32(56).bool(message.ExpectsNoMatchingEvent);
     }
+    if (message.MutationEpoch !== 0n) {
+      if (BigInt.asUintN(64, message.MutationEpoch) !== message.MutationEpoch) {
+        throw new globalThis.Error("value provided for field message.MutationEpoch of type uint64 too large");
+      }
+      writer.uint32(64).uint64(message.MutationEpoch);
+    }
     return writer;
   },
 
@@ -8647,6 +8688,14 @@ export const ConcurrencyScope: MessageFns<ConcurrencyScope> = {
             message.ExpectsNoMatchingEvent = reader.bool();
             continue;
           }
+          case 8: {
+            if (tag !== 64) {
+              break;
+            }
+
+            message.MutationEpoch = reader.uint64() as bigint;
+            continue;
+          }
         }
         if ((tag & 7) === 4 || tag === 0) {
           break;
@@ -8672,6 +8721,7 @@ export const ConcurrencyScope: MessageFns<ConcurrencyScope> = {
       ExpectsNoMatchingEvent: isSet(object.ExpectsNoMatchingEvent)
         ? globalThis.Boolean(object.ExpectsNoMatchingEvent)
         : false,
+      MutationEpoch: isSet(object.MutationEpoch) ? BigInt(object.MutationEpoch) : 0n,
     };
   },
 
@@ -8698,6 +8748,9 @@ export const ConcurrencyScope: MessageFns<ConcurrencyScope> = {
     if (message.ExpectsNoMatchingEvent !== false) {
       obj.ExpectsNoMatchingEvent = message.ExpectsNoMatchingEvent;
     }
+    if (message.MutationEpoch !== 0n) {
+      obj.MutationEpoch = message.MutationEpoch.toString();
+    }
     return obj;
   },
 
@@ -8715,6 +8768,9 @@ export const ConcurrencyScope: MessageFns<ConcurrencyScope> = {
     message.EventSourceType = object.EventSourceType ?? "";
     message.EventTypes = object.EventTypes?.map((e) => EventType.fromPartial(e)) || [];
     message.ExpectsNoMatchingEvent = object.ExpectsNoMatchingEvent ?? false;
+    message.MutationEpoch = (object.MutationEpoch !== undefined && object.MutationEpoch !== null)
+      ? BigInt(object.MutationEpoch)
+      : 0n;
     return message;
   },
 };
@@ -11015,8 +11071,98 @@ export const EventSequenceNamesResponse: MessageFns<EventSequenceNamesResponse>
   },
 };
 
+function createBaseEventSequencePageResponse(): EventSequencePageResponse {
+  return { Events: [], Next: 0n };
+}
+
+export const EventSequencePageResponse: MessageFns<EventSequencePageResponse> = {
+  encode(message: EventSequencePageResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.Events) {
+      AppendedEventResponse.encode(v!, writer.uint32(10).fork()).join();
+    }
+    if (message.Next !== 0n) {
+      if (BigInt.asUintN(64, message.Next) !== message.Next) {
+        throw new globalThis.Error("value provided for field message.Next of type uint64 too large");
+      }
+      writer.uint32(16).uint64(message.Next);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): EventSequencePageResponse {
+    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 = createBaseEventSequencePageResponse();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.Events.push(AppendedEventResponse.decode(reader, reader.uint32()));
+            continue;
+          }
+          case 2: {
+            if (tag !== 16) {
+              break;
+            }
+
+            message.Next = reader.uint64() as bigint;
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): EventSequencePageResponse {
+    return {
+      Events: globalThis.Array.isArray(object?.Events)
+        ? object.Events.map((e: any) => AppendedEventResponse.fromJSON(e))
+        : [],
+      Next: isSet(object.Next) ? BigInt(object.Next) : 0n,
+    };
+  },
+
+  toJSON(message: EventSequencePageResponse): unknown {
+    const obj: any = {};
+    if (message.Events?.length) {
+      obj.Events = message.Events.map((e) => AppendedEventResponse.toJSON(e));
+    }
+    if (message.Next !== 0n) {
+      obj.Next = message.Next.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<EventSequencePageResponse>): EventSequencePageResponse {
+    return EventSequencePageResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<EventSequencePageResponse>): EventSequencePageResponse {
+    const message = createBaseEventSequencePageResponse();
+    message.Events = object.Events?.map((e) => AppendedEventResponse.fromPartial(e)) || [];
+    message.Next = (object.Next !== undefined && object.Next !== null) ? BigInt(object.Next) : 0n;
+    return message;
+  },
+};
+
 function createBaseEventSequenceTailResponse(): EventSequenceTailResponse {
-  return { SequenceNumber: 0n };
+  return { SequenceNumber: 0n, MutationEpoch: 0n };
 }
 
 export const EventSequenceTailResponse: MessageFns<EventSequenceTailResponse> = {
@@ -11027,6 +11173,12 @@ export const EventSequenceTailResponse: MessageFns<EventSequenceTailResponse> =
       }
       writer.uint32(8).uint64(message.SequenceNumber);
     }
+    if (message.MutationEpoch !== 0n) {
+      if (BigInt.asUintN(64, message.MutationEpoch) !== message.MutationEpoch) {
+        throw new globalThis.Error("value provided for field message.MutationEpoch of type uint64 too large");
+      }
+      writer.uint32(16).uint64(message.MutationEpoch);
+    }
     return writer;
   },
 
@@ -11051,6 +11203,14 @@ export const EventSequenceTailResponse: MessageFns<EventSequenceTailResponse> =
             message.SequenceNumber = reader.uint64() as bigint;
             continue;
           }
+          case 2: {
+            if (tag !== 16) {
+              break;
+            }
+
+            message.MutationEpoch = reader.uint64() as bigint;
+            continue;
+          }
         }
         if ((tag & 7) === 4 || tag === 0) {
           break;
@@ -11064,7 +11224,10 @@ export const EventSequenceTailResponse: MessageFns<EventSequenceTailResponse> =
   },
 
   fromJSON(object: any): EventSequenceTailResponse {
-    return { SequenceNumber: isSet(object.SequenceNumber) ? BigInt(object.SequenceNumber) : 0n };
+    return {
+      SequenceNumber: isSet(object.SequenceNumber) ? BigInt(object.SequenceNumber) : 0n,
+      MutationEpoch: isSet(object.MutationEpoch) ? BigInt(object.MutationEpoch) : 0n,
+    };
   },
 
   toJSON(message: EventSequenceTailResponse): unknown {
@@ -11072,6 +11235,9 @@ export const EventSequenceTailResponse: MessageFns<EventSequenceTailResponse> =
     if (message.SequenceNumber !== 0n) {
       obj.SequenceNumber = message.SequenceNumber.toString();
     }
+    if (message.MutationEpoch !== 0n) {
+      obj.MutationEpoch = message.MutationEpoch.toString();
+    }
     return obj;
   },
 
@@ -11083,6 +11249,9 @@ export const EventSequenceTailResponse: MessageFns<EventSequenceTailResponse> =
     message.SequenceNumber = (object.SequenceNumber !== undefined && object.SequenceNumber !== null)
       ? BigInt(object.SequenceNumber)
       : 0n;
+    message.MutationEpoch = (object.MutationEpoch !== undefined && object.MutationEpoch !== null)
+      ? BigInt(object.MutationEpoch)
+      : 0n;
     return message;
   },
 };
@@ -13546,6 +13715,287 @@ export const NamedTagQueryCriterion: MessageFns<NamedTagQueryCriterion> = {
   },
 };
 
+function createBasePageRequest(): PageRequest {
+  return {
+    EventStore: "",
+    Namespace: "",
+    EventSequenceId: "",
+    From: 0n,
+    Count: 0,
+    Backward: false,
+    Until: 0n,
+    EventSourceId: "",
+    EventSourceType: "",
+    EventStreamType: "",
+    EventStreamId: "",
+    EventTypeIds: "",
+    Tags: "",
+  };
+}
+
+export const PageRequest: MessageFns<PageRequest> = {
+  encode(message: PageRequest, writer: BinaryWriter = new BinaryWriter()): 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.From !== 0n) {
+      if (BigInt.asUintN(64, message.From) !== message.From) {
+        throw new globalThis.Error("value provided for field message.From of type uint64 too large");
+      }
+      writer.uint32(32).uint64(message.From);
+    }
+    if (message.Count !== 0) {
+      writer.uint32(40).int32(message.Count);
+    }
+    if (message.Backward !== false) {
+      writer.uint32(48).bool(message.Backward);
+    }
+    if (message.Until !== 0n) {
+      if (BigInt.asUintN(64, message.Until) !== message.Until) {
+        throw new globalThis.Error("value provided for field message.Until of type uint64 too large");
+      }
+      writer.uint32(56).uint64(message.Until);
+    }
+    if (message.EventSourceId !== "") {
+      writer.uint32(66).string(message.EventSourceId);
+    }
+    if (message.EventSourceType !== "") {
+      writer.uint32(74).string(message.EventSourceType);
+    }
+    if (message.EventStreamType !== "") {
+      writer.uint32(82).string(message.EventStreamType);
+    }
+    if (message.EventStreamId !== "") {
+      writer.uint32(90).string(message.EventStreamId);
+    }
+    if (message.EventTypeIds !== "") {
+      writer.uint32(98).string(message.EventTypeIds);
+    }
+    if (message.Tags !== "") {
+      writer.uint32(106).string(message.Tags);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): PageRequest {
+    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 = createBasePageRequest();
+      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.From = reader.uint64() as bigint;
+            continue;
+          }
+          case 5: {
+            if (tag !== 40) {
+              break;
+            }
+
+            message.Count = reader.int32();
+            continue;
+          }
+          case 6: {
+            if (tag !== 48) {
+              break;
+            }
+
+            message.Backward = reader.bool();
+            continue;
+          }
+          case 7: {
+            if (tag !== 56) {
+              break;
+            }
+
+            message.Until = reader.uint64() as bigint;
+            continue;
+          }
+          case 8: {
+            if (tag !== 66) {
+              break;
+            }
+
+            message.EventSourceId = reader.string();
+            continue;
+          }
+          case 9: {
+            if (tag !== 74) {
+              break;
+            }
+
+            message.EventSourceType = reader.string();
+            continue;
+          }
+          case 10: {
+            if (tag !== 82) {
+              break;
+            }
+
+            message.EventStreamType = reader.string();
+            continue;
+          }
+          case 11: {
+            if (tag !== 90) {
+              break;
+            }
+
+            message.EventStreamId = reader.string();
+            continue;
+          }
+          case 12: {
+            if (tag !== 98) {
+              break;
+            }
+
+            message.EventTypeIds = reader.string();
+            continue;
+          }
+          case 13: {
+            if (tag !== 106) {
+              break;
+            }
+
+            message.Tags = 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): PageRequest {
+    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) : "",
+      From: isSet(object.From) ? BigInt(object.From) : 0n,
+      Count: isSet(object.Count) ? globalThis.Number(object.Count) : 0,
+      Backward: isSet(object.Backward) ? globalThis.Boolean(object.Backward) : false,
+      Until: isSet(object.Until) ? BigInt(object.Until) : 0n,
+      EventSourceId: isSet(object.EventSourceId) ? globalThis.String(object.EventSourceId) : "",
+      EventSourceType: isSet(object.EventSourceType) ? globalThis.String(object.EventSourceType) : "",
+      EventStreamType: isSet(object.EventStreamType) ? globalThis.String(object.EventStreamType) : "",
+      EventStreamId: isSet(object.EventStreamId) ? globalThis.String(object.EventStreamId) : "",
+      EventTypeIds: isSet(object.EventTypeIds) ? globalThis.String(object.EventTypeIds) : "",
+      Tags: isSet(object.Tags) ? globalThis.String(object.Tags) : "",
+    };
+  },
+
+  toJSON(message: PageRequest): unknown {
+    const obj: any = {};
+    if (message.EventStore !== "") {
+      obj.EventStore = message.EventStore;
+    }
+    if (message.Namespace !== "") {
+      obj.Namespace = message.Namespace;
+    }
+    if (message.EventSequenceId !== "") {
+      obj.EventSequenceId = message.EventSequenceId;
+    }
+    if (message.From !== 0n) {
+      obj.From = message.From.toString();
+    }
+    if (message.Count !== 0) {
+      obj.Count = Math.round(message.Count);
+    }
+    if (message.Backward !== false) {
+      obj.Backward = message.Backward;
+    }
+    if (message.Until !== 0n) {
+      obj.Until = message.Until.toString();
+    }
+    if (message.EventSourceId !== "") {
+      obj.EventSourceId = message.EventSourceId;
+    }
+    if (message.EventSourceType !== "") {
+      obj.EventSourceType = message.EventSourceType;
+    }
+    if (message.EventStreamType !== "") {
+      obj.EventStreamType = message.EventStreamType;
+    }
+    if (message.EventStreamId !== "") {
+      obj.EventStreamId = message.EventStreamId;
+    }
+    if (message.EventTypeIds !== "") {
+      obj.EventTypeIds = message.EventTypeIds;
+    }
+    if (message.Tags !== "") {
+      obj.Tags = message.Tags;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<PageRequest>): PageRequest {
+    return PageRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<PageRequest>): PageRequest {
+    const message = createBasePageRequest();
+    message.EventStore = object.EventStore ?? "";
+    message.Namespace = object.Namespace ?? "";
+    message.EventSequenceId = object.EventSequenceId ?? "";
+    message.From = (object.From !== undefined && object.From !== null) ? BigInt(object.From) : 0n;
+    message.Count = object.Count ?? 0;
+    message.Backward = object.Backward ?? false;
+    message.Until = (object.Until !== undefined && object.Until !== null) ? BigInt(object.Until) : 0n;
+    message.EventSourceId = object.EventSourceId ?? "";
+    message.EventSourceType = object.EventSourceType ?? "";
+    message.EventStreamType = object.EventStreamType ?? "";
+    message.EventStreamId = object.EventStreamId ?? "";
+    message.EventTypeIds = object.EventTypeIds ?? "";
+    message.Tags = object.Tags ?? "";
+    return message;
+  },
+};
+
 function createBaseParseResolutionRequest(): ParseResolutionRequest {
   return { Resolution: "" };
 }
@@ -14122,6 +14572,170 @@ export const QueryEventsWithNamedTagsRequest: MessageFns<QueryEventsWithNamedTag
   },
 };
 
+function createBaseQueryResultEventSequencePageResponse(): QueryResultEventSequencePageResponse {
+  return {
+    CorrelationId: undefined,
+    IsAuthorized: false,
+    ValidationResults: [],
+    ExceptionMessages: [],
+    ExceptionStackTrace: "",
+    Data: undefined,
+  };
+}
+
+export const QueryResultEventSequencePageResponse: MessageFns<QueryResultEventSequencePageResponse> = {
+  encode(message: QueryResultEventSequencePageResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.CorrelationId !== undefined) {
+      Guid.encode(message.CorrelationId, writer.uint32(10).fork()).join();
+    }
+    if (message.IsAuthorized !== false) {
+      writer.uint32(16).bool(message.IsAuthorized);
+    }
+    for (const v of message.ValidationResults) {
+      ValidationResult.encode(v!, writer.uint32(26).fork()).join();
+    }
+    for (const v of message.ExceptionMessages) {
+      writer.uint32(34).string(v!);
+    }
+    if (message.ExceptionStackTrace !== "") {
+      writer.uint32(42).string(message.ExceptionStackTrace);
+    }
+    if (message.Data !== undefined) {
+      EventSequencePageResponse.encode(message.Data, writer.uint32(50).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryResultEventSequencePageResponse {
+    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 = createBaseQueryResultEventSequencePageResponse();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.CorrelationId = Guid.decode(reader, reader.uint32());
+            continue;
+          }
+          case 2: {
+            if (tag !== 16) {
+              break;
+            }
+
+            message.IsAuthorized = reader.bool();
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.ValidationResults.push(ValidationResult.decode(reader, reader.uint32()));
+            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 !== 50) {
+              break;
+            }
+
+            message.Data = EventSequencePageResponse.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): QueryResultEventSequencePageResponse {
+    return {
+      CorrelationId: isSet(object.CorrelationId) ? Guid.fromJSON(object.CorrelationId) : undefined,
+      IsAuthorized: isSet(object.IsAuthorized) ? globalThis.Boolean(object.IsAuthorized) : false,
+      ValidationResults: globalThis.Array.isArray(object?.ValidationResults)
+        ? object.ValidationResults.map((e: any) => ValidationResult.fromJSON(e))
+        : [],
+      ExceptionMessages: globalThis.Array.isArray(object?.ExceptionMessages)
+        ? object.ExceptionMessages.map((e: any) => globalThis.String(e))
+        : [],
+      ExceptionStackTrace: isSet(object.ExceptionStackTrace) ? globalThis.String(object.ExceptionStackTrace) : "",
+      Data: isSet(object.Data) ? EventSequencePageResponse.fromJSON(object.Data) : undefined,
+    };
+  },
+
+  toJSON(message: QueryResultEventSequencePageResponse): unknown {
+    const obj: any = {};
+    if (message.CorrelationId !== undefined) {
+      obj.CorrelationId = Guid.toJSON(message.CorrelationId);
+    }
+    if (message.IsAuthorized !== false) {
+      obj.IsAuthorized = message.IsAuthorized;
+    }
+    if (message.ValidationResults?.length) {
+      obj.ValidationResults = message.ValidationResults.map((e) => ValidationResult.toJSON(e));
+    }
+    if (message.ExceptionMessages?.length) {
+      obj.ExceptionMessages = message.ExceptionMessages;
+    }
+    if (message.ExceptionStackTrace !== "") {
+      obj.ExceptionStackTrace = message.ExceptionStackTrace;
+    }
+    if (message.Data !== undefined) {
+      obj.Data = EventSequencePageResponse.toJSON(message.Data);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<QueryResultEventSequencePageResponse>): QueryResultEventSequencePageResponse {
+    return QueryResultEventSequencePageResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<QueryResultEventSequencePageResponse>): QueryResultEventSequencePageResponse {
+    const message = createBaseQueryResultEventSequencePageResponse();
+    message.CorrelationId = (object.CorrelationId !== undefined && object.CorrelationId !== null)
+      ? Guid.fromPartial(object.CorrelationId)
+      : undefined;
+    message.IsAuthorized = object.IsAuthorized ?? false;
+    message.ValidationResults = object.ValidationResults?.map((e) => ValidationResult.fromPartial(e)) || [];
+    message.ExceptionMessages = object.ExceptionMessages?.map((e) => e) || [];
+    message.ExceptionStackTrace = object.ExceptionStackTrace ?? "";
+    message.Data = (object.Data !== undefined && object.Data !== null)
+      ? EventSequencePageResponse.fromPartial(object.Data)
+      : undefined;
+    return message;
+  },
+};
+
 function createBaseQueryResultEventSequenceTailResponse(): QueryResultEventSequenceTailResponse {
   return {
     CorrelationId: undefined,
@@ -17779,6 +18393,7 @@ function createBaseTailSequenceNumberRequest(): TailSequenceNumberRequest {
     EventSourceType: "",
     EventStreamId: "",
     EventStreamType: "",
+    IncludeMutationEpoch: false,
   };
 }
 
@@ -17808,6 +18423,9 @@ export const TailSequenceNumberRequest: MessageFns<TailSequenceNumberRequest> =
     if (message.EventStreamType !== "") {
       writer.uint32(66).string(message.EventStreamType);
     }
+    if (message.IncludeMutationEpoch !== false) {
+      writer.uint32(72).bool(message.IncludeMutationEpoch);
+    }
     return writer;
   },
 
@@ -17888,6 +18506,14 @@ export const TailSequenceNumberRequest: MessageFns<TailSequenceNumberRequest> =
             message.EventStreamType = reader.string();
             continue;
           }
+          case 9: {
+            if (tag !== 72) {
+              break;
+            }
+
+            message.IncludeMutationEpoch = reader.bool();
+            continue;
+          }
         }
         if ((tag & 7) === 4 || tag === 0) {
           break;
@@ -17910,6 +18536,9 @@ export const TailSequenceNumberRequest: MessageFns<TailSequenceNumberRequest> =
       EventSourceType: isSet(object.EventSourceType) ? globalThis.String(object.EventSourceType) : "",
       EventStreamId: isSet(object.EventStreamId) ? globalThis.String(object.EventStreamId) : "",
       EventStreamType: isSet(object.EventStreamType) ? globalThis.String(object.EventStreamType) : "",
+      IncludeMutationEpoch: isSet(object.IncludeMutationEpoch)
+        ? globalThis.Boolean(object.IncludeMutationEpoch)
+        : false,
     };
   },
 
@@ -17939,6 +18568,9 @@ export const TailSequenceNumberRequest: MessageFns<TailSequenceNumberRequest> =
     if (message.EventStreamType !== "") {
       obj.EventStreamType = message.EventStreamType;
     }
+    if (message.IncludeMutationEpoch !== false) {
+      obj.IncludeMutationEpoch = message.IncludeMutationEpoch;
+    }
     return obj;
   },
 
@@ -17955,6 +18587,7 @@ export const TailSequenceNumberRequest: MessageFns<TailSequenceNumberRequest> =
     message.EventSourceType = object.EventSourceType ?? "";
     message.EventStreamId = object.EventStreamId ?? "";
     message.EventStreamType = object.EventStreamType ?? "";
+    message.IncludeMutationEpoch = object.IncludeMutationEpoch ?? false;
     return message;
   },
 };
@@ -18490,6 +19123,14 @@ export const EventSequencesDefinition = {
       responseStream: false,
       options: {},
     },
+    page: {
+      name: "Page",
+      requestType: PageRequest as typeof PageRequest,
+      requestStream: false,
+      responseType: QueryResultEventSequencePageResponse as typeof QueryResultEventSequencePageResponse,
+      responseStream: false,
+      options: {},
+    },
     parseResolution: {
       name: "ParseResolution",
       requestType: ParseResolutionRequest as typeof ParseResolutionRequest,
@@ -18672,6 +19313,10 @@ export interface EventSequencesServiceImplementation<CallContextExt = {}> {
     request: MetadataAtRequest,
     context: CallContext & CallContextExt,
   ): Promise<DeepPartial<QueryResultIEnumerableEventMetadataResponse>>;
+  page(
+    request: PageRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<QueryResultEventSequencePageResponse>>;
   parseResolution(
     request: ParseResolutionRequest,
     context: CallContext & CallContextExt,
@@ -18801,6 +19446,10 @@ export interface EventSequencesClient<CallOptionsExt = {}> {
     request: DeepPartial<MetadataAtRequest>,
     options?: CallOptions & CallOptionsExt,
   ): Promise<QueryResultIEnumerableEventMetadataResponse>;
+  page(
+    request: DeepPartial<PageRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<QueryResultEventSequencePageResponse>;
   parseResolution(
     request: DeepPartial<ParseResolutionRequest>,
     options?: CallOptions & CallOptionsExt,