@kronos-ts/axon-server 0.1.0

package/src/generated/event.ts

@@ -0,0 +1,4076 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.6
+//   protoc               v3.19.1
+// source: event.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import type { CallContext, CallOptions } from "nice-grpc-common";
+import { InstructionAck, MetaDataValue, SerializedObject } from "./common.js";
+import { Empty } from "./google/protobuf/empty.js";
+
+export const protobufPackage = "io.axoniq.axonserver.grpc.event";
+
+/** The state of the transformation. */
+export enum TransformationState {
+  /** ACTIVE - The transformation is opened, able to receive request to transform events, or to be applied or cancelled. */
+  ACTIVE = 0,
+  /** CANCELLED - The transformation has been cancelled. This a final state. */
+  CANCELLED = 1,
+  /** APPLYING - The transformation is in progress of applying its actions to the event store. */
+  APPLYING = 2,
+  /** APPLIED - The transformation has been applied to the event store. This a final state. */
+  APPLIED = 3,
+  UNRECOGNIZED = -1,
+}
+
+export function transformationStateFromJSON(object: any): TransformationState {
+  switch (object) {
+    case 0:
+    case "ACTIVE":
+      return TransformationState.ACTIVE;
+    case 1:
+    case "CANCELLED":
+      return TransformationState.CANCELLED;
+    case 2:
+    case "APPLYING":
+      return TransformationState.APPLYING;
+    case 3:
+    case "APPLIED":
+      return TransformationState.APPLIED;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return TransformationState.UNRECOGNIZED;
+  }
+}
+
+export function transformationStateToJSON(object: TransformationState): string {
+  switch (object) {
+    case TransformationState.ACTIVE:
+      return "ACTIVE";
+    case TransformationState.CANCELLED:
+      return "CANCELLED";
+    case TransformationState.APPLYING:
+      return "APPLYING";
+    case TransformationState.APPLIED:
+      return "APPLIED";
+    case TransformationState.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+/** Request to compact event store. */
+export interface CompactionRequest {
+}
+
+/** The transformation data. */
+export interface Transformation {
+  /** The identifier of the transformation. */
+  transformationId:
+    | TransformationId
+    | undefined;
+  /** The state of the transformation */
+  state: TransformationState;
+  /** The sequence of the last transformation action stored. Needed for checking sequential consistency of requests. */
+  sequence: bigint;
+  /** The bounded context in which this transformation is being executed. */
+  context: string;
+  /** The description of the transformation. */
+  description: string;
+  /** The timestamp at which the transformation was applied. Set to -1 if the transformation was not applied. */
+  appliedAt: bigint;
+  /** The username of user who requested the transformation to be applied. Empty if the transformation was not applied. */
+  applyRequester: string;
+  /** The version of the transformation. The sequence */
+  version: number;
+}
+
+/** Request to start a transformation */
+export interface StartTransformationRequest {
+  /** A description of the purpose of this transformation, for reference only */
+  description: string;
+}
+
+/** Request to apply a transformation */
+export interface ApplyTransformationRequest {
+  /** The identification of the transformation */
+  transformationId:
+    | TransformationId
+    | undefined;
+  /** The sequence of the last entry in this transformation */
+  lastSequence: bigint;
+}
+
+/** Message containing one event to transform within a transformation */
+export interface TransformRequest {
+  /** The identification of the transformation */
+  transformationId:
+    | TransformationId
+    | undefined;
+  /** The sequence of the current transformation */
+  sequence: bigint;
+  /** Replaces the content of an event with the new content */
+  replaceEvent?:
+    | TransformedEvent
+    | undefined;
+  /** Deletes the content of an event */
+  deleteEvent?: DeletedEvent | undefined;
+}
+
+/** Replaces the content of an event with the new content */
+export interface TransformedEvent {
+  /** The global index of the event to replace */
+  token: bigint;
+  /** The new content of the event */
+  event: Event | undefined;
+}
+
+/** Deletes the content of an event */
+export interface DeletedEvent {
+  /** The global index of the event to clear */
+  token: bigint;
+}
+
+/** Uniquely identifies a transformation */
+export interface TransformationId {
+  /** The value of the identifier. */
+  id: string;
+}
+
+/** Acknowledgement that event with given token has been transformed successfully */
+export interface TransformRequestAck {
+  /** The sequence of the transformation request */
+  sequence: bigint;
+}
+
+/** 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 {
+  /** optional token of scheduled event to cancel */
+  token: string;
+  /** timestamp when to publish the event */
+  instant: bigint;
+  /** the 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;
+}
+
+/** Request message to receive the first Token (Tail Token) of the Event Stream */
+export interface GetFirstTokenRequest {
+}
+
+/** Request message to receive the last Token (Head Token) of the Event Stream */
+export interface GetLastTokenRequest {
+}
+
+/** Request message to receive the Token that starts streaming events from the given timestamp */
+export interface GetTokenAtRequest {
+  /** Timestamp expressed as milliseconds since epoch */
+  instant: bigint;
+}
+
+/** Message containing the information necessary to track the position of events in the Event Stream */
+export interface TrackingToken {
+  /** The value of the Token */
+  token: bigint;
+}
+
+/** Message wrapping an Event and a Tracking Token */
+export interface EventWithToken {
+  /** The Token representing the position of this Event in the Stream */
+  token: bigint;
+  /** The actual Event Message */
+  event: Event | undefined;
+}
+
+/** Message providing the parameters for executing a Query against AxonServer. */
+export interface QueryEventsRequest {
+  /** The query to execute against the Event Stream */
+  query: string;
+  /** The number of results AxonServer may send before new permits need to be provided */
+  numberOfPermits: bigint;
+  /** Whether to keep the query running against incoming events once the Head of the Stream is reached */
+  liveEvents: boolean;
+  /**
+   * Indicates whether to force querying events from the leader node of an Axon Server. Forcing reads from leader
+   * reduces the staleness of the data read, but also puts extra burden on the leader, reducing overall scalability.
+   * <p>
+   * This property has no effect on connections to AxonServer SE.
+   * </p>
+   */
+  forceReadFromLeader: boolean;
+  /** If true, snapshots will be queried instead of events */
+  querySnapshots: boolean;
+  /** Query from this context, not from the default context of the connection */
+  contextName: string;
+}
+
+/** A message describing a response to a Query request */
+export interface QueryEventsResponse {
+  /** Provided when the response contains the names of the columns the response contains. This message typically arrives first. */
+  columns?:
+    | ColumnsResponse
+    | undefined;
+  /** Provided when the response message contains results of the Query */
+  row?:
+    | RowResponse
+    | undefined;
+  /** Provided when all historic events have been included in the query results */
+  filesCompleted?: Confirmation | undefined;
+}
+
+/** Message containing the names of the columns returned in a Query */
+export interface ColumnsResponse {
+  /** The names of the columns provided in the query */
+  column: string[];
+}
+
+/** Message providing Query Result data */
+export interface RowResponse {
+  /** The values which, when combined, uniquely update this row. Any previously received values with the same identifiers should be replaced with this value */
+  idValues: QueryValue[];
+  /** The sorting values to use when sorting this response compared to the others. */
+  sortValues: QueryValue[];
+  /** The actual data values for each of the columns, as a column name -> value mapping */
+  values: { [key: string]: QueryValue };
+}
+
+export interface RowResponse_ValuesEntry {
+  key: string;
+  value: QueryValue | undefined;
+}
+
+/** Describes the combination of an Aggregate Identifier and first expected Sequence number when opening an Aggregate-specific Event Stream */
+export interface ReadHighestSequenceNrRequest {
+  /** The Identifier of the Aggregate for which to load events */
+  aggregateId: string;
+  /** The Sequence Number of the first event expected */
+  fromSequenceNr: bigint;
+}
+
+/** The highest Sequence Number found for the provided request */
+export interface ReadHighestSequenceNrResponse {
+  /** The sequence number of the latest event */
+  toSequenceNr: bigint;
+}
+
+/** A confirmation to a request from the client */
+export interface Confirmation {
+  /** True when successful, otherwise false */
+  success: boolean;
+}
+
+/**
+ * A confirmation to a request from the client, including an optional consistency marker to track the position of this confirmation in the Event Stream.
+ * The consistency_marker is only set for AppendEvent requests towards a DCB context.
+ */
+export interface ConfirmationWithConsistencyMarker {
+  /** True when successful, otherwise false */
+  success: boolean;
+  /** The consistency marker token */
+  consistencyMarker: ConsistencyMarker | undefined;
+}
+
+/** A marker to track the position of a Confirmation in the Event Stream, used for consistency tracking in DCB contexts */
+export interface ConsistencyMarker {
+  /** The token representing the position of this marker in the Stream */
+  token: bigint;
+}
+
+/** Request describing the desire to read events for a specific Aggregate */
+export interface GetAggregateEventsRequest {
+  /** The identifier of the aggregate to read events for */
+  aggregateId: string;
+  /** The sequence number of the first event to receive */
+  initialSequence: bigint;
+  /** Whether a snapshot may be returned as first element in the stream */
+  allowSnapshots: boolean;
+  /** The maximum sequence number (inclusive) of the events to retrieve, 0 means up to last event */
+  maxSequence: bigint;
+  /** Hint for a minimum token to search events from */
+  minToken: bigint;
+}
+
+/** Request message to retrieve Snapshot Events for a specific Aggregate instance */
+export interface GetAggregateSnapshotsRequest {
+  /** The identifier to fetch the snapshots for */
+  aggregateId: string;
+  /** The minimal sequence number of the snapshots to retrieve */
+  initialSequence: bigint;
+  /** The maximum sequence number of the snapshots to retrieve */
+  maxSequence: bigint;
+  /** The maximum number of results to stream */
+  maxResults: number;
+}
+
+/** Request message to open an Event Stream from the Event Store. */
+export interface GetEventsRequest {
+  /** The token to start streaming from */
+  trackingToken: bigint;
+  /** The number of messages the server may send before it needs to wait for more permits */
+  numberOfPermits: bigint;
+  /** The unique identifier of this client instance. Used for monitoring. */
+  clientId: string;
+  /** The component name of this client instance. Used for monitoring. */
+  componentName: string;
+  /** The name of the processor requesting this stream. Used for monitoring. */
+  processor: string;
+  /**
+   * An enumeration of payload types that need to be blacklisted. The Server will stop sending messages of these
+   * types in order to reduce I/O. Note that the Server may occasionally send a blacklisted message to prevent
+   * time-outs and stale tokens on clients.
+   */
+  blacklist: PayloadDescription[];
+  /**
+   * Indicates whether to force reading events from the leader node of an Axon Server. Forcing reads from leader
+   * reduces the staleness of the data read, but also puts extra burden on the leader, reducing overall scalability.
+   * <p>
+   * This property has no effect on connections to AxonServer SE.
+   * </p>
+   */
+  forceReadFromLeader: boolean;
+}
+
+/** Message containing the information of an Event */
+export interface Event {
+  /** The unique identifier of this event */
+  messageIdentifier: string;
+  /** The identifier of the Aggregate instance that published this event, if any */
+  aggregateIdentifier: string;
+  /** The sequence number of the Event in the Aggregate instance that published it, if any */
+  aggregateSequenceNumber: bigint;
+  /** The Type of the Aggregate instance that published this Event, if any */
+  aggregateType: string;
+  /** The timestamp of the Event */
+  timestamp: bigint;
+  /** The Payload of the Event */
+  payload:
+    | SerializedObject
+    | undefined;
+  /** The Meta Data of the Event */
+  metaData: { [key: string]: MetaDataValue };
+  /** Flag indicating whether the Event is a snapshot Event */
+  snapshot: boolean;
+}
+
+export interface Event_MetaDataEntry {
+  key: string;
+  value: MetaDataValue | undefined;
+}
+
+/** Value used in Query Responses to represent a value in its original type */
+export interface QueryValue {
+  /** The text value */
+  textValue?:
+    | string
+    | undefined;
+  /** The (64 bits) integer value */
+  numberValue?:
+    | bigint
+    | undefined;
+  /** The boolean value */
+  booleanValue?:
+    | boolean
+    | undefined;
+  /** The (64 bits) floating point value */
+  doubleValue?: number | undefined;
+}
+
+/** Description of a Payload Type */
+export interface PayloadDescription {
+  /** The type identifier of the Payload */
+  type: string;
+  /** The revision of the Payload Type */
+  revision: string;
+}
+
+function createBaseCompactionRequest(): CompactionRequest {
+  return {};
+}
+
+export const CompactionRequest: MessageFns<CompactionRequest> = {
+  encode(_: CompactionRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CompactionRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCompactionRequest();
+    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): CompactionRequest {
+    return {};
+  },
+
+  toJSON(_: CompactionRequest): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create(base?: DeepPartial<CompactionRequest>): CompactionRequest {
+    return CompactionRequest.fromPartial(base ?? {});
+  },
+  fromPartial(_: DeepPartial<CompactionRequest>): CompactionRequest {
+    const message = createBaseCompactionRequest();
+    return message;
+  },
+};
+
+function createBaseTransformation(): Transformation {
+  return {
+    transformationId: undefined,
+    state: 0,
+    sequence: 0n,
+    context: "",
+    description: "",
+    appliedAt: 0n,
+    applyRequester: "",
+    version: 0,
+  };
+}
+
+export const Transformation: MessageFns<Transformation> = {
+  encode(message: Transformation, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.transformationId !== undefined) {
+      TransformationId.encode(message.transformationId, writer.uint32(10).fork()).join();
+    }
+    if (message.state !== 0) {
+      writer.uint32(16).int32(message.state);
+    }
+    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(24).int64(message.sequence);
+    }
+    if (message.context !== "") {
+      writer.uint32(34).string(message.context);
+    }
+    if (message.description !== "") {
+      writer.uint32(42).string(message.description);
+    }
+    if (message.appliedAt !== 0n) {
+      if (BigInt.asIntN(64, message.appliedAt) !== message.appliedAt) {
+        throw new globalThis.Error("value provided for field message.appliedAt of type int64 too large");
+      }
+      writer.uint32(48).int64(message.appliedAt);
+    }
+    if (message.applyRequester !== "") {
+      writer.uint32(58).string(message.applyRequester);
+    }
+    if (message.version !== 0) {
+      writer.uint32(64).int32(message.version);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Transformation {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTransformation();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.transformationId = TransformationId.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.state = reader.int32() as any;
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.sequence = reader.int64() as bigint;
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.context = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.description = reader.string();
+          continue;
+        }
+        case 6: {
+          if (tag !== 48) {
+            break;
+          }
+
+          message.appliedAt = reader.int64() as bigint;
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+
+          message.applyRequester = reader.string();
+          continue;
+        }
+        case 8: {
+          if (tag !== 64) {
+            break;
+          }
+
+          message.version = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Transformation {
+    return {
+      transformationId: isSet(object.transformationId) ? TransformationId.fromJSON(object.transformationId) : undefined,
+      state: isSet(object.state) ? transformationStateFromJSON(object.state) : 0,
+      sequence: isSet(object.sequence) ? BigInt(object.sequence) : 0n,
+      context: isSet(object.context) ? globalThis.String(object.context) : "",
+      description: isSet(object.description) ? globalThis.String(object.description) : "",
+      appliedAt: isSet(object.appliedAt)
+        ? BigInt(object.appliedAt)
+        : isSet(object.applied_at)
+        ? BigInt(object.applied_at)
+        : 0n,
+      applyRequester: isSet(object.applyRequester)
+        ? globalThis.String(object.applyRequester)
+        : isSet(object.apply_requester)
+        ? globalThis.String(object.apply_requester)
+        : "",
+      version: isSet(object.version) ? globalThis.Number(object.version) : 0,
+    };
+  },
+
+  toJSON(message: Transformation): unknown {
+    const obj: any = {};
+    if (message.transformationId !== undefined) {
+      obj.transformationId = TransformationId.toJSON(message.transformationId);
+    }
+    if (message.state !== 0) {
+      obj.state = transformationStateToJSON(message.state);
+    }
+    if (message.sequence !== 0n) {
+      obj.sequence = message.sequence.toString();
+    }
+    if (message.context !== "") {
+      obj.context = message.context;
+    }
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    if (message.appliedAt !== 0n) {
+      obj.appliedAt = message.appliedAt.toString();
+    }
+    if (message.applyRequester !== "") {
+      obj.applyRequester = message.applyRequester;
+    }
+    if (message.version !== 0) {
+      obj.version = Math.round(message.version);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<Transformation>): Transformation {
+    return Transformation.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<Transformation>): Transformation {
+    const message = createBaseTransformation();
+    message.transformationId = (object.transformationId !== undefined && object.transformationId !== null)
+      ? TransformationId.fromPartial(object.transformationId)
+      : undefined;
+    message.state = object.state ?? 0;
+    message.sequence = object.sequence ?? 0n;
+    message.context = object.context ?? "";
+    message.description = object.description ?? "";
+    message.appliedAt = object.appliedAt ?? 0n;
+    message.applyRequester = object.applyRequester ?? "";
+    message.version = object.version ?? 0;
+    return message;
+  },
+};
+
+function createBaseStartTransformationRequest(): StartTransformationRequest {
+  return { description: "" };
+}
+
+export const StartTransformationRequest: MessageFns<StartTransformationRequest> = {
+  encode(message: StartTransformationRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.description !== "") {
+      writer.uint32(10).string(message.description);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): StartTransformationRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStartTransformationRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.description = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): StartTransformationRequest {
+    return { description: isSet(object.description) ? globalThis.String(object.description) : "" };
+  },
+
+  toJSON(message: StartTransformationRequest): unknown {
+    const obj: any = {};
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<StartTransformationRequest>): StartTransformationRequest {
+    return StartTransformationRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<StartTransformationRequest>): StartTransformationRequest {
+    const message = createBaseStartTransformationRequest();
+    message.description = object.description ?? "";
+    return message;
+  },
+};
+
+function createBaseApplyTransformationRequest(): ApplyTransformationRequest {
+  return { transformationId: undefined, lastSequence: 0n };
+}
+
+export const ApplyTransformationRequest: MessageFns<ApplyTransformationRequest> = {
+  encode(message: ApplyTransformationRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.transformationId !== undefined) {
+      TransformationId.encode(message.transformationId, writer.uint32(10).fork()).join();
+    }
+    if (message.lastSequence !== 0n) {
+      if (BigInt.asIntN(64, message.lastSequence) !== message.lastSequence) {
+        throw new globalThis.Error("value provided for field message.lastSequence of type int64 too large");
+      }
+      writer.uint32(16).int64(message.lastSequence);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ApplyTransformationRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseApplyTransformationRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.transformationId = TransformationId.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.lastSequence = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ApplyTransformationRequest {
+    return {
+      transformationId: isSet(object.transformationId)
+        ? TransformationId.fromJSON(object.transformationId)
+        : isSet(object.transformation_id)
+        ? TransformationId.fromJSON(object.transformation_id)
+        : undefined,
+      lastSequence: isSet(object.lastSequence)
+        ? BigInt(object.lastSequence)
+        : isSet(object.last_sequence)
+        ? BigInt(object.last_sequence)
+        : 0n,
+    };
+  },
+
+  toJSON(message: ApplyTransformationRequest): unknown {
+    const obj: any = {};
+    if (message.transformationId !== undefined) {
+      obj.transformationId = TransformationId.toJSON(message.transformationId);
+    }
+    if (message.lastSequence !== 0n) {
+      obj.lastSequence = message.lastSequence.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<ApplyTransformationRequest>): ApplyTransformationRequest {
+    return ApplyTransformationRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ApplyTransformationRequest>): ApplyTransformationRequest {
+    const message = createBaseApplyTransformationRequest();
+    message.transformationId = (object.transformationId !== undefined && object.transformationId !== null)
+      ? TransformationId.fromPartial(object.transformationId)
+      : undefined;
+    message.lastSequence = object.lastSequence ?? 0n;
+    return message;
+  },
+};
+
+function createBaseTransformRequest(): TransformRequest {
+  return { transformationId: undefined, sequence: 0n, replaceEvent: undefined, deleteEvent: undefined };
+}
+
+export const TransformRequest: MessageFns<TransformRequest> = {
+  encode(message: TransformRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.transformationId !== undefined) {
+      TransformationId.encode(message.transformationId, writer.uint32(10).fork()).join();
+    }
+    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.replaceEvent !== undefined) {
+      TransformedEvent.encode(message.replaceEvent, writer.uint32(26).fork()).join();
+    }
+    if (message.deleteEvent !== undefined) {
+      DeletedEvent.encode(message.deleteEvent, writer.uint32(34).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TransformRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTransformRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.transformationId = TransformationId.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.sequence = reader.int64() as bigint;
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.replaceEvent = TransformedEvent.decode(reader, reader.uint32());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.deleteEvent = DeletedEvent.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TransformRequest {
+    return {
+      transformationId: isSet(object.transformationId)
+        ? TransformationId.fromJSON(object.transformationId)
+        : isSet(object.transformation_id)
+        ? TransformationId.fromJSON(object.transformation_id)
+        : undefined,
+      sequence: isSet(object.sequence) ? BigInt(object.sequence) : 0n,
+      replaceEvent: isSet(object.replaceEvent)
+        ? TransformedEvent.fromJSON(object.replaceEvent)
+        : isSet(object.replace_event)
+        ? TransformedEvent.fromJSON(object.replace_event)
+        : undefined,
+      deleteEvent: isSet(object.deleteEvent)
+        ? DeletedEvent.fromJSON(object.deleteEvent)
+        : isSet(object.delete_event)
+        ? DeletedEvent.fromJSON(object.delete_event)
+        : undefined,
+    };
+  },
+
+  toJSON(message: TransformRequest): unknown {
+    const obj: any = {};
+    if (message.transformationId !== undefined) {
+      obj.transformationId = TransformationId.toJSON(message.transformationId);
+    }
+    if (message.sequence !== 0n) {
+      obj.sequence = message.sequence.toString();
+    }
+    if (message.replaceEvent !== undefined) {
+      obj.replaceEvent = TransformedEvent.toJSON(message.replaceEvent);
+    }
+    if (message.deleteEvent !== undefined) {
+      obj.deleteEvent = DeletedEvent.toJSON(message.deleteEvent);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<TransformRequest>): TransformRequest {
+    return TransformRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<TransformRequest>): TransformRequest {
+    const message = createBaseTransformRequest();
+    message.transformationId = (object.transformationId !== undefined && object.transformationId !== null)
+      ? TransformationId.fromPartial(object.transformationId)
+      : undefined;
+    message.sequence = object.sequence ?? 0n;
+    message.replaceEvent = (object.replaceEvent !== undefined && object.replaceEvent !== null)
+      ? TransformedEvent.fromPartial(object.replaceEvent)
+      : undefined;
+    message.deleteEvent = (object.deleteEvent !== undefined && object.deleteEvent !== null)
+      ? DeletedEvent.fromPartial(object.deleteEvent)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseTransformedEvent(): TransformedEvent {
+  return { token: 0n, event: undefined };
+}
+
+export const TransformedEvent: MessageFns<TransformedEvent> = {
+  encode(message: TransformedEvent, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.token !== 0n) {
+      if (BigInt.asIntN(64, message.token) !== message.token) {
+        throw new globalThis.Error("value provided for field message.token of type int64 too large");
+      }
+      writer.uint32(8).int64(message.token);
+    }
+    if (message.event !== undefined) {
+      Event.encode(message.event, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TransformedEvent {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTransformedEvent();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.token = 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): TransformedEvent {
+    return {
+      token: isSet(object.token) ? BigInt(object.token) : 0n,
+      event: isSet(object.event) ? Event.fromJSON(object.event) : undefined,
+    };
+  },
+
+  toJSON(message: TransformedEvent): unknown {
+    const obj: any = {};
+    if (message.token !== 0n) {
+      obj.token = message.token.toString();
+    }
+    if (message.event !== undefined) {
+      obj.event = Event.toJSON(message.event);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<TransformedEvent>): TransformedEvent {
+    return TransformedEvent.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<TransformedEvent>): TransformedEvent {
+    const message = createBaseTransformedEvent();
+    message.token = object.token ?? 0n;
+    message.event = (object.event !== undefined && object.event !== null) ? Event.fromPartial(object.event) : undefined;
+    return message;
+  },
+};
+
+function createBaseDeletedEvent(): DeletedEvent {
+  return { token: 0n };
+}
+
+export const DeletedEvent: MessageFns<DeletedEvent> = {
+  encode(message: DeletedEvent, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.token !== 0n) {
+      if (BigInt.asIntN(64, message.token) !== message.token) {
+        throw new globalThis.Error("value provided for field message.token of type int64 too large");
+      }
+      writer.uint32(8).int64(message.token);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): DeletedEvent {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDeletedEvent();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.token = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DeletedEvent {
+    return { token: isSet(object.token) ? BigInt(object.token) : 0n };
+  },
+
+  toJSON(message: DeletedEvent): unknown {
+    const obj: any = {};
+    if (message.token !== 0n) {
+      obj.token = message.token.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<DeletedEvent>): DeletedEvent {
+    return DeletedEvent.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<DeletedEvent>): DeletedEvent {
+    const message = createBaseDeletedEvent();
+    message.token = object.token ?? 0n;
+    return message;
+  },
+};
+
+function createBaseTransformationId(): TransformationId {
+  return { id: "" };
+}
+
+export const TransformationId: MessageFns<TransformationId> = {
+  encode(message: TransformationId, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TransformationId {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTransformationId();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.id = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TransformationId {
+    return { id: isSet(object.id) ? globalThis.String(object.id) : "" };
+  },
+
+  toJSON(message: TransformationId): unknown {
+    const obj: any = {};
+    if (message.id !== "") {
+      obj.id = message.id;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<TransformationId>): TransformationId {
+    return TransformationId.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<TransformationId>): TransformationId {
+    const message = createBaseTransformationId();
+    message.id = object.id ?? "";
+    return message;
+  },
+};
+
+function createBaseTransformRequestAck(): TransformRequestAck {
+  return { sequence: 0n };
+}
+
+export const TransformRequestAck: MessageFns<TransformRequestAck> = {
+  encode(message: TransformRequestAck, 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): TransformRequestAck {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTransformRequestAck();
+    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): TransformRequestAck {
+    return { sequence: isSet(object.sequence) ? BigInt(object.sequence) : 0n };
+  },
+
+  toJSON(message: TransformRequestAck): unknown {
+    const obj: any = {};
+    if (message.sequence !== 0n) {
+      obj.sequence = message.sequence.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<TransformRequestAck>): TransformRequestAck {
+    return TransformRequestAck.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<TransformRequestAck>): TransformRequestAck {
+    const message = createBaseTransformRequestAck();
+    message.sequence = object.sequence ?? 0n;
+    return message;
+  },
+};
+
+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 createBaseGetFirstTokenRequest(): GetFirstTokenRequest {
+  return {};
+}
+
+export const GetFirstTokenRequest: MessageFns<GetFirstTokenRequest> = {
+  encode(_: GetFirstTokenRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetFirstTokenRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetFirstTokenRequest();
+    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): GetFirstTokenRequest {
+    return {};
+  },
+
+  toJSON(_: GetFirstTokenRequest): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetFirstTokenRequest>): GetFirstTokenRequest {
+    return GetFirstTokenRequest.fromPartial(base ?? {});
+  },
+  fromPartial(_: DeepPartial<GetFirstTokenRequest>): GetFirstTokenRequest {
+    const message = createBaseGetFirstTokenRequest();
+    return message;
+  },
+};
+
+function createBaseGetLastTokenRequest(): GetLastTokenRequest {
+  return {};
+}
+
+export const GetLastTokenRequest: MessageFns<GetLastTokenRequest> = {
+  encode(_: GetLastTokenRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetLastTokenRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetLastTokenRequest();
+    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): GetLastTokenRequest {
+    return {};
+  },
+
+  toJSON(_: GetLastTokenRequest): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetLastTokenRequest>): GetLastTokenRequest {
+    return GetLastTokenRequest.fromPartial(base ?? {});
+  },
+  fromPartial(_: DeepPartial<GetLastTokenRequest>): GetLastTokenRequest {
+    const message = createBaseGetLastTokenRequest();
+    return message;
+  },
+};
+
+function createBaseGetTokenAtRequest(): GetTokenAtRequest {
+  return { instant: 0n };
+}
+
+export const GetTokenAtRequest: MessageFns<GetTokenAtRequest> = {
+  encode(message: GetTokenAtRequest, 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);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetTokenAtRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetTokenAtRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.instant = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetTokenAtRequest {
+    return { instant: isSet(object.instant) ? BigInt(object.instant) : 0n };
+  },
+
+  toJSON(message: GetTokenAtRequest): unknown {
+    const obj: any = {};
+    if (message.instant !== 0n) {
+      obj.instant = message.instant.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetTokenAtRequest>): GetTokenAtRequest {
+    return GetTokenAtRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetTokenAtRequest>): GetTokenAtRequest {
+    const message = createBaseGetTokenAtRequest();
+    message.instant = object.instant ?? 0n;
+    return message;
+  },
+};
+
+function createBaseTrackingToken(): TrackingToken {
+  return { token: 0n };
+}
+
+export const TrackingToken: MessageFns<TrackingToken> = {
+  encode(message: TrackingToken, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.token !== 0n) {
+      if (BigInt.asIntN(64, message.token) !== message.token) {
+        throw new globalThis.Error("value provided for field message.token of type int64 too large");
+      }
+      writer.uint32(8).int64(message.token);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TrackingToken {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTrackingToken();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.token = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TrackingToken {
+    return { token: isSet(object.token) ? BigInt(object.token) : 0n };
+  },
+
+  toJSON(message: TrackingToken): unknown {
+    const obj: any = {};
+    if (message.token !== 0n) {
+      obj.token = message.token.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<TrackingToken>): TrackingToken {
+    return TrackingToken.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<TrackingToken>): TrackingToken {
+    const message = createBaseTrackingToken();
+    message.token = object.token ?? 0n;
+    return message;
+  },
+};
+
+function createBaseEventWithToken(): EventWithToken {
+  return { token: 0n, event: undefined };
+}
+
+export const EventWithToken: MessageFns<EventWithToken> = {
+  encode(message: EventWithToken, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.token !== 0n) {
+      if (BigInt.asIntN(64, message.token) !== message.token) {
+        throw new globalThis.Error("value provided for field message.token of type int64 too large");
+      }
+      writer.uint32(8).int64(message.token);
+    }
+    if (message.event !== undefined) {
+      Event.encode(message.event, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): EventWithToken {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEventWithToken();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.token = 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): EventWithToken {
+    return {
+      token: isSet(object.token) ? BigInt(object.token) : 0n,
+      event: isSet(object.event) ? Event.fromJSON(object.event) : undefined,
+    };
+  },
+
+  toJSON(message: EventWithToken): unknown {
+    const obj: any = {};
+    if (message.token !== 0n) {
+      obj.token = message.token.toString();
+    }
+    if (message.event !== undefined) {
+      obj.event = Event.toJSON(message.event);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<EventWithToken>): EventWithToken {
+    return EventWithToken.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<EventWithToken>): EventWithToken {
+    const message = createBaseEventWithToken();
+    message.token = object.token ?? 0n;
+    message.event = (object.event !== undefined && object.event !== null) ? Event.fromPartial(object.event) : undefined;
+    return message;
+  },
+};
+
+function createBaseQueryEventsRequest(): QueryEventsRequest {
+  return {
+    query: "",
+    numberOfPermits: 0n,
+    liveEvents: false,
+    forceReadFromLeader: false,
+    querySnapshots: false,
+    contextName: "",
+  };
+}
+
+export const QueryEventsRequest: MessageFns<QueryEventsRequest> = {
+  encode(message: QueryEventsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.query !== "") {
+      writer.uint32(10).string(message.query);
+    }
+    if (message.numberOfPermits !== 0n) {
+      if (BigInt.asIntN(64, message.numberOfPermits) !== message.numberOfPermits) {
+        throw new globalThis.Error("value provided for field message.numberOfPermits of type int64 too large");
+      }
+      writer.uint32(16).int64(message.numberOfPermits);
+    }
+    if (message.liveEvents !== false) {
+      writer.uint32(24).bool(message.liveEvents);
+    }
+    if (message.forceReadFromLeader !== false) {
+      writer.uint32(32).bool(message.forceReadFromLeader);
+    }
+    if (message.querySnapshots !== false) {
+      writer.uint32(40).bool(message.querySnapshots);
+    }
+    if (message.contextName !== "") {
+      writer.uint32(50).string(message.contextName);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryEventsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryEventsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.query = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.numberOfPermits = reader.int64() as bigint;
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.liveEvents = reader.bool();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+
+          message.forceReadFromLeader = reader.bool();
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+
+          message.querySnapshots = reader.bool();
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+
+          message.contextName = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): QueryEventsRequest {
+    return {
+      query: isSet(object.query) ? globalThis.String(object.query) : "",
+      numberOfPermits: isSet(object.numberOfPermits)
+        ? BigInt(object.numberOfPermits)
+        : isSet(object.number_of_permits)
+        ? BigInt(object.number_of_permits)
+        : 0n,
+      liveEvents: isSet(object.liveEvents)
+        ? globalThis.Boolean(object.liveEvents)
+        : isSet(object.live_events)
+        ? globalThis.Boolean(object.live_events)
+        : false,
+      forceReadFromLeader: isSet(object.forceReadFromLeader)
+        ? globalThis.Boolean(object.forceReadFromLeader)
+        : isSet(object.force_read_from_leader)
+        ? globalThis.Boolean(object.force_read_from_leader)
+        : false,
+      querySnapshots: isSet(object.querySnapshots)
+        ? globalThis.Boolean(object.querySnapshots)
+        : isSet(object.query_snapshots)
+        ? globalThis.Boolean(object.query_snapshots)
+        : false,
+      contextName: isSet(object.contextName)
+        ? globalThis.String(object.contextName)
+        : isSet(object.context_name)
+        ? globalThis.String(object.context_name)
+        : "",
+    };
+  },
+
+  toJSON(message: QueryEventsRequest): unknown {
+    const obj: any = {};
+    if (message.query !== "") {
+      obj.query = message.query;
+    }
+    if (message.numberOfPermits !== 0n) {
+      obj.numberOfPermits = message.numberOfPermits.toString();
+    }
+    if (message.liveEvents !== false) {
+      obj.liveEvents = message.liveEvents;
+    }
+    if (message.forceReadFromLeader !== false) {
+      obj.forceReadFromLeader = message.forceReadFromLeader;
+    }
+    if (message.querySnapshots !== false) {
+      obj.querySnapshots = message.querySnapshots;
+    }
+    if (message.contextName !== "") {
+      obj.contextName = message.contextName;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<QueryEventsRequest>): QueryEventsRequest {
+    return QueryEventsRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<QueryEventsRequest>): QueryEventsRequest {
+    const message = createBaseQueryEventsRequest();
+    message.query = object.query ?? "";
+    message.numberOfPermits = object.numberOfPermits ?? 0n;
+    message.liveEvents = object.liveEvents ?? false;
+    message.forceReadFromLeader = object.forceReadFromLeader ?? false;
+    message.querySnapshots = object.querySnapshots ?? false;
+    message.contextName = object.contextName ?? "";
+    return message;
+  },
+};
+
+function createBaseQueryEventsResponse(): QueryEventsResponse {
+  return { columns: undefined, row: undefined, filesCompleted: undefined };
+}
+
+export const QueryEventsResponse: MessageFns<QueryEventsResponse> = {
+  encode(message: QueryEventsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.columns !== undefined) {
+      ColumnsResponse.encode(message.columns, writer.uint32(10).fork()).join();
+    }
+    if (message.row !== undefined) {
+      RowResponse.encode(message.row, writer.uint32(18).fork()).join();
+    }
+    if (message.filesCompleted !== undefined) {
+      Confirmation.encode(message.filesCompleted, writer.uint32(26).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryEventsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryEventsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.columns = ColumnsResponse.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.row = RowResponse.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.filesCompleted = Confirmation.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): QueryEventsResponse {
+    return {
+      columns: isSet(object.columns) ? ColumnsResponse.fromJSON(object.columns) : undefined,
+      row: isSet(object.row) ? RowResponse.fromJSON(object.row) : undefined,
+      filesCompleted: isSet(object.filesCompleted)
+        ? Confirmation.fromJSON(object.filesCompleted)
+        : isSet(object.files_completed)
+        ? Confirmation.fromJSON(object.files_completed)
+        : undefined,
+    };
+  },
+
+  toJSON(message: QueryEventsResponse): unknown {
+    const obj: any = {};
+    if (message.columns !== undefined) {
+      obj.columns = ColumnsResponse.toJSON(message.columns);
+    }
+    if (message.row !== undefined) {
+      obj.row = RowResponse.toJSON(message.row);
+    }
+    if (message.filesCompleted !== undefined) {
+      obj.filesCompleted = Confirmation.toJSON(message.filesCompleted);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<QueryEventsResponse>): QueryEventsResponse {
+    return QueryEventsResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<QueryEventsResponse>): QueryEventsResponse {
+    const message = createBaseQueryEventsResponse();
+    message.columns = (object.columns !== undefined && object.columns !== null)
+      ? ColumnsResponse.fromPartial(object.columns)
+      : undefined;
+    message.row = (object.row !== undefined && object.row !== null) ? RowResponse.fromPartial(object.row) : undefined;
+    message.filesCompleted = (object.filesCompleted !== undefined && object.filesCompleted !== null)
+      ? Confirmation.fromPartial(object.filesCompleted)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseColumnsResponse(): ColumnsResponse {
+  return { column: [] };
+}
+
+export const ColumnsResponse: MessageFns<ColumnsResponse> = {
+  encode(message: ColumnsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.column) {
+      writer.uint32(10).string(v!);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ColumnsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseColumnsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.column.push(reader.string());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ColumnsResponse {
+    return {
+      column: globalThis.Array.isArray(object?.column) ? object.column.map((e: any) => globalThis.String(e)) : [],
+    };
+  },
+
+  toJSON(message: ColumnsResponse): unknown {
+    const obj: any = {};
+    if (message.column?.length) {
+      obj.column = message.column;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<ColumnsResponse>): ColumnsResponse {
+    return ColumnsResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ColumnsResponse>): ColumnsResponse {
+    const message = createBaseColumnsResponse();
+    message.column = object.column?.map((e) => e) || [];
+    return message;
+  },
+};
+
+function createBaseRowResponse(): RowResponse {
+  return { idValues: [], sortValues: [], values: {} };
+}
+
+export const RowResponse: MessageFns<RowResponse> = {
+  encode(message: RowResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.idValues) {
+      QueryValue.encode(v!, writer.uint32(10).fork()).join();
+    }
+    for (const v of message.sortValues) {
+      QueryValue.encode(v!, writer.uint32(18).fork()).join();
+    }
+    globalThis.Object.entries(message.values).forEach(([key, value]: [string, QueryValue]) => {
+      RowResponse_ValuesEntry.encode({ key: key as any, value }, writer.uint32(26).fork()).join();
+    });
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): RowResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRowResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.idValues.push(QueryValue.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.sortValues.push(QueryValue.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          const entry3 = RowResponse_ValuesEntry.decode(reader, reader.uint32());
+          if (entry3.value !== undefined) {
+            message.values[entry3.key] = entry3.value;
+          }
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RowResponse {
+    return {
+      idValues: globalThis.Array.isArray(object?.idValues)
+        ? object.idValues.map((e: any) => QueryValue.fromJSON(e))
+        : globalThis.Array.isArray(object?.id_values)
+        ? object.id_values.map((e: any) => QueryValue.fromJSON(e))
+        : [],
+      sortValues: globalThis.Array.isArray(object?.sortValues)
+        ? object.sortValues.map((e: any) => QueryValue.fromJSON(e))
+        : globalThis.Array.isArray(object?.sort_values)
+        ? object.sort_values.map((e: any) => QueryValue.fromJSON(e))
+        : [],
+      values: isObject(object.values)
+        ? (globalThis.Object.entries(object.values) as [string, any][]).reduce(
+          (acc: { [key: string]: QueryValue }, [key, value]: [string, any]) => {
+            acc[key] = QueryValue.fromJSON(value);
+            return acc;
+          },
+          {},
+        )
+        : {},
+    };
+  },
+
+  toJSON(message: RowResponse): unknown {
+    const obj: any = {};
+    if (message.idValues?.length) {
+      obj.idValues = message.idValues.map((e) => QueryValue.toJSON(e));
+    }
+    if (message.sortValues?.length) {
+      obj.sortValues = message.sortValues.map((e) => QueryValue.toJSON(e));
+    }
+    if (message.values) {
+      const entries = globalThis.Object.entries(message.values) as [string, QueryValue][];
+      if (entries.length > 0) {
+        obj.values = {};
+        entries.forEach(([k, v]) => {
+          obj.values[k] = QueryValue.toJSON(v);
+        });
+      }
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<RowResponse>): RowResponse {
+    return RowResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<RowResponse>): RowResponse {
+    const message = createBaseRowResponse();
+    message.idValues = object.idValues?.map((e) => QueryValue.fromPartial(e)) || [];
+    message.sortValues = object.sortValues?.map((e) => QueryValue.fromPartial(e)) || [];
+    message.values = (globalThis.Object.entries(object.values ?? {}) as [string, QueryValue][]).reduce(
+      (acc: { [key: string]: QueryValue }, [key, value]: [string, QueryValue]) => {
+        if (value !== undefined) {
+          acc[key] = QueryValue.fromPartial(value);
+        }
+        return acc;
+      },
+      {},
+    );
+    return message;
+  },
+};
+
+function createBaseRowResponse_ValuesEntry(): RowResponse_ValuesEntry {
+  return { key: "", value: undefined };
+}
+
+export const RowResponse_ValuesEntry: MessageFns<RowResponse_ValuesEntry> = {
+  encode(message: RowResponse_ValuesEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== undefined) {
+      QueryValue.encode(message.value, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): RowResponse_ValuesEntry {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRowResponse_ValuesEntry();
+    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 = QueryValue.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RowResponse_ValuesEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? QueryValue.fromJSON(object.value) : undefined,
+    };
+  },
+
+  toJSON(message: RowResponse_ValuesEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== undefined) {
+      obj.value = QueryValue.toJSON(message.value);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<RowResponse_ValuesEntry>): RowResponse_ValuesEntry {
+    return RowResponse_ValuesEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<RowResponse_ValuesEntry>): RowResponse_ValuesEntry {
+    const message = createBaseRowResponse_ValuesEntry();
+    message.key = object.key ?? "";
+    message.value = (object.value !== undefined && object.value !== null)
+      ? QueryValue.fromPartial(object.value)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseReadHighestSequenceNrRequest(): ReadHighestSequenceNrRequest {
+  return { aggregateId: "", fromSequenceNr: 0n };
+}
+
+export const ReadHighestSequenceNrRequest: MessageFns<ReadHighestSequenceNrRequest> = {
+  encode(message: ReadHighestSequenceNrRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.aggregateId !== "") {
+      writer.uint32(10).string(message.aggregateId);
+    }
+    if (message.fromSequenceNr !== 0n) {
+      if (BigInt.asIntN(64, message.fromSequenceNr) !== message.fromSequenceNr) {
+        throw new globalThis.Error("value provided for field message.fromSequenceNr of type int64 too large");
+      }
+      writer.uint32(24).int64(message.fromSequenceNr);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ReadHighestSequenceNrRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseReadHighestSequenceNrRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.aggregateId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.fromSequenceNr = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ReadHighestSequenceNrRequest {
+    return {
+      aggregateId: isSet(object.aggregateId)
+        ? globalThis.String(object.aggregateId)
+        : isSet(object.aggregate_id)
+        ? globalThis.String(object.aggregate_id)
+        : "",
+      fromSequenceNr: isSet(object.fromSequenceNr)
+        ? BigInt(object.fromSequenceNr)
+        : isSet(object.from_sequence_nr)
+        ? BigInt(object.from_sequence_nr)
+        : 0n,
+    };
+  },
+
+  toJSON(message: ReadHighestSequenceNrRequest): unknown {
+    const obj: any = {};
+    if (message.aggregateId !== "") {
+      obj.aggregateId = message.aggregateId;
+    }
+    if (message.fromSequenceNr !== 0n) {
+      obj.fromSequenceNr = message.fromSequenceNr.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<ReadHighestSequenceNrRequest>): ReadHighestSequenceNrRequest {
+    return ReadHighestSequenceNrRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ReadHighestSequenceNrRequest>): ReadHighestSequenceNrRequest {
+    const message = createBaseReadHighestSequenceNrRequest();
+    message.aggregateId = object.aggregateId ?? "";
+    message.fromSequenceNr = object.fromSequenceNr ?? 0n;
+    return message;
+  },
+};
+
+function createBaseReadHighestSequenceNrResponse(): ReadHighestSequenceNrResponse {
+  return { toSequenceNr: 0n };
+}
+
+export const ReadHighestSequenceNrResponse: MessageFns<ReadHighestSequenceNrResponse> = {
+  encode(message: ReadHighestSequenceNrResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.toSequenceNr !== 0n) {
+      if (BigInt.asIntN(64, message.toSequenceNr) !== message.toSequenceNr) {
+        throw new globalThis.Error("value provided for field message.toSequenceNr of type int64 too large");
+      }
+      writer.uint32(8).int64(message.toSequenceNr);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ReadHighestSequenceNrResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseReadHighestSequenceNrResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.toSequenceNr = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ReadHighestSequenceNrResponse {
+    return {
+      toSequenceNr: isSet(object.toSequenceNr)
+        ? BigInt(object.toSequenceNr)
+        : isSet(object.to_sequence_nr)
+        ? BigInt(object.to_sequence_nr)
+        : 0n,
+    };
+  },
+
+  toJSON(message: ReadHighestSequenceNrResponse): unknown {
+    const obj: any = {};
+    if (message.toSequenceNr !== 0n) {
+      obj.toSequenceNr = message.toSequenceNr.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<ReadHighestSequenceNrResponse>): ReadHighestSequenceNrResponse {
+    return ReadHighestSequenceNrResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ReadHighestSequenceNrResponse>): ReadHighestSequenceNrResponse {
+    const message = createBaseReadHighestSequenceNrResponse();
+    message.toSequenceNr = object.toSequenceNr ?? 0n;
+    return message;
+  },
+};
+
+function createBaseConfirmation(): Confirmation {
+  return { success: false };
+}
+
+export const Confirmation: MessageFns<Confirmation> = {
+  encode(message: Confirmation, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.success !== false) {
+      writer.uint32(8).bool(message.success);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Confirmation {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseConfirmation();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.success = reader.bool();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Confirmation {
+    return { success: isSet(object.success) ? globalThis.Boolean(object.success) : false };
+  },
+
+  toJSON(message: Confirmation): unknown {
+    const obj: any = {};
+    if (message.success !== false) {
+      obj.success = message.success;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<Confirmation>): Confirmation {
+    return Confirmation.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<Confirmation>): Confirmation {
+    const message = createBaseConfirmation();
+    message.success = object.success ?? false;
+    return message;
+  },
+};
+
+function createBaseConfirmationWithConsistencyMarker(): ConfirmationWithConsistencyMarker {
+  return { success: false, consistencyMarker: undefined };
+}
+
+export const ConfirmationWithConsistencyMarker: MessageFns<ConfirmationWithConsistencyMarker> = {
+  encode(message: ConfirmationWithConsistencyMarker, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.success !== false) {
+      writer.uint32(8).bool(message.success);
+    }
+    if (message.consistencyMarker !== undefined) {
+      ConsistencyMarker.encode(message.consistencyMarker, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ConfirmationWithConsistencyMarker {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseConfirmationWithConsistencyMarker();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.success = reader.bool();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.consistencyMarker = ConsistencyMarker.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ConfirmationWithConsistencyMarker {
+    return {
+      success: isSet(object.success) ? globalThis.Boolean(object.success) : false,
+      consistencyMarker: isSet(object.consistencyMarker)
+        ? ConsistencyMarker.fromJSON(object.consistencyMarker)
+        : isSet(object.consistency_marker)
+        ? ConsistencyMarker.fromJSON(object.consistency_marker)
+        : undefined,
+    };
+  },
+
+  toJSON(message: ConfirmationWithConsistencyMarker): unknown {
+    const obj: any = {};
+    if (message.success !== false) {
+      obj.success = message.success;
+    }
+    if (message.consistencyMarker !== undefined) {
+      obj.consistencyMarker = ConsistencyMarker.toJSON(message.consistencyMarker);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<ConfirmationWithConsistencyMarker>): ConfirmationWithConsistencyMarker {
+    return ConfirmationWithConsistencyMarker.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ConfirmationWithConsistencyMarker>): ConfirmationWithConsistencyMarker {
+    const message = createBaseConfirmationWithConsistencyMarker();
+    message.success = object.success ?? false;
+    message.consistencyMarker = (object.consistencyMarker !== undefined && object.consistencyMarker !== null)
+      ? ConsistencyMarker.fromPartial(object.consistencyMarker)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseConsistencyMarker(): ConsistencyMarker {
+  return { token: 0n };
+}
+
+export const ConsistencyMarker: MessageFns<ConsistencyMarker> = {
+  encode(message: ConsistencyMarker, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.token !== 0n) {
+      if (BigInt.asIntN(64, message.token) !== message.token) {
+        throw new globalThis.Error("value provided for field message.token of type int64 too large");
+      }
+      writer.uint32(8).int64(message.token);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ConsistencyMarker {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseConsistencyMarker();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.token = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ConsistencyMarker {
+    return { token: isSet(object.token) ? BigInt(object.token) : 0n };
+  },
+
+  toJSON(message: ConsistencyMarker): unknown {
+    const obj: any = {};
+    if (message.token !== 0n) {
+      obj.token = message.token.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<ConsistencyMarker>): ConsistencyMarker {
+    return ConsistencyMarker.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ConsistencyMarker>): ConsistencyMarker {
+    const message = createBaseConsistencyMarker();
+    message.token = object.token ?? 0n;
+    return message;
+  },
+};
+
+function createBaseGetAggregateEventsRequest(): GetAggregateEventsRequest {
+  return { aggregateId: "", initialSequence: 0n, allowSnapshots: false, maxSequence: 0n, minToken: 0n };
+}
+
+export const GetAggregateEventsRequest: MessageFns<GetAggregateEventsRequest> = {
+  encode(message: GetAggregateEventsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.aggregateId !== "") {
+      writer.uint32(10).string(message.aggregateId);
+    }
+    if (message.initialSequence !== 0n) {
+      if (BigInt.asIntN(64, message.initialSequence) !== message.initialSequence) {
+        throw new globalThis.Error("value provided for field message.initialSequence of type int64 too large");
+      }
+      writer.uint32(16).int64(message.initialSequence);
+    }
+    if (message.allowSnapshots !== false) {
+      writer.uint32(24).bool(message.allowSnapshots);
+    }
+    if (message.maxSequence !== 0n) {
+      if (BigInt.asIntN(64, message.maxSequence) !== message.maxSequence) {
+        throw new globalThis.Error("value provided for field message.maxSequence of type int64 too large");
+      }
+      writer.uint32(32).int64(message.maxSequence);
+    }
+    if (message.minToken !== 0n) {
+      if (BigInt.asIntN(64, message.minToken) !== message.minToken) {
+        throw new globalThis.Error("value provided for field message.minToken of type int64 too large");
+      }
+      writer.uint32(40).int64(message.minToken);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetAggregateEventsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetAggregateEventsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.aggregateId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.initialSequence = reader.int64() as bigint;
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.allowSnapshots = reader.bool();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+
+          message.maxSequence = reader.int64() as bigint;
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+
+          message.minToken = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetAggregateEventsRequest {
+    return {
+      aggregateId: isSet(object.aggregateId)
+        ? globalThis.String(object.aggregateId)
+        : isSet(object.aggregate_id)
+        ? globalThis.String(object.aggregate_id)
+        : "",
+      initialSequence: isSet(object.initialSequence)
+        ? BigInt(object.initialSequence)
+        : isSet(object.initial_sequence)
+        ? BigInt(object.initial_sequence)
+        : 0n,
+      allowSnapshots: isSet(object.allowSnapshots)
+        ? globalThis.Boolean(object.allowSnapshots)
+        : isSet(object.allow_snapshots)
+        ? globalThis.Boolean(object.allow_snapshots)
+        : false,
+      maxSequence: isSet(object.maxSequence)
+        ? BigInt(object.maxSequence)
+        : isSet(object.max_sequence)
+        ? BigInt(object.max_sequence)
+        : 0n,
+      minToken: isSet(object.minToken)
+        ? BigInt(object.minToken)
+        : isSet(object.min_token)
+        ? BigInt(object.min_token)
+        : 0n,
+    };
+  },
+
+  toJSON(message: GetAggregateEventsRequest): unknown {
+    const obj: any = {};
+    if (message.aggregateId !== "") {
+      obj.aggregateId = message.aggregateId;
+    }
+    if (message.initialSequence !== 0n) {
+      obj.initialSequence = message.initialSequence.toString();
+    }
+    if (message.allowSnapshots !== false) {
+      obj.allowSnapshots = message.allowSnapshots;
+    }
+    if (message.maxSequence !== 0n) {
+      obj.maxSequence = message.maxSequence.toString();
+    }
+    if (message.minToken !== 0n) {
+      obj.minToken = message.minToken.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetAggregateEventsRequest>): GetAggregateEventsRequest {
+    return GetAggregateEventsRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetAggregateEventsRequest>): GetAggregateEventsRequest {
+    const message = createBaseGetAggregateEventsRequest();
+    message.aggregateId = object.aggregateId ?? "";
+    message.initialSequence = object.initialSequence ?? 0n;
+    message.allowSnapshots = object.allowSnapshots ?? false;
+    message.maxSequence = object.maxSequence ?? 0n;
+    message.minToken = object.minToken ?? 0n;
+    return message;
+  },
+};
+
+function createBaseGetAggregateSnapshotsRequest(): GetAggregateSnapshotsRequest {
+  return { aggregateId: "", initialSequence: 0n, maxSequence: 0n, maxResults: 0 };
+}
+
+export const GetAggregateSnapshotsRequest: MessageFns<GetAggregateSnapshotsRequest> = {
+  encode(message: GetAggregateSnapshotsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.aggregateId !== "") {
+      writer.uint32(10).string(message.aggregateId);
+    }
+    if (message.initialSequence !== 0n) {
+      if (BigInt.asIntN(64, message.initialSequence) !== message.initialSequence) {
+        throw new globalThis.Error("value provided for field message.initialSequence of type int64 too large");
+      }
+      writer.uint32(16).int64(message.initialSequence);
+    }
+    if (message.maxSequence !== 0n) {
+      if (BigInt.asIntN(64, message.maxSequence) !== message.maxSequence) {
+        throw new globalThis.Error("value provided for field message.maxSequence of type int64 too large");
+      }
+      writer.uint32(24).int64(message.maxSequence);
+    }
+    if (message.maxResults !== 0) {
+      writer.uint32(32).int32(message.maxResults);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetAggregateSnapshotsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetAggregateSnapshotsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.aggregateId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.initialSequence = reader.int64() as bigint;
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.maxSequence = reader.int64() as bigint;
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+
+          message.maxResults = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetAggregateSnapshotsRequest {
+    return {
+      aggregateId: isSet(object.aggregateId)
+        ? globalThis.String(object.aggregateId)
+        : isSet(object.aggregate_id)
+        ? globalThis.String(object.aggregate_id)
+        : "",
+      initialSequence: isSet(object.initialSequence)
+        ? BigInt(object.initialSequence)
+        : isSet(object.initial_sequence)
+        ? BigInt(object.initial_sequence)
+        : 0n,
+      maxSequence: isSet(object.maxSequence)
+        ? BigInt(object.maxSequence)
+        : isSet(object.max_sequence)
+        ? BigInt(object.max_sequence)
+        : 0n,
+      maxResults: isSet(object.maxResults)
+        ? globalThis.Number(object.maxResults)
+        : isSet(object.max_results)
+        ? globalThis.Number(object.max_results)
+        : 0,
+    };
+  },
+
+  toJSON(message: GetAggregateSnapshotsRequest): unknown {
+    const obj: any = {};
+    if (message.aggregateId !== "") {
+      obj.aggregateId = message.aggregateId;
+    }
+    if (message.initialSequence !== 0n) {
+      obj.initialSequence = message.initialSequence.toString();
+    }
+    if (message.maxSequence !== 0n) {
+      obj.maxSequence = message.maxSequence.toString();
+    }
+    if (message.maxResults !== 0) {
+      obj.maxResults = Math.round(message.maxResults);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetAggregateSnapshotsRequest>): GetAggregateSnapshotsRequest {
+    return GetAggregateSnapshotsRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetAggregateSnapshotsRequest>): GetAggregateSnapshotsRequest {
+    const message = createBaseGetAggregateSnapshotsRequest();
+    message.aggregateId = object.aggregateId ?? "";
+    message.initialSequence = object.initialSequence ?? 0n;
+    message.maxSequence = object.maxSequence ?? 0n;
+    message.maxResults = object.maxResults ?? 0;
+    return message;
+  },
+};
+
+function createBaseGetEventsRequest(): GetEventsRequest {
+  return {
+    trackingToken: 0n,
+    numberOfPermits: 0n,
+    clientId: "",
+    componentName: "",
+    processor: "",
+    blacklist: [],
+    forceReadFromLeader: false,
+  };
+}
+
+export const GetEventsRequest: MessageFns<GetEventsRequest> = {
+  encode(message: GetEventsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.trackingToken !== 0n) {
+      if (BigInt.asIntN(64, message.trackingToken) !== message.trackingToken) {
+        throw new globalThis.Error("value provided for field message.trackingToken of type int64 too large");
+      }
+      writer.uint32(8).int64(message.trackingToken);
+    }
+    if (message.numberOfPermits !== 0n) {
+      if (BigInt.asIntN(64, message.numberOfPermits) !== message.numberOfPermits) {
+        throw new globalThis.Error("value provided for field message.numberOfPermits of type int64 too large");
+      }
+      writer.uint32(16).int64(message.numberOfPermits);
+    }
+    if (message.clientId !== "") {
+      writer.uint32(26).string(message.clientId);
+    }
+    if (message.componentName !== "") {
+      writer.uint32(34).string(message.componentName);
+    }
+    if (message.processor !== "") {
+      writer.uint32(42).string(message.processor);
+    }
+    for (const v of message.blacklist) {
+      PayloadDescription.encode(v!, writer.uint32(50).fork()).join();
+    }
+    if (message.forceReadFromLeader !== false) {
+      writer.uint32(56).bool(message.forceReadFromLeader);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetEventsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetEventsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.trackingToken = reader.int64() as bigint;
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.numberOfPermits = reader.int64() as bigint;
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.clientId = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.componentName = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.processor = reader.string();
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+
+          message.blacklist.push(PayloadDescription.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 7: {
+          if (tag !== 56) {
+            break;
+          }
+
+          message.forceReadFromLeader = reader.bool();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetEventsRequest {
+    return {
+      trackingToken: isSet(object.trackingToken)
+        ? BigInt(object.trackingToken)
+        : isSet(object.tracking_token)
+        ? BigInt(object.tracking_token)
+        : 0n,
+      numberOfPermits: isSet(object.numberOfPermits)
+        ? BigInt(object.numberOfPermits)
+        : isSet(object.number_of_permits)
+        ? BigInt(object.number_of_permits)
+        : 0n,
+      clientId: isSet(object.clientId)
+        ? globalThis.String(object.clientId)
+        : isSet(object.client_id)
+        ? globalThis.String(object.client_id)
+        : "",
+      componentName: isSet(object.componentName)
+        ? globalThis.String(object.componentName)
+        : isSet(object.component_name)
+        ? globalThis.String(object.component_name)
+        : "",
+      processor: isSet(object.processor) ? globalThis.String(object.processor) : "",
+      blacklist: globalThis.Array.isArray(object?.blacklist)
+        ? object.blacklist.map((e: any) => PayloadDescription.fromJSON(e))
+        : [],
+      forceReadFromLeader: isSet(object.forceReadFromLeader)
+        ? globalThis.Boolean(object.forceReadFromLeader)
+        : isSet(object.force_read_from_leader)
+        ? globalThis.Boolean(object.force_read_from_leader)
+        : false,
+    };
+  },
+
+  toJSON(message: GetEventsRequest): unknown {
+    const obj: any = {};
+    if (message.trackingToken !== 0n) {
+      obj.trackingToken = message.trackingToken.toString();
+    }
+    if (message.numberOfPermits !== 0n) {
+      obj.numberOfPermits = message.numberOfPermits.toString();
+    }
+    if (message.clientId !== "") {
+      obj.clientId = message.clientId;
+    }
+    if (message.componentName !== "") {
+      obj.componentName = message.componentName;
+    }
+    if (message.processor !== "") {
+      obj.processor = message.processor;
+    }
+    if (message.blacklist?.length) {
+      obj.blacklist = message.blacklist.map((e) => PayloadDescription.toJSON(e));
+    }
+    if (message.forceReadFromLeader !== false) {
+      obj.forceReadFromLeader = message.forceReadFromLeader;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetEventsRequest>): GetEventsRequest {
+    return GetEventsRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetEventsRequest>): GetEventsRequest {
+    const message = createBaseGetEventsRequest();
+    message.trackingToken = object.trackingToken ?? 0n;
+    message.numberOfPermits = object.numberOfPermits ?? 0n;
+    message.clientId = object.clientId ?? "";
+    message.componentName = object.componentName ?? "";
+    message.processor = object.processor ?? "";
+    message.blacklist = object.blacklist?.map((e) => PayloadDescription.fromPartial(e)) || [];
+    message.forceReadFromLeader = object.forceReadFromLeader ?? false;
+    return message;
+  },
+};
+
+function createBaseEvent(): Event {
+  return {
+    messageIdentifier: "",
+    aggregateIdentifier: "",
+    aggregateSequenceNumber: 0n,
+    aggregateType: "",
+    timestamp: 0n,
+    payload: undefined,
+    metaData: {},
+    snapshot: false,
+  };
+}
+
+export const Event: MessageFns<Event> = {
+  encode(message: Event, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.messageIdentifier !== "") {
+      writer.uint32(10).string(message.messageIdentifier);
+    }
+    if (message.aggregateIdentifier !== "") {
+      writer.uint32(18).string(message.aggregateIdentifier);
+    }
+    if (message.aggregateSequenceNumber !== 0n) {
+      if (BigInt.asIntN(64, message.aggregateSequenceNumber) !== message.aggregateSequenceNumber) {
+        throw new globalThis.Error("value provided for field message.aggregateSequenceNumber of type int64 too large");
+      }
+      writer.uint32(24).int64(message.aggregateSequenceNumber);
+    }
+    if (message.aggregateType !== "") {
+      writer.uint32(34).string(message.aggregateType);
+    }
+    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(40).int64(message.timestamp);
+    }
+    if (message.payload !== undefined) {
+      SerializedObject.encode(message.payload, writer.uint32(50).fork()).join();
+    }
+    globalThis.Object.entries(message.metaData).forEach(([key, value]: [string, MetaDataValue]) => {
+      Event_MetaDataEntry.encode({ key: key as any, value }, writer.uint32(58).fork()).join();
+    });
+    if (message.snapshot !== false) {
+      writer.uint32(64).bool(message.snapshot);
+    }
+    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.messageIdentifier = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.aggregateIdentifier = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.aggregateSequenceNumber = reader.int64() as bigint;
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.aggregateType = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+
+          message.timestamp = reader.int64() as bigint;
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+
+          message.payload = SerializedObject.decode(reader, reader.uint32());
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+
+          const entry7 = Event_MetaDataEntry.decode(reader, reader.uint32());
+          if (entry7.value !== undefined) {
+            message.metaData[entry7.key] = entry7.value;
+          }
+          continue;
+        }
+        case 8: {
+          if (tag !== 64) {
+            break;
+          }
+
+          message.snapshot = reader.bool();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Event {
+    return {
+      messageIdentifier: isSet(object.messageIdentifier)
+        ? globalThis.String(object.messageIdentifier)
+        : isSet(object.message_identifier)
+        ? globalThis.String(object.message_identifier)
+        : "",
+      aggregateIdentifier: isSet(object.aggregateIdentifier)
+        ? globalThis.String(object.aggregateIdentifier)
+        : isSet(object.aggregate_identifier)
+        ? globalThis.String(object.aggregate_identifier)
+        : "",
+      aggregateSequenceNumber: isSet(object.aggregateSequenceNumber)
+        ? BigInt(object.aggregateSequenceNumber)
+        : isSet(object.aggregate_sequence_number)
+        ? BigInt(object.aggregate_sequence_number)
+        : 0n,
+      aggregateType: isSet(object.aggregateType)
+        ? globalThis.String(object.aggregateType)
+        : isSet(object.aggregate_type)
+        ? globalThis.String(object.aggregate_type)
+        : "",
+      timestamp: isSet(object.timestamp) ? BigInt(object.timestamp) : 0n,
+      payload: isSet(object.payload) ? SerializedObject.fromJSON(object.payload) : undefined,
+      metaData: isObject(object.metaData)
+        ? (globalThis.Object.entries(object.metaData) as [string, any][]).reduce(
+          (acc: { [key: string]: MetaDataValue }, [key, value]: [string, any]) => {
+            acc[key] = MetaDataValue.fromJSON(value);
+            return acc;
+          },
+          {},
+        )
+        : isObject(object.meta_data)
+        ? (globalThis.Object.entries(object.meta_data) as [string, any][]).reduce(
+          (acc: { [key: string]: MetaDataValue }, [key, value]: [string, any]) => {
+            acc[key] = MetaDataValue.fromJSON(value);
+            return acc;
+          },
+          {},
+        )
+        : {},
+      snapshot: isSet(object.snapshot) ? globalThis.Boolean(object.snapshot) : false,
+    };
+  },
+
+  toJSON(message: Event): unknown {
+    const obj: any = {};
+    if (message.messageIdentifier !== "") {
+      obj.messageIdentifier = message.messageIdentifier;
+    }
+    if (message.aggregateIdentifier !== "") {
+      obj.aggregateIdentifier = message.aggregateIdentifier;
+    }
+    if (message.aggregateSequenceNumber !== 0n) {
+      obj.aggregateSequenceNumber = message.aggregateSequenceNumber.toString();
+    }
+    if (message.aggregateType !== "") {
+      obj.aggregateType = message.aggregateType;
+    }
+    if (message.timestamp !== 0n) {
+      obj.timestamp = message.timestamp.toString();
+    }
+    if (message.payload !== undefined) {
+      obj.payload = SerializedObject.toJSON(message.payload);
+    }
+    if (message.metaData) {
+      const entries = globalThis.Object.entries(message.metaData) as [string, MetaDataValue][];
+      if (entries.length > 0) {
+        obj.metaData = {};
+        entries.forEach(([k, v]) => {
+          obj.metaData[k] = MetaDataValue.toJSON(v);
+        });
+      }
+    }
+    if (message.snapshot !== false) {
+      obj.snapshot = message.snapshot;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<Event>): Event {
+    return Event.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<Event>): Event {
+    const message = createBaseEvent();
+    message.messageIdentifier = object.messageIdentifier ?? "";
+    message.aggregateIdentifier = object.aggregateIdentifier ?? "";
+    message.aggregateSequenceNumber = object.aggregateSequenceNumber ?? 0n;
+    message.aggregateType = object.aggregateType ?? "";
+    message.timestamp = object.timestamp ?? 0n;
+    message.payload = (object.payload !== undefined && object.payload !== null)
+      ? SerializedObject.fromPartial(object.payload)
+      : undefined;
+    message.metaData = (globalThis.Object.entries(object.metaData ?? {}) as [string, MetaDataValue][]).reduce(
+      (acc: { [key: string]: MetaDataValue }, [key, value]: [string, MetaDataValue]) => {
+        if (value !== undefined) {
+          acc[key] = MetaDataValue.fromPartial(value);
+        }
+        return acc;
+      },
+      {},
+    );
+    message.snapshot = object.snapshot ?? false;
+    return message;
+  },
+};
+
+function createBaseEvent_MetaDataEntry(): Event_MetaDataEntry {
+  return { key: "", value: undefined };
+}
+
+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 !== undefined) {
+      MetaDataValue.encode(message.value, writer.uint32(18).fork()).join();
+    }
+    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 = MetaDataValue.decode(reader, reader.uint32());
+          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) ? MetaDataValue.fromJSON(object.value) : undefined,
+    };
+  },
+
+  toJSON(message: Event_MetaDataEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== undefined) {
+      obj.value = MetaDataValue.toJSON(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 !== undefined && object.value !== null)
+      ? MetaDataValue.fromPartial(object.value)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseQueryValue(): QueryValue {
+  return { textValue: undefined, numberValue: undefined, booleanValue: undefined, doubleValue: undefined };
+}
+
+export const QueryValue: MessageFns<QueryValue> = {
+  encode(message: QueryValue, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.textValue !== undefined) {
+      writer.uint32(10).string(message.textValue);
+    }
+    if (message.numberValue !== undefined) {
+      if (BigInt.asIntN(64, message.numberValue) !== message.numberValue) {
+        throw new globalThis.Error("value provided for field message.numberValue of type sint64 too large");
+      }
+      writer.uint32(16).sint64(message.numberValue);
+    }
+    if (message.booleanValue !== undefined) {
+      writer.uint32(24).bool(message.booleanValue);
+    }
+    if (message.doubleValue !== undefined) {
+      writer.uint32(33).double(message.doubleValue);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryValue {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryValue();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.textValue = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.numberValue = reader.sint64() as bigint;
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.booleanValue = reader.bool();
+          continue;
+        }
+        case 4: {
+          if (tag !== 33) {
+            break;
+          }
+
+          message.doubleValue = reader.double();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): QueryValue {
+    return {
+      textValue: isSet(object.textValue)
+        ? globalThis.String(object.textValue)
+        : isSet(object.text_value)
+        ? globalThis.String(object.text_value)
+        : undefined,
+      numberValue: isSet(object.numberValue)
+        ? BigInt(object.numberValue)
+        : isSet(object.number_value)
+        ? BigInt(object.number_value)
+        : undefined,
+      booleanValue: isSet(object.booleanValue)
+        ? globalThis.Boolean(object.booleanValue)
+        : isSet(object.boolean_value)
+        ? globalThis.Boolean(object.boolean_value)
+        : undefined,
+      doubleValue: isSet(object.doubleValue)
+        ? globalThis.Number(object.doubleValue)
+        : isSet(object.double_value)
+        ? globalThis.Number(object.double_value)
+        : undefined,
+    };
+  },
+
+  toJSON(message: QueryValue): unknown {
+    const obj: any = {};
+    if (message.textValue !== undefined) {
+      obj.textValue = message.textValue;
+    }
+    if (message.numberValue !== undefined) {
+      obj.numberValue = message.numberValue.toString();
+    }
+    if (message.booleanValue !== undefined) {
+      obj.booleanValue = message.booleanValue;
+    }
+    if (message.doubleValue !== undefined) {
+      obj.doubleValue = message.doubleValue;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<QueryValue>): QueryValue {
+    return QueryValue.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<QueryValue>): QueryValue {
+    const message = createBaseQueryValue();
+    message.textValue = object.textValue ?? undefined;
+    message.numberValue = object.numberValue ?? undefined;
+    message.booleanValue = object.booleanValue ?? undefined;
+    message.doubleValue = object.doubleValue ?? undefined;
+    return message;
+  },
+};
+
+function createBasePayloadDescription(): PayloadDescription {
+  return { type: "", revision: "" };
+}
+
+export const PayloadDescription: MessageFns<PayloadDescription> = {
+  encode(message: PayloadDescription, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.type !== "") {
+      writer.uint32(10).string(message.type);
+    }
+    if (message.revision !== "") {
+      writer.uint32(18).string(message.revision);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): PayloadDescription {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePayloadDescription();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.type = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.revision = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PayloadDescription {
+    return {
+      type: isSet(object.type) ? globalThis.String(object.type) : "",
+      revision: isSet(object.revision) ? globalThis.String(object.revision) : "",
+    };
+  },
+
+  toJSON(message: PayloadDescription): unknown {
+    const obj: any = {};
+    if (message.type !== "") {
+      obj.type = message.type;
+    }
+    if (message.revision !== "") {
+      obj.revision = message.revision;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<PayloadDescription>): PayloadDescription {
+    return PayloadDescription.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<PayloadDescription>): PayloadDescription {
+    const message = createBasePayloadDescription();
+    message.type = object.type ?? "";
+    message.revision = object.revision ?? "";
+    return message;
+  },
+};
+
+/** Service providing operations against the EventStore functionality of Axon Server */
+export type EventStoreDefinition = typeof EventStoreDefinition;
+export const EventStoreDefinition = {
+  name: "EventStore",
+  fullName: "io.axoniq.axonserver.grpc.event.EventStore",
+  methods: {
+    /** Accepts a stream of Events returning a Confirmation when completed. */
+    appendEvent: {
+      name: "AppendEvent",
+      requestType: Event as typeof Event,
+      requestStream: true,
+      responseType: ConfirmationWithConsistencyMarker as typeof ConfirmationWithConsistencyMarker,
+      responseStream: false,
+      options: {},
+    },
+    /** Accepts a Snapshot event returning a Confirmation when completed. */
+    appendSnapshot: {
+      name: "AppendSnapshot",
+      requestType: Event as typeof Event,
+      requestStream: false,
+      responseType: Confirmation as typeof Confirmation,
+      responseStream: false,
+      options: {},
+    },
+    /** Retrieves the Events for a given aggregate. Results are streamed rather than returned at once. */
+    listAggregateEvents: {
+      name: "ListAggregateEvents",
+      requestType: GetAggregateEventsRequest as typeof GetAggregateEventsRequest,
+      requestStream: false,
+      responseType: Event as typeof Event,
+      responseStream: true,
+      options: {},
+    },
+    /** Retrieves the Snapshots for a given aggregate. Results are streamed rather than returned at once. */
+    listAggregateSnapshots: {
+      name: "ListAggregateSnapshots",
+      requestType: GetAggregateSnapshotsRequest as typeof GetAggregateSnapshotsRequest,
+      requestStream: false,
+      responseType: Event as typeof Event,
+      responseStream: true,
+      options: {},
+    },
+    /**
+     * Retrieves the Events from a given tracking token. However, if several GetEventsRequests are sent in the stream
+     * only first one will create the tracker, others are used for increasing number of permits or blacklisting. Results
+     * are streamed rather than returned at once.
+     */
+    listEvents: {
+      name: "ListEvents",
+      requestType: GetEventsRequest as typeof GetEventsRequest,
+      requestStream: true,
+      responseType: EventWithToken as typeof EventWithToken,
+      responseStream: true,
+      options: {},
+    },
+    /** Gets the highest sequence number for a specific aggregate. */
+    readHighestSequenceNr: {
+      name: "ReadHighestSequenceNr",
+      requestType: ReadHighestSequenceNrRequest as typeof ReadHighestSequenceNrRequest,
+      requestStream: false,
+      responseType: ReadHighestSequenceNrResponse as typeof ReadHighestSequenceNrResponse,
+      responseStream: false,
+      options: {},
+    },
+    /**
+     * Performs a query on the event store, returns a stream of results. Input is a stream to allow flow control from the
+     * client
+     */
+    queryEvents: {
+      name: "QueryEvents",
+      requestType: QueryEventsRequest as typeof QueryEventsRequest,
+      requestStream: true,
+      responseType: QueryEventsResponse as typeof QueryEventsResponse,
+      responseStream: true,
+      options: {},
+    },
+    /** Retrieves the first token available in event store (typically 0). Returns 0 when no events in store. */
+    getFirstToken: {
+      name: "GetFirstToken",
+      requestType: GetFirstTokenRequest as typeof GetFirstTokenRequest,
+      requestStream: false,
+      responseType: TrackingToken as typeof TrackingToken,
+      responseStream: false,
+      options: {},
+    },
+    /** Retrieves the last committed token in event store. Returns -1 when no events in store. */
+    getLastToken: {
+      name: "GetLastToken",
+      requestType: GetLastTokenRequest as typeof GetLastTokenRequest,
+      requestStream: false,
+      responseType: TrackingToken as typeof TrackingToken,
+      responseStream: false,
+      options: {},
+    },
+    /** Retrieves the token of the first token of an event from specified time in event store. Returns -1 when no events in store. */
+    getTokenAt: {
+      name: "GetTokenAt",
+      requestType: GetTokenAtRequest as typeof GetTokenAtRequest,
+      requestStream: false,
+      responseType: TrackingToken as typeof TrackingToken,
+      responseStream: false,
+      options: {},
+    },
+  },
+} as const;
+
+export interface EventStoreServiceImplementation<CallContextExt = {}> {
+  /** Accepts a stream of Events returning a Confirmation when completed. */
+  appendEvent(
+    request: AsyncIterable<Event>,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<ConfirmationWithConsistencyMarker>>;
+  /** Accepts a Snapshot event returning a Confirmation when completed. */
+  appendSnapshot(request: Event, context: CallContext & CallContextExt): Promise<DeepPartial<Confirmation>>;
+  /** Retrieves the Events for a given aggregate. Results are streamed rather than returned at once. */
+  listAggregateEvents(
+    request: GetAggregateEventsRequest,
+    context: CallContext & CallContextExt,
+  ): ServerStreamingMethodResult<DeepPartial<Event>>;
+  /** Retrieves the Snapshots for a given aggregate. Results are streamed rather than returned at once. */
+  listAggregateSnapshots(
+    request: GetAggregateSnapshotsRequest,
+    context: CallContext & CallContextExt,
+  ): ServerStreamingMethodResult<DeepPartial<Event>>;
+  /**
+   * Retrieves the Events from a given tracking token. However, if several GetEventsRequests are sent in the stream
+   * only first one will create the tracker, others are used for increasing number of permits or blacklisting. Results
+   * are streamed rather than returned at once.
+   */
+  listEvents(
+    request: AsyncIterable<GetEventsRequest>,
+    context: CallContext & CallContextExt,
+  ): ServerStreamingMethodResult<DeepPartial<EventWithToken>>;
+  /** Gets the highest sequence number for a specific aggregate. */
+  readHighestSequenceNr(
+    request: ReadHighestSequenceNrRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<ReadHighestSequenceNrResponse>>;
+  /**
+   * Performs a query on the event store, returns a stream of results. Input is a stream to allow flow control from the
+   * client
+   */
+  queryEvents(
+    request: AsyncIterable<QueryEventsRequest>,
+    context: CallContext & CallContextExt,
+  ): ServerStreamingMethodResult<DeepPartial<QueryEventsResponse>>;
+  /** Retrieves the first token available in event store (typically 0). Returns 0 when no events in store. */
+  getFirstToken(
+    request: GetFirstTokenRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<TrackingToken>>;
+  /** Retrieves the last committed token in event store. Returns -1 when no events in store. */
+  getLastToken(
+    request: GetLastTokenRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<TrackingToken>>;
+  /** Retrieves the token of the first token of an event from specified time in event store. Returns -1 when no events in store. */
+  getTokenAt(request: GetTokenAtRequest, context: CallContext & CallContextExt): Promise<DeepPartial<TrackingToken>>;
+}
+
+export interface EventStoreClient<CallOptionsExt = {}> {
+  /** Accepts a stream of Events returning a Confirmation when completed. */
+  appendEvent(
+    request: AsyncIterable<DeepPartial<Event>>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<ConfirmationWithConsistencyMarker>;
+  /** Accepts a Snapshot event returning a Confirmation when completed. */
+  appendSnapshot(request: DeepPartial<Event>, options?: CallOptions & CallOptionsExt): Promise<Confirmation>;
+  /** Retrieves the Events for a given aggregate. Results are streamed rather than returned at once. */
+  listAggregateEvents(
+    request: DeepPartial<GetAggregateEventsRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): AsyncIterable<Event>;
+  /** Retrieves the Snapshots for a given aggregate. Results are streamed rather than returned at once. */
+  listAggregateSnapshots(
+    request: DeepPartial<GetAggregateSnapshotsRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): AsyncIterable<Event>;
+  /**
+   * Retrieves the Events from a given tracking token. However, if several GetEventsRequests are sent in the stream
+   * only first one will create the tracker, others are used for increasing number of permits or blacklisting. Results
+   * are streamed rather than returned at once.
+   */
+  listEvents(
+    request: AsyncIterable<DeepPartial<GetEventsRequest>>,
+    options?: CallOptions & CallOptionsExt,
+  ): AsyncIterable<EventWithToken>;
+  /** Gets the highest sequence number for a specific aggregate. */
+  readHighestSequenceNr(
+    request: DeepPartial<ReadHighestSequenceNrRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<ReadHighestSequenceNrResponse>;
+  /**
+   * Performs a query on the event store, returns a stream of results. Input is a stream to allow flow control from the
+   * client
+   */
+  queryEvents(
+    request: AsyncIterable<DeepPartial<QueryEventsRequest>>,
+    options?: CallOptions & CallOptionsExt,
+  ): AsyncIterable<QueryEventsResponse>;
+  /** Retrieves the first token available in event store (typically 0). Returns 0 when no events in store. */
+  getFirstToken(
+    request: DeepPartial<GetFirstTokenRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<TrackingToken>;
+  /** Retrieves the last committed token in event store. Returns -1 when no events in store. */
+  getLastToken(
+    request: DeepPartial<GetLastTokenRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<TrackingToken>;
+  /** Retrieves the token of the first token of an event from specified time in event store. Returns -1 when no events in store. */
+  getTokenAt(request: DeepPartial<GetTokenAtRequest>, options?: CallOptions & CallOptionsExt): Promise<TrackingToken>;
+}
+
+/** Service to use AxonServer as a provider of an EventScheduler */
+export type EventSchedulerDefinition = typeof EventSchedulerDefinition;
+export const EventSchedulerDefinition = {
+  name: "EventScheduler",
+  fullName: "io.axoniq.axonserver.grpc.event.EventScheduler",
+  methods: {
+    /** Schedule the given event for publication at the given time}. The returned ScheduleToken can be used to cancel the planned publication. */
+    scheduleEvent: {
+      name: "ScheduleEvent",
+      requestType: ScheduleEventRequest as typeof ScheduleEventRequest,
+      requestStream: false,
+      responseType: ScheduleToken as typeof ScheduleToken,
+      responseStream: false,
+      options: {},
+    },
+    /** Cancel a scheduled event and schedule another in its place. */
+    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 EventSchedulerServiceImplementation<CallContextExt = {}> {
+  /** Schedule the given event for publication at the given time}. The returned ScheduleToken can be used to cancel the planned publication. */
+  scheduleEvent(
+    request: ScheduleEventRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<ScheduleToken>>;
+  /** Cancel a scheduled event and schedule another in its place. */
+  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 EventSchedulerClient<CallOptionsExt = {}> {
+  /** Schedule the given event for publication at the given time}. The returned ScheduleToken can be used to cancel the planned publication. */
+  scheduleEvent(
+    request: DeepPartial<ScheduleEventRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<ScheduleToken>;
+  /** Cancel a scheduled event and schedule another in its place. */
+  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>;
+}
+
+/** Service to transform events in an event store */
+export type EventTransformationServiceDefinition = typeof EventTransformationServiceDefinition;
+export const EventTransformationServiceDefinition = {
+  name: "EventTransformationService",
+  fullName: "io.axoniq.axonserver.grpc.event.EventTransformationService",
+  methods: {
+    /** Returns the list of all transformations. */
+    transformations: {
+      name: "Transformations",
+      requestType: Empty as typeof Empty,
+      requestStream: false,
+      responseType: Transformation as typeof Transformation,
+      responseStream: true,
+      options: {},
+    },
+    /** Starts a new transformation. */
+    startTransformation: {
+      name: "StartTransformation",
+      requestType: StartTransformationRequest as typeof StartTransformationRequest,
+      requestStream: false,
+      responseType: TransformationId as typeof TransformationId,
+      responseStream: false,
+      options: {},
+    },
+    /** Adds requests to transform an event to a transformation. */
+    transformEvents: {
+      name: "TransformEvents",
+      requestType: TransformRequest as typeof TransformRequest,
+      requestStream: true,
+      responseType: TransformRequestAck as typeof TransformRequestAck,
+      responseStream: true,
+      options: {},
+    },
+    /** Cancels a transformation before it is applied. */
+    cancelTransformation: {
+      name: "CancelTransformation",
+      requestType: TransformationId as typeof TransformationId,
+      requestStream: false,
+      responseType: Empty as typeof Empty,
+      responseStream: true,
+      options: {},
+    },
+    /** Applies the changes from a transformation in the event store. */
+    applyTransformation: {
+      name: "ApplyTransformation",
+      requestType: ApplyTransformationRequest as typeof ApplyTransformationRequest,
+      requestStream: false,
+      responseType: Empty as typeof Empty,
+      responseStream: true,
+      options: {},
+    },
+    /** Deletes old versions of events updated by a transformation. */
+    compact: {
+      name: "Compact",
+      requestType: CompactionRequest as typeof CompactionRequest,
+      requestStream: false,
+      responseType: Empty as typeof Empty,
+      responseStream: true,
+      options: {},
+    },
+  },
+} as const;
+
+export interface EventTransformationServiceImplementation<CallContextExt = {}> {
+  /** Returns the list of all transformations. */
+  transformations(
+    request: Empty,
+    context: CallContext & CallContextExt,
+  ): ServerStreamingMethodResult<DeepPartial<Transformation>>;
+  /** Starts a new transformation. */
+  startTransformation(
+    request: StartTransformationRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<TransformationId>>;
+  /** Adds requests to transform an event to a transformation. */
+  transformEvents(
+    request: AsyncIterable<TransformRequest>,
+    context: CallContext & CallContextExt,
+  ): ServerStreamingMethodResult<DeepPartial<TransformRequestAck>>;
+  /** Cancels a transformation before it is applied. */
+  cancelTransformation(
+    request: TransformationId,
+    context: CallContext & CallContextExt,
+  ): ServerStreamingMethodResult<DeepPartial<Empty>>;
+  /** Applies the changes from a transformation in the event store. */
+  applyTransformation(
+    request: ApplyTransformationRequest,
+    context: CallContext & CallContextExt,
+  ): ServerStreamingMethodResult<DeepPartial<Empty>>;
+  /** Deletes old versions of events updated by a transformation. */
+  compact(
+    request: CompactionRequest,
+    context: CallContext & CallContextExt,
+  ): ServerStreamingMethodResult<DeepPartial<Empty>>;
+}
+
+export interface EventTransformationServiceClient<CallOptionsExt = {}> {
+  /** Returns the list of all transformations. */
+  transformations(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): AsyncIterable<Transformation>;
+  /** Starts a new transformation. */
+  startTransformation(
+    request: DeepPartial<StartTransformationRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<TransformationId>;
+  /** Adds requests to transform an event to a transformation. */
+  transformEvents(
+    request: AsyncIterable<DeepPartial<TransformRequest>>,
+    options?: CallOptions & CallOptionsExt,
+  ): AsyncIterable<TransformRequestAck>;
+  /** Cancels a transformation before it is applied. */
+  cancelTransformation(
+    request: DeepPartial<TransformationId>,
+    options?: CallOptions & CallOptionsExt,
+  ): AsyncIterable<Empty>;
+  /** Applies the changes from a transformation in the event store. */
+  applyTransformation(
+    request: DeepPartial<ApplyTransformationRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): AsyncIterable<Empty>;
+  /** Deletes old versions of events updated by a transformation. */
+  compact(request: DeepPartial<CompactionRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<Empty>;
+}
+
+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;
+}