@kronos-ts/kronosdb 0.1.0

package/src/generated/eventstore.ts

@@ -0,0 +1,2241 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.6
+//   protoc               v3.19.1
+// source: eventstore.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import type { CallContext, CallOptions } from "nice-grpc-common";
+
+export const protobufPackage = "kronosdb.eventstore";
+
+/** An event as provided by the client. */
+export interface Event {
+  /** Client-provided unique identifier. */
+  identifier: string;
+  /** Timestamp in milliseconds since epoch. Client-provided. */
+  timestamp: bigint;
+  /** The event type name (e.g., "OrderPlaced"). */
+  name: string;
+  /** The schema version of the event payload. */
+  version: string;
+  /** The opaque event payload. */
+  payload: Uint8Array;
+  /** Arbitrary key-value metadata. */
+  metadata: { [key: string]: string };
+}
+
+export interface Event_MetadataEntry {
+  key: string;
+  value: string;
+}
+
+/** A tag describing an event. Key-value pair using domain concepts. */
+export interface Tag {
+  key: Uint8Array;
+  value: Uint8Array;
+}
+
+/** An event with its tags, used for appending. */
+export interface TaggedEvent {
+  event: Event | undefined;
+  tags: Tag[];
+}
+
+/** An event with its assigned sequence position, returned on reads. */
+export interface SequencedEvent {
+  sequence: bigint;
+  event: Event | undefined;
+}
+
+/** Request to append events. Sent as a stream to allow batching. */
+export interface AppendRequest {
+  /** Optional consistency condition. If omitted, events are appended unconditionally. */
+  condition:
+    | ConsistencyCondition
+    | undefined;
+  /** Events to append. All-or-nothing transaction. */
+  events: TaggedEvent[];
+}
+
+/** Response to a successful append. */
+export interface AppendResponse {
+  /** Sequence of the first event appended. */
+  firstSequence: bigint;
+  /** Number of events appended. */
+  count: number;
+  /** Consistency marker for subsequent appends. */
+  consistencyMarker: bigint;
+}
+
+/**
+ * The consistency condition for conditional appends.
+ * "Reject if any event matching the criteria exists after the consistency marker."
+ */
+export interface ConsistencyCondition {
+  /** Position after which to check for conflicts. Events with sequence > this are checked. */
+  consistencyMarker: bigint;
+  /** Criteria defining which events would conflict. */
+  criteria: Criterion[];
+}
+
+/**
+ * A single criterion. Matches an event if ALL tags are present AND the event name
+ * is in the names list (if names is non-empty).
+ */
+export interface Criterion {
+  /** Event type names. If non-empty, the event name must match one of these. */
+  names: string[];
+  /** Tags that must ALL be present on the event. */
+  tags: Tag[];
+}
+
+/** Request to source (finite read) events matching criteria. */
+export interface SourceRequest {
+  /** Inclusive starting sequence position. */
+  fromSequence: bigint;
+  /** Criteria to filter events. If empty, all events are returned. */
+  criteria: Criterion[];
+}
+
+/** Response containing either a matching event or the final consistency marker. */
+export interface SourceResponse {
+  /** A matching event with its sequence. */
+  event?:
+    | SequencedEvent
+    | undefined;
+  /**
+   * The consistency marker at the end of the stream.
+   * Use this for subsequent appends related to the same criteria.
+   */
+  consistencyMarker?: bigint | undefined;
+}
+
+/**
+ * Client-to-server messages on the Stream RPC.
+ * The first message MUST be a Subscribe; subsequent messages grant permits.
+ */
+export interface StreamControl {
+  /** Initial subscription — sent once to start the stream. */
+  subscribe?:
+    | StreamSubscribe
+    | undefined;
+  /** Grant additional permits — server may send one event per permit. */
+  permits?: StreamPermits | undefined;
+}
+
+/** Opens the event stream with criteria and initial permits. */
+export interface StreamSubscribe {
+  /** Inclusive starting sequence position. */
+  fromSequence: bigint;
+  /** Criteria to filter events. If empty, all events are streamed. */
+  criteria: Criterion[];
+  /**
+   * Initial number of permits. The server will send at most this many events
+   * before waiting for more permits. Must be > 0.
+   */
+  initialPermits: bigint;
+  /**
+   * Optional: event type names to exclude from the stream.
+   * Events matching any of these names are silently skipped (payload blacklisting).
+   */
+  blacklistedNames: string[];
+}
+
+/** Grants additional permits on an active stream. */
+export interface StreamPermits {
+  /** Number of additional permits to grant. */
+  permits: bigint;
+}
+
+/** A message on the event stream — either a matching event or a keep-alive heartbeat. */
+export interface StreamResponse {
+  /** A matching event with its sequence. */
+  event?:
+    | SequencedEvent
+    | undefined;
+  /**
+   * Server heartbeat — sent periodically to detect slow/dead consumers.
+   * Clients should ignore this (no response needed).
+   */
+  heartbeat?: StreamHeartbeat | undefined;
+}
+
+/** Keep-alive heartbeat on event streams. */
+export interface StreamHeartbeat {
+}
+
+export interface GetHeadRequest {
+}
+
+export interface GetHeadResponse {
+  /** The sequence of the next event to be appended. 0 for an empty store. */
+  sequence: bigint;
+}
+
+export interface GetTailRequest {
+}
+
+export interface GetTailResponse {
+  /** The sequence of the first event in the store. 0 for an empty or non-truncated store. */
+  sequence: bigint;
+}
+
+export interface GetTagsRequest {
+  sequence: bigint;
+}
+
+export interface GetTagsResponse {
+  tags: Tag[];
+}
+
+export interface GetSequenceAtRequest {
+  /** Timestamp in milliseconds since epoch. */
+  timestamp: bigint;
+}
+
+export interface GetSequenceAtResponse {
+  /**
+   * Sequence of the first event at or after the given timestamp.
+   * -1 if no such event exists.
+   */
+  sequence: bigint;
+}
+
+function createBaseEvent(): Event {
+  return { identifier: "", timestamp: 0n, name: "", version: "", payload: new Uint8Array(0), metadata: {} };
+}
+
+export const Event: MessageFns<Event> = {
+  encode(message: Event, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.identifier !== "") {
+      writer.uint32(10).string(message.identifier);
+    }
+    if (message.timestamp !== 0n) {
+      if (BigInt.asIntN(64, message.timestamp) !== message.timestamp) {
+        throw new globalThis.Error("value provided for field message.timestamp of type int64 too large");
+      }
+      writer.uint32(16).int64(message.timestamp);
+    }
+    if (message.name !== "") {
+      writer.uint32(26).string(message.name);
+    }
+    if (message.version !== "") {
+      writer.uint32(34).string(message.version);
+    }
+    if (message.payload.length !== 0) {
+      writer.uint32(42).bytes(message.payload);
+    }
+    globalThis.Object.entries(message.metadata).forEach(([key, value]: [string, string]) => {
+      Event_MetadataEntry.encode({ key: key as any, value }, writer.uint32(50).fork()).join();
+    });
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Event {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEvent();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.identifier = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.timestamp = reader.int64() as bigint;
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.version = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.payload = reader.bytes();
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+
+          const entry6 = Event_MetadataEntry.decode(reader, reader.uint32());
+          if (entry6.value !== undefined) {
+            message.metadata[entry6.key] = entry6.value;
+          }
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Event {
+    return {
+      identifier: isSet(object.identifier) ? globalThis.String(object.identifier) : "",
+      timestamp: isSet(object.timestamp) ? BigInt(object.timestamp) : 0n,
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+      version: isSet(object.version) ? globalThis.String(object.version) : "",
+      payload: isSet(object.payload) ? bytesFromBase64(object.payload) : new Uint8Array(0),
+      metadata: isObject(object.metadata)
+        ? (globalThis.Object.entries(object.metadata) as [string, any][]).reduce(
+          (acc: { [key: string]: string }, [key, value]: [string, any]) => {
+            acc[key] = globalThis.String(value);
+            return acc;
+          },
+          {},
+        )
+        : {},
+    };
+  },
+
+  toJSON(message: Event): unknown {
+    const obj: any = {};
+    if (message.identifier !== "") {
+      obj.identifier = message.identifier;
+    }
+    if (message.timestamp !== 0n) {
+      obj.timestamp = message.timestamp.toString();
+    }
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.version !== "") {
+      obj.version = message.version;
+    }
+    if (message.payload.length !== 0) {
+      obj.payload = base64FromBytes(message.payload);
+    }
+    if (message.metadata) {
+      const entries = globalThis.Object.entries(message.metadata) as [string, string][];
+      if (entries.length > 0) {
+        obj.metadata = {};
+        entries.forEach(([k, v]) => {
+          obj.metadata[k] = v;
+        });
+      }
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<Event>): Event {
+    return Event.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<Event>): Event {
+    const message = createBaseEvent();
+    message.identifier = object.identifier ?? "";
+    message.timestamp = object.timestamp ?? 0n;
+    message.name = object.name ?? "";
+    message.version = object.version ?? "";
+    message.payload = object.payload ?? new Uint8Array(0);
+    message.metadata = (globalThis.Object.entries(object.metadata ?? {}) as [string, string][]).reduce(
+      (acc: { [key: string]: string }, [key, value]: [string, string]) => {
+        if (value !== undefined) {
+          acc[key] = globalThis.String(value);
+        }
+        return acc;
+      },
+      {},
+    );
+    return message;
+  },
+};
+
+function createBaseEvent_MetadataEntry(): Event_MetadataEntry {
+  return { key: "", value: "" };
+}
+
+export const Event_MetadataEntry: MessageFns<Event_MetadataEntry> = {
+  encode(message: Event_MetadataEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Event_MetadataEntry {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEvent_MetadataEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.value = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Event_MetadataEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? globalThis.String(object.value) : "",
+    };
+  },
+
+  toJSON(message: Event_MetadataEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<Event_MetadataEntry>): Event_MetadataEntry {
+    return Event_MetadataEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<Event_MetadataEntry>): Event_MetadataEntry {
+    const message = createBaseEvent_MetadataEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  },
+};
+
+function createBaseTag(): Tag {
+  return { key: new Uint8Array(0), value: new Uint8Array(0) };
+}
+
+export const Tag: MessageFns<Tag> = {
+  encode(message: Tag, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key.length !== 0) {
+      writer.uint32(10).bytes(message.key);
+    }
+    if (message.value.length !== 0) {
+      writer.uint32(18).bytes(message.value);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Tag {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTag();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.key = reader.bytes();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.value = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Tag {
+    return {
+      key: isSet(object.key) ? bytesFromBase64(object.key) : new Uint8Array(0),
+      value: isSet(object.value) ? bytesFromBase64(object.value) : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: Tag): unknown {
+    const obj: any = {};
+    if (message.key.length !== 0) {
+      obj.key = base64FromBytes(message.key);
+    }
+    if (message.value.length !== 0) {
+      obj.value = base64FromBytes(message.value);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<Tag>): Tag {
+    return Tag.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<Tag>): Tag {
+    const message = createBaseTag();
+    message.key = object.key ?? new Uint8Array(0);
+    message.value = object.value ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+function createBaseTaggedEvent(): TaggedEvent {
+  return { event: undefined, tags: [] };
+}
+
+export const TaggedEvent: MessageFns<TaggedEvent> = {
+  encode(message: TaggedEvent, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.event !== undefined) {
+      Event.encode(message.event, writer.uint32(10).fork()).join();
+    }
+    for (const v of message.tags) {
+      Tag.encode(v!, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TaggedEvent {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTaggedEvent();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.event = Event.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.tags.push(Tag.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TaggedEvent {
+    return {
+      event: isSet(object.event) ? Event.fromJSON(object.event) : undefined,
+      tags: globalThis.Array.isArray(object?.tags) ? object.tags.map((e: any) => Tag.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: TaggedEvent): unknown {
+    const obj: any = {};
+    if (message.event !== undefined) {
+      obj.event = Event.toJSON(message.event);
+    }
+    if (message.tags?.length) {
+      obj.tags = message.tags.map((e) => Tag.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<TaggedEvent>): TaggedEvent {
+    return TaggedEvent.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<TaggedEvent>): TaggedEvent {
+    const message = createBaseTaggedEvent();
+    message.event = (object.event !== undefined && object.event !== null) ? Event.fromPartial(object.event) : undefined;
+    message.tags = object.tags?.map((e) => Tag.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseSequencedEvent(): SequencedEvent {
+  return { sequence: 0n, event: undefined };
+}
+
+export const SequencedEvent: MessageFns<SequencedEvent> = {
+  encode(message: SequencedEvent, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.sequence !== 0n) {
+      if (BigInt.asIntN(64, message.sequence) !== message.sequence) {
+        throw new globalThis.Error("value provided for field message.sequence of type int64 too large");
+      }
+      writer.uint32(8).int64(message.sequence);
+    }
+    if (message.event !== undefined) {
+      Event.encode(message.event, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SequencedEvent {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSequencedEvent();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.sequence = reader.int64() as bigint;
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.event = Event.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SequencedEvent {
+    return {
+      sequence: isSet(object.sequence) ? BigInt(object.sequence) : 0n,
+      event: isSet(object.event) ? Event.fromJSON(object.event) : undefined,
+    };
+  },
+
+  toJSON(message: SequencedEvent): unknown {
+    const obj: any = {};
+    if (message.sequence !== 0n) {
+      obj.sequence = message.sequence.toString();
+    }
+    if (message.event !== undefined) {
+      obj.event = Event.toJSON(message.event);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<SequencedEvent>): SequencedEvent {
+    return SequencedEvent.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<SequencedEvent>): SequencedEvent {
+    const message = createBaseSequencedEvent();
+    message.sequence = object.sequence ?? 0n;
+    message.event = (object.event !== undefined && object.event !== null) ? Event.fromPartial(object.event) : undefined;
+    return message;
+  },
+};
+
+function createBaseAppendRequest(): AppendRequest {
+  return { condition: undefined, events: [] };
+}
+
+export const AppendRequest: MessageFns<AppendRequest> = {
+  encode(message: AppendRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.condition !== undefined) {
+      ConsistencyCondition.encode(message.condition, writer.uint32(10).fork()).join();
+    }
+    for (const v of message.events) {
+      TaggedEvent.encode(v!, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): AppendRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAppendRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.condition = ConsistencyCondition.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.events.push(TaggedEvent.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): AppendRequest {
+    return {
+      condition: isSet(object.condition) ? ConsistencyCondition.fromJSON(object.condition) : undefined,
+      events: globalThis.Array.isArray(object?.events) ? object.events.map((e: any) => TaggedEvent.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: AppendRequest): unknown {
+    const obj: any = {};
+    if (message.condition !== undefined) {
+      obj.condition = ConsistencyCondition.toJSON(message.condition);
+    }
+    if (message.events?.length) {
+      obj.events = message.events.map((e) => TaggedEvent.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<AppendRequest>): AppendRequest {
+    return AppendRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<AppendRequest>): AppendRequest {
+    const message = createBaseAppendRequest();
+    message.condition = (object.condition !== undefined && object.condition !== null)
+      ? ConsistencyCondition.fromPartial(object.condition)
+      : undefined;
+    message.events = object.events?.map((e) => TaggedEvent.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseAppendResponse(): AppendResponse {
+  return { firstSequence: 0n, count: 0, consistencyMarker: 0n };
+}
+
+export const AppendResponse: MessageFns<AppendResponse> = {
+  encode(message: AppendResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.firstSequence !== 0n) {
+      if (BigInt.asIntN(64, message.firstSequence) !== message.firstSequence) {
+        throw new globalThis.Error("value provided for field message.firstSequence of type int64 too large");
+      }
+      writer.uint32(8).int64(message.firstSequence);
+    }
+    if (message.count !== 0) {
+      writer.uint32(16).int32(message.count);
+    }
+    if (message.consistencyMarker !== 0n) {
+      if (BigInt.asIntN(64, message.consistencyMarker) !== message.consistencyMarker) {
+        throw new globalThis.Error("value provided for field message.consistencyMarker of type int64 too large");
+      }
+      writer.uint32(24).int64(message.consistencyMarker);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): AppendResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAppendResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.firstSequence = reader.int64() as bigint;
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.count = reader.int32();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.consistencyMarker = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): AppendResponse {
+    return {
+      firstSequence: isSet(object.firstSequence)
+        ? BigInt(object.firstSequence)
+        : isSet(object.first_sequence)
+        ? BigInt(object.first_sequence)
+        : 0n,
+      count: isSet(object.count) ? globalThis.Number(object.count) : 0,
+      consistencyMarker: isSet(object.consistencyMarker)
+        ? BigInt(object.consistencyMarker)
+        : isSet(object.consistency_marker)
+        ? BigInt(object.consistency_marker)
+        : 0n,
+    };
+  },
+
+  toJSON(message: AppendResponse): unknown {
+    const obj: any = {};
+    if (message.firstSequence !== 0n) {
+      obj.firstSequence = message.firstSequence.toString();
+    }
+    if (message.count !== 0) {
+      obj.count = Math.round(message.count);
+    }
+    if (message.consistencyMarker !== 0n) {
+      obj.consistencyMarker = message.consistencyMarker.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<AppendResponse>): AppendResponse {
+    return AppendResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<AppendResponse>): AppendResponse {
+    const message = createBaseAppendResponse();
+    message.firstSequence = object.firstSequence ?? 0n;
+    message.count = object.count ?? 0;
+    message.consistencyMarker = object.consistencyMarker ?? 0n;
+    return message;
+  },
+};
+
+function createBaseConsistencyCondition(): ConsistencyCondition {
+  return { consistencyMarker: 0n, criteria: [] };
+}
+
+export const ConsistencyCondition: MessageFns<ConsistencyCondition> = {
+  encode(message: ConsistencyCondition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.consistencyMarker !== 0n) {
+      if (BigInt.asIntN(64, message.consistencyMarker) !== message.consistencyMarker) {
+        throw new globalThis.Error("value provided for field message.consistencyMarker of type int64 too large");
+      }
+      writer.uint32(8).int64(message.consistencyMarker);
+    }
+    for (const v of message.criteria) {
+      Criterion.encode(v!, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ConsistencyCondition {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseConsistencyCondition();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.consistencyMarker = reader.int64() as bigint;
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.criteria.push(Criterion.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ConsistencyCondition {
+    return {
+      consistencyMarker: isSet(object.consistencyMarker)
+        ? BigInt(object.consistencyMarker)
+        : isSet(object.consistency_marker)
+        ? BigInt(object.consistency_marker)
+        : 0n,
+      criteria: globalThis.Array.isArray(object?.criteria)
+        ? object.criteria.map((e: any) => Criterion.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: ConsistencyCondition): unknown {
+    const obj: any = {};
+    if (message.consistencyMarker !== 0n) {
+      obj.consistencyMarker = message.consistencyMarker.toString();
+    }
+    if (message.criteria?.length) {
+      obj.criteria = message.criteria.map((e) => Criterion.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<ConsistencyCondition>): ConsistencyCondition {
+    return ConsistencyCondition.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ConsistencyCondition>): ConsistencyCondition {
+    const message = createBaseConsistencyCondition();
+    message.consistencyMarker = object.consistencyMarker ?? 0n;
+    message.criteria = object.criteria?.map((e) => Criterion.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseCriterion(): Criterion {
+  return { names: [], tags: [] };
+}
+
+export const Criterion: MessageFns<Criterion> = {
+  encode(message: Criterion, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.names) {
+      writer.uint32(10).string(v!);
+    }
+    for (const v of message.tags) {
+      Tag.encode(v!, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): Criterion {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCriterion();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.names.push(reader.string());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.tags.push(Tag.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Criterion {
+    return {
+      names: globalThis.Array.isArray(object?.names) ? object.names.map((e: any) => globalThis.String(e)) : [],
+      tags: globalThis.Array.isArray(object?.tags) ? object.tags.map((e: any) => Tag.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: Criterion): unknown {
+    const obj: any = {};
+    if (message.names?.length) {
+      obj.names = message.names;
+    }
+    if (message.tags?.length) {
+      obj.tags = message.tags.map((e) => Tag.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<Criterion>): Criterion {
+    return Criterion.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<Criterion>): Criterion {
+    const message = createBaseCriterion();
+    message.names = object.names?.map((e) => e) || [];
+    message.tags = object.tags?.map((e) => Tag.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseSourceRequest(): SourceRequest {
+  return { fromSequence: 0n, criteria: [] };
+}
+
+export const SourceRequest: MessageFns<SourceRequest> = {
+  encode(message: SourceRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.fromSequence !== 0n) {
+      if (BigInt.asIntN(64, message.fromSequence) !== message.fromSequence) {
+        throw new globalThis.Error("value provided for field message.fromSequence of type int64 too large");
+      }
+      writer.uint32(8).int64(message.fromSequence);
+    }
+    for (const v of message.criteria) {
+      Criterion.encode(v!, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SourceRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSourceRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.fromSequence = reader.int64() as bigint;
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.criteria.push(Criterion.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SourceRequest {
+    return {
+      fromSequence: isSet(object.fromSequence)
+        ? BigInt(object.fromSequence)
+        : isSet(object.from_sequence)
+        ? BigInt(object.from_sequence)
+        : 0n,
+      criteria: globalThis.Array.isArray(object?.criteria)
+        ? object.criteria.map((e: any) => Criterion.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: SourceRequest): unknown {
+    const obj: any = {};
+    if (message.fromSequence !== 0n) {
+      obj.fromSequence = message.fromSequence.toString();
+    }
+    if (message.criteria?.length) {
+      obj.criteria = message.criteria.map((e) => Criterion.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<SourceRequest>): SourceRequest {
+    return SourceRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<SourceRequest>): SourceRequest {
+    const message = createBaseSourceRequest();
+    message.fromSequence = object.fromSequence ?? 0n;
+    message.criteria = object.criteria?.map((e) => Criterion.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseSourceResponse(): SourceResponse {
+  return { event: undefined, consistencyMarker: undefined };
+}
+
+export const SourceResponse: MessageFns<SourceResponse> = {
+  encode(message: SourceResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.event !== undefined) {
+      SequencedEvent.encode(message.event, writer.uint32(10).fork()).join();
+    }
+    if (message.consistencyMarker !== undefined) {
+      if (BigInt.asIntN(64, message.consistencyMarker) !== message.consistencyMarker) {
+        throw new globalThis.Error("value provided for field message.consistencyMarker of type int64 too large");
+      }
+      writer.uint32(16).int64(message.consistencyMarker);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SourceResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSourceResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.event = SequencedEvent.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.consistencyMarker = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SourceResponse {
+    return {
+      event: isSet(object.event) ? SequencedEvent.fromJSON(object.event) : undefined,
+      consistencyMarker: isSet(object.consistencyMarker)
+        ? BigInt(object.consistencyMarker)
+        : isSet(object.consistency_marker)
+        ? BigInt(object.consistency_marker)
+        : undefined,
+    };
+  },
+
+  toJSON(message: SourceResponse): unknown {
+    const obj: any = {};
+    if (message.event !== undefined) {
+      obj.event = SequencedEvent.toJSON(message.event);
+    }
+    if (message.consistencyMarker !== undefined) {
+      obj.consistencyMarker = message.consistencyMarker.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<SourceResponse>): SourceResponse {
+    return SourceResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<SourceResponse>): SourceResponse {
+    const message = createBaseSourceResponse();
+    message.event = (object.event !== undefined && object.event !== null)
+      ? SequencedEvent.fromPartial(object.event)
+      : undefined;
+    message.consistencyMarker = object.consistencyMarker ?? undefined;
+    return message;
+  },
+};
+
+function createBaseStreamControl(): StreamControl {
+  return { subscribe: undefined, permits: undefined };
+}
+
+export const StreamControl: MessageFns<StreamControl> = {
+  encode(message: StreamControl, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.subscribe !== undefined) {
+      StreamSubscribe.encode(message.subscribe, writer.uint32(10).fork()).join();
+    }
+    if (message.permits !== undefined) {
+      StreamPermits.encode(message.permits, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): StreamControl {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStreamControl();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.subscribe = StreamSubscribe.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.permits = StreamPermits.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): StreamControl {
+    return {
+      subscribe: isSet(object.subscribe) ? StreamSubscribe.fromJSON(object.subscribe) : undefined,
+      permits: isSet(object.permits) ? StreamPermits.fromJSON(object.permits) : undefined,
+    };
+  },
+
+  toJSON(message: StreamControl): unknown {
+    const obj: any = {};
+    if (message.subscribe !== undefined) {
+      obj.subscribe = StreamSubscribe.toJSON(message.subscribe);
+    }
+    if (message.permits !== undefined) {
+      obj.permits = StreamPermits.toJSON(message.permits);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<StreamControl>): StreamControl {
+    return StreamControl.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<StreamControl>): StreamControl {
+    const message = createBaseStreamControl();
+    message.subscribe = (object.subscribe !== undefined && object.subscribe !== null)
+      ? StreamSubscribe.fromPartial(object.subscribe)
+      : undefined;
+    message.permits = (object.permits !== undefined && object.permits !== null)
+      ? StreamPermits.fromPartial(object.permits)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseStreamSubscribe(): StreamSubscribe {
+  return { fromSequence: 0n, criteria: [], initialPermits: 0n, blacklistedNames: [] };
+}
+
+export const StreamSubscribe: MessageFns<StreamSubscribe> = {
+  encode(message: StreamSubscribe, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.fromSequence !== 0n) {
+      if (BigInt.asIntN(64, message.fromSequence) !== message.fromSequence) {
+        throw new globalThis.Error("value provided for field message.fromSequence of type int64 too large");
+      }
+      writer.uint32(8).int64(message.fromSequence);
+    }
+    for (const v of message.criteria) {
+      Criterion.encode(v!, writer.uint32(18).fork()).join();
+    }
+    if (message.initialPermits !== 0n) {
+      if (BigInt.asIntN(64, message.initialPermits) !== message.initialPermits) {
+        throw new globalThis.Error("value provided for field message.initialPermits of type int64 too large");
+      }
+      writer.uint32(24).int64(message.initialPermits);
+    }
+    for (const v of message.blacklistedNames) {
+      writer.uint32(34).string(v!);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): StreamSubscribe {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStreamSubscribe();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.fromSequence = reader.int64() as bigint;
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.criteria.push(Criterion.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.initialPermits = reader.int64() as bigint;
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.blacklistedNames.push(reader.string());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): StreamSubscribe {
+    return {
+      fromSequence: isSet(object.fromSequence)
+        ? BigInt(object.fromSequence)
+        : isSet(object.from_sequence)
+        ? BigInt(object.from_sequence)
+        : 0n,
+      criteria: globalThis.Array.isArray(object?.criteria)
+        ? object.criteria.map((e: any) => Criterion.fromJSON(e))
+        : [],
+      initialPermits: isSet(object.initialPermits)
+        ? BigInt(object.initialPermits)
+        : isSet(object.initial_permits)
+        ? BigInt(object.initial_permits)
+        : 0n,
+      blacklistedNames: globalThis.Array.isArray(object?.blacklistedNames)
+        ? object.blacklistedNames.map((e: any) => globalThis.String(e))
+        : globalThis.Array.isArray(object?.blacklisted_names)
+        ? object.blacklisted_names.map((e: any) => globalThis.String(e))
+        : [],
+    };
+  },
+
+  toJSON(message: StreamSubscribe): unknown {
+    const obj: any = {};
+    if (message.fromSequence !== 0n) {
+      obj.fromSequence = message.fromSequence.toString();
+    }
+    if (message.criteria?.length) {
+      obj.criteria = message.criteria.map((e) => Criterion.toJSON(e));
+    }
+    if (message.initialPermits !== 0n) {
+      obj.initialPermits = message.initialPermits.toString();
+    }
+    if (message.blacklistedNames?.length) {
+      obj.blacklistedNames = message.blacklistedNames;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<StreamSubscribe>): StreamSubscribe {
+    return StreamSubscribe.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<StreamSubscribe>): StreamSubscribe {
+    const message = createBaseStreamSubscribe();
+    message.fromSequence = object.fromSequence ?? 0n;
+    message.criteria = object.criteria?.map((e) => Criterion.fromPartial(e)) || [];
+    message.initialPermits = object.initialPermits ?? 0n;
+    message.blacklistedNames = object.blacklistedNames?.map((e) => e) || [];
+    return message;
+  },
+};
+
+function createBaseStreamPermits(): StreamPermits {
+  return { permits: 0n };
+}
+
+export const StreamPermits: MessageFns<StreamPermits> = {
+  encode(message: StreamPermits, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.permits !== 0n) {
+      if (BigInt.asIntN(64, message.permits) !== message.permits) {
+        throw new globalThis.Error("value provided for field message.permits of type int64 too large");
+      }
+      writer.uint32(8).int64(message.permits);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): StreamPermits {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStreamPermits();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.permits = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): StreamPermits {
+    return { permits: isSet(object.permits) ? BigInt(object.permits) : 0n };
+  },
+
+  toJSON(message: StreamPermits): unknown {
+    const obj: any = {};
+    if (message.permits !== 0n) {
+      obj.permits = message.permits.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<StreamPermits>): StreamPermits {
+    return StreamPermits.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<StreamPermits>): StreamPermits {
+    const message = createBaseStreamPermits();
+    message.permits = object.permits ?? 0n;
+    return message;
+  },
+};
+
+function createBaseStreamResponse(): StreamResponse {
+  return { event: undefined, heartbeat: undefined };
+}
+
+export const StreamResponse: MessageFns<StreamResponse> = {
+  encode(message: StreamResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.event !== undefined) {
+      SequencedEvent.encode(message.event, writer.uint32(10).fork()).join();
+    }
+    if (message.heartbeat !== undefined) {
+      StreamHeartbeat.encode(message.heartbeat, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): StreamResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStreamResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.event = SequencedEvent.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.heartbeat = StreamHeartbeat.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): StreamResponse {
+    return {
+      event: isSet(object.event) ? SequencedEvent.fromJSON(object.event) : undefined,
+      heartbeat: isSet(object.heartbeat) ? StreamHeartbeat.fromJSON(object.heartbeat) : undefined,
+    };
+  },
+
+  toJSON(message: StreamResponse): unknown {
+    const obj: any = {};
+    if (message.event !== undefined) {
+      obj.event = SequencedEvent.toJSON(message.event);
+    }
+    if (message.heartbeat !== undefined) {
+      obj.heartbeat = StreamHeartbeat.toJSON(message.heartbeat);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<StreamResponse>): StreamResponse {
+    return StreamResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<StreamResponse>): StreamResponse {
+    const message = createBaseStreamResponse();
+    message.event = (object.event !== undefined && object.event !== null)
+      ? SequencedEvent.fromPartial(object.event)
+      : undefined;
+    message.heartbeat = (object.heartbeat !== undefined && object.heartbeat !== null)
+      ? StreamHeartbeat.fromPartial(object.heartbeat)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseStreamHeartbeat(): StreamHeartbeat {
+  return {};
+}
+
+export const StreamHeartbeat: MessageFns<StreamHeartbeat> = {
+  encode(_: StreamHeartbeat, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): StreamHeartbeat {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStreamHeartbeat();
+    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): StreamHeartbeat {
+    return {};
+  },
+
+  toJSON(_: StreamHeartbeat): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create(base?: DeepPartial<StreamHeartbeat>): StreamHeartbeat {
+    return StreamHeartbeat.fromPartial(base ?? {});
+  },
+  fromPartial(_: DeepPartial<StreamHeartbeat>): StreamHeartbeat {
+    const message = createBaseStreamHeartbeat();
+    return message;
+  },
+};
+
+function createBaseGetHeadRequest(): GetHeadRequest {
+  return {};
+}
+
+export const GetHeadRequest: MessageFns<GetHeadRequest> = {
+  encode(_: GetHeadRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetHeadRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetHeadRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): GetHeadRequest {
+    return {};
+  },
+
+  toJSON(_: GetHeadRequest): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetHeadRequest>): GetHeadRequest {
+    return GetHeadRequest.fromPartial(base ?? {});
+  },
+  fromPartial(_: DeepPartial<GetHeadRequest>): GetHeadRequest {
+    const message = createBaseGetHeadRequest();
+    return message;
+  },
+};
+
+function createBaseGetHeadResponse(): GetHeadResponse {
+  return { sequence: 0n };
+}
+
+export const GetHeadResponse: MessageFns<GetHeadResponse> = {
+  encode(message: GetHeadResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.sequence !== 0n) {
+      if (BigInt.asIntN(64, message.sequence) !== message.sequence) {
+        throw new globalThis.Error("value provided for field message.sequence of type int64 too large");
+      }
+      writer.uint32(8).int64(message.sequence);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetHeadResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetHeadResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.sequence = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetHeadResponse {
+    return { sequence: isSet(object.sequence) ? BigInt(object.sequence) : 0n };
+  },
+
+  toJSON(message: GetHeadResponse): unknown {
+    const obj: any = {};
+    if (message.sequence !== 0n) {
+      obj.sequence = message.sequence.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetHeadResponse>): GetHeadResponse {
+    return GetHeadResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetHeadResponse>): GetHeadResponse {
+    const message = createBaseGetHeadResponse();
+    message.sequence = object.sequence ?? 0n;
+    return message;
+  },
+};
+
+function createBaseGetTailRequest(): GetTailRequest {
+  return {};
+}
+
+export const GetTailRequest: MessageFns<GetTailRequest> = {
+  encode(_: GetTailRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetTailRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetTailRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(_: any): GetTailRequest {
+    return {};
+  },
+
+  toJSON(_: GetTailRequest): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetTailRequest>): GetTailRequest {
+    return GetTailRequest.fromPartial(base ?? {});
+  },
+  fromPartial(_: DeepPartial<GetTailRequest>): GetTailRequest {
+    const message = createBaseGetTailRequest();
+    return message;
+  },
+};
+
+function createBaseGetTailResponse(): GetTailResponse {
+  return { sequence: 0n };
+}
+
+export const GetTailResponse: MessageFns<GetTailResponse> = {
+  encode(message: GetTailResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.sequence !== 0n) {
+      if (BigInt.asIntN(64, message.sequence) !== message.sequence) {
+        throw new globalThis.Error("value provided for field message.sequence of type int64 too large");
+      }
+      writer.uint32(8).int64(message.sequence);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetTailResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetTailResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.sequence = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetTailResponse {
+    return { sequence: isSet(object.sequence) ? BigInt(object.sequence) : 0n };
+  },
+
+  toJSON(message: GetTailResponse): unknown {
+    const obj: any = {};
+    if (message.sequence !== 0n) {
+      obj.sequence = message.sequence.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetTailResponse>): GetTailResponse {
+    return GetTailResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetTailResponse>): GetTailResponse {
+    const message = createBaseGetTailResponse();
+    message.sequence = object.sequence ?? 0n;
+    return message;
+  },
+};
+
+function createBaseGetTagsRequest(): GetTagsRequest {
+  return { sequence: 0n };
+}
+
+export const GetTagsRequest: MessageFns<GetTagsRequest> = {
+  encode(message: GetTagsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.sequence !== 0n) {
+      if (BigInt.asIntN(64, message.sequence) !== message.sequence) {
+        throw new globalThis.Error("value provided for field message.sequence of type int64 too large");
+      }
+      writer.uint32(8).int64(message.sequence);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetTagsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetTagsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.sequence = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetTagsRequest {
+    return { sequence: isSet(object.sequence) ? BigInt(object.sequence) : 0n };
+  },
+
+  toJSON(message: GetTagsRequest): unknown {
+    const obj: any = {};
+    if (message.sequence !== 0n) {
+      obj.sequence = message.sequence.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetTagsRequest>): GetTagsRequest {
+    return GetTagsRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetTagsRequest>): GetTagsRequest {
+    const message = createBaseGetTagsRequest();
+    message.sequence = object.sequence ?? 0n;
+    return message;
+  },
+};
+
+function createBaseGetTagsResponse(): GetTagsResponse {
+  return { tags: [] };
+}
+
+export const GetTagsResponse: MessageFns<GetTagsResponse> = {
+  encode(message: GetTagsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.tags) {
+      Tag.encode(v!, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetTagsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetTagsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.tags.push(Tag.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetTagsResponse {
+    return { tags: globalThis.Array.isArray(object?.tags) ? object.tags.map((e: any) => Tag.fromJSON(e)) : [] };
+  },
+
+  toJSON(message: GetTagsResponse): unknown {
+    const obj: any = {};
+    if (message.tags?.length) {
+      obj.tags = message.tags.map((e) => Tag.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetTagsResponse>): GetTagsResponse {
+    return GetTagsResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetTagsResponse>): GetTagsResponse {
+    const message = createBaseGetTagsResponse();
+    message.tags = object.tags?.map((e) => Tag.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseGetSequenceAtRequest(): GetSequenceAtRequest {
+  return { timestamp: 0n };
+}
+
+export const GetSequenceAtRequest: MessageFns<GetSequenceAtRequest> = {
+  encode(message: GetSequenceAtRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.timestamp !== 0n) {
+      if (BigInt.asIntN(64, message.timestamp) !== message.timestamp) {
+        throw new globalThis.Error("value provided for field message.timestamp of type int64 too large");
+      }
+      writer.uint32(8).int64(message.timestamp);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetSequenceAtRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetSequenceAtRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.timestamp = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetSequenceAtRequest {
+    return { timestamp: isSet(object.timestamp) ? BigInt(object.timestamp) : 0n };
+  },
+
+  toJSON(message: GetSequenceAtRequest): unknown {
+    const obj: any = {};
+    if (message.timestamp !== 0n) {
+      obj.timestamp = message.timestamp.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetSequenceAtRequest>): GetSequenceAtRequest {
+    return GetSequenceAtRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetSequenceAtRequest>): GetSequenceAtRequest {
+    const message = createBaseGetSequenceAtRequest();
+    message.timestamp = object.timestamp ?? 0n;
+    return message;
+  },
+};
+
+function createBaseGetSequenceAtResponse(): GetSequenceAtResponse {
+  return { sequence: 0n };
+}
+
+export const GetSequenceAtResponse: MessageFns<GetSequenceAtResponse> = {
+  encode(message: GetSequenceAtResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.sequence !== 0n) {
+      if (BigInt.asIntN(64, message.sequence) !== message.sequence) {
+        throw new globalThis.Error("value provided for field message.sequence of type int64 too large");
+      }
+      writer.uint32(8).int64(message.sequence);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetSequenceAtResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetSequenceAtResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.sequence = reader.int64() as bigint;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetSequenceAtResponse {
+    return { sequence: isSet(object.sequence) ? BigInt(object.sequence) : 0n };
+  },
+
+  toJSON(message: GetSequenceAtResponse): unknown {
+    const obj: any = {};
+    if (message.sequence !== 0n) {
+      obj.sequence = message.sequence.toString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<GetSequenceAtResponse>): GetSequenceAtResponse {
+    return GetSequenceAtResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<GetSequenceAtResponse>): GetSequenceAtResponse {
+    const message = createBaseGetSequenceAtResponse();
+    message.sequence = object.sequence ?? 0n;
+    return message;
+  },
+};
+
+/** The Event Store service. */
+export type EventStoreDefinition = typeof EventStoreDefinition;
+export const EventStoreDefinition = {
+  name: "EventStore",
+  fullName: "kronosdb.eventstore.EventStore",
+  methods: {
+    /** Appends new events to the store. */
+    append: {
+      name: "Append",
+      requestType: AppendRequest as typeof AppendRequest,
+      requestStream: true,
+      responseType: AppendResponse as typeof AppendResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** Provides a finite stream of events matching the given criteria. */
+    source: {
+      name: "Source",
+      requestType: SourceRequest as typeof SourceRequest,
+      requestStream: false,
+      responseType: SourceResponse as typeof SourceResponse,
+      responseStream: true,
+      options: {},
+    },
+    /**
+     * Provides an infinite stream of events matching the given criteria.
+     * Stays open and pushes new events as they are appended.
+     * Bidirectional with permit-based flow control: the first client message
+     * carries the criteria and initial permits. Subsequent messages grant
+     * additional permits. The server only sends events when permits > 0.
+     */
+    stream: {
+      name: "Stream",
+      requestType: StreamControl as typeof StreamControl,
+      requestStream: true,
+      responseType: StreamResponse as typeof StreamResponse,
+      responseStream: true,
+      options: {},
+    },
+    /** Gets the current head of the event store (next position to be assigned). */
+    getHead: {
+      name: "GetHead",
+      requestType: GetHeadRequest as typeof GetHeadRequest,
+      requestStream: false,
+      responseType: GetHeadResponse as typeof GetHeadResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** Gets the current tail of the event store (first event position). */
+    getTail: {
+      name: "GetTail",
+      requestType: GetTailRequest as typeof GetTailRequest,
+      requestStream: false,
+      responseType: GetTailResponse as typeof GetTailResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** Gets tags for an event by its sequence position. */
+    getTags: {
+      name: "GetTags",
+      requestType: GetTagsRequest as typeof GetTagsRequest,
+      requestStream: false,
+      responseType: GetTagsResponse as typeof GetTagsResponse,
+      responseStream: false,
+      options: {},
+    },
+    /**
+     * Gets the sequence number of the first event at or after the given timestamp.
+     * Used by event processors to support time-based replay (e.g., Axon's tokenAt).
+     */
+    getSequenceAt: {
+      name: "GetSequenceAt",
+      requestType: GetSequenceAtRequest as typeof GetSequenceAtRequest,
+      requestStream: false,
+      responseType: GetSequenceAtResponse as typeof GetSequenceAtResponse,
+      responseStream: false,
+      options: {},
+    },
+  },
+} as const;
+
+export interface EventStoreServiceImplementation<CallContextExt = {}> {
+  /** Appends new events to the store. */
+  append(
+    request: AsyncIterable<AppendRequest>,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<AppendResponse>>;
+  /** Provides a finite stream of events matching the given criteria. */
+  source(
+    request: SourceRequest,
+    context: CallContext & CallContextExt,
+  ): ServerStreamingMethodResult<DeepPartial<SourceResponse>>;
+  /**
+   * Provides an infinite stream of events matching the given criteria.
+   * Stays open and pushes new events as they are appended.
+   * Bidirectional with permit-based flow control: the first client message
+   * carries the criteria and initial permits. Subsequent messages grant
+   * additional permits. The server only sends events when permits > 0.
+   */
+  stream(
+    request: AsyncIterable<StreamControl>,
+    context: CallContext & CallContextExt,
+  ): ServerStreamingMethodResult<DeepPartial<StreamResponse>>;
+  /** Gets the current head of the event store (next position to be assigned). */
+  getHead(request: GetHeadRequest, context: CallContext & CallContextExt): Promise<DeepPartial<GetHeadResponse>>;
+  /** Gets the current tail of the event store (first event position). */
+  getTail(request: GetTailRequest, context: CallContext & CallContextExt): Promise<DeepPartial<GetTailResponse>>;
+  /** Gets tags for an event by its sequence position. */
+  getTags(request: GetTagsRequest, context: CallContext & CallContextExt): Promise<DeepPartial<GetTagsResponse>>;
+  /**
+   * Gets the sequence number of the first event at or after the given timestamp.
+   * Used by event processors to support time-based replay (e.g., Axon's tokenAt).
+   */
+  getSequenceAt(
+    request: GetSequenceAtRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<GetSequenceAtResponse>>;
+}
+
+export interface EventStoreClient<CallOptionsExt = {}> {
+  /** Appends new events to the store. */
+  append(
+    request: AsyncIterable<DeepPartial<AppendRequest>>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<AppendResponse>;
+  /** Provides a finite stream of events matching the given criteria. */
+  source(request: DeepPartial<SourceRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<SourceResponse>;
+  /**
+   * Provides an infinite stream of events matching the given criteria.
+   * Stays open and pushes new events as they are appended.
+   * Bidirectional with permit-based flow control: the first client message
+   * carries the criteria and initial permits. Subsequent messages grant
+   * additional permits. The server only sends events when permits > 0.
+   */
+  stream(
+    request: AsyncIterable<DeepPartial<StreamControl>>,
+    options?: CallOptions & CallOptionsExt,
+  ): AsyncIterable<StreamResponse>;
+  /** Gets the current head of the event store (next position to be assigned). */
+  getHead(request: DeepPartial<GetHeadRequest>, options?: CallOptions & CallOptionsExt): Promise<GetHeadResponse>;
+  /** Gets the current tail of the event store (first event position). */
+  getTail(request: DeepPartial<GetTailRequest>, options?: CallOptions & CallOptionsExt): Promise<GetTailResponse>;
+  /** Gets tags for an event by its sequence position. */
+  getTags(request: DeepPartial<GetTagsRequest>, options?: CallOptions & CallOptionsExt): Promise<GetTagsResponse>;
+  /**
+   * Gets the sequence number of the first event at or after the given timestamp.
+   * Used by event processors to support time-based replay (e.g., Axon's tokenAt).
+   */
+  getSequenceAt(
+    request: DeepPartial<GetSequenceAtRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<GetSequenceAtResponse>;
+}
+
+function bytesFromBase64(b64: string): Uint8Array {
+  if ((globalThis as any).Buffer) {
+    return Uint8Array.from((globalThis as any).Buffer.from(b64, "base64"));
+  } else {
+    const bin = globalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+
+function base64FromBytes(arr: Uint8Array): string {
+  if ((globalThis as any).Buffer) {
+    return (globalThis as any).Buffer.from(arr).toString("base64");
+  } else {
+    const bin: string[] = [];
+    arr.forEach((byte) => {
+      bin.push(globalThis.String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
+  }
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+function isObject(value: any): boolean {
+  return typeof value === "object" && value !== null;
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+export type ServerStreamingMethodResult<Response> = { [Symbol.asyncIterator](): AsyncIterator<Response, void> };
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create(base?: DeepPartial<T>): T;
+  fromPartial(object: DeepPartial<T>): T;
+}