@kronos-ts/axon-server 0.1.0

package/src/generated/dcb.ts

@@ -0,0 +1,3826 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.6
+//   protoc               v3.19.1
+// source: dcb.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import type { CallContext, CallOptions } from "nice-grpc-common";
+import { InstructionAck } from "./common.js";
+
+export const protobufPackage = "io.axoniq.axonserver.grpc.event.dcb";
+
+/** Request message to schedule an event */
+export interface ScheduleEventRequest {
+  /** timestamp when to publish the event */
+  instant: bigint;
+  /** the event to publish */
+  event: Event | undefined;
+}
+
+/** Request message to reschedule an event */
+export interface RescheduleEventRequest {
+  /** schedule token of the event to reschedule */
+  token: string;
+  /** timestamp when to publish the event */
+  instant: bigint;
+  /** optionally provide a new event to publish */
+  event: Event | undefined;
+}
+
+/** Request message to cancel an event */
+export interface CancelScheduledEventRequest {
+  /** token of scheduled event to cancel */
+  token: string;
+}
+
+/** Token to manage a scheduled event */
+export interface ScheduleToken {
+  /** Field defining the token identifier */
+  token: string;
+}
+
+/** The event message. */
+export interface Event {
+  /** The unique identifier of the event. */
+  identifier: string;
+  /** The timestamp of the event. */
+  timestamp: bigint;
+  /** The name of the event. */
+  name: string;
+  /** The version of the event. */
+  version: string;
+  /** The payload of the event. */
+  payload: Uint8Array;
+  /** The metadata of the event. */
+  metadata: { [key: string]: string };
+}
+
+export interface Event_MetadataEntry {
+  key: string;
+  value: string;
+}
+
+/** The tag. Describes an event with more details. Usually using concepts from the Domain. */
+export interface Tag {
+  /** The key of the tag. */
+  key: Uint8Array;
+  /** The value of the tag. */
+  value: Uint8Array;
+}
+
+/** The event described in more details by a list of tags. */
+export interface TaggedEvent {
+  /** The event. */
+  event:
+    | Event
+    | undefined;
+  /** List of tags describing the given event in more details. */
+  tag: Tag[];
+}
+
+/** The event retrieved from the event store with its corresponding sequence. */
+export interface SequencedEvent {
+  /** The sequence of the event. */
+  sequence: bigint;
+  /** The event. */
+  event: Event | undefined;
+}
+
+/** The message representing the request to append events to the event store. */
+export interface AppendEventsRequest {
+  /** The condition used to check the validity of this request. If omitted, events will be appended unconditionally. */
+  condition:
+    | ConsistencyCondition
+    | undefined;
+  /**
+   * A list of tagged events to be appended to the event store if the condition is met.
+   * These events are considered as a transaction - they are either all appended or none of them are appended.
+   * The event store will index the events based on provided tags for future faster retrieval.
+   */
+  event: TaggedEvent[];
+}
+
+/**
+ * The response of a successful append events request. If there was an issue with the append events request,
+ * the stream will complete with an error.
+ */
+export interface AppendEventsResponse {
+  /**
+   * The sequence of the first event stored in the event store.
+   * Corresponding to the list of events (a transaction) passed in the AppendEventsRequest.
+   */
+  sequenceOfTheFirstEvent: bigint;
+  /** The number of events appended. Matches the number of events passed in the AppendEventsRequest. */
+  transactionSize: number;
+  /**
+   * The consistency marker which may be used for a subsequent append events requests. Do note that during the time this
+   * consistency marker may get far behind the head of the event store which will increase the time needed for the append
+   * events request to be validated. If you don't plan to do subsequent append events requests in a "short" period of time,
+   * use the Source RPC to refresh the consistency marker.
+   */
+  consistencyMarker: bigint;
+}
+
+/**
+ * The request to source events from the event store. It results in a finite stream of events completed by
+ * the event store. It may also be cancelled by the client. Only events matching the given criteria
+ * (a provided list of criterions) will be present in the stream. The stream is capped by the HEAD of the event store.
+ */
+export interface SourceEventsRequest {
+  /** An inclusive sequence of the first event to be included in the resulting stream. */
+  fromSequence: bigint;
+  /**
+   * The criteria consisting of the list of criterions. If at least one of these criterions is met,
+   * the criteria is met.
+   */
+  criterion: Criterion[];
+}
+
+/**
+ * The response to the SourceEventsRequest. It consists either of an event (with its corresponding sequence) or a
+ * consistency marker. The consistency marker should be used in a following AppendEventsRequest related to the criteria used in the SourceEventsRequest this response originates from.
+ */
+export interface SourceEventsResponse {
+  /** The event matching the criteria with its corresponding sequence. */
+  event?:
+    | SequencedEvent
+    | undefined;
+  /** The consistency marker to be used for the following append related to the same criteria. */
+  consistencyMarker?: bigint | undefined;
+}
+
+/**
+ * The condition for an AppendEventsRequest. Consists of the consistency marker and the criteria
+ * (a list of criterions).
+ */
+export interface ConsistencyCondition {
+  /**
+   * The sequence used to start checking for the consistency of an append. If there are events with a sequence greater
+   * or equal than the consistency marker and those are matching the given criteria, the condition is not met and the transaction
+   * is rejected. Otherwise, it is accepted.
+   */
+  consistencyMarker: bigint;
+  /** The criteria. Consists of a list of criterions. If a single criterion is met, the whole criteria is met. */
+  criterion: Criterion[];
+}
+
+/** The integral part of the criteria. */
+export interface Criterion {
+  /** The criterion based on event tags and event names. */
+  tagsAndNames: TagsAndNamesCriterion | undefined;
+}
+
+/**
+ * The criterion based on event tags and event names. The event meets this criterion if ALL tags from this criterion
+ * are present in the tags of the event AND if the event name is present in one of the names of the this criterion.
+ */
+export interface TagsAndNamesCriterion {
+  /** A list of event names. The event meets this criterion if its name is in one of the names in this list. */
+  name: string[];
+  /**
+   * A list of event tags. The event meets this criterion if it contains all the tags from this list. It meets the
+   * criterion if it contains more than provided list here, but it MUST contain all from the list.
+   */
+  tag: Tag[];
+}
+
+/**
+ * The request to provide an infinite stream of events from the event store. The client may cancel the stream at any
+ * time.
+ */
+export interface StreamEventsRequest {
+  /** The inclusive sequence to start streaming from. */
+  fromSequence: bigint;
+  /**
+   * The criteria used to filter out events. Represented by a list of criterions. If at least one is met, the whole
+   * criteria is met.
+   */
+  criterion: Criterion[];
+}
+
+/** The response to the StreamEventsRequest. */
+export interface StreamEventsResponse {
+  /** The event with its corresponding sequence. */
+  event: SequencedEvent | undefined;
+}
+
+/** The request to retrieve the current HEAD of the event store. */
+export interface GetHeadRequest {
+}
+
+/** The current HEAD of the event store. */
+export interface GetHeadResponse {
+  /**
+   * The sequence of the current head. Points to the position of the first event to be appended. The HEAD of an empty
+   * event store is 0.
+   */
+  sequence: bigint;
+}
+
+/** The request to retrieve the current TAIL of the event store. */
+export interface GetTailRequest {
+}
+
+/** The current TAIL of the event store. */
+export interface GetTailResponse {
+  /**
+   * The sequence of the first event in the event store. 0 for an empty event store. 0 for a non-truncated event store.
+   * Non-zero for a truncated event store.
+   */
+  sequence: bigint;
+}
+
+/**
+ * The request to get the sequence of the event whose timestamp is the same as the timestamp provided in the request.
+ * If there are no events with the exact timestamp, then the sequence of the first one after the provided timestamp is
+ * returned. If the provided timestamp is greater that the sequence of the last event in the event store,
+ * the HEAD is returned.
+ */
+export interface GetSequenceAtRequest {
+  /** The timestamp. */
+  timestamp: bigint;
+}
+
+/** The sequence of the event approximately close to the provided timestamp. */
+export interface GetSequenceAtResponse {
+  /** The sequence of the event. */
+  sequence: bigint;
+}
+
+/** The request to add tags to the event. */
+export interface AddTagsRequest {
+  /** The sequence of the event whose tags list will be expanded with the tags from the request. */
+  sequence: bigint;
+  /**
+   * The tags to be added to the event. If the event already contains a tag from the same list
+   * (with the same key and the value) the new one will be ignored.
+   */
+  tag: Tag[];
+}
+
+/** The response indicating a successful addition of tags to the event. */
+export interface AddTagsResponse {
+}
+
+/** The request to remove tags from the event. */
+export interface RemoveTagsRequest {
+  /** The sequence of the event whose tags should be removed. */
+  sequence: bigint;
+  /** Tags to be removed. If the event is not tagged with listed tags, they are skipped. */
+  tag: Tag[];
+}
+
+/** The response indicating a successful removal of tags for the event. */
+export interface RemoveTagsResponse {
+}
+
+/** The request to retrieve tags of the event. */
+export interface GetTagsRequest {
+  /** The sequence of the event whose tags should be retrieved. */
+  sequence: bigint;
+}
+
+/** The response containing tags of an event. */
+export interface GetTagsResponse {
+  /** The tags associated to the event. */
+  tag: Tag[];
+}
+
+/** The snapshot. */
+export interface Snapshot {
+  /** The name of the snapshot. */
+  name: string;
+  /** The version of the snapshot. */
+  version: string;
+  /** The payload of the snapshot. */
+  payload: Uint8Array;
+  /** The timestamp of the snapshot. */
+  timestamp: bigint;
+  /** The metadata of the snapshot. */
+  metadata: { [key: string]: string };
+}
+
+export interface Snapshot_MetadataEntry {
+  key: string;
+  value: string;
+}
+
+/** The request to add the snapshot to the snapshot store. */
+export interface AddSnapshotRequest {
+  /** The key this snapshot is added to. */
+  key: Uint8Array;
+  /**
+   * The sequence of the snapshot. Usually linked to the sequence of the event in the event store up to which
+   * the snapshot is taken.
+   */
+  sequence: bigint;
+  /** If set to true, older snapshots for the same key are pruned. */
+  prune: boolean;
+  /** The snapshot. */
+  snapshot: Snapshot | undefined;
+}
+
+/** The response indicating the successful addition of the snapshot. */
+export interface AddSnapshotResponse {
+}
+
+/**
+ * The request to delete the snapshot from the snapshot store.
+ * Deletes from a sequence of `0` to the specified `to_sequence`
+ */
+export interface DeleteSnapshotsRequest {
+  /** The key the snapshot is identified by. */
+  key: Uint8Array;
+  /** The exclusive upper bound sequence of the snapshot to end the deletion. */
+  toSequence: bigint;
+}
+
+/** The response indicating the successful deletion of the snapshot. */
+export interface DeleteSnapshotsResponse {
+}
+
+/** The request to retrieve all snapshots from the snapshot store based on the key and sequence bounds. */
+export interface ListSnapshotsRequest {
+  /** The key of the snapshot. */
+  key: Uint8Array;
+  /** The inclusive bottom bound sequence used to filter out snapshots. */
+  fromSequence: bigint;
+  /** The exclusive upper bound sequence used to filter out snapshots. */
+  toSequence: bigint;
+}
+
+/** The response to the ListSnapshotRequest. */
+export interface ListSnapshotsResponse {
+  /** The key of the snapshot. */
+  key: Uint8Array;
+  /** The sequence of the snapshot. */
+  sequence: bigint;
+  /** The snapshot. */
+  snapshot: Snapshot | undefined;
+}
+
+/** The request to retrieve the snapshot with the highest sequence from the snapshot store. */
+export interface GetLastSnapshotRequest {
+  /** The key of the snapshot. */
+  key: Uint8Array;
+}
+
+/** The response to GetLatestSnapshotRequest. */
+export interface GetLastSnapshotResponse {
+  /** The key of the snapshot. */
+  key: Uint8Array;
+  /** The sequence of the snapshot. */
+  sequence: bigint;
+  /** The snapshot. */
+  snapshot: Snapshot | undefined;
+}
+
+function createBaseScheduleEventRequest(): ScheduleEventRequest {
+  return { instant: 0n, event: undefined };
+}
+
+export const ScheduleEventRequest: MessageFns<ScheduleEventRequest> = {
+  encode(message: ScheduleEventRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.instant !== 0n) {
+      if (BigInt.asIntN(64, message.instant) !== message.instant) {
+        throw new globalThis.Error("value provided for field message.instant of type int64 too large");
+      }
+      writer.uint32(8).int64(message.instant);
+    }
+    if (message.event !== undefined) {
+      Event.encode(message.event, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ScheduleEventRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseScheduleEventRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.instant = reader.int64() as bigint;
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.event = Event.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ScheduleEventRequest {
+    return {
+      instant: isSet(object.instant) ? BigInt(object.instant) : 0n,
+      event: isSet(object.event) ? Event.fromJSON(object.event) : undefined,
+    };
+  },
+
+  toJSON(message: ScheduleEventRequest): unknown {
+    const obj: any = {};
+    if (message.instant !== 0n) {
+      obj.instant = message.instant.toString();
+    }
+    if (message.event !== undefined) {
+      obj.event = Event.toJSON(message.event);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<ScheduleEventRequest>): ScheduleEventRequest {
+    return ScheduleEventRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ScheduleEventRequest>): ScheduleEventRequest {
+    const message = createBaseScheduleEventRequest();
+    message.instant = object.instant ?? 0n;
+    message.event = (object.event !== undefined && object.event !== null) ? Event.fromPartial(object.event) : undefined;
+    return message;
+  },
+};
+
+function createBaseRescheduleEventRequest(): RescheduleEventRequest {
+  return { token: "", instant: 0n, event: undefined };
+}
+
+export const RescheduleEventRequest: MessageFns<RescheduleEventRequest> = {
+  encode(message: RescheduleEventRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.token !== "") {
+      writer.uint32(10).string(message.token);
+    }
+    if (message.instant !== 0n) {
+      if (BigInt.asIntN(64, message.instant) !== message.instant) {
+        throw new globalThis.Error("value provided for field message.instant of type int64 too large");
+      }
+      writer.uint32(16).int64(message.instant);
+    }
+    if (message.event !== undefined) {
+      Event.encode(message.event, writer.uint32(26).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): RescheduleEventRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRescheduleEventRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.token = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.instant = reader.int64() as bigint;
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.event = Event.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RescheduleEventRequest {
+    return {
+      token: isSet(object.token) ? globalThis.String(object.token) : "",
+      instant: isSet(object.instant) ? BigInt(object.instant) : 0n,
+      event: isSet(object.event) ? Event.fromJSON(object.event) : undefined,
+    };
+  },
+
+  toJSON(message: RescheduleEventRequest): unknown {
+    const obj: any = {};
+    if (message.token !== "") {
+      obj.token = message.token;
+    }
+    if (message.instant !== 0n) {
+      obj.instant = message.instant.toString();
+    }
+    if (message.event !== undefined) {
+      obj.event = Event.toJSON(message.event);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<RescheduleEventRequest>): RescheduleEventRequest {
+    return RescheduleEventRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<RescheduleEventRequest>): RescheduleEventRequest {
+    const message = createBaseRescheduleEventRequest();
+    message.token = object.token ?? "";
+    message.instant = object.instant ?? 0n;
+    message.event = (object.event !== undefined && object.event !== null) ? Event.fromPartial(object.event) : undefined;
+    return message;
+  },
+};
+
+function createBaseCancelScheduledEventRequest(): CancelScheduledEventRequest {
+  return { token: "" };
+}
+
+export const CancelScheduledEventRequest: MessageFns<CancelScheduledEventRequest> = {
+  encode(message: CancelScheduledEventRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.token !== "") {
+      writer.uint32(10).string(message.token);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CancelScheduledEventRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCancelScheduledEventRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.token = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CancelScheduledEventRequest {
+    return { token: isSet(object.token) ? globalThis.String(object.token) : "" };
+  },
+
+  toJSON(message: CancelScheduledEventRequest): unknown {
+    const obj: any = {};
+    if (message.token !== "") {
+      obj.token = message.token;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<CancelScheduledEventRequest>): CancelScheduledEventRequest {
+    return CancelScheduledEventRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<CancelScheduledEventRequest>): CancelScheduledEventRequest {
+    const message = createBaseCancelScheduledEventRequest();
+    message.token = object.token ?? "";
+    return message;
+  },
+};
+
+function createBaseScheduleToken(): ScheduleToken {
+  return { token: "" };
+}
+
+export const ScheduleToken: MessageFns<ScheduleToken> = {
+  encode(message: ScheduleToken, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.token !== "") {
+      writer.uint32(10).string(message.token);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ScheduleToken {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseScheduleToken();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.token = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ScheduleToken {
+    return { token: isSet(object.token) ? globalThis.String(object.token) : "" };
+  },
+
+  toJSON(message: ScheduleToken): unknown {
+    const obj: any = {};
+    if (message.token !== "") {
+      obj.token = message.token;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<ScheduleToken>): ScheduleToken {
+    return ScheduleToken.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ScheduleToken>): ScheduleToken {
+    const message = createBaseScheduleToken();
+    message.token = object.token ?? "";
+    return message;
+  },
+};
+
+function createBaseEvent(): Event {
+  return { identifier: "", timestamp: 0n, name: "", version: "", payload: new Uint8Array(0), metadata: {} };
+}
+
+export const Event: MessageFns<Event> = {
+  encode(message: Event, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.identifier !== "") {
+      writer.uint32(10).string(message.identifier);
+    }
+    if (message.timestamp !== 0n) {
+      if (BigInt.asIntN(64, message.timestamp) !== message.timestamp) {
+        throw new globalThis.Error("value provided for field message.timestamp of type int64 too large");
+      }
+      writer.uint32(16).int64(message.timestamp);
+    }
+    if (message.name !== "") {
+      writer.uint32(26).string(message.name);
+    }
+    if (message.version !== "") {
+      writer.uint32(34).string(message.version);
+    }
+    if (message.payload.length !== 0) {
+      writer.uint32(42).bytes(message.payload);
+    }
+    globalThis.Object.entries(message.metadata).forEach(([key, value]: [string, string]) => {
+      Event_MetadataEntry.encode({ key: key as any, value }, writer.uint32(50).fork()).join();
+    });
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Event {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEvent();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.identifier = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.timestamp = reader.int64() as bigint;
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.version = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.payload = reader.bytes();
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+
+          const entry6 = Event_MetadataEntry.decode(reader, reader.uint32());
+          if (entry6.value !== undefined) {
+            message.metadata[entry6.key] = entry6.value;
+          }
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Event {
+    return {
+      identifier: isSet(object.identifier) ? globalThis.String(object.identifier) : "",
+      timestamp: isSet(object.timestamp) ? BigInt(object.timestamp) : 0n,
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+      version: isSet(object.version) ? globalThis.String(object.version) : "",
+      payload: isSet(object.payload) ? bytesFromBase64(object.payload) : new Uint8Array(0),
+      metadata: isObject(object.metadata)
+        ? (globalThis.Object.entries(object.metadata) as [string, any][]).reduce(
+          (acc: { [key: string]: string }, [key, value]: [string, any]) => {
+            acc[key] = globalThis.String(value);
+            return acc;
+          },
+          {},
+        )
+        : {},
+    };
+  },
+
+  toJSON(message: Event): unknown {
+    const obj: any = {};
+    if (message.identifier !== "") {
+      obj.identifier = message.identifier;
+    }
+    if (message.timestamp !== 0n) {
+      obj.timestamp = message.timestamp.toString();
+    }
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.version !== "") {
+      obj.version = message.version;
+    }
+    if (message.payload.length !== 0) {
+      obj.payload = base64FromBytes(message.payload);
+    }
+    if (message.metadata) {
+      const entries = globalThis.Object.entries(message.metadata) as [string, string][];
+      if (entries.length > 0) {
+        obj.metadata = {};
+        entries.forEach(([k, v]) => {
+          obj.metadata[k] = v;
+        });
+      }
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<Event>): Event {
+    return Event.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<Event>): Event {
+    const message = createBaseEvent();
+    message.identifier = object.identifier ?? "";
+    message.timestamp = object.timestamp ?? 0n;
+    message.name = object.name ?? "";
+    message.version = object.version ?? "";
+    message.payload = object.payload ?? new Uint8Array(0);
+    message.metadata = (globalThis.Object.entries(object.metadata ?? {}) as [string, string][]).reduce(
+      (acc: { [key: string]: string }, [key, value]: [string, string]) => {
+        if (value !== undefined) {
+          acc[key] = globalThis.String(value);
+        }
+        return acc;
+      },
+      {},
+    );
+    return message;
+  },
+};
+
+function createBaseEvent_MetadataEntry(): Event_MetadataEntry {
+  return { key: "", value: "" };
+}
+
+export const Event_MetadataEntry: MessageFns<Event_MetadataEntry> = {
+  encode(message: Event_MetadataEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Event_MetadataEntry {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEvent_MetadataEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.value = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Event_MetadataEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? globalThis.String(object.value) : "",
+    };
+  },
+
+  toJSON(message: Event_MetadataEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<Event_MetadataEntry>): Event_MetadataEntry {
+    return Event_MetadataEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<Event_MetadataEntry>): Event_MetadataEntry {
+    const message = createBaseEvent_MetadataEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  },
+};
+
+function createBaseTag(): Tag {
+  return { key: new Uint8Array(0), value: new Uint8Array(0) };
+}
+
+export const Tag: MessageFns<Tag> = {
+  encode(message: Tag, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+    if (message.value.length !== 0) {
+      writer.uint32(18).bytes(message.value);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Tag {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTag();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.key = reader.bytes();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.value = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Tag {
+    return {
+      key: isSet(object.key) ? bytesFromBase64(object.key) : new Uint8Array(0),
+      value: isSet(object.value) ? bytesFromBase64(object.value) : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: Tag): unknown {
+    const obj: any = {};
+    if (message.key.length !== 0) {
+      obj.key = base64FromBytes(message.key);
+    }
+    if (message.value.length !== 0) {
+      obj.value = base64FromBytes(message.value);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<Tag>): Tag {
+    return Tag.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<Tag>): Tag {
+    const message = createBaseTag();
+    message.key = object.key ?? new Uint8Array(0);
+    message.value = object.value ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+function createBaseTaggedEvent(): TaggedEvent {
+  return { event: undefined, tag: [] };
+}
+
+export const TaggedEvent: MessageFns<TaggedEvent> = {
+  encode(message: TaggedEvent, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.event !== undefined) {
+      Event.encode(message.event, writer.uint32(10).fork()).join();
+    }
+    for (const v of message.tag) {
+      Tag.encode(v!, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TaggedEvent {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTaggedEvent();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.event = Event.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.tag.push(Tag.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TaggedEvent {
+    return {
+      event: isSet(object.event) ? Event.fromJSON(object.event) : undefined,
+      tag: globalThis.Array.isArray(object?.tag) ? object.tag.map((e: any) => Tag.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: TaggedEvent): unknown {
+    const obj: any = {};
+    if (message.event !== undefined) {
+      obj.event = Event.toJSON(message.event);
+    }
+    if (message.tag?.length) {
+      obj.tag = message.tag.map((e) => Tag.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<TaggedEvent>): TaggedEvent {
+    return TaggedEvent.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<TaggedEvent>): TaggedEvent {
+    const message = createBaseTaggedEvent();
+    message.event = (object.event !== undefined && object.event !== null) ? Event.fromPartial(object.event) : undefined;
+    message.tag = object.tag?.map((e) => Tag.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseSequencedEvent(): SequencedEvent {
+  return { sequence: 0n, event: undefined };
+}
+
+export const SequencedEvent: MessageFns<SequencedEvent> = {
+  encode(message: SequencedEvent, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.sequence !== 0n) {
+      if (BigInt.asIntN(64, message.sequence) !== message.sequence) {
+        throw new globalThis.Error("value provided for field message.sequence of type int64 too large");
+      }
+      writer.uint32(8).int64(message.sequence);
+    }
+    if (message.event !== undefined) {
+      Event.encode(message.event, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SequencedEvent {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSequencedEvent();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.sequence = reader.int64() as bigint;
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.event = Event.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SequencedEvent {
+    return {
+      sequence: isSet(object.sequence) ? BigInt(object.sequence) : 0n,
+      event: isSet(object.event) ? Event.fromJSON(object.event) : undefined,
+    };
+  },
+
+  toJSON(message: SequencedEvent): unknown {
+    const obj: any = {};
+    if (message.sequence !== 0n) {
+      obj.sequence = message.sequence.toString();
+    }
+    if (message.event !== undefined) {
+      obj.event = Event.toJSON(message.event);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<SequencedEvent>): SequencedEvent {
+    return SequencedEvent.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<SequencedEvent>): SequencedEvent {
+    const message = createBaseSequencedEvent();
+    message.sequence = object.sequence ?? 0n;
+    message.event = (object.event !== undefined && object.event !== null) ? Event.fromPartial(object.event) : undefined;
+    return message;
+  },
+};
+
+function createBaseAppendEventsRequest(): AppendEventsRequest {
+  return { condition: undefined, event: [] };
+}
+
+export const AppendEventsRequest: MessageFns<AppendEventsRequest> = {
+  encode(message: AppendEventsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.condition !== undefined) {
+      ConsistencyCondition.encode(message.condition, writer.uint32(10).fork()).join();
+    }
+    for (const v of message.event) {
+      TaggedEvent.encode(v!, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): AppendEventsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAppendEventsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.condition = ConsistencyCondition.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.event.push(TaggedEvent.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): AppendEventsRequest {
+    return {
+      condition: isSet(object.condition) ? ConsistencyCondition.fromJSON(object.condition) : undefined,
+      event: globalThis.Array.isArray(object?.event) ? object.event.map((e: any) => TaggedEvent.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: AppendEventsRequest): unknown {
+    const obj: any = {};
+    if (message.condition !== undefined) {
+      obj.condition = ConsistencyCondition.toJSON(message.condition);
+    }
+    if (message.event?.length) {
+      obj.event = message.event.map((e) => TaggedEvent.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<AppendEventsRequest>): AppendEventsRequest {
+    return AppendEventsRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<AppendEventsRequest>): AppendEventsRequest {
+    const message = createBaseAppendEventsRequest();
+    message.condition = (object.condition !== undefined && object.condition !== null)
+      ? ConsistencyCondition.fromPartial(object.condition)
+      : undefined;
+    message.event = object.event?.map((e) => TaggedEvent.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseAppendEventsResponse(): AppendEventsResponse {
+  return { sequenceOfTheFirstEvent: 0n, transactionSize: 0, consistencyMarker: 0n };
+}
+
+export const AppendEventsResponse: MessageFns<AppendEventsResponse> = {
+  encode(message: AppendEventsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.sequenceOfTheFirstEvent !== 0n) {
+      if (BigInt.asIntN(64, message.sequenceOfTheFirstEvent) !== message.sequenceOfTheFirstEvent) {
+        throw new globalThis.Error("value provided for field message.sequenceOfTheFirstEvent of type int64 too large");
+      }
+      writer.uint32(8).int64(message.sequenceOfTheFirstEvent);
+    }
+    if (message.transactionSize !== 0) {
+      writer.uint32(16).int32(message.transactionSize);
+    }
+    if (message.consistencyMarker !== 0n) {
+      if (BigInt.asIntN(64, message.consistencyMarker) !== message.consistencyMarker) {
+        throw new globalThis.Error("value provided for field message.consistencyMarker of type int64 too large");
+      }
+      writer.uint32(24).int64(message.consistencyMarker);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): AppendEventsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAppendEventsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.sequenceOfTheFirstEvent = reader.int64() as bigint;
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.transactionSize = reader.int32();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.consistencyMarker = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): AppendEventsResponse {
+    return {
+      sequenceOfTheFirstEvent: isSet(object.sequenceOfTheFirstEvent)
+        ? BigInt(object.sequenceOfTheFirstEvent)
+        : isSet(object.sequence_of_the_first_event)
+        ? BigInt(object.sequence_of_the_first_event)
+        : 0n,
+      transactionSize: isSet(object.transactionSize)
+        ? globalThis.Number(object.transactionSize)
+        : isSet(object.transaction_size)
+        ? globalThis.Number(object.transaction_size)
+        : 0,
+      consistencyMarker: isSet(object.consistencyMarker)
+        ? BigInt(object.consistencyMarker)
+        : isSet(object.consistency_marker)
+        ? BigInt(object.consistency_marker)
+        : 0n,
+    };
+  },
+
+  toJSON(message: AppendEventsResponse): unknown {
+    const obj: any = {};
+    if (message.sequenceOfTheFirstEvent !== 0n) {
+      obj.sequenceOfTheFirstEvent = message.sequenceOfTheFirstEvent.toString();
+    }
+    if (message.transactionSize !== 0) {
+      obj.transactionSize = Math.round(message.transactionSize);
+    }
+    if (message.consistencyMarker !== 0n) {
+      obj.consistencyMarker = message.consistencyMarker.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<AppendEventsResponse>): AppendEventsResponse {
+    return AppendEventsResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<AppendEventsResponse>): AppendEventsResponse {
+    const message = createBaseAppendEventsResponse();
+    message.sequenceOfTheFirstEvent = object.sequenceOfTheFirstEvent ?? 0n;
+    message.transactionSize = object.transactionSize ?? 0;
+    message.consistencyMarker = object.consistencyMarker ?? 0n;
+    return message;
+  },
+};
+
+function createBaseSourceEventsRequest(): SourceEventsRequest {
+  return { fromSequence: 0n, criterion: [] };
+}
+
+export const SourceEventsRequest: MessageFns<SourceEventsRequest> = {
+  encode(message: SourceEventsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.fromSequence !== 0n) {
+      if (BigInt.asIntN(64, message.fromSequence) !== message.fromSequence) {
+        throw new globalThis.Error("value provided for field message.fromSequence of type int64 too large");
+      }
+      writer.uint32(8).int64(message.fromSequence);
+    }
+    for (const v of message.criterion) {
+      Criterion.encode(v!, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SourceEventsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSourceEventsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.fromSequence = reader.int64() as bigint;
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.criterion.push(Criterion.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SourceEventsRequest {
+    return {
+      fromSequence: isSet(object.fromSequence)
+        ? BigInt(object.fromSequence)
+        : isSet(object.from_sequence)
+        ? BigInt(object.from_sequence)
+        : 0n,
+      criterion: globalThis.Array.isArray(object?.criterion)
+        ? object.criterion.map((e: any) => Criterion.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: SourceEventsRequest): unknown {
+    const obj: any = {};
+    if (message.fromSequence !== 0n) {
+      obj.fromSequence = message.fromSequence.toString();
+    }
+    if (message.criterion?.length) {
+      obj.criterion = message.criterion.map((e) => Criterion.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<SourceEventsRequest>): SourceEventsRequest {
+    return SourceEventsRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<SourceEventsRequest>): SourceEventsRequest {
+    const message = createBaseSourceEventsRequest();
+    message.fromSequence = object.fromSequence ?? 0n;
+    message.criterion = object.criterion?.map((e) => Criterion.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseSourceEventsResponse(): SourceEventsResponse {
+  return { event: undefined, consistencyMarker: undefined };
+}
+
+export const SourceEventsResponse: MessageFns<SourceEventsResponse> = {
+  encode(message: SourceEventsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.event !== undefined) {
+      SequencedEvent.encode(message.event, writer.uint32(10).fork()).join();
+    }
+    if (message.consistencyMarker !== undefined) {
+      if (BigInt.asIntN(64, message.consistencyMarker) !== message.consistencyMarker) {
+        throw new globalThis.Error("value provided for field message.consistencyMarker of type int64 too large");
+      }
+      writer.uint32(16).int64(message.consistencyMarker);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SourceEventsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSourceEventsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.event = SequencedEvent.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.consistencyMarker = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SourceEventsResponse {
+    return {
+      event: isSet(object.event) ? SequencedEvent.fromJSON(object.event) : undefined,
+      consistencyMarker: isSet(object.consistencyMarker)
+        ? BigInt(object.consistencyMarker)
+        : isSet(object.consistency_marker)
+        ? BigInt(object.consistency_marker)
+        : undefined,
+    };
+  },
+
+  toJSON(message: SourceEventsResponse): unknown {
+    const obj: any = {};
+    if (message.event !== undefined) {
+      obj.event = SequencedEvent.toJSON(message.event);
+    }
+    if (message.consistencyMarker !== undefined) {
+      obj.consistencyMarker = message.consistencyMarker.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<SourceEventsResponse>): SourceEventsResponse {
+    return SourceEventsResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<SourceEventsResponse>): SourceEventsResponse {
+    const message = createBaseSourceEventsResponse();
+    message.event = (object.event !== undefined && object.event !== null)
+      ? SequencedEvent.fromPartial(object.event)
+      : undefined;
+    message.consistencyMarker = object.consistencyMarker ?? undefined;
+    return message;
+  },
+};
+
+function createBaseConsistencyCondition(): ConsistencyCondition {
+  return { consistencyMarker: 0n, criterion: [] };
+}
+
+export const ConsistencyCondition: MessageFns<ConsistencyCondition> = {
+  encode(message: ConsistencyCondition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.consistencyMarker !== 0n) {
+      if (BigInt.asIntN(64, message.consistencyMarker) !== message.consistencyMarker) {
+        throw new globalThis.Error("value provided for field message.consistencyMarker of type int64 too large");
+      }
+      writer.uint32(8).int64(message.consistencyMarker);
+    }
+    for (const v of message.criterion) {
+      Criterion.encode(v!, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ConsistencyCondition {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseConsistencyCondition();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.consistencyMarker = reader.int64() as bigint;
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.criterion.push(Criterion.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ConsistencyCondition {
+    return {
+      consistencyMarker: isSet(object.consistencyMarker)
+        ? BigInt(object.consistencyMarker)
+        : isSet(object.consistency_marker)
+        ? BigInt(object.consistency_marker)
+        : 0n,
+      criterion: globalThis.Array.isArray(object?.criterion)
+        ? object.criterion.map((e: any) => Criterion.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: ConsistencyCondition): unknown {
+    const obj: any = {};
+    if (message.consistencyMarker !== 0n) {
+      obj.consistencyMarker = message.consistencyMarker.toString();
+    }
+    if (message.criterion?.length) {
+      obj.criterion = message.criterion.map((e) => Criterion.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<ConsistencyCondition>): ConsistencyCondition {
+    return ConsistencyCondition.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ConsistencyCondition>): ConsistencyCondition {
+    const message = createBaseConsistencyCondition();
+    message.consistencyMarker = object.consistencyMarker ?? 0n;
+    message.criterion = object.criterion?.map((e) => Criterion.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseCriterion(): Criterion {
+  return { tagsAndNames: undefined };
+}
+
+export const Criterion: MessageFns<Criterion> = {
+  encode(message: Criterion, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.tagsAndNames !== undefined) {
+      TagsAndNamesCriterion.encode(message.tagsAndNames, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Criterion {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCriterion();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.tagsAndNames = TagsAndNamesCriterion.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Criterion {
+    return {
+      tagsAndNames: isSet(object.tagsAndNames)
+        ? TagsAndNamesCriterion.fromJSON(object.tagsAndNames)
+        : isSet(object.tags_and_names)
+        ? TagsAndNamesCriterion.fromJSON(object.tags_and_names)
+        : undefined,
+    };
+  },
+
+  toJSON(message: Criterion): unknown {
+    const obj: any = {};
+    if (message.tagsAndNames !== undefined) {
+      obj.tagsAndNames = TagsAndNamesCriterion.toJSON(message.tagsAndNames);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<Criterion>): Criterion {
+    return Criterion.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<Criterion>): Criterion {
+    const message = createBaseCriterion();
+    message.tagsAndNames = (object.tagsAndNames !== undefined && object.tagsAndNames !== null)
+      ? TagsAndNamesCriterion.fromPartial(object.tagsAndNames)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseTagsAndNamesCriterion(): TagsAndNamesCriterion {
+  return { name: [], tag: [] };
+}
+
+export const TagsAndNamesCriterion: MessageFns<TagsAndNamesCriterion> = {
+  encode(message: TagsAndNamesCriterion, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.name) {
+      writer.uint32(10).string(v!);
+    }
+    for (const v of message.tag) {
+      Tag.encode(v!, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TagsAndNamesCriterion {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTagsAndNamesCriterion();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.name.push(reader.string());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.tag.push(Tag.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TagsAndNamesCriterion {
+    return {
+      name: globalThis.Array.isArray(object?.name) ? object.name.map((e: any) => globalThis.String(e)) : [],
+      tag: globalThis.Array.isArray(object?.tag) ? object.tag.map((e: any) => Tag.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: TagsAndNamesCriterion): unknown {
+    const obj: any = {};
+    if (message.name?.length) {
+      obj.name = message.name;
+    }
+    if (message.tag?.length) {
+      obj.tag = message.tag.map((e) => Tag.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<TagsAndNamesCriterion>): TagsAndNamesCriterion {
+    return TagsAndNamesCriterion.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<TagsAndNamesCriterion>): TagsAndNamesCriterion {
+    const message = createBaseTagsAndNamesCriterion();
+    message.name = object.name?.map((e) => e) || [];
+    message.tag = object.tag?.map((e) => Tag.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseStreamEventsRequest(): StreamEventsRequest {
+  return { fromSequence: 0n, criterion: [] };
+}
+
+export const StreamEventsRequest: MessageFns<StreamEventsRequest> = {
+  encode(message: StreamEventsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.fromSequence !== 0n) {
+      if (BigInt.asIntN(64, message.fromSequence) !== message.fromSequence) {
+        throw new globalThis.Error("value provided for field message.fromSequence of type int64 too large");
+      }
+      writer.uint32(8).int64(message.fromSequence);
+    }
+    for (const v of message.criterion) {
+      Criterion.encode(v!, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): StreamEventsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStreamEventsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.fromSequence = reader.int64() as bigint;
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.criterion.push(Criterion.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): StreamEventsRequest {
+    return {
+      fromSequence: isSet(object.fromSequence)
+        ? BigInt(object.fromSequence)
+        : isSet(object.from_sequence)
+        ? BigInt(object.from_sequence)
+        : 0n,
+      criterion: globalThis.Array.isArray(object?.criterion)
+        ? object.criterion.map((e: any) => Criterion.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: StreamEventsRequest): unknown {
+    const obj: any = {};
+    if (message.fromSequence !== 0n) {
+      obj.fromSequence = message.fromSequence.toString();
+    }
+    if (message.criterion?.length) {
+      obj.criterion = message.criterion.map((e) => Criterion.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<StreamEventsRequest>): StreamEventsRequest {
+    return StreamEventsRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<StreamEventsRequest>): StreamEventsRequest {
+    const message = createBaseStreamEventsRequest();
+    message.fromSequence = object.fromSequence ?? 0n;
+    message.criterion = object.criterion?.map((e) => Criterion.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseStreamEventsResponse(): StreamEventsResponse {
+  return { event: undefined };
+}
+
+export const StreamEventsResponse: MessageFns<StreamEventsResponse> = {
+  encode(message: StreamEventsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.event !== undefined) {
+      SequencedEvent.encode(message.event, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): StreamEventsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStreamEventsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.event = SequencedEvent.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): StreamEventsResponse {
+    return { event: isSet(object.event) ? SequencedEvent.fromJSON(object.event) : undefined };
+  },
+
+  toJSON(message: StreamEventsResponse): unknown {
+    const obj: any = {};
+    if (message.event !== undefined) {
+      obj.event = SequencedEvent.toJSON(message.event);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<StreamEventsResponse>): StreamEventsResponse {
+    return StreamEventsResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<StreamEventsResponse>): StreamEventsResponse {
+    const message = createBaseStreamEventsResponse();
+    message.event = (object.event !== undefined && object.event !== null)
+      ? SequencedEvent.fromPartial(object.event)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseGetHeadRequest(): GetHeadRequest {
+  return {};
+}
+
+export const GetHeadRequest: MessageFns<GetHeadRequest> = {
+  encode(_: GetHeadRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetHeadRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetHeadRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): GetHeadRequest {
+    return {};
+  },
+
+  toJSON(_: GetHeadRequest): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetHeadRequest>): GetHeadRequest {
+    return GetHeadRequest.fromPartial(base ?? {});
+  },
+  fromPartial(_: DeepPartial<GetHeadRequest>): GetHeadRequest {
+    const message = createBaseGetHeadRequest();
+    return message;
+  },
+};
+
+function createBaseGetHeadResponse(): GetHeadResponse {
+  return { sequence: 0n };
+}
+
+export const GetHeadResponse: MessageFns<GetHeadResponse> = {
+  encode(message: GetHeadResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.sequence !== 0n) {
+      if (BigInt.asIntN(64, message.sequence) !== message.sequence) {
+        throw new globalThis.Error("value provided for field message.sequence of type int64 too large");
+      }
+      writer.uint32(8).int64(message.sequence);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetHeadResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetHeadResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.sequence = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetHeadResponse {
+    return { sequence: isSet(object.sequence) ? BigInt(object.sequence) : 0n };
+  },
+
+  toJSON(message: GetHeadResponse): unknown {
+    const obj: any = {};
+    if (message.sequence !== 0n) {
+      obj.sequence = message.sequence.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetHeadResponse>): GetHeadResponse {
+    return GetHeadResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetHeadResponse>): GetHeadResponse {
+    const message = createBaseGetHeadResponse();
+    message.sequence = object.sequence ?? 0n;
+    return message;
+  },
+};
+
+function createBaseGetTailRequest(): GetTailRequest {
+  return {};
+}
+
+export const GetTailRequest: MessageFns<GetTailRequest> = {
+  encode(_: GetTailRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetTailRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetTailRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): GetTailRequest {
+    return {};
+  },
+
+  toJSON(_: GetTailRequest): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetTailRequest>): GetTailRequest {
+    return GetTailRequest.fromPartial(base ?? {});
+  },
+  fromPartial(_: DeepPartial<GetTailRequest>): GetTailRequest {
+    const message = createBaseGetTailRequest();
+    return message;
+  },
+};
+
+function createBaseGetTailResponse(): GetTailResponse {
+  return { sequence: 0n };
+}
+
+export const GetTailResponse: MessageFns<GetTailResponse> = {
+  encode(message: GetTailResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.sequence !== 0n) {
+      if (BigInt.asIntN(64, message.sequence) !== message.sequence) {
+        throw new globalThis.Error("value provided for field message.sequence of type int64 too large");
+      }
+      writer.uint32(8).int64(message.sequence);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetTailResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetTailResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.sequence = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetTailResponse {
+    return { sequence: isSet(object.sequence) ? BigInt(object.sequence) : 0n };
+  },
+
+  toJSON(message: GetTailResponse): unknown {
+    const obj: any = {};
+    if (message.sequence !== 0n) {
+      obj.sequence = message.sequence.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetTailResponse>): GetTailResponse {
+    return GetTailResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetTailResponse>): GetTailResponse {
+    const message = createBaseGetTailResponse();
+    message.sequence = object.sequence ?? 0n;
+    return message;
+  },
+};
+
+function createBaseGetSequenceAtRequest(): GetSequenceAtRequest {
+  return { timestamp: 0n };
+}
+
+export const GetSequenceAtRequest: MessageFns<GetSequenceAtRequest> = {
+  encode(message: GetSequenceAtRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.timestamp !== 0n) {
+      if (BigInt.asIntN(64, message.timestamp) !== message.timestamp) {
+        throw new globalThis.Error("value provided for field message.timestamp of type int64 too large");
+      }
+      writer.uint32(8).int64(message.timestamp);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetSequenceAtRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetSequenceAtRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.timestamp = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetSequenceAtRequest {
+    return { timestamp: isSet(object.timestamp) ? BigInt(object.timestamp) : 0n };
+  },
+
+  toJSON(message: GetSequenceAtRequest): unknown {
+    const obj: any = {};
+    if (message.timestamp !== 0n) {
+      obj.timestamp = message.timestamp.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetSequenceAtRequest>): GetSequenceAtRequest {
+    return GetSequenceAtRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetSequenceAtRequest>): GetSequenceAtRequest {
+    const message = createBaseGetSequenceAtRequest();
+    message.timestamp = object.timestamp ?? 0n;
+    return message;
+  },
+};
+
+function createBaseGetSequenceAtResponse(): GetSequenceAtResponse {
+  return { sequence: 0n };
+}
+
+export const GetSequenceAtResponse: MessageFns<GetSequenceAtResponse> = {
+  encode(message: GetSequenceAtResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.sequence !== 0n) {
+      if (BigInt.asIntN(64, message.sequence) !== message.sequence) {
+        throw new globalThis.Error("value provided for field message.sequence of type int64 too large");
+      }
+      writer.uint32(8).int64(message.sequence);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetSequenceAtResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetSequenceAtResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.sequence = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetSequenceAtResponse {
+    return { sequence: isSet(object.sequence) ? BigInt(object.sequence) : 0n };
+  },
+
+  toJSON(message: GetSequenceAtResponse): unknown {
+    const obj: any = {};
+    if (message.sequence !== 0n) {
+      obj.sequence = message.sequence.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetSequenceAtResponse>): GetSequenceAtResponse {
+    return GetSequenceAtResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetSequenceAtResponse>): GetSequenceAtResponse {
+    const message = createBaseGetSequenceAtResponse();
+    message.sequence = object.sequence ?? 0n;
+    return message;
+  },
+};
+
+function createBaseAddTagsRequest(): AddTagsRequest {
+  return { sequence: 0n, tag: [] };
+}
+
+export const AddTagsRequest: MessageFns<AddTagsRequest> = {
+  encode(message: AddTagsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.sequence !== 0n) {
+      if (BigInt.asIntN(64, message.sequence) !== message.sequence) {
+        throw new globalThis.Error("value provided for field message.sequence of type int64 too large");
+      }
+      writer.uint32(8).int64(message.sequence);
+    }
+    for (const v of message.tag) {
+      Tag.encode(v!, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): AddTagsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAddTagsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.sequence = reader.int64() as bigint;
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.tag.push(Tag.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): AddTagsRequest {
+    return {
+      sequence: isSet(object.sequence) ? BigInt(object.sequence) : 0n,
+      tag: globalThis.Array.isArray(object?.tag) ? object.tag.map((e: any) => Tag.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: AddTagsRequest): unknown {
+    const obj: any = {};
+    if (message.sequence !== 0n) {
+      obj.sequence = message.sequence.toString();
+    }
+    if (message.tag?.length) {
+      obj.tag = message.tag.map((e) => Tag.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<AddTagsRequest>): AddTagsRequest {
+    return AddTagsRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<AddTagsRequest>): AddTagsRequest {
+    const message = createBaseAddTagsRequest();
+    message.sequence = object.sequence ?? 0n;
+    message.tag = object.tag?.map((e) => Tag.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseAddTagsResponse(): AddTagsResponse {
+  return {};
+}
+
+export const AddTagsResponse: MessageFns<AddTagsResponse> = {
+  encode(_: AddTagsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): AddTagsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAddTagsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): AddTagsResponse {
+    return {};
+  },
+
+  toJSON(_: AddTagsResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create(base?: DeepPartial<AddTagsResponse>): AddTagsResponse {
+    return AddTagsResponse.fromPartial(base ?? {});
+  },
+  fromPartial(_: DeepPartial<AddTagsResponse>): AddTagsResponse {
+    const message = createBaseAddTagsResponse();
+    return message;
+  },
+};
+
+function createBaseRemoveTagsRequest(): RemoveTagsRequest {
+  return { sequence: 0n, tag: [] };
+}
+
+export const RemoveTagsRequest: MessageFns<RemoveTagsRequest> = {
+  encode(message: RemoveTagsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.sequence !== 0n) {
+      if (BigInt.asIntN(64, message.sequence) !== message.sequence) {
+        throw new globalThis.Error("value provided for field message.sequence of type int64 too large");
+      }
+      writer.uint32(8).int64(message.sequence);
+    }
+    for (const v of message.tag) {
+      Tag.encode(v!, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): RemoveTagsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRemoveTagsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.sequence = reader.int64() as bigint;
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.tag.push(Tag.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RemoveTagsRequest {
+    return {
+      sequence: isSet(object.sequence) ? BigInt(object.sequence) : 0n,
+      tag: globalThis.Array.isArray(object?.tag) ? object.tag.map((e: any) => Tag.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: RemoveTagsRequest): unknown {
+    const obj: any = {};
+    if (message.sequence !== 0n) {
+      obj.sequence = message.sequence.toString();
+    }
+    if (message.tag?.length) {
+      obj.tag = message.tag.map((e) => Tag.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<RemoveTagsRequest>): RemoveTagsRequest {
+    return RemoveTagsRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<RemoveTagsRequest>): RemoveTagsRequest {
+    const message = createBaseRemoveTagsRequest();
+    message.sequence = object.sequence ?? 0n;
+    message.tag = object.tag?.map((e) => Tag.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseRemoveTagsResponse(): RemoveTagsResponse {
+  return {};
+}
+
+export const RemoveTagsResponse: MessageFns<RemoveTagsResponse> = {
+  encode(_: RemoveTagsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): RemoveTagsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRemoveTagsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): RemoveTagsResponse {
+    return {};
+  },
+
+  toJSON(_: RemoveTagsResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create(base?: DeepPartial<RemoveTagsResponse>): RemoveTagsResponse {
+    return RemoveTagsResponse.fromPartial(base ?? {});
+  },
+  fromPartial(_: DeepPartial<RemoveTagsResponse>): RemoveTagsResponse {
+    const message = createBaseRemoveTagsResponse();
+    return message;
+  },
+};
+
+function createBaseGetTagsRequest(): GetTagsRequest {
+  return { sequence: 0n };
+}
+
+export const GetTagsRequest: MessageFns<GetTagsRequest> = {
+  encode(message: GetTagsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.sequence !== 0n) {
+      if (BigInt.asIntN(64, message.sequence) !== message.sequence) {
+        throw new globalThis.Error("value provided for field message.sequence of type int64 too large");
+      }
+      writer.uint32(8).int64(message.sequence);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetTagsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetTagsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.sequence = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetTagsRequest {
+    return { sequence: isSet(object.sequence) ? BigInt(object.sequence) : 0n };
+  },
+
+  toJSON(message: GetTagsRequest): unknown {
+    const obj: any = {};
+    if (message.sequence !== 0n) {
+      obj.sequence = message.sequence.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetTagsRequest>): GetTagsRequest {
+    return GetTagsRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetTagsRequest>): GetTagsRequest {
+    const message = createBaseGetTagsRequest();
+    message.sequence = object.sequence ?? 0n;
+    return message;
+  },
+};
+
+function createBaseGetTagsResponse(): GetTagsResponse {
+  return { tag: [] };
+}
+
+export const GetTagsResponse: MessageFns<GetTagsResponse> = {
+  encode(message: GetTagsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.tag) {
+      Tag.encode(v!, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetTagsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetTagsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.tag.push(Tag.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetTagsResponse {
+    return { tag: globalThis.Array.isArray(object?.tag) ? object.tag.map((e: any) => Tag.fromJSON(e)) : [] };
+  },
+
+  toJSON(message: GetTagsResponse): unknown {
+    const obj: any = {};
+    if (message.tag?.length) {
+      obj.tag = message.tag.map((e) => Tag.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetTagsResponse>): GetTagsResponse {
+    return GetTagsResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetTagsResponse>): GetTagsResponse {
+    const message = createBaseGetTagsResponse();
+    message.tag = object.tag?.map((e) => Tag.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseSnapshot(): Snapshot {
+  return { name: "", version: "", payload: new Uint8Array(0), timestamp: 0n, metadata: {} };
+}
+
+export const Snapshot: MessageFns<Snapshot> = {
+  encode(message: Snapshot, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+    if (message.version !== "") {
+      writer.uint32(18).string(message.version);
+    }
+    if (message.payload.length !== 0) {
+      writer.uint32(26).bytes(message.payload);
+    }
+    if (message.timestamp !== 0n) {
+      if (BigInt.asIntN(64, message.timestamp) !== message.timestamp) {
+        throw new globalThis.Error("value provided for field message.timestamp of type int64 too large");
+      }
+      writer.uint32(32).int64(message.timestamp);
+    }
+    globalThis.Object.entries(message.metadata).forEach(([key, value]: [string, string]) => {
+      Snapshot_MetadataEntry.encode({ key: key as any, value }, writer.uint32(42).fork()).join();
+    });
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Snapshot {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSnapshot();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.version = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.payload = reader.bytes();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+
+          message.timestamp = reader.int64() as bigint;
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          const entry5 = Snapshot_MetadataEntry.decode(reader, reader.uint32());
+          if (entry5.value !== undefined) {
+            message.metadata[entry5.key] = entry5.value;
+          }
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Snapshot {
+    return {
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+      version: isSet(object.version) ? globalThis.String(object.version) : "",
+      payload: isSet(object.payload) ? bytesFromBase64(object.payload) : new Uint8Array(0),
+      timestamp: isSet(object.timestamp) ? BigInt(object.timestamp) : 0n,
+      metadata: isObject(object.metadata)
+        ? (globalThis.Object.entries(object.metadata) as [string, any][]).reduce(
+          (acc: { [key: string]: string }, [key, value]: [string, any]) => {
+            acc[key] = globalThis.String(value);
+            return acc;
+          },
+          {},
+        )
+        : {},
+    };
+  },
+
+  toJSON(message: Snapshot): unknown {
+    const obj: any = {};
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.version !== "") {
+      obj.version = message.version;
+    }
+    if (message.payload.length !== 0) {
+      obj.payload = base64FromBytes(message.payload);
+    }
+    if (message.timestamp !== 0n) {
+      obj.timestamp = message.timestamp.toString();
+    }
+    if (message.metadata) {
+      const entries = globalThis.Object.entries(message.metadata) as [string, string][];
+      if (entries.length > 0) {
+        obj.metadata = {};
+        entries.forEach(([k, v]) => {
+          obj.metadata[k] = v;
+        });
+      }
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<Snapshot>): Snapshot {
+    return Snapshot.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<Snapshot>): Snapshot {
+    const message = createBaseSnapshot();
+    message.name = object.name ?? "";
+    message.version = object.version ?? "";
+    message.payload = object.payload ?? new Uint8Array(0);
+    message.timestamp = object.timestamp ?? 0n;
+    message.metadata = (globalThis.Object.entries(object.metadata ?? {}) as [string, string][]).reduce(
+      (acc: { [key: string]: string }, [key, value]: [string, string]) => {
+        if (value !== undefined) {
+          acc[key] = globalThis.String(value);
+        }
+        return acc;
+      },
+      {},
+    );
+    return message;
+  },
+};
+
+function createBaseSnapshot_MetadataEntry(): Snapshot_MetadataEntry {
+  return { key: "", value: "" };
+}
+
+export const Snapshot_MetadataEntry: MessageFns<Snapshot_MetadataEntry> = {
+  encode(message: Snapshot_MetadataEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Snapshot_MetadataEntry {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSnapshot_MetadataEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.value = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Snapshot_MetadataEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? globalThis.String(object.value) : "",
+    };
+  },
+
+  toJSON(message: Snapshot_MetadataEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<Snapshot_MetadataEntry>): Snapshot_MetadataEntry {
+    return Snapshot_MetadataEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<Snapshot_MetadataEntry>): Snapshot_MetadataEntry {
+    const message = createBaseSnapshot_MetadataEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  },
+};
+
+function createBaseAddSnapshotRequest(): AddSnapshotRequest {
+  return { key: new Uint8Array(0), sequence: 0n, prune: false, snapshot: undefined };
+}
+
+export const AddSnapshotRequest: MessageFns<AddSnapshotRequest> = {
+  encode(message: AddSnapshotRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+    if (message.sequence !== 0n) {
+      if (BigInt.asIntN(64, message.sequence) !== message.sequence) {
+        throw new globalThis.Error("value provided for field message.sequence of type int64 too large");
+      }
+      writer.uint32(16).int64(message.sequence);
+    }
+    if (message.prune !== false) {
+      writer.uint32(24).bool(message.prune);
+    }
+    if (message.snapshot !== undefined) {
+      Snapshot.encode(message.snapshot, writer.uint32(34).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): AddSnapshotRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAddSnapshotRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.key = reader.bytes();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.sequence = reader.int64() as bigint;
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.prune = reader.bool();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.snapshot = Snapshot.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): AddSnapshotRequest {
+    return {
+      key: isSet(object.key) ? bytesFromBase64(object.key) : new Uint8Array(0),
+      sequence: isSet(object.sequence) ? BigInt(object.sequence) : 0n,
+      prune: isSet(object.prune) ? globalThis.Boolean(object.prune) : false,
+      snapshot: isSet(object.snapshot) ? Snapshot.fromJSON(object.snapshot) : undefined,
+    };
+  },
+
+  toJSON(message: AddSnapshotRequest): unknown {
+    const obj: any = {};
+    if (message.key.length !== 0) {
+      obj.key = base64FromBytes(message.key);
+    }
+    if (message.sequence !== 0n) {
+      obj.sequence = message.sequence.toString();
+    }
+    if (message.prune !== false) {
+      obj.prune = message.prune;
+    }
+    if (message.snapshot !== undefined) {
+      obj.snapshot = Snapshot.toJSON(message.snapshot);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<AddSnapshotRequest>): AddSnapshotRequest {
+    return AddSnapshotRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<AddSnapshotRequest>): AddSnapshotRequest {
+    const message = createBaseAddSnapshotRequest();
+    message.key = object.key ?? new Uint8Array(0);
+    message.sequence = object.sequence ?? 0n;
+    message.prune = object.prune ?? false;
+    message.snapshot = (object.snapshot !== undefined && object.snapshot !== null)
+      ? Snapshot.fromPartial(object.snapshot)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseAddSnapshotResponse(): AddSnapshotResponse {
+  return {};
+}
+
+export const AddSnapshotResponse: MessageFns<AddSnapshotResponse> = {
+  encode(_: AddSnapshotResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): AddSnapshotResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAddSnapshotResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): AddSnapshotResponse {
+    return {};
+  },
+
+  toJSON(_: AddSnapshotResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create(base?: DeepPartial<AddSnapshotResponse>): AddSnapshotResponse {
+    return AddSnapshotResponse.fromPartial(base ?? {});
+  },
+  fromPartial(_: DeepPartial<AddSnapshotResponse>): AddSnapshotResponse {
+    const message = createBaseAddSnapshotResponse();
+    return message;
+  },
+};
+
+function createBaseDeleteSnapshotsRequest(): DeleteSnapshotsRequest {
+  return { key: new Uint8Array(0), toSequence: 0n };
+}
+
+export const DeleteSnapshotsRequest: MessageFns<DeleteSnapshotsRequest> = {
+  encode(message: DeleteSnapshotsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+    if (message.toSequence !== 0n) {
+      if (BigInt.asIntN(64, message.toSequence) !== message.toSequence) {
+        throw new globalThis.Error("value provided for field message.toSequence of type int64 too large");
+      }
+      writer.uint32(24).int64(message.toSequence);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): DeleteSnapshotsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDeleteSnapshotsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.key = reader.bytes();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.toSequence = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DeleteSnapshotsRequest {
+    return {
+      key: isSet(object.key) ? bytesFromBase64(object.key) : new Uint8Array(0),
+      toSequence: isSet(object.toSequence)
+        ? BigInt(object.toSequence)
+        : isSet(object.to_sequence)
+        ? BigInt(object.to_sequence)
+        : 0n,
+    };
+  },
+
+  toJSON(message: DeleteSnapshotsRequest): unknown {
+    const obj: any = {};
+    if (message.key.length !== 0) {
+      obj.key = base64FromBytes(message.key);
+    }
+    if (message.toSequence !== 0n) {
+      obj.toSequence = message.toSequence.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<DeleteSnapshotsRequest>): DeleteSnapshotsRequest {
+    return DeleteSnapshotsRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<DeleteSnapshotsRequest>): DeleteSnapshotsRequest {
+    const message = createBaseDeleteSnapshotsRequest();
+    message.key = object.key ?? new Uint8Array(0);
+    message.toSequence = object.toSequence ?? 0n;
+    return message;
+  },
+};
+
+function createBaseDeleteSnapshotsResponse(): DeleteSnapshotsResponse {
+  return {};
+}
+
+export const DeleteSnapshotsResponse: MessageFns<DeleteSnapshotsResponse> = {
+  encode(_: DeleteSnapshotsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): DeleteSnapshotsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDeleteSnapshotsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): DeleteSnapshotsResponse {
+    return {};
+  },
+
+  toJSON(_: DeleteSnapshotsResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create(base?: DeepPartial<DeleteSnapshotsResponse>): DeleteSnapshotsResponse {
+    return DeleteSnapshotsResponse.fromPartial(base ?? {});
+  },
+  fromPartial(_: DeepPartial<DeleteSnapshotsResponse>): DeleteSnapshotsResponse {
+    const message = createBaseDeleteSnapshotsResponse();
+    return message;
+  },
+};
+
+function createBaseListSnapshotsRequest(): ListSnapshotsRequest {
+  return { key: new Uint8Array(0), fromSequence: 0n, toSequence: 0n };
+}
+
+export const ListSnapshotsRequest: MessageFns<ListSnapshotsRequest> = {
+  encode(message: ListSnapshotsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+    if (message.fromSequence !== 0n) {
+      if (BigInt.asIntN(64, message.fromSequence) !== message.fromSequence) {
+        throw new globalThis.Error("value provided for field message.fromSequence of type int64 too large");
+      }
+      writer.uint32(16).int64(message.fromSequence);
+    }
+    if (message.toSequence !== 0n) {
+      if (BigInt.asIntN(64, message.toSequence) !== message.toSequence) {
+        throw new globalThis.Error("value provided for field message.toSequence of type int64 too large");
+      }
+      writer.uint32(24).int64(message.toSequence);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ListSnapshotsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListSnapshotsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.key = reader.bytes();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.fromSequence = reader.int64() as bigint;
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.toSequence = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ListSnapshotsRequest {
+    return {
+      key: isSet(object.key) ? bytesFromBase64(object.key) : new Uint8Array(0),
+      fromSequence: isSet(object.fromSequence)
+        ? BigInt(object.fromSequence)
+        : isSet(object.from_sequence)
+        ? BigInt(object.from_sequence)
+        : 0n,
+      toSequence: isSet(object.toSequence)
+        ? BigInt(object.toSequence)
+        : isSet(object.to_sequence)
+        ? BigInt(object.to_sequence)
+        : 0n,
+    };
+  },
+
+  toJSON(message: ListSnapshotsRequest): unknown {
+    const obj: any = {};
+    if (message.key.length !== 0) {
+      obj.key = base64FromBytes(message.key);
+    }
+    if (message.fromSequence !== 0n) {
+      obj.fromSequence = message.fromSequence.toString();
+    }
+    if (message.toSequence !== 0n) {
+      obj.toSequence = message.toSequence.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<ListSnapshotsRequest>): ListSnapshotsRequest {
+    return ListSnapshotsRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ListSnapshotsRequest>): ListSnapshotsRequest {
+    const message = createBaseListSnapshotsRequest();
+    message.key = object.key ?? new Uint8Array(0);
+    message.fromSequence = object.fromSequence ?? 0n;
+    message.toSequence = object.toSequence ?? 0n;
+    return message;
+  },
+};
+
+function createBaseListSnapshotsResponse(): ListSnapshotsResponse {
+  return { key: new Uint8Array(0), sequence: 0n, snapshot: undefined };
+}
+
+export const ListSnapshotsResponse: MessageFns<ListSnapshotsResponse> = {
+  encode(message: ListSnapshotsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+    if (message.sequence !== 0n) {
+      if (BigInt.asIntN(64, message.sequence) !== message.sequence) {
+        throw new globalThis.Error("value provided for field message.sequence of type int64 too large");
+      }
+      writer.uint32(16).int64(message.sequence);
+    }
+    if (message.snapshot !== undefined) {
+      Snapshot.encode(message.snapshot, writer.uint32(26).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ListSnapshotsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListSnapshotsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.key = reader.bytes();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.sequence = reader.int64() as bigint;
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.snapshot = Snapshot.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ListSnapshotsResponse {
+    return {
+      key: isSet(object.key) ? bytesFromBase64(object.key) : new Uint8Array(0),
+      sequence: isSet(object.sequence) ? BigInt(object.sequence) : 0n,
+      snapshot: isSet(object.snapshot) ? Snapshot.fromJSON(object.snapshot) : undefined,
+    };
+  },
+
+  toJSON(message: ListSnapshotsResponse): unknown {
+    const obj: any = {};
+    if (message.key.length !== 0) {
+      obj.key = base64FromBytes(message.key);
+    }
+    if (message.sequence !== 0n) {
+      obj.sequence = message.sequence.toString();
+    }
+    if (message.snapshot !== undefined) {
+      obj.snapshot = Snapshot.toJSON(message.snapshot);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<ListSnapshotsResponse>): ListSnapshotsResponse {
+    return ListSnapshotsResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ListSnapshotsResponse>): ListSnapshotsResponse {
+    const message = createBaseListSnapshotsResponse();
+    message.key = object.key ?? new Uint8Array(0);
+    message.sequence = object.sequence ?? 0n;
+    message.snapshot = (object.snapshot !== undefined && object.snapshot !== null)
+      ? Snapshot.fromPartial(object.snapshot)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseGetLastSnapshotRequest(): GetLastSnapshotRequest {
+  return { key: new Uint8Array(0) };
+}
+
+export const GetLastSnapshotRequest: MessageFns<GetLastSnapshotRequest> = {
+  encode(message: GetLastSnapshotRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetLastSnapshotRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetLastSnapshotRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.key = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetLastSnapshotRequest {
+    return { key: isSet(object.key) ? bytesFromBase64(object.key) : new Uint8Array(0) };
+  },
+
+  toJSON(message: GetLastSnapshotRequest): unknown {
+    const obj: any = {};
+    if (message.key.length !== 0) {
+      obj.key = base64FromBytes(message.key);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetLastSnapshotRequest>): GetLastSnapshotRequest {
+    return GetLastSnapshotRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetLastSnapshotRequest>): GetLastSnapshotRequest {
+    const message = createBaseGetLastSnapshotRequest();
+    message.key = object.key ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+function createBaseGetLastSnapshotResponse(): GetLastSnapshotResponse {
+  return { key: new Uint8Array(0), sequence: 0n, snapshot: undefined };
+}
+
+export const GetLastSnapshotResponse: MessageFns<GetLastSnapshotResponse> = {
+  encode(message: GetLastSnapshotResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+    if (message.sequence !== 0n) {
+      if (BigInt.asIntN(64, message.sequence) !== message.sequence) {
+        throw new globalThis.Error("value provided for field message.sequence of type int64 too large");
+      }
+      writer.uint32(16).int64(message.sequence);
+    }
+    if (message.snapshot !== undefined) {
+      Snapshot.encode(message.snapshot, writer.uint32(26).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetLastSnapshotResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetLastSnapshotResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.key = reader.bytes();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.sequence = reader.int64() as bigint;
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.snapshot = Snapshot.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetLastSnapshotResponse {
+    return {
+      key: isSet(object.key) ? bytesFromBase64(object.key) : new Uint8Array(0),
+      sequence: isSet(object.sequence) ? BigInt(object.sequence) : 0n,
+      snapshot: isSet(object.snapshot) ? Snapshot.fromJSON(object.snapshot) : undefined,
+    };
+  },
+
+  toJSON(message: GetLastSnapshotResponse): unknown {
+    const obj: any = {};
+    if (message.key.length !== 0) {
+      obj.key = base64FromBytes(message.key);
+    }
+    if (message.sequence !== 0n) {
+      obj.sequence = message.sequence.toString();
+    }
+    if (message.snapshot !== undefined) {
+      obj.snapshot = Snapshot.toJSON(message.snapshot);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetLastSnapshotResponse>): GetLastSnapshotResponse {
+    return GetLastSnapshotResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetLastSnapshotResponse>): GetLastSnapshotResponse {
+    const message = createBaseGetLastSnapshotResponse();
+    message.key = object.key ?? new Uint8Array(0);
+    message.sequence = object.sequence ?? 0n;
+    message.snapshot = (object.snapshot !== undefined && object.snapshot !== null)
+      ? Snapshot.fromPartial(object.snapshot)
+      : undefined;
+    return message;
+  },
+};
+
+/** Service providing Event Store RPCs supporting DCB. */
+export type DcbEventStoreDefinition = typeof DcbEventStoreDefinition;
+export const DcbEventStoreDefinition = {
+  name: "DcbEventStore",
+  fullName: "io.axoniq.axonserver.grpc.event.dcb.DcbEventStore",
+  methods: {
+    /** Appends new events to the store. */
+    append: {
+      name: "Append",
+      requestType: AppendEventsRequest as typeof AppendEventsRequest,
+      requestStream: true,
+      responseType: AppendEventsResponse as typeof AppendEventsResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** Provides a finite stream of events based on the passed SourceEventsRequest. */
+    source: {
+      name: "Source",
+      requestType: SourceEventsRequest as typeof SourceEventsRequest,
+      requestStream: false,
+      responseType: SourceEventsResponse as typeof SourceEventsResponse,
+      responseStream: true,
+      options: {},
+    },
+    /** Provides an infinite stream of events based on the passed StreamEventsRequest. */
+    stream: {
+      name: "Stream",
+      requestType: StreamEventsRequest as typeof StreamEventsRequest,
+      requestStream: false,
+      responseType: StreamEventsResponse as typeof StreamEventsResponse,
+      responseStream: true,
+      options: {},
+    },
+    /** Gets the current _head_ of the Event Store. The _head_ points to the sequence of the first event to be appended. */
+    getHead: {
+      name: "GetHead",
+      requestType: GetHeadRequest as typeof GetHeadRequest,
+      requestStream: false,
+      responseType: GetHeadResponse as typeof GetHeadResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** Gets the current _tail_ of the Event Store. The _tail_ points to the sequence of the first event stored. */
+    getTail: {
+      name: "GetTail",
+      requestType: GetTailRequest as typeof GetTailRequest,
+      requestStream: false,
+      responseType: GetTailResponse as typeof GetTailResponse,
+      responseStream: false,
+      options: {},
+    },
+    /**
+     * Returns the lowest sequence of an event with a timestamp equal to or higher than the given timestamp. The HEAD is
+     * returned if no events exist with a timestamp equal to or higher than the given timestamp.
+     *
+     * N.B. Axon Server does not assign timestamps to events. The timestamps used for fulfilling this RPC are timestamps
+     * provided by the client. It could happen that there are events after the returned sequence that have an earlier
+     * timestamp. Axon Server does not reject appends if timestamps of events are not monotonically increasing.
+     */
+    getSequenceAt: {
+      name: "GetSequenceAt",
+      requestType: GetSequenceAtRequest as typeof GetSequenceAtRequest,
+      requestStream: false,
+      responseType: GetSequenceAtResponse as typeof GetSequenceAtResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** Assigns tags to the event identified by its sequence. */
+    addTags: {
+      name: "AddTags",
+      requestType: AddTagsRequest as typeof AddTagsRequest,
+      requestStream: false,
+      responseType: AddTagsResponse as typeof AddTagsResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** Removes tags from the event identified by its sequence. */
+    removeTags: {
+      name: "RemoveTags",
+      requestType: RemoveTagsRequest as typeof RemoveTagsRequest,
+      requestStream: false,
+      responseType: RemoveTagsResponse as typeof RemoveTagsResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** Gets tags for the event identified by its sequence. */
+    getTags: {
+      name: "GetTags",
+      requestType: GetTagsRequest as typeof GetTagsRequest,
+      requestStream: false,
+      responseType: GetTagsResponse as typeof GetTagsResponse,
+      responseStream: false,
+      options: {},
+    },
+  },
+} as const;
+
+export interface DcbEventStoreServiceImplementation<CallContextExt = {}> {
+  /** Appends new events to the store. */
+  append(
+    request: AsyncIterable<AppendEventsRequest>,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<AppendEventsResponse>>;
+  /** Provides a finite stream of events based on the passed SourceEventsRequest. */
+  source(
+    request: SourceEventsRequest,
+    context: CallContext & CallContextExt,
+  ): ServerStreamingMethodResult<DeepPartial<SourceEventsResponse>>;
+  /** Provides an infinite stream of events based on the passed StreamEventsRequest. */
+  stream(
+    request: StreamEventsRequest,
+    context: CallContext & CallContextExt,
+  ): ServerStreamingMethodResult<DeepPartial<StreamEventsResponse>>;
+  /** Gets the current _head_ of the Event Store. The _head_ points to the sequence of the first event to be appended. */
+  getHead(request: GetHeadRequest, context: CallContext & CallContextExt): Promise<DeepPartial<GetHeadResponse>>;
+  /** Gets the current _tail_ of the Event Store. The _tail_ points to the sequence of the first event stored. */
+  getTail(request: GetTailRequest, context: CallContext & CallContextExt): Promise<DeepPartial<GetTailResponse>>;
+  /**
+   * Returns the lowest sequence of an event with a timestamp equal to or higher than the given timestamp. The HEAD is
+   * returned if no events exist with a timestamp equal to or higher than the given timestamp.
+   *
+   * N.B. Axon Server does not assign timestamps to events. The timestamps used for fulfilling this RPC are timestamps
+   * provided by the client. It could happen that there are events after the returned sequence that have an earlier
+   * timestamp. Axon Server does not reject appends if timestamps of events are not monotonically increasing.
+   */
+  getSequenceAt(
+    request: GetSequenceAtRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<GetSequenceAtResponse>>;
+  /** Assigns tags to the event identified by its sequence. */
+  addTags(request: AddTagsRequest, context: CallContext & CallContextExt): Promise<DeepPartial<AddTagsResponse>>;
+  /** Removes tags from the event identified by its sequence. */
+  removeTags(
+    request: RemoveTagsRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<RemoveTagsResponse>>;
+  /** Gets tags for the event identified by its sequence. */
+  getTags(request: GetTagsRequest, context: CallContext & CallContextExt): Promise<DeepPartial<GetTagsResponse>>;
+}
+
+export interface DcbEventStoreClient<CallOptionsExt = {}> {
+  /** Appends new events to the store. */
+  append(
+    request: AsyncIterable<DeepPartial<AppendEventsRequest>>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<AppendEventsResponse>;
+  /** Provides a finite stream of events based on the passed SourceEventsRequest. */
+  source(
+    request: DeepPartial<SourceEventsRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): AsyncIterable<SourceEventsResponse>;
+  /** Provides an infinite stream of events based on the passed StreamEventsRequest. */
+  stream(
+    request: DeepPartial<StreamEventsRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): AsyncIterable<StreamEventsResponse>;
+  /** Gets the current _head_ of the Event Store. The _head_ points to the sequence of the first event to be appended. */
+  getHead(request: DeepPartial<GetHeadRequest>, options?: CallOptions & CallOptionsExt): Promise<GetHeadResponse>;
+  /** Gets the current _tail_ of the Event Store. The _tail_ points to the sequence of the first event stored. */
+  getTail(request: DeepPartial<GetTailRequest>, options?: CallOptions & CallOptionsExt): Promise<GetTailResponse>;
+  /**
+   * Returns the lowest sequence of an event with a timestamp equal to or higher than the given timestamp. The HEAD is
+   * returned if no events exist with a timestamp equal to or higher than the given timestamp.
+   *
+   * N.B. Axon Server does not assign timestamps to events. The timestamps used for fulfilling this RPC are timestamps
+   * provided by the client. It could happen that there are events after the returned sequence that have an earlier
+   * timestamp. Axon Server does not reject appends if timestamps of events are not monotonically increasing.
+   */
+  getSequenceAt(
+    request: DeepPartial<GetSequenceAtRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<GetSequenceAtResponse>;
+  /** Assigns tags to the event identified by its sequence. */
+  addTags(request: DeepPartial<AddTagsRequest>, options?: CallOptions & CallOptionsExt): Promise<AddTagsResponse>;
+  /** Removes tags from the event identified by its sequence. */
+  removeTags(
+    request: DeepPartial<RemoveTagsRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<RemoveTagsResponse>;
+  /** Gets tags for the event identified by its sequence. */
+  getTags(request: DeepPartial<GetTagsRequest>, options?: CallOptions & CallOptionsExt): Promise<GetTagsResponse>;
+}
+
+/** Service providing Snapshot Store RPCs. */
+export type DcbSnapshotStoreDefinition = typeof DcbSnapshotStoreDefinition;
+export const DcbSnapshotStoreDefinition = {
+  name: "DcbSnapshotStore",
+  fullName: "io.axoniq.axonserver.grpc.event.dcb.DcbSnapshotStore",
+  methods: {
+    /** Adds a snapshot to the snapshot store. */
+    add: {
+      name: "Add",
+      requestType: AddSnapshotRequest as typeof AddSnapshotRequest,
+      requestStream: false,
+      responseType: AddSnapshotResponse as typeof AddSnapshotResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** Deletes a snapshot from the snapshot store. */
+    delete: {
+      name: "Delete",
+      requestType: DeleteSnapshotsRequest as typeof DeleteSnapshotsRequest,
+      requestStream: false,
+      responseType: DeleteSnapshotsResponse as typeof DeleteSnapshotsResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** Retrieves snapshots from the snapshot store. */
+    list: {
+      name: "List",
+      requestType: ListSnapshotsRequest as typeof ListSnapshotsRequest,
+      requestStream: false,
+      responseType: ListSnapshotsResponse as typeof ListSnapshotsResponse,
+      responseStream: true,
+      options: {},
+    },
+    /** Gets the latest snapshot based on the request from the snapshot store. */
+    getLast: {
+      name: "GetLast",
+      requestType: GetLastSnapshotRequest as typeof GetLastSnapshotRequest,
+      requestStream: false,
+      responseType: GetLastSnapshotResponse as typeof GetLastSnapshotResponse,
+      responseStream: false,
+      options: {},
+    },
+  },
+} as const;
+
+export interface DcbSnapshotStoreServiceImplementation<CallContextExt = {}> {
+  /** Adds a snapshot to the snapshot store. */
+  add(request: AddSnapshotRequest, context: CallContext & CallContextExt): Promise<DeepPartial<AddSnapshotResponse>>;
+  /** Deletes a snapshot from the snapshot store. */
+  delete(
+    request: DeleteSnapshotsRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<DeleteSnapshotsResponse>>;
+  /** Retrieves snapshots from the snapshot store. */
+  list(
+    request: ListSnapshotsRequest,
+    context: CallContext & CallContextExt,
+  ): ServerStreamingMethodResult<DeepPartial<ListSnapshotsResponse>>;
+  /** Gets the latest snapshot based on the request from the snapshot store. */
+  getLast(
+    request: GetLastSnapshotRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<GetLastSnapshotResponse>>;
+}
+
+export interface DcbSnapshotStoreClient<CallOptionsExt = {}> {
+  /** Adds a snapshot to the snapshot store. */
+  add(request: DeepPartial<AddSnapshotRequest>, options?: CallOptions & CallOptionsExt): Promise<AddSnapshotResponse>;
+  /** Deletes a snapshot from the snapshot store. */
+  delete(
+    request: DeepPartial<DeleteSnapshotsRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<DeleteSnapshotsResponse>;
+  /** Retrieves snapshots from the snapshot store. */
+  list(
+    request: DeepPartial<ListSnapshotsRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): AsyncIterable<ListSnapshotsResponse>;
+  /** Gets the latest snapshot based on the request from the snapshot store. */
+  getLast(
+    request: DeepPartial<GetLastSnapshotRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<GetLastSnapshotResponse>;
+}
+
+/** Service to use AxonServer as a provider of an EventScheduler */
+export type DcbEventSchedulerDefinition = typeof DcbEventSchedulerDefinition;
+export const DcbEventSchedulerDefinition = {
+  name: "DcbEventScheduler",
+  fullName: "io.axoniq.axonserver.grpc.event.dcb.DcbEventScheduler",
+  methods: {
+    /** Schedule the given event for publication at the given time}. The returned ScheduleToken can be used to reschedule or cancel the planned publication. */
+    scheduleEvent: {
+      name: "ScheduleEvent",
+      requestType: ScheduleEventRequest as typeof ScheduleEventRequest,
+      requestStream: false,
+      responseType: ScheduleToken as typeof ScheduleToken,
+      responseStream: false,
+      options: {},
+    },
+    /** Reschedule a scheduled event and optionally replace it by a new event. */
+    rescheduleEvent: {
+      name: "RescheduleEvent",
+      requestType: RescheduleEventRequest as typeof RescheduleEventRequest,
+      requestStream: false,
+      responseType: ScheduleToken as typeof ScheduleToken,
+      responseStream: false,
+      options: {},
+    },
+    /** Cancel the publication of a scheduled event. If the events has already been published, this method does nothing. */
+    cancelScheduledEvent: {
+      name: "CancelScheduledEvent",
+      requestType: CancelScheduledEventRequest as typeof CancelScheduledEventRequest,
+      requestStream: false,
+      responseType: InstructionAck as typeof InstructionAck,
+      responseStream: false,
+      options: {},
+    },
+  },
+} as const;
+
+export interface DcbEventSchedulerServiceImplementation<CallContextExt = {}> {
+  /** Schedule the given event for publication at the given time}. The returned ScheduleToken can be used to reschedule or cancel the planned publication. */
+  scheduleEvent(
+    request: ScheduleEventRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<ScheduleToken>>;
+  /** Reschedule a scheduled event and optionally replace it by a new event. */
+  rescheduleEvent(
+    request: RescheduleEventRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<ScheduleToken>>;
+  /** Cancel the publication of a scheduled event. If the events has already been published, this method does nothing. */
+  cancelScheduledEvent(
+    request: CancelScheduledEventRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<InstructionAck>>;
+}
+
+export interface DcbEventSchedulerClient<CallOptionsExt = {}> {
+  /** Schedule the given event for publication at the given time}. The returned ScheduleToken can be used to reschedule or cancel the planned publication. */
+  scheduleEvent(
+    request: DeepPartial<ScheduleEventRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<ScheduleToken>;
+  /** Reschedule a scheduled event and optionally replace it by a new event. */
+  rescheduleEvent(
+    request: DeepPartial<RescheduleEventRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<ScheduleToken>;
+  /** Cancel the publication of a scheduled event. If the events has already been published, this method does nothing. */
+  cancelScheduledEvent(
+    request: DeepPartial<CancelScheduledEventRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<InstructionAck>;
+}
+
+function bytesFromBase64(b64: string): Uint8Array {
+  if ((globalThis as any).Buffer) {
+    return Uint8Array.from((globalThis as any).Buffer.from(b64, "base64"));
+  } else {
+    const bin = globalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+
+function base64FromBytes(arr: Uint8Array): string {
+  if ((globalThis as any).Buffer) {
+    return (globalThis as any).Buffer.from(arr).toString("base64");
+  } else {
+    const bin: string[] = [];
+    arr.forEach((byte) => {
+      bin.push(globalThis.String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
+  }
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+function isObject(value: any): boolean {
+  return typeof value === "object" && value !== null;
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+export type ServerStreamingMethodResult<Response> = { [Symbol.asyncIterator](): AsyncIterator<Response, void> };
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create(base?: DeepPartial<T>): T;
+  fromPartial(object: DeepPartial<T>): T;
+}