// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// versions:
//   protoc-gen-ts_proto  v2.12.4
//   protoc               v5.28.3
// source: observation.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.Observation";

export enum FailureKind {
  FAILURE_KIND_Unknown = 0,
  Handling = 1,
  Timeout = 2,
  FAILURE_KIND_Disconnected = 3,
  UNRECOGNIZED = -1,
}

export function failureKindFromJSON(object: any): FailureKind {
  switch (object) {
    case 0:
    case "FAILURE_KIND_Unknown":
      return FailureKind.FAILURE_KIND_Unknown;
    case 1:
    case "Handling":
      return FailureKind.Handling;
    case 2:
    case "Timeout":
      return FailureKind.Timeout;
    case 3:
    case "FAILURE_KIND_Disconnected":
      return FailureKind.FAILURE_KIND_Disconnected;
    case -1:
    case "UNRECOGNIZED":
    default:
      return FailureKind.UNRECOGNIZED;
  }
}

export function failureKindToJSON(object: FailureKind): string {
  switch (object) {
    case FailureKind.FAILURE_KIND_Unknown:
      return "FAILURE_KIND_Unknown";
    case FailureKind.Handling:
      return "Handling";
    case FailureKind.Timeout:
      return "Timeout";
    case FailureKind.FAILURE_KIND_Disconnected:
      return "FAILURE_KIND_Disconnected";
    case FailureKind.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export enum ObserverOwner {
  None = 0,
  Client = 1,
  Kernel = 2,
  UNRECOGNIZED = -1,
}

export function observerOwnerFromJSON(object: any): ObserverOwner {
  switch (object) {
    case 0:
    case "None":
      return ObserverOwner.None;
    case 1:
    case "Client":
      return ObserverOwner.Client;
    case 2:
    case "Kernel":
      return ObserverOwner.Kernel;
    case -1:
    case "UNRECOGNIZED":
    default:
      return ObserverOwner.UNRECOGNIZED;
  }
}

export function observerOwnerToJSON(object: ObserverOwner): string {
  switch (object) {
    case ObserverOwner.None:
      return "None";
    case ObserverOwner.Client:
      return "Client";
    case ObserverOwner.Kernel:
      return "Kernel";
    case ObserverOwner.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export enum ObserverRunningState {
  OBSERVER_RUNNING_STATE_Unknown = 0,
  Active = 1,
  Suspended = 2,
  Replaying = 3,
  OBSERVER_RUNNING_STATE_Disconnected = 4,
  Quarantined = 5,
  UNRECOGNIZED = -1,
}

export function observerRunningStateFromJSON(object: any): ObserverRunningState {
  switch (object) {
    case 0:
    case "OBSERVER_RUNNING_STATE_Unknown":
      return ObserverRunningState.OBSERVER_RUNNING_STATE_Unknown;
    case 1:
    case "Active":
      return ObserverRunningState.Active;
    case 2:
    case "Suspended":
      return ObserverRunningState.Suspended;
    case 3:
    case "Replaying":
      return ObserverRunningState.Replaying;
    case 4:
    case "OBSERVER_RUNNING_STATE_Disconnected":
      return ObserverRunningState.OBSERVER_RUNNING_STATE_Disconnected;
    case 5:
    case "Quarantined":
      return ObserverRunningState.Quarantined;
    case -1:
    case "UNRECOGNIZED":
    default:
      return ObserverRunningState.UNRECOGNIZED;
  }
}

export function observerRunningStateToJSON(object: ObserverRunningState): string {
  switch (object) {
    case ObserverRunningState.OBSERVER_RUNNING_STATE_Unknown:
      return "OBSERVER_RUNNING_STATE_Unknown";
    case ObserverRunningState.Active:
      return "Active";
    case ObserverRunningState.Suspended:
      return "Suspended";
    case ObserverRunningState.Replaying:
      return "Replaying";
    case ObserverRunningState.OBSERVER_RUNNING_STATE_Disconnected:
      return "OBSERVER_RUNNING_STATE_Disconnected";
    case ObserverRunningState.Quarantined:
      return "Quarantined";
    case ObserverRunningState.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export enum ObserverType {
  OBSERVER_TYPE_Unknown = 0,
  Reactor = 1,
  Projection = 2,
  Reducer = 3,
  External = 4,
  UNRECOGNIZED = -1,
}

export function observerTypeFromJSON(object: any): ObserverType {
  switch (object) {
    case 0:
    case "OBSERVER_TYPE_Unknown":
      return ObserverType.OBSERVER_TYPE_Unknown;
    case 1:
    case "Reactor":
      return ObserverType.Reactor;
    case 2:
    case "Projection":
      return ObserverType.Projection;
    case 3:
    case "Reducer":
      return ObserverType.Reducer;
    case 4:
    case "External":
      return ObserverType.External;
    case -1:
    case "UNRECOGNIZED":
    default:
      return ObserverType.UNRECOGNIZED;
  }
}

export function observerTypeToJSON(object: ObserverType): string {
  switch (object) {
    case ObserverType.OBSERVER_TYPE_Unknown:
      return "OBSERVER_TYPE_Unknown";
    case ObserverType.Reactor:
      return "Reactor";
    case ObserverType.Projection:
      return "Projection";
    case ObserverType.Reducer:
      return "Reducer";
    case ObserverType.External:
      return "External";
    case ObserverType.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export enum PartitionRecoveryOutcome {
  Started = 0,
  PartitionNotFound = 1,
  ObserverQuarantined = 2,
  PartitionQuarantined = 3,
  UNRECOGNIZED = -1,
}

export function partitionRecoveryOutcomeFromJSON(object: any): PartitionRecoveryOutcome {
  switch (object) {
    case 0:
    case "Started":
      return PartitionRecoveryOutcome.Started;
    case 1:
    case "PartitionNotFound":
      return PartitionRecoveryOutcome.PartitionNotFound;
    case 2:
    case "ObserverQuarantined":
      return PartitionRecoveryOutcome.ObserverQuarantined;
    case 3:
    case "PartitionQuarantined":
      return PartitionRecoveryOutcome.PartitionQuarantined;
    case -1:
    case "UNRECOGNIZED":
    default:
      return PartitionRecoveryOutcome.UNRECOGNIZED;
  }
}

export function partitionRecoveryOutcomeToJSON(object: PartitionRecoveryOutcome): string {
  switch (object) {
    case PartitionRecoveryOutcome.Started:
      return "Started";
    case PartitionRecoveryOutcome.PartitionNotFound:
      return "PartitionNotFound";
    case PartitionRecoveryOutcome.ObserverQuarantined:
      return "ObserverQuarantined";
    case PartitionRecoveryOutcome.PartitionQuarantined:
      return "PartitionQuarantined";
    case PartitionRecoveryOutcome.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export interface AllObserversRequest {
  EventStore: string;
  Namespace: string;
}

export interface ClearFailedPartitions {
  EventStore: string;
  Namespace: string;
  ObserverId: string;
  EventSequenceId: string;
}

export interface ClearObserverQuarantine {
  EventStore: string;
  Namespace: string;
  ObserverId: string;
  EventSequenceId: string;
}

export interface ConnectedClient {
  ConnectionId: string;
  Version: string;
  LastSeen: SerializableDateTimeOffset | undefined;
  IsRunningWithDebugger: boolean;
  SiloAddress: string;
  ProcessId: number;
  ProcessPath: string;
  MachineName: string;
  ClientType: string;
}

export interface EventType {
  Id: string;
  Generation: number;
  Tombstone: boolean;
}

export interface FailedPartition {
  /** default value could not be applied: 00000000-0000-0000-0000-000000000000 */
  Id: Guid | undefined;
  ObserverId: string;
  Partition: string;
  Attempts: FailedPartitionAttempt[];
  IsResolved: boolean;
  IsQuarantined: boolean;
}

export interface FailedPartitionAttempt {
  Occurred: SerializableDateTimeOffset | undefined;
  SequenceNumber: bigint;
  Messages: string[];
  StackTrace: string;
  Kind: FailureKind;
}

export interface GetConnectedClientsForObserverRequest {
  EventStore: string;
  Namespace: string;
  ObserverId: string;
  EventSequenceId: string;
}

export interface GetFailedPartitionsRequest {
  EventStore: string;
  Namespace: string;
  ObserverId: string;
}

export interface GetObserverInformationRequest {
  EventStore: string;
  Namespace: string;
  ObserverId: string;
  EventSequenceId: string;
}

export interface GetReplayableObserversForEventTypesRequest {
  EventStore: string;
  Namespace: string;
  EventTypes: EventType[];
}

export interface IEnumerableConnectedClient {
  items: ConnectedClient[];
}

export interface IEnumerableFailedPartition {
  items: FailedPartition[];
}

export interface IEnumerableObserverInformation {
  items: ObserverInformation[];
}

export interface ObserverInformation {
  Id: string;
  EventSequenceId: string;
  Type: ObserverType;
  Owner: ObserverOwner;
  EventTypes: EventType[];
  NextEventSequenceNumber: bigint;
  LastHandledEventSequenceNumber: bigint;
  RunningState: ObserverRunningState;
  IsSubscribed: boolean;
  /** default value could not be applied: True */
  IsReplayable: boolean;
  TailEventSequenceNumber: bigint;
  HandledEventCount: bigint;
}

export interface Replay {
  EventStore: string;
  Namespace: string;
  ObserverId: string;
  EventSequenceId: string;
}

export interface ReplayPartition {
  EventStore: string;
  Namespace: string;
  ObserverId: string;
  EventSequenceId: string;
  Partition: string;
}

export interface ReplayResponse {
  JobId: string;
}

export interface RetryPartition {
  EventStore: string;
  Namespace: string;
  ObserverId: string;
  EventSequenceId: string;
  Partition: string;
}

export interface RetryPartitionResponse {
  Outcome: PartitionRecoveryOutcome;
}

/** 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 WaitForObserverCompletionRequest {
  EventStore: string;
  Namespace: string;
  EventSequenceId: string;
  TailEventSequenceNumber: bigint;
}

export interface WaitForObserverCompletionResponse {
  IsSuccess: boolean;
  FailedPartitions: FailedPartition[];
}

function createBaseAllObserversRequest(): AllObserversRequest {
  return { EventStore: "", Namespace: "" };
}

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

  decode(input: BinaryReader | Uint8Array, length?: number): AllObserversRequest {
    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 = createBaseAllObserversRequest();
      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;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

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

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

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

function createBaseClearFailedPartitions(): ClearFailedPartitions {
  return { EventStore: "", Namespace: "", ObserverId: "", EventSequenceId: "" };
}

export const ClearFailedPartitions: MessageFns<ClearFailedPartitions> = {
  encode(message: ClearFailedPartitions, 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.ObserverId !== "") {
      writer.uint32(26).string(message.ObserverId);
    }
    if (message.EventSequenceId !== "") {
      writer.uint32(34).string(message.EventSequenceId);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClearFailedPartitions {
    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 = createBaseClearFailedPartitions();
      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.ObserverId = 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): ClearFailedPartitions {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      ObserverId: isSet(object.ObserverId) ? globalThis.String(object.ObserverId) : "",
      EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
    };
  },

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

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

function createBaseClearObserverQuarantine(): ClearObserverQuarantine {
  return { EventStore: "", Namespace: "", ObserverId: "", EventSequenceId: "" };
}

export const ClearObserverQuarantine: MessageFns<ClearObserverQuarantine> = {
  encode(message: ClearObserverQuarantine, 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.ObserverId !== "") {
      writer.uint32(26).string(message.ObserverId);
    }
    if (message.EventSequenceId !== "") {
      writer.uint32(34).string(message.EventSequenceId);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ClearObserverQuarantine {
    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 = createBaseClearObserverQuarantine();
      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.ObserverId = 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): ClearObserverQuarantine {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      ObserverId: isSet(object.ObserverId) ? globalThis.String(object.ObserverId) : "",
      EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
    };
  },

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

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

function createBaseConnectedClient(): ConnectedClient {
  return {
    ConnectionId: "",
    Version: "",
    LastSeen: undefined,
    IsRunningWithDebugger: false,
    SiloAddress: "",
    ProcessId: 0,
    ProcessPath: "",
    MachineName: "",
    ClientType: "",
  };
}

export const ConnectedClient: MessageFns<ConnectedClient> = {
  encode(message: ConnectedClient, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.ConnectionId !== "") {
      writer.uint32(10).string(message.ConnectionId);
    }
    if (message.Version !== "") {
      writer.uint32(18).string(message.Version);
    }
    if (message.LastSeen !== undefined) {
      SerializableDateTimeOffset.encode(message.LastSeen, writer.uint32(26).fork()).join();
    }
    if (message.IsRunningWithDebugger !== false) {
      writer.uint32(32).bool(message.IsRunningWithDebugger);
    }
    if (message.SiloAddress !== "") {
      writer.uint32(42).string(message.SiloAddress);
    }
    if (message.ProcessId !== 0) {
      writer.uint32(48).int32(message.ProcessId);
    }
    if (message.ProcessPath !== "") {
      writer.uint32(58).string(message.ProcessPath);
    }
    if (message.MachineName !== "") {
      writer.uint32(66).string(message.MachineName);
    }
    if (message.ClientType !== "") {
      writer.uint32(74).string(message.ClientType);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ConnectedClient {
    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 = createBaseConnectedClient();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

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

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

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

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

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

            message.ProcessId = reader.int32();
            continue;
          }
          case 7: {
            if (tag !== 58) {
              break;
            }

            message.ProcessPath = reader.string();
            continue;
          }
          case 8: {
            if (tag !== 66) {
              break;
            }

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

            message.ClientType = 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): ConnectedClient {
    return {
      ConnectionId: isSet(object.ConnectionId) ? globalThis.String(object.ConnectionId) : "",
      Version: isSet(object.Version) ? globalThis.String(object.Version) : "",
      LastSeen: isSet(object.LastSeen) ? SerializableDateTimeOffset.fromJSON(object.LastSeen) : undefined,
      IsRunningWithDebugger: isSet(object.IsRunningWithDebugger)
        ? globalThis.Boolean(object.IsRunningWithDebugger)
        : false,
      SiloAddress: isSet(object.SiloAddress) ? globalThis.String(object.SiloAddress) : "",
      ProcessId: isSet(object.ProcessId) ? globalThis.Number(object.ProcessId) : 0,
      ProcessPath: isSet(object.ProcessPath) ? globalThis.String(object.ProcessPath) : "",
      MachineName: isSet(object.MachineName) ? globalThis.String(object.MachineName) : "",
      ClientType: isSet(object.ClientType) ? globalThis.String(object.ClientType) : "",
    };
  },

  toJSON(message: ConnectedClient): unknown {
    const obj: any = {};
    if (message.ConnectionId !== "") {
      obj.ConnectionId = message.ConnectionId;
    }
    if (message.Version !== "") {
      obj.Version = message.Version;
    }
    if (message.LastSeen !== undefined) {
      obj.LastSeen = SerializableDateTimeOffset.toJSON(message.LastSeen);
    }
    if (message.IsRunningWithDebugger !== false) {
      obj.IsRunningWithDebugger = message.IsRunningWithDebugger;
    }
    if (message.SiloAddress !== "") {
      obj.SiloAddress = message.SiloAddress;
    }
    if (message.ProcessId !== 0) {
      obj.ProcessId = Math.round(message.ProcessId);
    }
    if (message.ProcessPath !== "") {
      obj.ProcessPath = message.ProcessPath;
    }
    if (message.MachineName !== "") {
      obj.MachineName = message.MachineName;
    }
    if (message.ClientType !== "") {
      obj.ClientType = message.ClientType;
    }
    return obj;
  },

  create(base?: DeepPartial<ConnectedClient>): ConnectedClient {
    return ConnectedClient.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ConnectedClient>): ConnectedClient {
    const message = createBaseConnectedClient();
    message.ConnectionId = object.ConnectionId ?? "";
    message.Version = object.Version ?? "";
    message.LastSeen = (object.LastSeen !== undefined && object.LastSeen !== null)
      ? SerializableDateTimeOffset.fromPartial(object.LastSeen)
      : undefined;
    message.IsRunningWithDebugger = object.IsRunningWithDebugger ?? false;
    message.SiloAddress = object.SiloAddress ?? "";
    message.ProcessId = object.ProcessId ?? 0;
    message.ProcessPath = object.ProcessPath ?? "";
    message.MachineName = object.MachineName ?? "";
    message.ClientType = object.ClientType ?? "";
    return message;
  },
};

function createBaseEventType(): EventType {
  return { Id: "", Generation: 0, Tombstone: false };
}

export const EventType: MessageFns<EventType> = {
  encode(message: EventType, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Id !== "") {
      writer.uint32(10).string(message.Id);
    }
    if (message.Generation !== 0) {
      writer.uint32(16).uint32(message.Generation);
    }
    if (message.Tombstone !== false) {
      writer.uint32(24).bool(message.Tombstone);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): EventType {
    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 = createBaseEventType();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

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

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

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

  fromJSON(object: any): EventType {
    return {
      Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
      Generation: isSet(object.Generation) ? globalThis.Number(object.Generation) : 0,
      Tombstone: isSet(object.Tombstone) ? globalThis.Boolean(object.Tombstone) : false,
    };
  },

  toJSON(message: EventType): unknown {
    const obj: any = {};
    if (message.Id !== "") {
      obj.Id = message.Id;
    }
    if (message.Generation !== 0) {
      obj.Generation = Math.round(message.Generation);
    }
    if (message.Tombstone !== false) {
      obj.Tombstone = message.Tombstone;
    }
    return obj;
  },

  create(base?: DeepPartial<EventType>): EventType {
    return EventType.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<EventType>): EventType {
    const message = createBaseEventType();
    message.Id = object.Id ?? "";
    message.Generation = object.Generation ?? 0;
    message.Tombstone = object.Tombstone ?? false;
    return message;
  },
};

function createBaseFailedPartition(): FailedPartition {
  return { Id: undefined, ObserverId: "", Partition: "", Attempts: [], IsResolved: false, IsQuarantined: false };
}

export const FailedPartition: MessageFns<FailedPartition> = {
  encode(message: FailedPartition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Id !== undefined) {
      Guid.encode(message.Id, writer.uint32(10).fork()).join();
    }
    if (message.ObserverId !== "") {
      writer.uint32(18).string(message.ObserverId);
    }
    if (message.Partition !== "") {
      writer.uint32(26).string(message.Partition);
    }
    for (const v of message.Attempts) {
      FailedPartitionAttempt.encode(v!, writer.uint32(34).fork()).join();
    }
    if (message.IsResolved !== false) {
      writer.uint32(40).bool(message.IsResolved);
    }
    if (message.IsQuarantined !== false) {
      writer.uint32(48).bool(message.IsQuarantined);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): FailedPartition {
    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 = createBaseFailedPartition();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

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

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

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

            message.Attempts.push(FailedPartitionAttempt.decode(reader, reader.uint32()));
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }

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

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

  fromJSON(object: any): FailedPartition {
    return {
      Id: isSet(object.Id) ? Guid.fromJSON(object.Id) : undefined,
      ObserverId: isSet(object.ObserverId) ? globalThis.String(object.ObserverId) : "",
      Partition: isSet(object.Partition) ? globalThis.String(object.Partition) : "",
      Attempts: globalThis.Array.isArray(object?.Attempts)
        ? object.Attempts.map((e: any) => FailedPartitionAttempt.fromJSON(e))
        : [],
      IsResolved: isSet(object.IsResolved) ? globalThis.Boolean(object.IsResolved) : false,
      IsQuarantined: isSet(object.IsQuarantined) ? globalThis.Boolean(object.IsQuarantined) : false,
    };
  },

  toJSON(message: FailedPartition): unknown {
    const obj: any = {};
    if (message.Id !== undefined) {
      obj.Id = Guid.toJSON(message.Id);
    }
    if (message.ObserverId !== "") {
      obj.ObserverId = message.ObserverId;
    }
    if (message.Partition !== "") {
      obj.Partition = message.Partition;
    }
    if (message.Attempts?.length) {
      obj.Attempts = message.Attempts.map((e) => FailedPartitionAttempt.toJSON(e));
    }
    if (message.IsResolved !== false) {
      obj.IsResolved = message.IsResolved;
    }
    if (message.IsQuarantined !== false) {
      obj.IsQuarantined = message.IsQuarantined;
    }
    return obj;
  },

  create(base?: DeepPartial<FailedPartition>): FailedPartition {
    return FailedPartition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<FailedPartition>): FailedPartition {
    const message = createBaseFailedPartition();
    message.Id = (object.Id !== undefined && object.Id !== null) ? Guid.fromPartial(object.Id) : undefined;
    message.ObserverId = object.ObserverId ?? "";
    message.Partition = object.Partition ?? "";
    message.Attempts = object.Attempts?.map((e) => FailedPartitionAttempt.fromPartial(e)) || [];
    message.IsResolved = object.IsResolved ?? false;
    message.IsQuarantined = object.IsQuarantined ?? false;
    return message;
  },
};

function createBaseFailedPartitionAttempt(): FailedPartitionAttempt {
  return { Occurred: undefined, SequenceNumber: 0n, Messages: [], StackTrace: "", Kind: 0 };
}

export const FailedPartitionAttempt: MessageFns<FailedPartitionAttempt> = {
  encode(message: FailedPartitionAttempt, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Occurred !== undefined) {
      SerializableDateTimeOffset.encode(message.Occurred, writer.uint32(10).fork()).join();
    }
    if (message.SequenceNumber !== 0n) {
      if (BigInt.asUintN(64, message.SequenceNumber) !== message.SequenceNumber) {
        throw new globalThis.Error("value provided for field message.SequenceNumber of type uint64 too large");
      }
      writer.uint32(16).uint64(message.SequenceNumber);
    }
    for (const v of message.Messages) {
      writer.uint32(26).string(v!);
    }
    if (message.StackTrace !== "") {
      writer.uint32(34).string(message.StackTrace);
    }
    if (message.Kind !== 0) {
      writer.uint32(40).int32(message.Kind);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): FailedPartitionAttempt {
    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 = createBaseFailedPartitionAttempt();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

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

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

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

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

            message.Kind = 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): FailedPartitionAttempt {
    return {
      Occurred: isSet(object.Occurred) ? SerializableDateTimeOffset.fromJSON(object.Occurred) : undefined,
      SequenceNumber: isSet(object.SequenceNumber) ? BigInt(object.SequenceNumber) : 0n,
      Messages: globalThis.Array.isArray(object?.Messages) ? object.Messages.map((e: any) => globalThis.String(e)) : [],
      StackTrace: isSet(object.StackTrace) ? globalThis.String(object.StackTrace) : "",
      Kind: isSet(object.Kind) ? failureKindFromJSON(object.Kind) : 0,
    };
  },

  toJSON(message: FailedPartitionAttempt): unknown {
    const obj: any = {};
    if (message.Occurred !== undefined) {
      obj.Occurred = SerializableDateTimeOffset.toJSON(message.Occurred);
    }
    if (message.SequenceNumber !== 0n) {
      obj.SequenceNumber = message.SequenceNumber.toString();
    }
    if (message.Messages?.length) {
      obj.Messages = message.Messages;
    }
    if (message.StackTrace !== "") {
      obj.StackTrace = message.StackTrace;
    }
    if (message.Kind !== 0) {
      obj.Kind = failureKindToJSON(message.Kind);
    }
    return obj;
  },

  create(base?: DeepPartial<FailedPartitionAttempt>): FailedPartitionAttempt {
    return FailedPartitionAttempt.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<FailedPartitionAttempt>): FailedPartitionAttempt {
    const message = createBaseFailedPartitionAttempt();
    message.Occurred = (object.Occurred !== undefined && object.Occurred !== null)
      ? SerializableDateTimeOffset.fromPartial(object.Occurred)
      : undefined;
    message.SequenceNumber = (object.SequenceNumber !== undefined && object.SequenceNumber !== null)
      ? BigInt(object.SequenceNumber)
      : 0n;
    message.Messages = object.Messages?.map((e) => e) || [];
    message.StackTrace = object.StackTrace ?? "";
    message.Kind = object.Kind ?? 0;
    return message;
  },
};

function createBaseGetConnectedClientsForObserverRequest(): GetConnectedClientsForObserverRequest {
  return { EventStore: "", Namespace: "", ObserverId: "", EventSequenceId: "" };
}

export const GetConnectedClientsForObserverRequest: MessageFns<GetConnectedClientsForObserverRequest> = {
  encode(message: GetConnectedClientsForObserverRequest, 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.ObserverId !== "") {
      writer.uint32(26).string(message.ObserverId);
    }
    if (message.EventSequenceId !== "") {
      writer.uint32(34).string(message.EventSequenceId);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): GetConnectedClientsForObserverRequest {
    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 = createBaseGetConnectedClientsForObserverRequest();
      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.ObserverId = 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): GetConnectedClientsForObserverRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      ObserverId: isSet(object.ObserverId) ? globalThis.String(object.ObserverId) : "",
      EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
    };
  },

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

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

function createBaseGetFailedPartitionsRequest(): GetFailedPartitionsRequest {
  return { EventStore: "", Namespace: "", ObserverId: "" };
}

export const GetFailedPartitionsRequest: MessageFns<GetFailedPartitionsRequest> = {
  encode(message: GetFailedPartitionsRequest, 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.ObserverId !== "") {
      writer.uint32(26).string(message.ObserverId);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): GetFailedPartitionsRequest {
    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 = createBaseGetFailedPartitionsRequest();
      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.ObserverId = 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): GetFailedPartitionsRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      ObserverId: isSet(object.ObserverId) ? globalThis.String(object.ObserverId) : "",
    };
  },

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

  create(base?: DeepPartial<GetFailedPartitionsRequest>): GetFailedPartitionsRequest {
    return GetFailedPartitionsRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<GetFailedPartitionsRequest>): GetFailedPartitionsRequest {
    const message = createBaseGetFailedPartitionsRequest();
    message.EventStore = object.EventStore ?? "";
    message.Namespace = object.Namespace ?? "";
    message.ObserverId = object.ObserverId ?? "";
    return message;
  },
};

function createBaseGetObserverInformationRequest(): GetObserverInformationRequest {
  return { EventStore: "", Namespace: "", ObserverId: "", EventSequenceId: "" };
}

export const GetObserverInformationRequest: MessageFns<GetObserverInformationRequest> = {
  encode(message: GetObserverInformationRequest, 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.ObserverId !== "") {
      writer.uint32(26).string(message.ObserverId);
    }
    if (message.EventSequenceId !== "") {
      writer.uint32(34).string(message.EventSequenceId);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): GetObserverInformationRequest {
    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 = createBaseGetObserverInformationRequest();
      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.ObserverId = 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): GetObserverInformationRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      ObserverId: isSet(object.ObserverId) ? globalThis.String(object.ObserverId) : "",
      EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
    };
  },

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

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

function createBaseGetReplayableObserversForEventTypesRequest(): GetReplayableObserversForEventTypesRequest {
  return { EventStore: "", Namespace: "", EventTypes: [] };
}

export const GetReplayableObserversForEventTypesRequest: MessageFns<GetReplayableObserversForEventTypesRequest> = {
  encode(message: GetReplayableObserversForEventTypesRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    if (message.Namespace !== "") {
      writer.uint32(18).string(message.Namespace);
    }
    for (const v of message.EventTypes) {
      EventType.encode(v!, writer.uint32(26).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): GetReplayableObserversForEventTypesRequest {
    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 = createBaseGetReplayableObserversForEventTypesRequest();
      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.EventTypes.push(EventType.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): GetReplayableObserversForEventTypesRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      EventTypes: globalThis.Array.isArray(object?.EventTypes)
        ? object.EventTypes.map((e: any) => EventType.fromJSON(e))
        : [],
    };
  },

  toJSON(message: GetReplayableObserversForEventTypesRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Namespace !== "") {
      obj.Namespace = message.Namespace;
    }
    if (message.EventTypes?.length) {
      obj.EventTypes = message.EventTypes.map((e) => EventType.toJSON(e));
    }
    return obj;
  },

  create(base?: DeepPartial<GetReplayableObserversForEventTypesRequest>): GetReplayableObserversForEventTypesRequest {
    return GetReplayableObserversForEventTypesRequest.fromPartial(base ?? {});
  },
  fromPartial(
    object: DeepPartial<GetReplayableObserversForEventTypesRequest>,
  ): GetReplayableObserversForEventTypesRequest {
    const message = createBaseGetReplayableObserversForEventTypesRequest();
    message.EventStore = object.EventStore ?? "";
    message.Namespace = object.Namespace ?? "";
    message.EventTypes = object.EventTypes?.map((e) => EventType.fromPartial(e)) || [];
    return message;
  },
};

function createBaseIEnumerableConnectedClient(): IEnumerableConnectedClient {
  return { items: [] };
}

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

  decode(input: BinaryReader | Uint8Array, length?: number): IEnumerableConnectedClient {
    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 = createBaseIEnumerableConnectedClient();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.items.push(ConnectedClient.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): IEnumerableConnectedClient {
    return {
      items: globalThis.Array.isArray(object?.items) ? object.items.map((e: any) => ConnectedClient.fromJSON(e)) : [],
    };
  },

  toJSON(message: IEnumerableConnectedClient): unknown {
    const obj: any = {};
    if (message.items?.length) {
      obj.items = message.items.map((e) => ConnectedClient.toJSON(e));
    }
    return obj;
  },

  create(base?: DeepPartial<IEnumerableConnectedClient>): IEnumerableConnectedClient {
    return IEnumerableConnectedClient.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<IEnumerableConnectedClient>): IEnumerableConnectedClient {
    const message = createBaseIEnumerableConnectedClient();
    message.items = object.items?.map((e) => ConnectedClient.fromPartial(e)) || [];
    return message;
  },
};

function createBaseIEnumerableFailedPartition(): IEnumerableFailedPartition {
  return { items: [] };
}

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

  decode(input: BinaryReader | Uint8Array, length?: number): IEnumerableFailedPartition {
    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 = createBaseIEnumerableFailedPartition();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.items.push(FailedPartition.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): IEnumerableFailedPartition {
    return {
      items: globalThis.Array.isArray(object?.items) ? object.items.map((e: any) => FailedPartition.fromJSON(e)) : [],
    };
  },

  toJSON(message: IEnumerableFailedPartition): unknown {
    const obj: any = {};
    if (message.items?.length) {
      obj.items = message.items.map((e) => FailedPartition.toJSON(e));
    }
    return obj;
  },

  create(base?: DeepPartial<IEnumerableFailedPartition>): IEnumerableFailedPartition {
    return IEnumerableFailedPartition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<IEnumerableFailedPartition>): IEnumerableFailedPartition {
    const message = createBaseIEnumerableFailedPartition();
    message.items = object.items?.map((e) => FailedPartition.fromPartial(e)) || [];
    return message;
  },
};

function createBaseIEnumerableObserverInformation(): IEnumerableObserverInformation {
  return { items: [] };
}

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

  decode(input: BinaryReader | Uint8Array, length?: number): IEnumerableObserverInformation {
    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 = createBaseIEnumerableObserverInformation();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.items.push(ObserverInformation.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): IEnumerableObserverInformation {
    return {
      items: globalThis.Array.isArray(object?.items)
        ? object.items.map((e: any) => ObserverInformation.fromJSON(e))
        : [],
    };
  },

  toJSON(message: IEnumerableObserverInformation): unknown {
    const obj: any = {};
    if (message.items?.length) {
      obj.items = message.items.map((e) => ObserverInformation.toJSON(e));
    }
    return obj;
  },

  create(base?: DeepPartial<IEnumerableObserverInformation>): IEnumerableObserverInformation {
    return IEnumerableObserverInformation.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<IEnumerableObserverInformation>): IEnumerableObserverInformation {
    const message = createBaseIEnumerableObserverInformation();
    message.items = object.items?.map((e) => ObserverInformation.fromPartial(e)) || [];
    return message;
  },
};

function createBaseObserverInformation(): ObserverInformation {
  return {
    Id: "",
    EventSequenceId: "",
    Type: 0,
    Owner: 0,
    EventTypes: [],
    NextEventSequenceNumber: 0n,
    LastHandledEventSequenceNumber: 0n,
    RunningState: 0,
    IsSubscribed: false,
    IsReplayable: false,
    TailEventSequenceNumber: 0n,
    HandledEventCount: 0n,
  };
}

export const ObserverInformation: MessageFns<ObserverInformation> = {
  encode(message: ObserverInformation, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Id !== "") {
      writer.uint32(10).string(message.Id);
    }
    if (message.EventSequenceId !== "") {
      writer.uint32(18).string(message.EventSequenceId);
    }
    if (message.Type !== 0) {
      writer.uint32(24).int32(message.Type);
    }
    if (message.Owner !== 0) {
      writer.uint32(32).int32(message.Owner);
    }
    for (const v of message.EventTypes) {
      EventType.encode(v!, writer.uint32(42).fork()).join();
    }
    if (message.NextEventSequenceNumber !== 0n) {
      if (BigInt.asUintN(64, message.NextEventSequenceNumber) !== message.NextEventSequenceNumber) {
        throw new globalThis.Error("value provided for field message.NextEventSequenceNumber of type uint64 too large");
      }
      writer.uint32(48).uint64(message.NextEventSequenceNumber);
    }
    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(56).uint64(message.LastHandledEventSequenceNumber);
    }
    if (message.RunningState !== 0) {
      writer.uint32(64).int32(message.RunningState);
    }
    if (message.IsSubscribed !== false) {
      writer.uint32(72).bool(message.IsSubscribed);
    }
    if (message.IsReplayable !== false) {
      writer.uint32(80).bool(message.IsReplayable);
    }
    if (message.TailEventSequenceNumber !== 0n) {
      if (BigInt.asUintN(64, message.TailEventSequenceNumber) !== message.TailEventSequenceNumber) {
        throw new globalThis.Error("value provided for field message.TailEventSequenceNumber of type uint64 too large");
      }
      writer.uint32(88).uint64(message.TailEventSequenceNumber);
    }
    if (message.HandledEventCount !== 0n) {
      if (BigInt.asUintN(64, message.HandledEventCount) !== message.HandledEventCount) {
        throw new globalThis.Error("value provided for field message.HandledEventCount of type uint64 too large");
      }
      writer.uint32(96).uint64(message.HandledEventCount);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ObserverInformation {
    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 = createBaseObserverInformation();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

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

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

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

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

            message.EventTypes.push(EventType.decode(reader, reader.uint32()));
            continue;
          }
          case 6: {
            if (tag !== 48) {
              break;
            }

            message.NextEventSequenceNumber = reader.uint64() as bigint;
            continue;
          }
          case 7: {
            if (tag !== 56) {
              break;
            }

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

            message.RunningState = reader.int32() as any;
            continue;
          }
          case 9: {
            if (tag !== 72) {
              break;
            }

            message.IsSubscribed = reader.bool();
            continue;
          }
          case 10: {
            if (tag !== 80) {
              break;
            }

            message.IsReplayable = reader.bool();
            continue;
          }
          case 11: {
            if (tag !== 88) {
              break;
            }

            message.TailEventSequenceNumber = reader.uint64() as bigint;
            continue;
          }
          case 12: {
            if (tag !== 96) {
              break;
            }

            message.HandledEventCount = 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): ObserverInformation {
    return {
      Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
      EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
      Type: isSet(object.Type) ? observerTypeFromJSON(object.Type) : 0,
      Owner: isSet(object.Owner) ? observerOwnerFromJSON(object.Owner) : 0,
      EventTypes: globalThis.Array.isArray(object?.EventTypes)
        ? object.EventTypes.map((e: any) => EventType.fromJSON(e))
        : [],
      NextEventSequenceNumber: isSet(object.NextEventSequenceNumber) ? BigInt(object.NextEventSequenceNumber) : 0n,
      LastHandledEventSequenceNumber: isSet(object.LastHandledEventSequenceNumber)
        ? BigInt(object.LastHandledEventSequenceNumber)
        : 0n,
      RunningState: isSet(object.RunningState) ? observerRunningStateFromJSON(object.RunningState) : 0,
      IsSubscribed: isSet(object.IsSubscribed) ? globalThis.Boolean(object.IsSubscribed) : false,
      IsReplayable: isSet(object.IsReplayable) ? globalThis.Boolean(object.IsReplayable) : false,
      TailEventSequenceNumber: isSet(object.TailEventSequenceNumber) ? BigInt(object.TailEventSequenceNumber) : 0n,
      HandledEventCount: isSet(object.HandledEventCount) ? BigInt(object.HandledEventCount) : 0n,
    };
  },

  toJSON(message: ObserverInformation): unknown {
    const obj: any = {};
    if (message.Id !== "") {
      obj.Id = message.Id;
    }
    if (message.EventSequenceId !== "") {
      obj.EventSequenceId = message.EventSequenceId;
    }
    if (message.Type !== 0) {
      obj.Type = observerTypeToJSON(message.Type);
    }
    if (message.Owner !== 0) {
      obj.Owner = observerOwnerToJSON(message.Owner);
    }
    if (message.EventTypes?.length) {
      obj.EventTypes = message.EventTypes.map((e) => EventType.toJSON(e));
    }
    if (message.NextEventSequenceNumber !== 0n) {
      obj.NextEventSequenceNumber = message.NextEventSequenceNumber.toString();
    }
    if (message.LastHandledEventSequenceNumber !== 0n) {
      obj.LastHandledEventSequenceNumber = message.LastHandledEventSequenceNumber.toString();
    }
    if (message.RunningState !== 0) {
      obj.RunningState = observerRunningStateToJSON(message.RunningState);
    }
    if (message.IsSubscribed !== false) {
      obj.IsSubscribed = message.IsSubscribed;
    }
    if (message.IsReplayable !== false) {
      obj.IsReplayable = message.IsReplayable;
    }
    if (message.TailEventSequenceNumber !== 0n) {
      obj.TailEventSequenceNumber = message.TailEventSequenceNumber.toString();
    }
    if (message.HandledEventCount !== 0n) {
      obj.HandledEventCount = message.HandledEventCount.toString();
    }
    return obj;
  },

  create(base?: DeepPartial<ObserverInformation>): ObserverInformation {
    return ObserverInformation.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ObserverInformation>): ObserverInformation {
    const message = createBaseObserverInformation();
    message.Id = object.Id ?? "";
    message.EventSequenceId = object.EventSequenceId ?? "";
    message.Type = object.Type ?? 0;
    message.Owner = object.Owner ?? 0;
    message.EventTypes = object.EventTypes?.map((e) => EventType.fromPartial(e)) || [];
    message.NextEventSequenceNumber =
      (object.NextEventSequenceNumber !== undefined && object.NextEventSequenceNumber !== null)
        ? BigInt(object.NextEventSequenceNumber)
        : 0n;
    message.LastHandledEventSequenceNumber =
      (object.LastHandledEventSequenceNumber !== undefined && object.LastHandledEventSequenceNumber !== null)
        ? BigInt(object.LastHandledEventSequenceNumber)
        : 0n;
    message.RunningState = object.RunningState ?? 0;
    message.IsSubscribed = object.IsSubscribed ?? false;
    message.IsReplayable = object.IsReplayable ?? false;
    message.TailEventSequenceNumber =
      (object.TailEventSequenceNumber !== undefined && object.TailEventSequenceNumber !== null)
        ? BigInt(object.TailEventSequenceNumber)
        : 0n;
    message.HandledEventCount = (object.HandledEventCount !== undefined && object.HandledEventCount !== null)
      ? BigInt(object.HandledEventCount)
      : 0n;
    return message;
  },
};

function createBaseReplay(): Replay {
  return { EventStore: "", Namespace: "", ObserverId: "", EventSequenceId: "" };
}

export const Replay: MessageFns<Replay> = {
  encode(message: Replay, 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.ObserverId !== "") {
      writer.uint32(26).string(message.ObserverId);
    }
    if (message.EventSequenceId !== "") {
      writer.uint32(34).string(message.EventSequenceId);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): Replay {
    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 = createBaseReplay();
      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.ObserverId = 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): Replay {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      ObserverId: isSet(object.ObserverId) ? globalThis.String(object.ObserverId) : "",
      EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
    };
  },

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

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

function createBaseReplayPartition(): ReplayPartition {
  return { EventStore: "", Namespace: "", ObserverId: "", EventSequenceId: "", Partition: "" };
}

export const ReplayPartition: MessageFns<ReplayPartition> = {
  encode(message: ReplayPartition, 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.ObserverId !== "") {
      writer.uint32(26).string(message.ObserverId);
    }
    if (message.EventSequenceId !== "") {
      writer.uint32(34).string(message.EventSequenceId);
    }
    if (message.Partition !== "") {
      writer.uint32(42).string(message.Partition);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ReplayPartition {
    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 = createBaseReplayPartition();
      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.ObserverId = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }

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

            message.Partition = 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): ReplayPartition {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      ObserverId: isSet(object.ObserverId) ? globalThis.String(object.ObserverId) : "",
      EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
      Partition: isSet(object.Partition) ? globalThis.String(object.Partition) : "",
    };
  },

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

  create(base?: DeepPartial<ReplayPartition>): ReplayPartition {
    return ReplayPartition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ReplayPartition>): ReplayPartition {
    const message = createBaseReplayPartition();
    message.EventStore = object.EventStore ?? "";
    message.Namespace = object.Namespace ?? "";
    message.ObserverId = object.ObserverId ?? "";
    message.EventSequenceId = object.EventSequenceId ?? "";
    message.Partition = object.Partition ?? "";
    return message;
  },
};

function createBaseReplayResponse(): ReplayResponse {
  return { JobId: "" };
}

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

  decode(input: BinaryReader | Uint8Array, length?: number): ReplayResponse {
    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 = createBaseReplayResponse();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.JobId = 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): ReplayResponse {
    return { JobId: isSet(object.JobId) ? globalThis.String(object.JobId) : "" };
  },

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

  create(base?: DeepPartial<ReplayResponse>): ReplayResponse {
    return ReplayResponse.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ReplayResponse>): ReplayResponse {
    const message = createBaseReplayResponse();
    message.JobId = object.JobId ?? "";
    return message;
  },
};

function createBaseRetryPartition(): RetryPartition {
  return { EventStore: "", Namespace: "", ObserverId: "", EventSequenceId: "", Partition: "" };
}

export const RetryPartition: MessageFns<RetryPartition> = {
  encode(message: RetryPartition, 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.ObserverId !== "") {
      writer.uint32(26).string(message.ObserverId);
    }
    if (message.EventSequenceId !== "") {
      writer.uint32(34).string(message.EventSequenceId);
    }
    if (message.Partition !== "") {
      writer.uint32(42).string(message.Partition);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): RetryPartition {
    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 = createBaseRetryPartition();
      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.ObserverId = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }

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

            message.Partition = 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): RetryPartition {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      ObserverId: isSet(object.ObserverId) ? globalThis.String(object.ObserverId) : "",
      EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
      Partition: isSet(object.Partition) ? globalThis.String(object.Partition) : "",
    };
  },

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

  create(base?: DeepPartial<RetryPartition>): RetryPartition {
    return RetryPartition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<RetryPartition>): RetryPartition {
    const message = createBaseRetryPartition();
    message.EventStore = object.EventStore ?? "";
    message.Namespace = object.Namespace ?? "";
    message.ObserverId = object.ObserverId ?? "";
    message.EventSequenceId = object.EventSequenceId ?? "";
    message.Partition = object.Partition ?? "";
    return message;
  },
};

function createBaseRetryPartitionResponse(): RetryPartitionResponse {
  return { Outcome: 0 };
}

export const RetryPartitionResponse: MessageFns<RetryPartitionResponse> = {
  encode(message: RetryPartitionResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Outcome !== 0) {
      writer.uint32(8).int32(message.Outcome);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): RetryPartitionResponse {
    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 = createBaseRetryPartitionResponse();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }

            message.Outcome = 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): RetryPartitionResponse {
    return { Outcome: isSet(object.Outcome) ? partitionRecoveryOutcomeFromJSON(object.Outcome) : 0 };
  },

  toJSON(message: RetryPartitionResponse): unknown {
    const obj: any = {};
    if (message.Outcome !== 0) {
      obj.Outcome = partitionRecoveryOutcomeToJSON(message.Outcome);
    }
    return obj;
  },

  create(base?: DeepPartial<RetryPartitionResponse>): RetryPartitionResponse {
    return RetryPartitionResponse.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<RetryPartitionResponse>): RetryPartitionResponse {
    const message = createBaseRetryPartitionResponse();
    message.Outcome = object.Outcome ?? 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 createBaseWaitForObserverCompletionRequest(): WaitForObserverCompletionRequest {
  return { EventStore: "", Namespace: "", EventSequenceId: "", TailEventSequenceNumber: 0n };
}

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

  decode(input: BinaryReader | Uint8Array, length?: number): WaitForObserverCompletionRequest {
    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 = createBaseWaitForObserverCompletionRequest();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

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

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

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

            message.TailEventSequenceNumber = 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): WaitForObserverCompletionRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
      TailEventSequenceNumber: isSet(object.TailEventSequenceNumber) ? BigInt(object.TailEventSequenceNumber) : 0n,
    };
  },

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

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

function createBaseWaitForObserverCompletionResponse(): WaitForObserverCompletionResponse {
  return { IsSuccess: false, FailedPartitions: [] };
}

export const WaitForObserverCompletionResponse: MessageFns<WaitForObserverCompletionResponse> = {
  encode(message: WaitForObserverCompletionResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.IsSuccess !== false) {
      writer.uint32(8).bool(message.IsSuccess);
    }
    for (const v of message.FailedPartitions) {
      FailedPartition.encode(v!, writer.uint32(18).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): WaitForObserverCompletionResponse {
    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 = createBaseWaitForObserverCompletionResponse();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }

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

            message.FailedPartitions.push(FailedPartition.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): WaitForObserverCompletionResponse {
    return {
      IsSuccess: isSet(object.IsSuccess) ? globalThis.Boolean(object.IsSuccess) : false,
      FailedPartitions: globalThis.Array.isArray(object?.FailedPartitions)
        ? object.FailedPartitions.map((e: any) => FailedPartition.fromJSON(e))
        : [],
    };
  },

  toJSON(message: WaitForObserverCompletionResponse): unknown {
    const obj: any = {};
    if (message.IsSuccess !== false) {
      obj.IsSuccess = message.IsSuccess;
    }
    if (message.FailedPartitions?.length) {
      obj.FailedPartitions = message.FailedPartitions.map((e) => FailedPartition.toJSON(e));
    }
    return obj;
  },

  create(base?: DeepPartial<WaitForObserverCompletionResponse>): WaitForObserverCompletionResponse {
    return WaitForObserverCompletionResponse.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<WaitForObserverCompletionResponse>): WaitForObserverCompletionResponse {
    const message = createBaseWaitForObserverCompletionResponse();
    message.IsSuccess = object.IsSuccess ?? false;
    message.FailedPartitions = object.FailedPartitions?.map((e) => FailedPartition.fromPartial(e)) || [];
    return message;
  },
};

export type FailedPartitionsDefinition = typeof FailedPartitionsDefinition;
export const FailedPartitionsDefinition = {
  name: "FailedPartitions",
  fullName: "Cratis.Chronicle.Contracts.Observation.FailedPartitions",
  methods: {
    getFailedPartitions: {
      name: "GetFailedPartitions",
      requestType: GetFailedPartitionsRequest as typeof GetFailedPartitionsRequest,
      requestStream: false,
      responseType: IEnumerableFailedPartition as typeof IEnumerableFailedPartition,
      responseStream: false,
      options: {},
    },
    observeFailedPartitions: {
      name: "ObserveFailedPartitions",
      requestType: GetFailedPartitionsRequest as typeof GetFailedPartitionsRequest,
      requestStream: false,
      responseType: IEnumerableFailedPartition as typeof IEnumerableFailedPartition,
      responseStream: true,
      options: {},
    },
  },
} as const;

export interface FailedPartitionsServiceImplementation<CallContextExt = {}> {
  getFailedPartitions(
    request: GetFailedPartitionsRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<IEnumerableFailedPartition>>;
  observeFailedPartitions(
    request: GetFailedPartitionsRequest,
    context: CallContext & CallContextExt,
  ): ServerStreamingMethodResult<DeepPartial<IEnumerableFailedPartition>>;
}

export interface FailedPartitionsClient<CallOptionsExt = {}> {
  getFailedPartitions(
    request: DeepPartial<GetFailedPartitionsRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<IEnumerableFailedPartition>;
  observeFailedPartitions(
    request: DeepPartial<GetFailedPartitionsRequest>,
    options?: CallOptions & CallOptionsExt,
  ): AsyncIterable<IEnumerableFailedPartition>;
}

export type ObserversDefinition = typeof ObserversDefinition;
export const ObserversDefinition = {
  name: "Observers",
  fullName: "Cratis.Chronicle.Contracts.Observation.Observers",
  methods: {
    clearFailedPartitions: {
      name: "ClearFailedPartitions",
      requestType: ClearFailedPartitions as typeof ClearFailedPartitions,
      requestStream: false,
      responseType: Empty as typeof Empty,
      responseStream: false,
      options: {},
    },
    clearObserverQuarantine: {
      name: "ClearObserverQuarantine",
      requestType: ClearObserverQuarantine as typeof ClearObserverQuarantine,
      requestStream: false,
      responseType: Empty as typeof Empty,
      responseStream: false,
      options: {},
    },
    getConnectedClientsForObserver: {
      name: "GetConnectedClientsForObserver",
      requestType: GetConnectedClientsForObserverRequest as typeof GetConnectedClientsForObserverRequest,
      requestStream: false,
      responseType: IEnumerableConnectedClient as typeof IEnumerableConnectedClient,
      responseStream: false,
      options: {},
    },
    getObserverInformation: {
      name: "GetObserverInformation",
      requestType: GetObserverInformationRequest as typeof GetObserverInformationRequest,
      requestStream: false,
      responseType: ObserverInformation as typeof ObserverInformation,
      responseStream: false,
      options: {},
    },
    getObservers: {
      name: "GetObservers",
      requestType: AllObserversRequest as typeof AllObserversRequest,
      requestStream: false,
      responseType: IEnumerableObserverInformation as typeof IEnumerableObserverInformation,
      responseStream: false,
      options: {},
    },
    getReplayableObserversForEventTypes: {
      name: "GetReplayableObserversForEventTypes",
      requestType: GetReplayableObserversForEventTypesRequest as typeof GetReplayableObserversForEventTypesRequest,
      requestStream: false,
      responseType: IEnumerableObserverInformation as typeof IEnumerableObserverInformation,
      responseStream: false,
      options: {},
    },
    observeObservers: {
      name: "ObserveObservers",
      requestType: AllObserversRequest as typeof AllObserversRequest,
      requestStream: false,
      responseType: IEnumerableObserverInformation as typeof IEnumerableObserverInformation,
      responseStream: true,
      options: {},
    },
    replay: {
      name: "Replay",
      requestType: Replay as typeof Replay,
      requestStream: false,
      responseType: ReplayResponse as typeof ReplayResponse,
      responseStream: false,
      options: {},
    },
    replayPartition: {
      name: "ReplayPartition",
      requestType: ReplayPartition as typeof ReplayPartition,
      requestStream: false,
      responseType: Empty as typeof Empty,
      responseStream: false,
      options: {},
    },
    retryPartition: {
      name: "RetryPartition",
      requestType: RetryPartition as typeof RetryPartition,
      requestStream: false,
      responseType: RetryPartitionResponse as typeof RetryPartitionResponse,
      responseStream: false,
      options: {},
    },
    waitForCompletion: {
      name: "WaitForCompletion",
      requestType: WaitForObserverCompletionRequest as typeof WaitForObserverCompletionRequest,
      requestStream: false,
      responseType: WaitForObserverCompletionResponse as typeof WaitForObserverCompletionResponse,
      responseStream: false,
      options: {},
    },
  },
} as const;

export interface ObserversServiceImplementation<CallContextExt = {}> {
  clearFailedPartitions(
    request: ClearFailedPartitions,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<Empty>>;
  clearObserverQuarantine(
    request: ClearObserverQuarantine,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<Empty>>;
  getConnectedClientsForObserver(
    request: GetConnectedClientsForObserverRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<IEnumerableConnectedClient>>;
  getObserverInformation(
    request: GetObserverInformationRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<ObserverInformation>>;
  getObservers(
    request: AllObserversRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<IEnumerableObserverInformation>>;
  getReplayableObserversForEventTypes(
    request: GetReplayableObserversForEventTypesRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<IEnumerableObserverInformation>>;
  observeObservers(
    request: AllObserversRequest,
    context: CallContext & CallContextExt,
  ): ServerStreamingMethodResult<DeepPartial<IEnumerableObserverInformation>>;
  replay(request: Replay, context: CallContext & CallContextExt): Promise<DeepPartial<ReplayResponse>>;
  replayPartition(request: ReplayPartition, context: CallContext & CallContextExt): Promise<DeepPartial<Empty>>;
  retryPartition(
    request: RetryPartition,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<RetryPartitionResponse>>;
  waitForCompletion(
    request: WaitForObserverCompletionRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<WaitForObserverCompletionResponse>>;
}

export interface ObserversClient<CallOptionsExt = {}> {
  clearFailedPartitions(
    request: DeepPartial<ClearFailedPartitions>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<Empty>;
  clearObserverQuarantine(
    request: DeepPartial<ClearObserverQuarantine>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<Empty>;
  getConnectedClientsForObserver(
    request: DeepPartial<GetConnectedClientsForObserverRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<IEnumerableConnectedClient>;
  getObserverInformation(
    request: DeepPartial<GetObserverInformationRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<ObserverInformation>;
  getObservers(
    request: DeepPartial<AllObserversRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<IEnumerableObserverInformation>;
  getReplayableObserversForEventTypes(
    request: DeepPartial<GetReplayableObserversForEventTypesRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<IEnumerableObserverInformation>;
  observeObservers(
    request: DeepPartial<AllObserversRequest>,
    options?: CallOptions & CallOptionsExt,
  ): AsyncIterable<IEnumerableObserverInformation>;
  replay(request: DeepPartial<Replay>, options?: CallOptions & CallOptionsExt): Promise<ReplayResponse>;
  replayPartition(request: DeepPartial<ReplayPartition>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
  retryPartition(
    request: DeepPartial<RetryPartition>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<RetryPartitionResponse>;
  waitForCompletion(
    request: DeepPartial<WaitForObserverCompletionRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<WaitForObserverCompletionResponse>;
}

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;
}