@cratis/chronicle.contracts 19.79.0 → 19.81.1

package/generated/observation.ts

@@ -549,6 +549,17 @@ export interface ReplayResponse {
   JobId: string;
 }
 
+export interface RetryFailedPartitions {
+  EventStore: string;
+  Namespace: string;
+  ObserverId: string;
+  EventSequenceId: string;
+}
+
+export interface RetryFailedPartitionsResponse {
+  FailedPartitions: number;
+}
+
 export interface RetryPartition {
   EventStore: string;
   Namespace: string;
@@ -3521,6 +3532,190 @@ export const ReplayResponse: MessageFns<ReplayResponse> = {
   },
 };
 
+function createBaseRetryFailedPartitions(): RetryFailedPartitions {
+  return { EventStore: "", Namespace: "", ObserverId: "", EventSequenceId: "" };
+}
+
+export const RetryFailedPartitions: MessageFns<RetryFailedPartitions> = {
+  encode(message: RetryFailedPartitions, 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): RetryFailedPartitions {
+    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 = createBaseRetryFailedPartitions();
+      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): RetryFailedPartitions {
+    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: RetryFailedPartitions): 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<RetryFailedPartitions>): RetryFailedPartitions {
+    return RetryFailedPartitions.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<RetryFailedPartitions>): RetryFailedPartitions {
+    const message = createBaseRetryFailedPartitions();
+    message.EventStore = object.EventStore ?? "";
+    message.Namespace = object.Namespace ?? "";
+    message.ObserverId = object.ObserverId ?? "";
+    message.EventSequenceId = object.EventSequenceId ?? "";
+    return message;
+  },
+};
+
+function createBaseRetryFailedPartitionsResponse(): RetryFailedPartitionsResponse {
+  return { FailedPartitions: 0 };
+}
+
+export const RetryFailedPartitionsResponse: MessageFns<RetryFailedPartitionsResponse> = {
+  encode(message: RetryFailedPartitionsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.FailedPartitions !== 0) {
+      writer.uint32(8).int32(message.FailedPartitions);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): RetryFailedPartitionsResponse {
+    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 = createBaseRetryFailedPartitionsResponse();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 8) {
+              break;
+            }
+
+            message.FailedPartitions = reader.int32();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): RetryFailedPartitionsResponse {
+    return { FailedPartitions: isSet(object.FailedPartitions) ? globalThis.Number(object.FailedPartitions) : 0 };
+  },
+
+  toJSON(message: RetryFailedPartitionsResponse): unknown {
+    const obj: any = {};
+    if (message.FailedPartitions !== 0) {
+      obj.FailedPartitions = Math.round(message.FailedPartitions);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<RetryFailedPartitionsResponse>): RetryFailedPartitionsResponse {
+    return RetryFailedPartitionsResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<RetryFailedPartitionsResponse>): RetryFailedPartitionsResponse {
+    const message = createBaseRetryFailedPartitionsResponse();
+    message.FailedPartitions = object.FailedPartitions ?? 0;
+    return message;
+  },
+};
+
 function createBaseRetryPartition(): RetryPartition {
   return { EventStore: "", Namespace: "", ObserverId: "", EventSequenceId: "", Partition: "" };
 }
@@ -4269,6 +4464,14 @@ export const ObserversDefinition = {
       responseStream: false,
       options: {},
     },
+    retryFailedPartitions: {
+      name: "RetryFailedPartitions",
+      requestType: RetryFailedPartitions as typeof RetryFailedPartitions,
+      requestStream: false,
+      responseType: RetryFailedPartitionsResponse as typeof RetryFailedPartitionsResponse,
+      responseStream: false,
+      options: {},
+    },
     retryPartition: {
       name: "RetryPartition",
       requestType: RetryPartition as typeof RetryPartition,
@@ -4328,6 +4531,10 @@ export interface ObserversServiceImplementation<CallContextExt = {}> {
   ): Promise<DeepPartial<RemoveObserverResponse>>;
   replay(request: Replay, context: CallContext & CallContextExt): Promise<DeepPartial<ReplayResponse>>;
   replayPartition(request: ReplayPartition, context: CallContext & CallContextExt): Promise<DeepPartial<Empty>>;
+  retryFailedPartitions(
+    request: RetryFailedPartitions,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<RetryFailedPartitionsResponse>>;
   retryPartition(
     request: RetryPartition,
     context: CallContext & CallContextExt,
@@ -4378,6 +4585,10 @@ export interface ObserversClient<CallOptionsExt = {}> {
   ): Promise<RemoveObserverResponse>;
   replay(request: DeepPartial<Replay>, options?: CallOptions & CallOptionsExt): Promise<ReplayResponse>;
   replayPartition(request: DeepPartial<ReplayPartition>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
+  retryFailedPartitions(
+    request: DeepPartial<RetryFailedPartitions>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<RetryFailedPartitionsResponse>;
   retryPartition(
     request: DeepPartial<RetryPartition>,
     options?: CallOptions & CallOptionsExt,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/chronicle.contracts",
-    "version": "19.79.0",
+    "version": "19.81.1",
     "description": "TypeScript gRPC client contracts for Cratis Chronicle - the open-source event-sourcing database",
     "keywords": [
         "event-sourcing",