// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// versions:
//   protoc-gen-ts_proto  v2.12.4
//   protoc               v5.28.3
// source: readmodels.proto

/* eslint-disable */
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import type { CallContext, CallOptions } from "nice-grpc-common";
import { Empty } from "./google/protobuf/empty";
import { Guid } from "./protobuf-net/bcl";

export const protobufPackage = "Cratis.Chronicle.Contracts.ReadModels";

export enum ReadModelChangeType {
  Added = 0,
  Modified = 1,
  Removed = 2,
  UNRECOGNIZED = -1,
}

export function readModelChangeTypeFromJSON(object: any): ReadModelChangeType {
  switch (object) {
    case 0:
    case "Added":
      return ReadModelChangeType.Added;
    case 1:
    case "Modified":
      return ReadModelChangeType.Modified;
    case 2:
    case "Removed":
      return ReadModelChangeType.Removed;
    case -1:
    case "UNRECOGNIZED":
    default:
      return ReadModelChangeType.UNRECOGNIZED;
  }
}

export function readModelChangeTypeToJSON(object: ReadModelChangeType): string {
  switch (object) {
    case ReadModelChangeType.Added:
      return "Added";
    case ReadModelChangeType.Modified:
      return "Modified";
    case ReadModelChangeType.Removed:
      return "Removed";
    case ReadModelChangeType.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export enum ReadModelObserverType {
  NotSet = 0,
  Reducer = 1,
  Projection = 2,
  UNRECOGNIZED = -1,
}

export function readModelObserverTypeFromJSON(object: any): ReadModelObserverType {
  switch (object) {
    case 0:
    case "NotSet":
      return ReadModelObserverType.NotSet;
    case 1:
    case "Reducer":
      return ReadModelObserverType.Reducer;
    case 2:
    case "Projection":
      return ReadModelObserverType.Projection;
    case -1:
    case "UNRECOGNIZED":
    default:
      return ReadModelObserverType.UNRECOGNIZED;
  }
}

export function readModelObserverTypeToJSON(object: ReadModelObserverType): string {
  switch (object) {
    case ReadModelObserverType.NotSet:
      return "NotSet";
    case ReadModelObserverType.Reducer:
      return "Reducer";
    case ReadModelObserverType.Projection:
      return "Projection";
    case ReadModelObserverType.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export enum ReadModelOwner {
  None = 0,
  Client = 1,
  Server = 2,
  UNRECOGNIZED = -1,
}

export function readModelOwnerFromJSON(object: any): ReadModelOwner {
  switch (object) {
    case 0:
    case "None":
      return ReadModelOwner.None;
    case 1:
    case "Client":
      return ReadModelOwner.Client;
    case 2:
    case "Server":
      return ReadModelOwner.Server;
    case -1:
    case "UNRECOGNIZED":
    default:
      return ReadModelOwner.UNRECOGNIZED;
  }
}

export function readModelOwnerToJSON(object: ReadModelOwner): string {
  switch (object) {
    case ReadModelOwner.None:
      return "None";
    case ReadModelOwner.Client:
      return "Client";
    case ReadModelOwner.Server:
      return "Server";
    case ReadModelOwner.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export enum ReadModelSource {
  Unknown = 0,
  Code = 1,
  User = 2,
  UNRECOGNIZED = -1,
}

export function readModelSourceFromJSON(object: any): ReadModelSource {
  switch (object) {
    case 0:
    case "Unknown":
      return ReadModelSource.Unknown;
    case 1:
    case "Code":
      return ReadModelSource.Code;
    case 2:
    case "User":
      return ReadModelSource.User;
    case -1:
    case "UNRECOGNIZED":
    default:
      return ReadModelSource.UNRECOGNIZED;
  }
}

export function readModelSourceToJSON(object: ReadModelSource): string {
  switch (object) {
    case ReadModelSource.Unknown:
      return "Unknown";
    case ReadModelSource.Code:
      return "Code";
    case ReadModelSource.User:
      return "User";
    case ReadModelSource.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export interface DehydrateSessionRequest {
  EventStore: string;
  Namespace: string;
  ReadModelIdentifier: string;
  EventSequenceId: string;
  ReadModelKey: string;
  SessionId: string;
}

export interface GetAllInstancesRequest {
  EventStore: string;
  Namespace: string;
  ReadModelIdentifier: string;
  /** default value could not be applied: event-log */
  EventSequenceId: string;
  /** default value could not be applied: 18446744073709551615 */
  EventCount: bigint;
}

export interface GetAllInstancesResponse {
  Instances: string[];
  ProcessedEventsCount: bigint;
}

export interface GetDefinitionsRequest {
  EventStore: string;
}

export interface GetDefinitionsResponse {
  ReadModels: ReadModelDefinition[];
}

export interface GetInstanceByKeyRequest {
  EventStore: string;
  Namespace: string;
  ReadModelIdentifier: string;
  EventSequenceId: string;
  ReadModelKey: string;
  SessionId: string;
}

export interface GetInstanceByKeyResponse {
  ReadModel: string;
  ProjectedEventsCount: bigint;
  LastHandledEventSequenceNumber: bigint;
}

export interface GetInstancesRequest {
  EventStore: string;
  Namespace: string;
  ReadModel: string;
  Occurrence: string;
  Page: number;
  PageSize: number;
}

export interface GetInstancesResponse {
  Instances: string[];
  TotalCount: bigint;
  Page: number;
  PageSize: number;
}

export interface GetOccurrencesRequest {
  EventStore: string;
  Namespace: string;
  Type: ReadModelType | undefined;
}

export interface GetOccurrencesResponse {
  Occurrences: ReadModelOccurrence[];
}

export interface IndexDefinition {
  PropertyPath: string;
}

export interface ObserveInstancesRequest {
  EventStore: string;
  Namespace: string;
  ReadModel: string;
  Page: number;
  PageSize: number;
  Occurrence: string;
}

export interface ObserveInstancesResponse {
  Instances: string[];
  TotalCount: number;
  Page: number;
  PageSize: number;
}

export interface ReadModelChangeset {
  Namespace: string;
  ModelKey: string;
  ReadModel: string;
  Removed: boolean;
  Subscribed: boolean;
  ChangeType: ReadModelChangeType;
  EventSequenceNumber: bigint;
  Occurred:
    | SerializableDateTimeOffset
    | undefined;
  /** default value could not be applied: 00000000-0000-0000-0000-000000000000 */
  CorrelationId: Guid | undefined;
}

export interface ReadModelDefinition {
  Type: ReadModelType | undefined;
  ContainerName: string;
  DisplayName: string;
  Sink: SinkDefinition | undefined;
  Schema: string;
  Indexes: IndexDefinition[];
  ObserverType: ReadModelObserverType;
  ObserverIdentifier: string;
  Owner: ReadModelOwner;
  Source: ReadModelSource;
}

export interface ReadModelOccurrence {
  ObserverId: string;
  Occurred: SerializableDateTimeOffset | undefined;
  Type: ReadModelType | undefined;
  ContainerName: string;
  RevertContainerName: string;
}

export interface ReadModelType {
  Identifier: string;
  Generation: number;
}

export interface RegisterManyRequest {
  EventStore: string;
  Owner: ReadModelOwner;
  ReadModels: ReadModelDefinition[];
  /** default value could not be applied: Code */
  Source: ReadModelSource;
}

export interface RegisterSingleRequest {
  EventStore: string;
  Owner: ReadModelOwner;
  ReadModel:
    | ReadModelDefinition
    | undefined;
  /** default value could not be applied: Code */
  Source: ReadModelSource;
}

/** Represents a DateTimeOffset value as an ISO 8601 string (e.g., "2024-01-15T12:30:00.0000000+02:00"). */
export interface SerializableDateTimeOffset {
  Value: string;
}

export interface SinkDefinition {
  /** default value could not be applied: 00000000-0000-0000-0000-000000000000 */
  ConfigurationId: Guid | undefined;
  TypeId: string;
}

export interface UpdateDefinitionRequest {
  EventStore: string;
  ReadModel: ReadModelDefinition | undefined;
}

export interface WatchRequest {
  EventStore: string;
  Namespace: string;
  ReadModelIdentifier: string;
  EventSequenceId: string;
}

function createBaseDehydrateSessionRequest(): DehydrateSessionRequest {
  return {
    EventStore: "",
    Namespace: "",
    ReadModelIdentifier: "",
    EventSequenceId: "",
    ReadModelKey: "",
    SessionId: "",
  };
}

export const DehydrateSessionRequest: MessageFns<DehydrateSessionRequest> = {
  encode(message: DehydrateSessionRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    if (message.Namespace !== "") {
      writer.uint32(18).string(message.Namespace);
    }
    if (message.ReadModelIdentifier !== "") {
      writer.uint32(26).string(message.ReadModelIdentifier);
    }
    if (message.EventSequenceId !== "") {
      writer.uint32(34).string(message.EventSequenceId);
    }
    if (message.ReadModelKey !== "") {
      writer.uint32(42).string(message.ReadModelKey);
    }
    if (message.SessionId !== "") {
      writer.uint32(50).string(message.SessionId);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): DehydrateSessionRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseDehydrateSessionRequest();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.EventStore = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.Namespace = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.ReadModelIdentifier = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }

            message.EventSequenceId = reader.string();
            continue;
          }
          case 5: {
            if (tag !== 42) {
              break;
            }

            message.ReadModelKey = reader.string();
            continue;
          }
          case 6: {
            if (tag !== 50) {
              break;
            }

            message.SessionId = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): DehydrateSessionRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      ReadModelIdentifier: isSet(object.ReadModelIdentifier) ? globalThis.String(object.ReadModelIdentifier) : "",
      EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
      ReadModelKey: isSet(object.ReadModelKey) ? globalThis.String(object.ReadModelKey) : "",
      SessionId: isSet(object.SessionId) ? globalThis.String(object.SessionId) : "",
    };
  },

  toJSON(message: DehydrateSessionRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Namespace !== "") {
      obj.Namespace = message.Namespace;
    }
    if (message.ReadModelIdentifier !== "") {
      obj.ReadModelIdentifier = message.ReadModelIdentifier;
    }
    if (message.EventSequenceId !== "") {
      obj.EventSequenceId = message.EventSequenceId;
    }
    if (message.ReadModelKey !== "") {
      obj.ReadModelKey = message.ReadModelKey;
    }
    if (message.SessionId !== "") {
      obj.SessionId = message.SessionId;
    }
    return obj;
  },

  create(base?: DeepPartial<DehydrateSessionRequest>): DehydrateSessionRequest {
    return DehydrateSessionRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<DehydrateSessionRequest>): DehydrateSessionRequest {
    const message = createBaseDehydrateSessionRequest();
    message.EventStore = object.EventStore ?? "";
    message.Namespace = object.Namespace ?? "";
    message.ReadModelIdentifier = object.ReadModelIdentifier ?? "";
    message.EventSequenceId = object.EventSequenceId ?? "";
    message.ReadModelKey = object.ReadModelKey ?? "";
    message.SessionId = object.SessionId ?? "";
    return message;
  },
};

function createBaseGetAllInstancesRequest(): GetAllInstancesRequest {
  return { EventStore: "", Namespace: "", ReadModelIdentifier: "", EventSequenceId: "", EventCount: 0n };
}

export const GetAllInstancesRequest: MessageFns<GetAllInstancesRequest> = {
  encode(message: GetAllInstancesRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    if (message.Namespace !== "") {
      writer.uint32(18).string(message.Namespace);
    }
    if (message.ReadModelIdentifier !== "") {
      writer.uint32(26).string(message.ReadModelIdentifier);
    }
    if (message.EventSequenceId !== "") {
      writer.uint32(34).string(message.EventSequenceId);
    }
    if (message.EventCount !== 0n) {
      if (BigInt.asUintN(64, message.EventCount) !== message.EventCount) {
        throw new globalThis.Error("value provided for field message.EventCount of type uint64 too large");
      }
      writer.uint32(40).uint64(message.EventCount);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): GetAllInstancesRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseGetAllInstancesRequest();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.EventStore = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.Namespace = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.ReadModelIdentifier = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }

            message.EventSequenceId = reader.string();
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }

            message.EventCount = reader.uint64() as bigint;
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): GetAllInstancesRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      ReadModelIdentifier: isSet(object.ReadModelIdentifier) ? globalThis.String(object.ReadModelIdentifier) : "",
      EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
      EventCount: isSet(object.EventCount) ? BigInt(object.EventCount) : 0n,
    };
  },

  toJSON(message: GetAllInstancesRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Namespace !== "") {
      obj.Namespace = message.Namespace;
    }
    if (message.ReadModelIdentifier !== "") {
      obj.ReadModelIdentifier = message.ReadModelIdentifier;
    }
    if (message.EventSequenceId !== "") {
      obj.EventSequenceId = message.EventSequenceId;
    }
    if (message.EventCount !== 0n) {
      obj.EventCount = message.EventCount.toString();
    }
    return obj;
  },

  create(base?: DeepPartial<GetAllInstancesRequest>): GetAllInstancesRequest {
    return GetAllInstancesRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<GetAllInstancesRequest>): GetAllInstancesRequest {
    const message = createBaseGetAllInstancesRequest();
    message.EventStore = object.EventStore ?? "";
    message.Namespace = object.Namespace ?? "";
    message.ReadModelIdentifier = object.ReadModelIdentifier ?? "";
    message.EventSequenceId = object.EventSequenceId ?? "";
    message.EventCount = (object.EventCount !== undefined && object.EventCount !== null)
      ? BigInt(object.EventCount)
      : 0n;
    return message;
  },
};

function createBaseGetAllInstancesResponse(): GetAllInstancesResponse {
  return { Instances: [], ProcessedEventsCount: 0n };
}

export const GetAllInstancesResponse: MessageFns<GetAllInstancesResponse> = {
  encode(message: GetAllInstancesResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.Instances) {
      writer.uint32(10).string(v!);
    }
    if (message.ProcessedEventsCount !== 0n) {
      if (BigInt.asUintN(64, message.ProcessedEventsCount) !== message.ProcessedEventsCount) {
        throw new globalThis.Error("value provided for field message.ProcessedEventsCount of type uint64 too large");
      }
      writer.uint32(16).uint64(message.ProcessedEventsCount);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): GetAllInstancesResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseGetAllInstancesResponse();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.Instances.push(reader.string());
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }

            message.ProcessedEventsCount = reader.uint64() as bigint;
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): GetAllInstancesResponse {
    return {
      Instances: globalThis.Array.isArray(object?.Instances)
        ? object.Instances.map((e: any) => globalThis.String(e))
        : [],
      ProcessedEventsCount: isSet(object.ProcessedEventsCount) ? BigInt(object.ProcessedEventsCount) : 0n,
    };
  },

  toJSON(message: GetAllInstancesResponse): unknown {
    const obj: any = {};
    if (message.Instances?.length) {
      obj.Instances = message.Instances;
    }
    if (message.ProcessedEventsCount !== 0n) {
      obj.ProcessedEventsCount = message.ProcessedEventsCount.toString();
    }
    return obj;
  },

  create(base?: DeepPartial<GetAllInstancesResponse>): GetAllInstancesResponse {
    return GetAllInstancesResponse.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<GetAllInstancesResponse>): GetAllInstancesResponse {
    const message = createBaseGetAllInstancesResponse();
    message.Instances = object.Instances?.map((e) => e) || [];
    message.ProcessedEventsCount = (object.ProcessedEventsCount !== undefined && object.ProcessedEventsCount !== null)
      ? BigInt(object.ProcessedEventsCount)
      : 0n;
    return message;
  },
};

function createBaseGetDefinitionsRequest(): GetDefinitionsRequest {
  return { EventStore: "" };
}

export const GetDefinitionsRequest: MessageFns<GetDefinitionsRequest> = {
  encode(message: GetDefinitionsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): GetDefinitionsRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseGetDefinitionsRequest();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.EventStore = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): GetDefinitionsRequest {
    return { EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "" };
  },

  toJSON(message: GetDefinitionsRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    return obj;
  },

  create(base?: DeepPartial<GetDefinitionsRequest>): GetDefinitionsRequest {
    return GetDefinitionsRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<GetDefinitionsRequest>): GetDefinitionsRequest {
    const message = createBaseGetDefinitionsRequest();
    message.EventStore = object.EventStore ?? "";
    return message;
  },
};

function createBaseGetDefinitionsResponse(): GetDefinitionsResponse {
  return { ReadModels: [] };
}

export const GetDefinitionsResponse: MessageFns<GetDefinitionsResponse> = {
  encode(message: GetDefinitionsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.ReadModels) {
      ReadModelDefinition.encode(v!, writer.uint32(10).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): GetDefinitionsResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseGetDefinitionsResponse();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.ReadModels.push(ReadModelDefinition.decode(reader, reader.uint32()));
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): GetDefinitionsResponse {
    return {
      ReadModels: globalThis.Array.isArray(object?.ReadModels)
        ? object.ReadModels.map((e: any) => ReadModelDefinition.fromJSON(e))
        : [],
    };
  },

  toJSON(message: GetDefinitionsResponse): unknown {
    const obj: any = {};
    if (message.ReadModels?.length) {
      obj.ReadModels = message.ReadModels.map((e) => ReadModelDefinition.toJSON(e));
    }
    return obj;
  },

  create(base?: DeepPartial<GetDefinitionsResponse>): GetDefinitionsResponse {
    return GetDefinitionsResponse.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<GetDefinitionsResponse>): GetDefinitionsResponse {
    const message = createBaseGetDefinitionsResponse();
    message.ReadModels = object.ReadModels?.map((e) => ReadModelDefinition.fromPartial(e)) || [];
    return message;
  },
};

function createBaseGetInstanceByKeyRequest(): GetInstanceByKeyRequest {
  return {
    EventStore: "",
    Namespace: "",
    ReadModelIdentifier: "",
    EventSequenceId: "",
    ReadModelKey: "",
    SessionId: "",
  };
}

export const GetInstanceByKeyRequest: MessageFns<GetInstanceByKeyRequest> = {
  encode(message: GetInstanceByKeyRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    if (message.Namespace !== "") {
      writer.uint32(18).string(message.Namespace);
    }
    if (message.ReadModelIdentifier !== "") {
      writer.uint32(26).string(message.ReadModelIdentifier);
    }
    if (message.EventSequenceId !== "") {
      writer.uint32(34).string(message.EventSequenceId);
    }
    if (message.ReadModelKey !== "") {
      writer.uint32(42).string(message.ReadModelKey);
    }
    if (message.SessionId !== "") {
      writer.uint32(50).string(message.SessionId);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): GetInstanceByKeyRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseGetInstanceByKeyRequest();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.EventStore = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.Namespace = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.ReadModelIdentifier = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }

            message.EventSequenceId = reader.string();
            continue;
          }
          case 5: {
            if (tag !== 42) {
              break;
            }

            message.ReadModelKey = reader.string();
            continue;
          }
          case 6: {
            if (tag !== 50) {
              break;
            }

            message.SessionId = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): GetInstanceByKeyRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      ReadModelIdentifier: isSet(object.ReadModelIdentifier) ? globalThis.String(object.ReadModelIdentifier) : "",
      EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
      ReadModelKey: isSet(object.ReadModelKey) ? globalThis.String(object.ReadModelKey) : "",
      SessionId: isSet(object.SessionId) ? globalThis.String(object.SessionId) : "",
    };
  },

  toJSON(message: GetInstanceByKeyRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Namespace !== "") {
      obj.Namespace = message.Namespace;
    }
    if (message.ReadModelIdentifier !== "") {
      obj.ReadModelIdentifier = message.ReadModelIdentifier;
    }
    if (message.EventSequenceId !== "") {
      obj.EventSequenceId = message.EventSequenceId;
    }
    if (message.ReadModelKey !== "") {
      obj.ReadModelKey = message.ReadModelKey;
    }
    if (message.SessionId !== "") {
      obj.SessionId = message.SessionId;
    }
    return obj;
  },

  create(base?: DeepPartial<GetInstanceByKeyRequest>): GetInstanceByKeyRequest {
    return GetInstanceByKeyRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<GetInstanceByKeyRequest>): GetInstanceByKeyRequest {
    const message = createBaseGetInstanceByKeyRequest();
    message.EventStore = object.EventStore ?? "";
    message.Namespace = object.Namespace ?? "";
    message.ReadModelIdentifier = object.ReadModelIdentifier ?? "";
    message.EventSequenceId = object.EventSequenceId ?? "";
    message.ReadModelKey = object.ReadModelKey ?? "";
    message.SessionId = object.SessionId ?? "";
    return message;
  },
};

function createBaseGetInstanceByKeyResponse(): GetInstanceByKeyResponse {
  return { ReadModel: "", ProjectedEventsCount: 0n, LastHandledEventSequenceNumber: 0n };
}

export const GetInstanceByKeyResponse: MessageFns<GetInstanceByKeyResponse> = {
  encode(message: GetInstanceByKeyResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.ReadModel !== "") {
      writer.uint32(10).string(message.ReadModel);
    }
    if (message.ProjectedEventsCount !== 0n) {
      if (BigInt.asUintN(64, message.ProjectedEventsCount) !== message.ProjectedEventsCount) {
        throw new globalThis.Error("value provided for field message.ProjectedEventsCount of type uint64 too large");
      }
      writer.uint32(16).uint64(message.ProjectedEventsCount);
    }
    if (message.LastHandledEventSequenceNumber !== 0n) {
      if (BigInt.asUintN(64, message.LastHandledEventSequenceNumber) !== message.LastHandledEventSequenceNumber) {
        throw new globalThis.Error(
          "value provided for field message.LastHandledEventSequenceNumber of type uint64 too large",
        );
      }
      writer.uint32(24).uint64(message.LastHandledEventSequenceNumber);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): GetInstanceByKeyResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseGetInstanceByKeyResponse();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.ReadModel = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }

            message.ProjectedEventsCount = reader.uint64() as bigint;
            continue;
          }
          case 3: {
            if (tag !== 24) {
              break;
            }

            message.LastHandledEventSequenceNumber = reader.uint64() as bigint;
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): GetInstanceByKeyResponse {
    return {
      ReadModel: isSet(object.ReadModel) ? globalThis.String(object.ReadModel) : "",
      ProjectedEventsCount: isSet(object.ProjectedEventsCount) ? BigInt(object.ProjectedEventsCount) : 0n,
      LastHandledEventSequenceNumber: isSet(object.LastHandledEventSequenceNumber)
        ? BigInt(object.LastHandledEventSequenceNumber)
        : 0n,
    };
  },

  toJSON(message: GetInstanceByKeyResponse): unknown {
    const obj: any = {};
    if (message.ReadModel !== "") {
      obj.ReadModel = message.ReadModel;
    }
    if (message.ProjectedEventsCount !== 0n) {
      obj.ProjectedEventsCount = message.ProjectedEventsCount.toString();
    }
    if (message.LastHandledEventSequenceNumber !== 0n) {
      obj.LastHandledEventSequenceNumber = message.LastHandledEventSequenceNumber.toString();
    }
    return obj;
  },

  create(base?: DeepPartial<GetInstanceByKeyResponse>): GetInstanceByKeyResponse {
    return GetInstanceByKeyResponse.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<GetInstanceByKeyResponse>): GetInstanceByKeyResponse {
    const message = createBaseGetInstanceByKeyResponse();
    message.ReadModel = object.ReadModel ?? "";
    message.ProjectedEventsCount = (object.ProjectedEventsCount !== undefined && object.ProjectedEventsCount !== null)
      ? BigInt(object.ProjectedEventsCount)
      : 0n;
    message.LastHandledEventSequenceNumber =
      (object.LastHandledEventSequenceNumber !== undefined && object.LastHandledEventSequenceNumber !== null)
        ? BigInt(object.LastHandledEventSequenceNumber)
        : 0n;
    return message;
  },
};

function createBaseGetInstancesRequest(): GetInstancesRequest {
  return { EventStore: "", Namespace: "", ReadModel: "", Occurrence: "", Page: 0, PageSize: 0 };
}

export const GetInstancesRequest: MessageFns<GetInstancesRequest> = {
  encode(message: GetInstancesRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    if (message.Namespace !== "") {
      writer.uint32(18).string(message.Namespace);
    }
    if (message.ReadModel !== "") {
      writer.uint32(26).string(message.ReadModel);
    }
    if (message.Occurrence !== "") {
      writer.uint32(34).string(message.Occurrence);
    }
    if (message.Page !== 0) {
      writer.uint32(40).int32(message.Page);
    }
    if (message.PageSize !== 0) {
      writer.uint32(48).int32(message.PageSize);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): GetInstancesRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseGetInstancesRequest();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.EventStore = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.Namespace = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.ReadModel = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }

            message.Occurrence = reader.string();
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }

            message.Page = reader.int32();
            continue;
          }
          case 6: {
            if (tag !== 48) {
              break;
            }

            message.PageSize = reader.int32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): GetInstancesRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      ReadModel: isSet(object.ReadModel) ? globalThis.String(object.ReadModel) : "",
      Occurrence: isSet(object.Occurrence) ? globalThis.String(object.Occurrence) : "",
      Page: isSet(object.Page) ? globalThis.Number(object.Page) : 0,
      PageSize: isSet(object.PageSize) ? globalThis.Number(object.PageSize) : 0,
    };
  },

  toJSON(message: GetInstancesRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Namespace !== "") {
      obj.Namespace = message.Namespace;
    }
    if (message.ReadModel !== "") {
      obj.ReadModel = message.ReadModel;
    }
    if (message.Occurrence !== "") {
      obj.Occurrence = message.Occurrence;
    }
    if (message.Page !== 0) {
      obj.Page = Math.round(message.Page);
    }
    if (message.PageSize !== 0) {
      obj.PageSize = Math.round(message.PageSize);
    }
    return obj;
  },

  create(base?: DeepPartial<GetInstancesRequest>): GetInstancesRequest {
    return GetInstancesRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<GetInstancesRequest>): GetInstancesRequest {
    const message = createBaseGetInstancesRequest();
    message.EventStore = object.EventStore ?? "";
    message.Namespace = object.Namespace ?? "";
    message.ReadModel = object.ReadModel ?? "";
    message.Occurrence = object.Occurrence ?? "";
    message.Page = object.Page ?? 0;
    message.PageSize = object.PageSize ?? 0;
    return message;
  },
};

function createBaseGetInstancesResponse(): GetInstancesResponse {
  return { Instances: [], TotalCount: 0n, Page: 0, PageSize: 0 };
}

export const GetInstancesResponse: MessageFns<GetInstancesResponse> = {
  encode(message: GetInstancesResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.Instances) {
      writer.uint32(10).string(v!);
    }
    if (message.TotalCount !== 0n) {
      if (BigInt.asIntN(64, message.TotalCount) !== message.TotalCount) {
        throw new globalThis.Error("value provided for field message.TotalCount of type int64 too large");
      }
      writer.uint32(16).int64(message.TotalCount);
    }
    if (message.Page !== 0) {
      writer.uint32(24).int32(message.Page);
    }
    if (message.PageSize !== 0) {
      writer.uint32(32).int32(message.PageSize);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): GetInstancesResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseGetInstancesResponse();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.Instances.push(reader.string());
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }

            message.TotalCount = reader.int64() as bigint;
            continue;
          }
          case 3: {
            if (tag !== 24) {
              break;
            }

            message.Page = reader.int32();
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }

            message.PageSize = reader.int32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): GetInstancesResponse {
    return {
      Instances: globalThis.Array.isArray(object?.Instances)
        ? object.Instances.map((e: any) => globalThis.String(e))
        : [],
      TotalCount: isSet(object.TotalCount) ? BigInt(object.TotalCount) : 0n,
      Page: isSet(object.Page) ? globalThis.Number(object.Page) : 0,
      PageSize: isSet(object.PageSize) ? globalThis.Number(object.PageSize) : 0,
    };
  },

  toJSON(message: GetInstancesResponse): unknown {
    const obj: any = {};
    if (message.Instances?.length) {
      obj.Instances = message.Instances;
    }
    if (message.TotalCount !== 0n) {
      obj.TotalCount = message.TotalCount.toString();
    }
    if (message.Page !== 0) {
      obj.Page = Math.round(message.Page);
    }
    if (message.PageSize !== 0) {
      obj.PageSize = Math.round(message.PageSize);
    }
    return obj;
  },

  create(base?: DeepPartial<GetInstancesResponse>): GetInstancesResponse {
    return GetInstancesResponse.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<GetInstancesResponse>): GetInstancesResponse {
    const message = createBaseGetInstancesResponse();
    message.Instances = object.Instances?.map((e) => e) || [];
    message.TotalCount = (object.TotalCount !== undefined && object.TotalCount !== null)
      ? BigInt(object.TotalCount)
      : 0n;
    message.Page = object.Page ?? 0;
    message.PageSize = object.PageSize ?? 0;
    return message;
  },
};

function createBaseGetOccurrencesRequest(): GetOccurrencesRequest {
  return { EventStore: "", Namespace: "", Type: undefined };
}

export const GetOccurrencesRequest: MessageFns<GetOccurrencesRequest> = {
  encode(message: GetOccurrencesRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    if (message.Namespace !== "") {
      writer.uint32(18).string(message.Namespace);
    }
    if (message.Type !== undefined) {
      ReadModelType.encode(message.Type, writer.uint32(26).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): GetOccurrencesRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseGetOccurrencesRequest();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.EventStore = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.Namespace = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.Type = ReadModelType.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): GetOccurrencesRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      Type: isSet(object.Type) ? ReadModelType.fromJSON(object.Type) : undefined,
    };
  },

  toJSON(message: GetOccurrencesRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Namespace !== "") {
      obj.Namespace = message.Namespace;
    }
    if (message.Type !== undefined) {
      obj.Type = ReadModelType.toJSON(message.Type);
    }
    return obj;
  },

  create(base?: DeepPartial<GetOccurrencesRequest>): GetOccurrencesRequest {
    return GetOccurrencesRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<GetOccurrencesRequest>): GetOccurrencesRequest {
    const message = createBaseGetOccurrencesRequest();
    message.EventStore = object.EventStore ?? "";
    message.Namespace = object.Namespace ?? "";
    message.Type = (object.Type !== undefined && object.Type !== null)
      ? ReadModelType.fromPartial(object.Type)
      : undefined;
    return message;
  },
};

function createBaseGetOccurrencesResponse(): GetOccurrencesResponse {
  return { Occurrences: [] };
}

export const GetOccurrencesResponse: MessageFns<GetOccurrencesResponse> = {
  encode(message: GetOccurrencesResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.Occurrences) {
      ReadModelOccurrence.encode(v!, writer.uint32(10).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): GetOccurrencesResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseGetOccurrencesResponse();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.Occurrences.push(ReadModelOccurrence.decode(reader, reader.uint32()));
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): GetOccurrencesResponse {
    return {
      Occurrences: globalThis.Array.isArray(object?.Occurrences)
        ? object.Occurrences.map((e: any) => ReadModelOccurrence.fromJSON(e))
        : [],
    };
  },

  toJSON(message: GetOccurrencesResponse): unknown {
    const obj: any = {};
    if (message.Occurrences?.length) {
      obj.Occurrences = message.Occurrences.map((e) => ReadModelOccurrence.toJSON(e));
    }
    return obj;
  },

  create(base?: DeepPartial<GetOccurrencesResponse>): GetOccurrencesResponse {
    return GetOccurrencesResponse.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<GetOccurrencesResponse>): GetOccurrencesResponse {
    const message = createBaseGetOccurrencesResponse();
    message.Occurrences = object.Occurrences?.map((e) => ReadModelOccurrence.fromPartial(e)) || [];
    return message;
  },
};

function createBaseIndexDefinition(): IndexDefinition {
  return { PropertyPath: "" };
}

export const IndexDefinition: MessageFns<IndexDefinition> = {
  encode(message: IndexDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.PropertyPath !== "") {
      writer.uint32(10).string(message.PropertyPath);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): IndexDefinition {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseIndexDefinition();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.PropertyPath = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): IndexDefinition {
    return { PropertyPath: isSet(object.PropertyPath) ? globalThis.String(object.PropertyPath) : "" };
  },

  toJSON(message: IndexDefinition): unknown {
    const obj: any = {};
    if (message.PropertyPath !== "") {
      obj.PropertyPath = message.PropertyPath;
    }
    return obj;
  },

  create(base?: DeepPartial<IndexDefinition>): IndexDefinition {
    return IndexDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<IndexDefinition>): IndexDefinition {
    const message = createBaseIndexDefinition();
    message.PropertyPath = object.PropertyPath ?? "";
    return message;
  },
};

function createBaseObserveInstancesRequest(): ObserveInstancesRequest {
  return { EventStore: "", Namespace: "", ReadModel: "", Page: 0, PageSize: 0, Occurrence: "" };
}

export const ObserveInstancesRequest: MessageFns<ObserveInstancesRequest> = {
  encode(message: ObserveInstancesRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    if (message.Namespace !== "") {
      writer.uint32(18).string(message.Namespace);
    }
    if (message.ReadModel !== "") {
      writer.uint32(26).string(message.ReadModel);
    }
    if (message.Page !== 0) {
      writer.uint32(32).int32(message.Page);
    }
    if (message.PageSize !== 0) {
      writer.uint32(40).int32(message.PageSize);
    }
    if (message.Occurrence !== "") {
      writer.uint32(50).string(message.Occurrence);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ObserveInstancesRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseObserveInstancesRequest();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.EventStore = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.Namespace = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.ReadModel = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }

            message.Page = reader.int32();
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }

            message.PageSize = reader.int32();
            continue;
          }
          case 6: {
            if (tag !== 50) {
              break;
            }

            message.Occurrence = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): ObserveInstancesRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      ReadModel: isSet(object.ReadModel) ? globalThis.String(object.ReadModel) : "",
      Page: isSet(object.Page) ? globalThis.Number(object.Page) : 0,
      PageSize: isSet(object.PageSize) ? globalThis.Number(object.PageSize) : 0,
      Occurrence: isSet(object.Occurrence) ? globalThis.String(object.Occurrence) : "",
    };
  },

  toJSON(message: ObserveInstancesRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Namespace !== "") {
      obj.Namespace = message.Namespace;
    }
    if (message.ReadModel !== "") {
      obj.ReadModel = message.ReadModel;
    }
    if (message.Page !== 0) {
      obj.Page = Math.round(message.Page);
    }
    if (message.PageSize !== 0) {
      obj.PageSize = Math.round(message.PageSize);
    }
    if (message.Occurrence !== "") {
      obj.Occurrence = message.Occurrence;
    }
    return obj;
  },

  create(base?: DeepPartial<ObserveInstancesRequest>): ObserveInstancesRequest {
    return ObserveInstancesRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ObserveInstancesRequest>): ObserveInstancesRequest {
    const message = createBaseObserveInstancesRequest();
    message.EventStore = object.EventStore ?? "";
    message.Namespace = object.Namespace ?? "";
    message.ReadModel = object.ReadModel ?? "";
    message.Page = object.Page ?? 0;
    message.PageSize = object.PageSize ?? 0;
    message.Occurrence = object.Occurrence ?? "";
    return message;
  },
};

function createBaseObserveInstancesResponse(): ObserveInstancesResponse {
  return { Instances: [], TotalCount: 0, Page: 0, PageSize: 0 };
}

export const ObserveInstancesResponse: MessageFns<ObserveInstancesResponse> = {
  encode(message: ObserveInstancesResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.Instances) {
      writer.uint32(10).string(v!);
    }
    if (message.TotalCount !== 0) {
      writer.uint32(16).int32(message.TotalCount);
    }
    if (message.Page !== 0) {
      writer.uint32(24).int32(message.Page);
    }
    if (message.PageSize !== 0) {
      writer.uint32(32).int32(message.PageSize);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ObserveInstancesResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseObserveInstancesResponse();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.Instances.push(reader.string());
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }

            message.TotalCount = reader.int32();
            continue;
          }
          case 3: {
            if (tag !== 24) {
              break;
            }

            message.Page = reader.int32();
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }

            message.PageSize = reader.int32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): ObserveInstancesResponse {
    return {
      Instances: globalThis.Array.isArray(object?.Instances)
        ? object.Instances.map((e: any) => globalThis.String(e))
        : [],
      TotalCount: isSet(object.TotalCount) ? globalThis.Number(object.TotalCount) : 0,
      Page: isSet(object.Page) ? globalThis.Number(object.Page) : 0,
      PageSize: isSet(object.PageSize) ? globalThis.Number(object.PageSize) : 0,
    };
  },

  toJSON(message: ObserveInstancesResponse): unknown {
    const obj: any = {};
    if (message.Instances?.length) {
      obj.Instances = message.Instances;
    }
    if (message.TotalCount !== 0) {
      obj.TotalCount = Math.round(message.TotalCount);
    }
    if (message.Page !== 0) {
      obj.Page = Math.round(message.Page);
    }
    if (message.PageSize !== 0) {
      obj.PageSize = Math.round(message.PageSize);
    }
    return obj;
  },

  create(base?: DeepPartial<ObserveInstancesResponse>): ObserveInstancesResponse {
    return ObserveInstancesResponse.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ObserveInstancesResponse>): ObserveInstancesResponse {
    const message = createBaseObserveInstancesResponse();
    message.Instances = object.Instances?.map((e) => e) || [];
    message.TotalCount = object.TotalCount ?? 0;
    message.Page = object.Page ?? 0;
    message.PageSize = object.PageSize ?? 0;
    return message;
  },
};

function createBaseReadModelChangeset(): ReadModelChangeset {
  return {
    Namespace: "",
    ModelKey: "",
    ReadModel: "",
    Removed: false,
    Subscribed: false,
    ChangeType: 0,
    EventSequenceNumber: 0n,
    Occurred: undefined,
    CorrelationId: undefined,
  };
}

export const ReadModelChangeset: MessageFns<ReadModelChangeset> = {
  encode(message: ReadModelChangeset, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Namespace !== "") {
      writer.uint32(10).string(message.Namespace);
    }
    if (message.ModelKey !== "") {
      writer.uint32(18).string(message.ModelKey);
    }
    if (message.ReadModel !== "") {
      writer.uint32(26).string(message.ReadModel);
    }
    if (message.Removed !== false) {
      writer.uint32(32).bool(message.Removed);
    }
    if (message.Subscribed !== false) {
      writer.uint32(40).bool(message.Subscribed);
    }
    if (message.ChangeType !== 0) {
      writer.uint32(48).int32(message.ChangeType);
    }
    if (message.EventSequenceNumber !== 0n) {
      if (BigInt.asUintN(64, message.EventSequenceNumber) !== message.EventSequenceNumber) {
        throw new globalThis.Error("value provided for field message.EventSequenceNumber of type uint64 too large");
      }
      writer.uint32(56).uint64(message.EventSequenceNumber);
    }
    if (message.Occurred !== undefined) {
      SerializableDateTimeOffset.encode(message.Occurred, writer.uint32(66).fork()).join();
    }
    if (message.CorrelationId !== undefined) {
      Guid.encode(message.CorrelationId, writer.uint32(74).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ReadModelChangeset {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseReadModelChangeset();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.Namespace = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.ModelKey = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.ReadModel = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }

            message.Removed = reader.bool();
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }

            message.Subscribed = reader.bool();
            continue;
          }
          case 6: {
            if (tag !== 48) {
              break;
            }

            message.ChangeType = reader.int32() as any;
            continue;
          }
          case 7: {
            if (tag !== 56) {
              break;
            }

            message.EventSequenceNumber = reader.uint64() as bigint;
            continue;
          }
          case 8: {
            if (tag !== 66) {
              break;
            }

            message.Occurred = SerializableDateTimeOffset.decode(reader, reader.uint32());
            continue;
          }
          case 9: {
            if (tag !== 74) {
              break;
            }

            message.CorrelationId = Guid.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): ReadModelChangeset {
    return {
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      ModelKey: isSet(object.ModelKey) ? globalThis.String(object.ModelKey) : "",
      ReadModel: isSet(object.ReadModel) ? globalThis.String(object.ReadModel) : "",
      Removed: isSet(object.Removed) ? globalThis.Boolean(object.Removed) : false,
      Subscribed: isSet(object.Subscribed) ? globalThis.Boolean(object.Subscribed) : false,
      ChangeType: isSet(object.ChangeType) ? readModelChangeTypeFromJSON(object.ChangeType) : 0,
      EventSequenceNumber: isSet(object.EventSequenceNumber) ? BigInt(object.EventSequenceNumber) : 0n,
      Occurred: isSet(object.Occurred) ? SerializableDateTimeOffset.fromJSON(object.Occurred) : undefined,
      CorrelationId: isSet(object.CorrelationId) ? Guid.fromJSON(object.CorrelationId) : undefined,
    };
  },

  toJSON(message: ReadModelChangeset): unknown {
    const obj: any = {};
    if (message.Namespace !== "") {
      obj.Namespace = message.Namespace;
    }
    if (message.ModelKey !== "") {
      obj.ModelKey = message.ModelKey;
    }
    if (message.ReadModel !== "") {
      obj.ReadModel = message.ReadModel;
    }
    if (message.Removed !== false) {
      obj.Removed = message.Removed;
    }
    if (message.Subscribed !== false) {
      obj.Subscribed = message.Subscribed;
    }
    if (message.ChangeType !== 0) {
      obj.ChangeType = readModelChangeTypeToJSON(message.ChangeType);
    }
    if (message.EventSequenceNumber !== 0n) {
      obj.EventSequenceNumber = message.EventSequenceNumber.toString();
    }
    if (message.Occurred !== undefined) {
      obj.Occurred = SerializableDateTimeOffset.toJSON(message.Occurred);
    }
    if (message.CorrelationId !== undefined) {
      obj.CorrelationId = Guid.toJSON(message.CorrelationId);
    }
    return obj;
  },

  create(base?: DeepPartial<ReadModelChangeset>): ReadModelChangeset {
    return ReadModelChangeset.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ReadModelChangeset>): ReadModelChangeset {
    const message = createBaseReadModelChangeset();
    message.Namespace = object.Namespace ?? "";
    message.ModelKey = object.ModelKey ?? "";
    message.ReadModel = object.ReadModel ?? "";
    message.Removed = object.Removed ?? false;
    message.Subscribed = object.Subscribed ?? false;
    message.ChangeType = object.ChangeType ?? 0;
    message.EventSequenceNumber = (object.EventSequenceNumber !== undefined && object.EventSequenceNumber !== null)
      ? BigInt(object.EventSequenceNumber)
      : 0n;
    message.Occurred = (object.Occurred !== undefined && object.Occurred !== null)
      ? SerializableDateTimeOffset.fromPartial(object.Occurred)
      : undefined;
    message.CorrelationId = (object.CorrelationId !== undefined && object.CorrelationId !== null)
      ? Guid.fromPartial(object.CorrelationId)
      : undefined;
    return message;
  },
};

function createBaseReadModelDefinition(): ReadModelDefinition {
  return {
    Type: undefined,
    ContainerName: "",
    DisplayName: "",
    Sink: undefined,
    Schema: "",
    Indexes: [],
    ObserverType: 0,
    ObserverIdentifier: "",
    Owner: 0,
    Source: 0,
  };
}

export const ReadModelDefinition: MessageFns<ReadModelDefinition> = {
  encode(message: ReadModelDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Type !== undefined) {
      ReadModelType.encode(message.Type, writer.uint32(10).fork()).join();
    }
    if (message.ContainerName !== "") {
      writer.uint32(18).string(message.ContainerName);
    }
    if (message.DisplayName !== "") {
      writer.uint32(26).string(message.DisplayName);
    }
    if (message.Sink !== undefined) {
      SinkDefinition.encode(message.Sink, writer.uint32(34).fork()).join();
    }
    if (message.Schema !== "") {
      writer.uint32(42).string(message.Schema);
    }
    for (const v of message.Indexes) {
      IndexDefinition.encode(v!, writer.uint32(50).fork()).join();
    }
    if (message.ObserverType !== 0) {
      writer.uint32(56).int32(message.ObserverType);
    }
    if (message.ObserverIdentifier !== "") {
      writer.uint32(66).string(message.ObserverIdentifier);
    }
    if (message.Owner !== 0) {
      writer.uint32(72).int32(message.Owner);
    }
    if (message.Source !== 0) {
      writer.uint32(80).int32(message.Source);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ReadModelDefinition {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseReadModelDefinition();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.Type = ReadModelType.decode(reader, reader.uint32());
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.ContainerName = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.DisplayName = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }

            message.Sink = SinkDefinition.decode(reader, reader.uint32());
            continue;
          }
          case 5: {
            if (tag !== 42) {
              break;
            }

            message.Schema = reader.string();
            continue;
          }
          case 6: {
            if (tag !== 50) {
              break;
            }

            message.Indexes.push(IndexDefinition.decode(reader, reader.uint32()));
            continue;
          }
          case 7: {
            if (tag !== 56) {
              break;
            }

            message.ObserverType = reader.int32() as any;
            continue;
          }
          case 8: {
            if (tag !== 66) {
              break;
            }

            message.ObserverIdentifier = reader.string();
            continue;
          }
          case 9: {
            if (tag !== 72) {
              break;
            }

            message.Owner = reader.int32() as any;
            continue;
          }
          case 10: {
            if (tag !== 80) {
              break;
            }

            message.Source = reader.int32() as any;
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): ReadModelDefinition {
    return {
      Type: isSet(object.Type) ? ReadModelType.fromJSON(object.Type) : undefined,
      ContainerName: isSet(object.ContainerName) ? globalThis.String(object.ContainerName) : "",
      DisplayName: isSet(object.DisplayName) ? globalThis.String(object.DisplayName) : "",
      Sink: isSet(object.Sink) ? SinkDefinition.fromJSON(object.Sink) : undefined,
      Schema: isSet(object.Schema) ? globalThis.String(object.Schema) : "",
      Indexes: globalThis.Array.isArray(object?.Indexes)
        ? object.Indexes.map((e: any) => IndexDefinition.fromJSON(e))
        : [],
      ObserverType: isSet(object.ObserverType) ? readModelObserverTypeFromJSON(object.ObserverType) : 0,
      ObserverIdentifier: isSet(object.ObserverIdentifier) ? globalThis.String(object.ObserverIdentifier) : "",
      Owner: isSet(object.Owner) ? readModelOwnerFromJSON(object.Owner) : 0,
      Source: isSet(object.Source) ? readModelSourceFromJSON(object.Source) : 0,
    };
  },

  toJSON(message: ReadModelDefinition): unknown {
    const obj: any = {};
    if (message.Type !== undefined) {
      obj.Type = ReadModelType.toJSON(message.Type);
    }
    if (message.ContainerName !== "") {
      obj.ContainerName = message.ContainerName;
    }
    if (message.DisplayName !== "") {
      obj.DisplayName = message.DisplayName;
    }
    if (message.Sink !== undefined) {
      obj.Sink = SinkDefinition.toJSON(message.Sink);
    }
    if (message.Schema !== "") {
      obj.Schema = message.Schema;
    }
    if (message.Indexes?.length) {
      obj.Indexes = message.Indexes.map((e) => IndexDefinition.toJSON(e));
    }
    if (message.ObserverType !== 0) {
      obj.ObserverType = readModelObserverTypeToJSON(message.ObserverType);
    }
    if (message.ObserverIdentifier !== "") {
      obj.ObserverIdentifier = message.ObserverIdentifier;
    }
    if (message.Owner !== 0) {
      obj.Owner = readModelOwnerToJSON(message.Owner);
    }
    if (message.Source !== 0) {
      obj.Source = readModelSourceToJSON(message.Source);
    }
    return obj;
  },

  create(base?: DeepPartial<ReadModelDefinition>): ReadModelDefinition {
    return ReadModelDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ReadModelDefinition>): ReadModelDefinition {
    const message = createBaseReadModelDefinition();
    message.Type = (object.Type !== undefined && object.Type !== null)
      ? ReadModelType.fromPartial(object.Type)
      : undefined;
    message.ContainerName = object.ContainerName ?? "";
    message.DisplayName = object.DisplayName ?? "";
    message.Sink = (object.Sink !== undefined && object.Sink !== null)
      ? SinkDefinition.fromPartial(object.Sink)
      : undefined;
    message.Schema = object.Schema ?? "";
    message.Indexes = object.Indexes?.map((e) => IndexDefinition.fromPartial(e)) || [];
    message.ObserverType = object.ObserverType ?? 0;
    message.ObserverIdentifier = object.ObserverIdentifier ?? "";
    message.Owner = object.Owner ?? 0;
    message.Source = object.Source ?? 0;
    return message;
  },
};

function createBaseReadModelOccurrence(): ReadModelOccurrence {
  return { ObserverId: "", Occurred: undefined, Type: undefined, ContainerName: "", RevertContainerName: "" };
}

export const ReadModelOccurrence: MessageFns<ReadModelOccurrence> = {
  encode(message: ReadModelOccurrence, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.ObserverId !== "") {
      writer.uint32(10).string(message.ObserverId);
    }
    if (message.Occurred !== undefined) {
      SerializableDateTimeOffset.encode(message.Occurred, writer.uint32(18).fork()).join();
    }
    if (message.Type !== undefined) {
      ReadModelType.encode(message.Type, writer.uint32(26).fork()).join();
    }
    if (message.ContainerName !== "") {
      writer.uint32(34).string(message.ContainerName);
    }
    if (message.RevertContainerName !== "") {
      writer.uint32(42).string(message.RevertContainerName);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ReadModelOccurrence {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseReadModelOccurrence();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.ObserverId = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.Occurred = SerializableDateTimeOffset.decode(reader, reader.uint32());
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.Type = ReadModelType.decode(reader, reader.uint32());
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }

            message.ContainerName = reader.string();
            continue;
          }
          case 5: {
            if (tag !== 42) {
              break;
            }

            message.RevertContainerName = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): ReadModelOccurrence {
    return {
      ObserverId: isSet(object.ObserverId) ? globalThis.String(object.ObserverId) : "",
      Occurred: isSet(object.Occurred) ? SerializableDateTimeOffset.fromJSON(object.Occurred) : undefined,
      Type: isSet(object.Type) ? ReadModelType.fromJSON(object.Type) : undefined,
      ContainerName: isSet(object.ContainerName) ? globalThis.String(object.ContainerName) : "",
      RevertContainerName: isSet(object.RevertContainerName) ? globalThis.String(object.RevertContainerName) : "",
    };
  },

  toJSON(message: ReadModelOccurrence): unknown {
    const obj: any = {};
    if (message.ObserverId !== "") {
      obj.ObserverId = message.ObserverId;
    }
    if (message.Occurred !== undefined) {
      obj.Occurred = SerializableDateTimeOffset.toJSON(message.Occurred);
    }
    if (message.Type !== undefined) {
      obj.Type = ReadModelType.toJSON(message.Type);
    }
    if (message.ContainerName !== "") {
      obj.ContainerName = message.ContainerName;
    }
    if (message.RevertContainerName !== "") {
      obj.RevertContainerName = message.RevertContainerName;
    }
    return obj;
  },

  create(base?: DeepPartial<ReadModelOccurrence>): ReadModelOccurrence {
    return ReadModelOccurrence.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ReadModelOccurrence>): ReadModelOccurrence {
    const message = createBaseReadModelOccurrence();
    message.ObserverId = object.ObserverId ?? "";
    message.Occurred = (object.Occurred !== undefined && object.Occurred !== null)
      ? SerializableDateTimeOffset.fromPartial(object.Occurred)
      : undefined;
    message.Type = (object.Type !== undefined && object.Type !== null)
      ? ReadModelType.fromPartial(object.Type)
      : undefined;
    message.ContainerName = object.ContainerName ?? "";
    message.RevertContainerName = object.RevertContainerName ?? "";
    return message;
  },
};

function createBaseReadModelType(): ReadModelType {
  return { Identifier: "", Generation: 0 };
}

export const ReadModelType: MessageFns<ReadModelType> = {
  encode(message: ReadModelType, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Identifier !== "") {
      writer.uint32(10).string(message.Identifier);
    }
    if (message.Generation !== 0) {
      writer.uint32(16).uint32(message.Generation);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ReadModelType {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseReadModelType();
      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.Generation = reader.uint32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): ReadModelType {
    return {
      Identifier: isSet(object.Identifier) ? globalThis.String(object.Identifier) : "",
      Generation: isSet(object.Generation) ? globalThis.Number(object.Generation) : 0,
    };
  },

  toJSON(message: ReadModelType): unknown {
    const obj: any = {};
    if (message.Identifier !== "") {
      obj.Identifier = message.Identifier;
    }
    if (message.Generation !== 0) {
      obj.Generation = Math.round(message.Generation);
    }
    return obj;
  },

  create(base?: DeepPartial<ReadModelType>): ReadModelType {
    return ReadModelType.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ReadModelType>): ReadModelType {
    const message = createBaseReadModelType();
    message.Identifier = object.Identifier ?? "";
    message.Generation = object.Generation ?? 0;
    return message;
  },
};

function createBaseRegisterManyRequest(): RegisterManyRequest {
  return { EventStore: "", Owner: 0, ReadModels: [], Source: 0 };
}

export const RegisterManyRequest: MessageFns<RegisterManyRequest> = {
  encode(message: RegisterManyRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    if (message.Owner !== 0) {
      writer.uint32(16).int32(message.Owner);
    }
    for (const v of message.ReadModels) {
      ReadModelDefinition.encode(v!, writer.uint32(26).fork()).join();
    }
    if (message.Source !== 0) {
      writer.uint32(32).int32(message.Source);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): RegisterManyRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseRegisterManyRequest();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.EventStore = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }

            message.Owner = reader.int32() as any;
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.ReadModels.push(ReadModelDefinition.decode(reader, reader.uint32()));
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }

            message.Source = reader.int32() as any;
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): RegisterManyRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Owner: isSet(object.Owner) ? readModelOwnerFromJSON(object.Owner) : 0,
      ReadModels: globalThis.Array.isArray(object?.ReadModels)
        ? object.ReadModels.map((e: any) => ReadModelDefinition.fromJSON(e))
        : [],
      Source: isSet(object.Source) ? readModelSourceFromJSON(object.Source) : 0,
    };
  },

  toJSON(message: RegisterManyRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Owner !== 0) {
      obj.Owner = readModelOwnerToJSON(message.Owner);
    }
    if (message.ReadModels?.length) {
      obj.ReadModels = message.ReadModels.map((e) => ReadModelDefinition.toJSON(e));
    }
    if (message.Source !== 0) {
      obj.Source = readModelSourceToJSON(message.Source);
    }
    return obj;
  },

  create(base?: DeepPartial<RegisterManyRequest>): RegisterManyRequest {
    return RegisterManyRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<RegisterManyRequest>): RegisterManyRequest {
    const message = createBaseRegisterManyRequest();
    message.EventStore = object.EventStore ?? "";
    message.Owner = object.Owner ?? 0;
    message.ReadModels = object.ReadModels?.map((e) => ReadModelDefinition.fromPartial(e)) || [];
    message.Source = object.Source ?? 0;
    return message;
  },
};

function createBaseRegisterSingleRequest(): RegisterSingleRequest {
  return { EventStore: "", Owner: 0, ReadModel: undefined, Source: 0 };
}

export const RegisterSingleRequest: MessageFns<RegisterSingleRequest> = {
  encode(message: RegisterSingleRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    if (message.Owner !== 0) {
      writer.uint32(16).int32(message.Owner);
    }
    if (message.ReadModel !== undefined) {
      ReadModelDefinition.encode(message.ReadModel, writer.uint32(26).fork()).join();
    }
    if (message.Source !== 0) {
      writer.uint32(32).int32(message.Source);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): RegisterSingleRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseRegisterSingleRequest();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.EventStore = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }

            message.Owner = reader.int32() as any;
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.ReadModel = ReadModelDefinition.decode(reader, reader.uint32());
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }

            message.Source = reader.int32() as any;
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): RegisterSingleRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Owner: isSet(object.Owner) ? readModelOwnerFromJSON(object.Owner) : 0,
      ReadModel: isSet(object.ReadModel) ? ReadModelDefinition.fromJSON(object.ReadModel) : undefined,
      Source: isSet(object.Source) ? readModelSourceFromJSON(object.Source) : 0,
    };
  },

  toJSON(message: RegisterSingleRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Owner !== 0) {
      obj.Owner = readModelOwnerToJSON(message.Owner);
    }
    if (message.ReadModel !== undefined) {
      obj.ReadModel = ReadModelDefinition.toJSON(message.ReadModel);
    }
    if (message.Source !== 0) {
      obj.Source = readModelSourceToJSON(message.Source);
    }
    return obj;
  },

  create(base?: DeepPartial<RegisterSingleRequest>): RegisterSingleRequest {
    return RegisterSingleRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<RegisterSingleRequest>): RegisterSingleRequest {
    const message = createBaseRegisterSingleRequest();
    message.EventStore = object.EventStore ?? "";
    message.Owner = object.Owner ?? 0;
    message.ReadModel = (object.ReadModel !== undefined && object.ReadModel !== null)
      ? ReadModelDefinition.fromPartial(object.ReadModel)
      : undefined;
    message.Source = object.Source ?? 0;
    return message;
  },
};

function createBaseSerializableDateTimeOffset(): SerializableDateTimeOffset {
  return { Value: "" };
}

export const SerializableDateTimeOffset: MessageFns<SerializableDateTimeOffset> = {
  encode(message: SerializableDateTimeOffset, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Value !== "") {
      writer.uint32(10).string(message.Value);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): SerializableDateTimeOffset {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseSerializableDateTimeOffset();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.Value = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): SerializableDateTimeOffset {
    return { Value: isSet(object.Value) ? globalThis.String(object.Value) : "" };
  },

  toJSON(message: SerializableDateTimeOffset): unknown {
    const obj: any = {};
    if (message.Value !== "") {
      obj.Value = message.Value;
    }
    return obj;
  },

  create(base?: DeepPartial<SerializableDateTimeOffset>): SerializableDateTimeOffset {
    return SerializableDateTimeOffset.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<SerializableDateTimeOffset>): SerializableDateTimeOffset {
    const message = createBaseSerializableDateTimeOffset();
    message.Value = object.Value ?? "";
    return message;
  },
};

function createBaseSinkDefinition(): SinkDefinition {
  return { ConfigurationId: undefined, TypeId: "" };
}

export const SinkDefinition: MessageFns<SinkDefinition> = {
  encode(message: SinkDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.ConfigurationId !== undefined) {
      Guid.encode(message.ConfigurationId, writer.uint32(10).fork()).join();
    }
    if (message.TypeId !== "") {
      writer.uint32(18).string(message.TypeId);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): SinkDefinition {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseSinkDefinition();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.ConfigurationId = Guid.decode(reader, reader.uint32());
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.TypeId = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): SinkDefinition {
    return {
      ConfigurationId: isSet(object.ConfigurationId) ? Guid.fromJSON(object.ConfigurationId) : undefined,
      TypeId: isSet(object.TypeId) ? globalThis.String(object.TypeId) : "",
    };
  },

  toJSON(message: SinkDefinition): unknown {
    const obj: any = {};
    if (message.ConfigurationId !== undefined) {
      obj.ConfigurationId = Guid.toJSON(message.ConfigurationId);
    }
    if (message.TypeId !== "") {
      obj.TypeId = message.TypeId;
    }
    return obj;
  },

  create(base?: DeepPartial<SinkDefinition>): SinkDefinition {
    return SinkDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<SinkDefinition>): SinkDefinition {
    const message = createBaseSinkDefinition();
    message.ConfigurationId = (object.ConfigurationId !== undefined && object.ConfigurationId !== null)
      ? Guid.fromPartial(object.ConfigurationId)
      : undefined;
    message.TypeId = object.TypeId ?? "";
    return message;
  },
};

function createBaseUpdateDefinitionRequest(): UpdateDefinitionRequest {
  return { EventStore: "", ReadModel: undefined };
}

export const UpdateDefinitionRequest: MessageFns<UpdateDefinitionRequest> = {
  encode(message: UpdateDefinitionRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    if (message.ReadModel !== undefined) {
      ReadModelDefinition.encode(message.ReadModel, writer.uint32(18).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): UpdateDefinitionRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseUpdateDefinitionRequest();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.EventStore = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.ReadModel = ReadModelDefinition.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): UpdateDefinitionRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      ReadModel: isSet(object.ReadModel) ? ReadModelDefinition.fromJSON(object.ReadModel) : undefined,
    };
  },

  toJSON(message: UpdateDefinitionRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.ReadModel !== undefined) {
      obj.ReadModel = ReadModelDefinition.toJSON(message.ReadModel);
    }
    return obj;
  },

  create(base?: DeepPartial<UpdateDefinitionRequest>): UpdateDefinitionRequest {
    return UpdateDefinitionRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<UpdateDefinitionRequest>): UpdateDefinitionRequest {
    const message = createBaseUpdateDefinitionRequest();
    message.EventStore = object.EventStore ?? "";
    message.ReadModel = (object.ReadModel !== undefined && object.ReadModel !== null)
      ? ReadModelDefinition.fromPartial(object.ReadModel)
      : undefined;
    return message;
  },
};

function createBaseWatchRequest(): WatchRequest {
  return { EventStore: "", Namespace: "", ReadModelIdentifier: "", EventSequenceId: "" };
}

export const WatchRequest: MessageFns<WatchRequest> = {
  encode(message: WatchRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    if (message.Namespace !== "") {
      writer.uint32(18).string(message.Namespace);
    }
    if (message.ReadModelIdentifier !== "") {
      writer.uint32(26).string(message.ReadModelIdentifier);
    }
    if (message.EventSequenceId !== "") {
      writer.uint32(34).string(message.EventSequenceId);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): WatchRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseWatchRequest();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.EventStore = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.Namespace = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.ReadModelIdentifier = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }

            message.EventSequenceId = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): WatchRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      ReadModelIdentifier: isSet(object.ReadModelIdentifier) ? globalThis.String(object.ReadModelIdentifier) : "",
      EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
    };
  },

  toJSON(message: WatchRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Namespace !== "") {
      obj.Namespace = message.Namespace;
    }
    if (message.ReadModelIdentifier !== "") {
      obj.ReadModelIdentifier = message.ReadModelIdentifier;
    }
    if (message.EventSequenceId !== "") {
      obj.EventSequenceId = message.EventSequenceId;
    }
    return obj;
  },

  create(base?: DeepPartial<WatchRequest>): WatchRequest {
    return WatchRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<WatchRequest>): WatchRequest {
    const message = createBaseWatchRequest();
    message.EventStore = object.EventStore ?? "";
    message.Namespace = object.Namespace ?? "";
    message.ReadModelIdentifier = object.ReadModelIdentifier ?? "";
    message.EventSequenceId = object.EventSequenceId ?? "";
    return message;
  },
};

export type MaterializedReadModelsDefinition = typeof MaterializedReadModelsDefinition;
export const MaterializedReadModelsDefinition = {
  name: "MaterializedReadModels",
  fullName: "Cratis.Chronicle.Contracts.ReadModels.MaterializedReadModels",
  methods: {
    getInstances: {
      name: "GetInstances",
      requestType: GetInstancesRequest as typeof GetInstancesRequest,
      requestStream: false,
      responseType: GetInstancesResponse as typeof GetInstancesResponse,
      responseStream: false,
      options: {},
    },
    observeInstances: {
      name: "ObserveInstances",
      requestType: ObserveInstancesRequest as typeof ObserveInstancesRequest,
      requestStream: false,
      responseType: ObserveInstancesResponse as typeof ObserveInstancesResponse,
      responseStream: true,
      options: {},
    },
  },
} as const;

export interface MaterializedReadModelsServiceImplementation<CallContextExt = {}> {
  getInstances(
    request: GetInstancesRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<GetInstancesResponse>>;
  observeInstances(
    request: ObserveInstancesRequest,
    context: CallContext & CallContextExt,
  ): ServerStreamingMethodResult<DeepPartial<ObserveInstancesResponse>>;
}

export interface MaterializedReadModelsClient<CallOptionsExt = {}> {
  getInstances(
    request: DeepPartial<GetInstancesRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<GetInstancesResponse>;
  observeInstances(
    request: DeepPartial<ObserveInstancesRequest>,
    options?: CallOptions & CallOptionsExt,
  ): AsyncIterable<ObserveInstancesResponse>;
}

export type ReadModelsDefinition = typeof ReadModelsDefinition;
export const ReadModelsDefinition = {
  name: "ReadModels",
  fullName: "Cratis.Chronicle.Contracts.ReadModels.ReadModels",
  methods: {
    dehydrateSession: {
      name: "DehydrateSession",
      requestType: DehydrateSessionRequest as typeof DehydrateSessionRequest,
      requestStream: false,
      responseType: Empty as typeof Empty,
      responseStream: false,
      options: {},
    },
    getAllInstances: {
      name: "GetAllInstances",
      requestType: GetAllInstancesRequest as typeof GetAllInstancesRequest,
      requestStream: false,
      responseType: GetAllInstancesResponse as typeof GetAllInstancesResponse,
      responseStream: false,
      options: {},
    },
    getDefinitions: {
      name: "GetDefinitions",
      requestType: GetDefinitionsRequest as typeof GetDefinitionsRequest,
      requestStream: false,
      responseType: GetDefinitionsResponse as typeof GetDefinitionsResponse,
      responseStream: false,
      options: {},
    },
    getInstanceByKey: {
      name: "GetInstanceByKey",
      requestType: GetInstanceByKeyRequest as typeof GetInstanceByKeyRequest,
      requestStream: false,
      responseType: GetInstanceByKeyResponse as typeof GetInstanceByKeyResponse,
      responseStream: false,
      options: {},
    },
    getInstances: {
      name: "GetInstances",
      requestType: GetInstancesRequest as typeof GetInstancesRequest,
      requestStream: false,
      responseType: GetInstancesResponse as typeof GetInstancesResponse,
      responseStream: false,
      options: {},
    },
    getOccurrences: {
      name: "GetOccurrences",
      requestType: GetOccurrencesRequest as typeof GetOccurrencesRequest,
      requestStream: false,
      responseType: GetOccurrencesResponse as typeof GetOccurrencesResponse,
      responseStream: false,
      options: {},
    },
    registerMany: {
      name: "RegisterMany",
      requestType: RegisterManyRequest as typeof RegisterManyRequest,
      requestStream: false,
      responseType: Empty as typeof Empty,
      responseStream: false,
      options: {},
    },
    registerSingle: {
      name: "RegisterSingle",
      requestType: RegisterSingleRequest as typeof RegisterSingleRequest,
      requestStream: false,
      responseType: Empty as typeof Empty,
      responseStream: false,
      options: {},
    },
    updateDefinition: {
      name: "UpdateDefinition",
      requestType: UpdateDefinitionRequest as typeof UpdateDefinitionRequest,
      requestStream: false,
      responseType: Empty as typeof Empty,
      responseStream: false,
      options: {},
    },
    watch: {
      name: "Watch",
      requestType: WatchRequest as typeof WatchRequest,
      requestStream: false,
      responseType: ReadModelChangeset as typeof ReadModelChangeset,
      responseStream: true,
      options: {},
    },
  },
} as const;

export interface ReadModelsServiceImplementation<CallContextExt = {}> {
  dehydrateSession(
    request: DehydrateSessionRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<Empty>>;
  getAllInstances(
    request: GetAllInstancesRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<GetAllInstancesResponse>>;
  getDefinitions(
    request: GetDefinitionsRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<GetDefinitionsResponse>>;
  getInstanceByKey(
    request: GetInstanceByKeyRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<GetInstanceByKeyResponse>>;
  getInstances(
    request: GetInstancesRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<GetInstancesResponse>>;
  getOccurrences(
    request: GetOccurrencesRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<GetOccurrencesResponse>>;
  registerMany(request: RegisterManyRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Empty>>;
  registerSingle(request: RegisterSingleRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Empty>>;
  updateDefinition(
    request: UpdateDefinitionRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<Empty>>;
  watch(
    request: WatchRequest,
    context: CallContext & CallContextExt,
  ): ServerStreamingMethodResult<DeepPartial<ReadModelChangeset>>;
}

export interface ReadModelsClient<CallOptionsExt = {}> {
  dehydrateSession(
    request: DeepPartial<DehydrateSessionRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<Empty>;
  getAllInstances(
    request: DeepPartial<GetAllInstancesRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<GetAllInstancesResponse>;
  getDefinitions(
    request: DeepPartial<GetDefinitionsRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<GetDefinitionsResponse>;
  getInstanceByKey(
    request: DeepPartial<GetInstanceByKeyRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<GetInstanceByKeyResponse>;
  getInstances(
    request: DeepPartial<GetInstancesRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<GetInstancesResponse>;
  getOccurrences(
    request: DeepPartial<GetOccurrencesRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<GetOccurrencesResponse>;
  registerMany(request: DeepPartial<RegisterManyRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
  registerSingle(request: DeepPartial<RegisterSingleRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
  updateDefinition(
    request: DeepPartial<UpdateDefinitionRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<Empty>;
  watch(request: DeepPartial<WatchRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<ReadModelChangeset>;
}

type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;

export type DeepPartial<T> = T extends bigint ? string | number | bigint
  : 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 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;
}