@cratis/chronicle.contracts 16.2.0 → 16.3.0

package/generated/observation.ts

@@ -171,6 +171,18 @@ export interface ClearObserverQuarantine {
   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;
@@ -192,6 +204,13 @@ export interface FailedPartitionAttempt {
   StackTrace: string;
 }
 
+export interface GetConnectedClientsForObserverRequest {
+  EventStore: string;
+  Namespace: string;
+  ObserverId: string;
+  EventSequenceId: string;
+}
+
 export interface GetFailedPartitionsRequest {
   EventStore: string;
   Namespace: string;
@@ -211,6 +230,10 @@ export interface GetReplayableObserversForEventTypesRequest {
   EventTypes: EventType[];
 }
 
+export interface IEnumerableConnectedClient {
+  items: ConnectedClient[];
+}
+
 export interface IEnumerableFailedPartition {
   items: FailedPartition[];
 }
@@ -463,6 +486,208 @@ export const ClearObserverQuarantine: MessageFns<ClearObserverQuarantine> = {
   },
 };
 
+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 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;
+  },
+
+  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 };
 }
@@ -780,6 +1005,114 @@ export const FailedPartitionAttempt: MessageFns<FailedPartitionAttempt> = {
   },
 };
 
+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 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;
+  },
+
+  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: "" };
 }
@@ -1076,6 +1409,66 @@ export const GetReplayableObserversForEventTypesRequest: MessageFns<GetReplayabl
   },
 };
 
+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 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;
+  },
+
+  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: [] };
 }
@@ -2199,6 +2592,14 @@ export const ObserversDefinition = {
       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,
@@ -2271,6 +2672,10 @@ export interface ObserversServiceImplementation<CallContextExt = {}> {
     request: ClearObserverQuarantine,
     context: CallContext & CallContextExt,
   ): Promise<DeepPartial<Empty>>;
+  getConnectedClientsForObserver(
+    request: GetConnectedClientsForObserverRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<IEnumerableConnectedClient>>;
   getObserverInformation(
     request: GetObserverInformationRequest,
     context: CallContext & CallContextExt,
@@ -2301,6 +2706,10 @@ export interface ObserversClient<CallOptionsExt = {}> {
     request: DeepPartial<ClearObserverQuarantine>,
     options?: CallOptions & CallOptionsExt,
   ): Promise<Empty>;
+  getConnectedClientsForObserver(
+    request: DeepPartial<GetConnectedClientsForObserverRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<IEnumerableConnectedClient>;
   getObserverInformation(
     request: DeepPartial<GetObserverInformationRequest>,
     options?: CallOptions & CallOptionsExt,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/chronicle.contracts",
-    "version": "16.2.0",
+    "version": "16.3.0",
     "description": "TypeScript gRPC contracts for Chronicle",
     "author": "Cratis",
     "license": "MIT",