@cratis/chronicle.contracts 19.27.4 → 19.29.0

package/generated/index.ts

@@ -39,7 +39,7 @@ export type { JobsClient, JobsServiceImplementation } from './jobs';
 export { AllNamespacesRequest, EnsureNamespaceRequest, NamespaceNamesResponse, NamespacesDefinition, ObserveNamespacesRequest, QueryResultIEnumerableNamespaceNamesResponse } from './namespaces';
 export type { NamespacesClient, NamespacesServiceImplementation } from './namespaces';
 
-export { AllObserversRequest, AppendedEventTypeTail, ClearFailedPartitions, ClearObserverQuarantine, FailedPartition, FailedPartitionAttempt, FailedPartitionsDefinition, FailureKind, failureKindFromJSON, failureKindToJSON, GetConnectedClientsForObserverRequest, GetFailedPartitionsRequest, GetObserverInformationRequest, GetReplayableObserversForEventTypesRequest, IEnumerableFailedPartition, IEnumerableObserverInformation, ObserverInformation, ObserverOwner, observerOwnerFromJSON, observerOwnerToJSON, ObserverRemovalOutcome, observerRemovalOutcomeFromJSON, observerRemovalOutcomeToJSON, ObserverRunningState, observerRunningStateFromJSON, observerRunningStateToJSON, ObserversDefinition, ObserverType, observerTypeFromJSON, observerTypeToJSON, PartitionRecoveryOutcome, partitionRecoveryOutcomeFromJSON, partitionRecoveryOutcomeToJSON, RemoveObserver, RemoveObserverResponse, Replay, ReplayPartition, ReplayResponse, RetryPartition, RetryPartitionResponse, WaitForObserverCompletionRequest, WaitForObserverCompletionResponse } from './observation';
+export { AllObserversRequest, AppendedEventTypeTail, ClearFailedPartitions, ClearObserverQuarantine, ClearPartitionQuarantine, ClearPartitionQuarantineOutcome, clearPartitionQuarantineOutcomeFromJSON, clearPartitionQuarantineOutcomeToJSON, ClearPartitionQuarantineResponse, FailedPartition, FailedPartitionAttempt, FailedPartitionsDefinition, FailureKind, failureKindFromJSON, failureKindToJSON, GetConnectedClientsForObserverRequest, GetFailedPartitionsRequest, GetObserverInformationRequest, GetReplayableObserversForEventTypesRequest, IEnumerableFailedPartition, IEnumerableObserverInformation, ObserverInformation, ObserverOwner, observerOwnerFromJSON, observerOwnerToJSON, ObserverRemovalOutcome, observerRemovalOutcomeFromJSON, observerRemovalOutcomeToJSON, ObserverRunningState, observerRunningStateFromJSON, observerRunningStateToJSON, ObserversDefinition, ObserverType, observerTypeFromJSON, observerTypeToJSON, PartitionRecoveryOutcome, partitionRecoveryOutcomeFromJSON, partitionRecoveryOutcomeToJSON, RemoveObserver, RemoveObserverResponse, Replay, ReplayPartition, ReplayResponse, RetryPartition, RetryPartitionResponse, WaitForObserverCompletionRequest, WaitForObserverCompletionResponse } from './observation';
 export type { FailedPartitionsClient, FailedPartitionsServiceImplementation, ObserversClient, ObserversServiceImplementation } from './observation';
 
 export { AddEventStoreSubscriptions, EventStoreSubscriptionDefinition, EventStoreSubscriptionsDefinition, GetEventStoreSubscriptionsRequest, IEnumerableEventStoreSubscriptionDefinition, RemoveEventStoreSubscriptions } from './observation_eventstoresubscriptions';

package/generated/observation.ts

@@ -12,6 +12,45 @@ import { Guid } from "./protobuf-net/bcl";
 
 export const protobufPackage = "Cratis.Chronicle.Contracts.Observation";
 
+export enum ClearPartitionQuarantineOutcome {
+  Cleared = 0,
+  NotFound = 1,
+  NotQuarantined = 2,
+  UNRECOGNIZED = -1,
+}
+
+export function clearPartitionQuarantineOutcomeFromJSON(object: any): ClearPartitionQuarantineOutcome {
+  switch (object) {
+    case 0:
+    case "Cleared":
+      return ClearPartitionQuarantineOutcome.Cleared;
+    case 1:
+    case "NotFound":
+      return ClearPartitionQuarantineOutcome.NotFound;
+    case 2:
+    case "NotQuarantined":
+      return ClearPartitionQuarantineOutcome.NotQuarantined;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return ClearPartitionQuarantineOutcome.UNRECOGNIZED;
+  }
+}
+
+export function clearPartitionQuarantineOutcomeToJSON(object: ClearPartitionQuarantineOutcome): string {
+  switch (object) {
+    case ClearPartitionQuarantineOutcome.Cleared:
+      return "Cleared";
+    case ClearPartitionQuarantineOutcome.NotFound:
+      return "NotFound";
+    case ClearPartitionQuarantineOutcome.NotQuarantined:
+      return "NotQuarantined";
+    case ClearPartitionQuarantineOutcome.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
 export enum FailureKind {
   FAILURE_KIND_Unknown = 0,
   Handling = 1,
@@ -318,6 +357,20 @@ export interface ClearObserverQuarantine {
   EventSequenceId: string;
 }
 
+export interface ClearPartitionQuarantine {
+  EventStore: string;
+  Namespace: string;
+  ObserverId: string;
+  EventSequenceId: string;
+  Partition: string;
+  RetryImmediately: boolean;
+}
+
+export interface ClearPartitionQuarantineResponse {
+  Outcome: ClearPartitionQuarantineOutcome;
+  RetryOutcome: PartitionRecoveryOutcome;
+}
+
 export interface ConnectedClient {
   ConnectionId: string;
   Version: string;
@@ -885,6 +938,240 @@ export const ClearObserverQuarantine: MessageFns<ClearObserverQuarantine> = {
   },
 };
 
+function createBaseClearPartitionQuarantine(): ClearPartitionQuarantine {
+  return { EventStore: "", Namespace: "", ObserverId: "", EventSequenceId: "", Partition: "", RetryImmediately: false };
+}
+
+export const ClearPartitionQuarantine: MessageFns<ClearPartitionQuarantine> = {
+  encode(message: ClearPartitionQuarantine, 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);
+    }
+    if (message.RetryImmediately !== false) {
+      writer.uint32(48).bool(message.RetryImmediately);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ClearPartitionQuarantine {
+    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 = createBaseClearPartitionQuarantine();
+      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;
+          }
+          case 6: {
+            if (tag !== 48) {
+              break;
+            }
+
+            message.RetryImmediately = 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): ClearPartitionQuarantine {
+    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) : "",
+      RetryImmediately: isSet(object.RetryImmediately) ? globalThis.Boolean(object.RetryImmediately) : false,
+    };
+  },
+
+  toJSON(message: ClearPartitionQuarantine): 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;
+    }
+    if (message.RetryImmediately !== false) {
+      obj.RetryImmediately = message.RetryImmediately;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<ClearPartitionQuarantine>): ClearPartitionQuarantine {
+    return ClearPartitionQuarantine.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ClearPartitionQuarantine>): ClearPartitionQuarantine {
+    const message = createBaseClearPartitionQuarantine();
+    message.EventStore = object.EventStore ?? "";
+    message.Namespace = object.Namespace ?? "";
+    message.ObserverId = object.ObserverId ?? "";
+    message.EventSequenceId = object.EventSequenceId ?? "";
+    message.Partition = object.Partition ?? "";
+    message.RetryImmediately = object.RetryImmediately ?? false;
+    return message;
+  },
+};
+
+function createBaseClearPartitionQuarantineResponse(): ClearPartitionQuarantineResponse {
+  return { Outcome: 0, RetryOutcome: 0 };
+}
+
+export const ClearPartitionQuarantineResponse: MessageFns<ClearPartitionQuarantineResponse> = {
+  encode(message: ClearPartitionQuarantineResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.Outcome !== 0) {
+      writer.uint32(8).int32(message.Outcome);
+    }
+    if (message.RetryOutcome !== 0) {
+      writer.uint32(16).int32(message.RetryOutcome);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ClearPartitionQuarantineResponse {
+    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 = createBaseClearPartitionQuarantineResponse();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 8) {
+              break;
+            }
+
+            message.Outcome = reader.int32() as any;
+            continue;
+          }
+          case 2: {
+            if (tag !== 16) {
+              break;
+            }
+
+            message.RetryOutcome = 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): ClearPartitionQuarantineResponse {
+    return {
+      Outcome: isSet(object.Outcome) ? clearPartitionQuarantineOutcomeFromJSON(object.Outcome) : 0,
+      RetryOutcome: isSet(object.RetryOutcome) ? partitionRecoveryOutcomeFromJSON(object.RetryOutcome) : 0,
+    };
+  },
+
+  toJSON(message: ClearPartitionQuarantineResponse): unknown {
+    const obj: any = {};
+    if (message.Outcome !== 0) {
+      obj.Outcome = clearPartitionQuarantineOutcomeToJSON(message.Outcome);
+    }
+    if (message.RetryOutcome !== 0) {
+      obj.RetryOutcome = partitionRecoveryOutcomeToJSON(message.RetryOutcome);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<ClearPartitionQuarantineResponse>): ClearPartitionQuarantineResponse {
+    return ClearPartitionQuarantineResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ClearPartitionQuarantineResponse>): ClearPartitionQuarantineResponse {
+    const message = createBaseClearPartitionQuarantineResponse();
+    message.Outcome = object.Outcome ?? 0;
+    message.RetryOutcome = object.RetryOutcome ?? 0;
+    return message;
+  },
+};
+
 function createBaseConnectedClient(): ConnectedClient {
   return {
     ConnectionId: "",
@@ -3611,6 +3898,14 @@ export const ObserversDefinition = {
       responseStream: false,
       options: {},
     },
+    clearPartitionQuarantine: {
+      name: "ClearPartitionQuarantine",
+      requestType: ClearPartitionQuarantine as typeof ClearPartitionQuarantine,
+      requestStream: false,
+      responseType: ClearPartitionQuarantineResponse as typeof ClearPartitionQuarantineResponse,
+      responseStream: false,
+      options: {},
+    },
     getConnectedClientsForObserver: {
       name: "GetConnectedClientsForObserver",
       requestType: GetConnectedClientsForObserverRequest as typeof GetConnectedClientsForObserverRequest,
@@ -3703,6 +3998,10 @@ export interface ObserversServiceImplementation<CallContextExt = {}> {
     request: ClearObserverQuarantine,
     context: CallContext & CallContextExt,
   ): Promise<DeepPartial<Empty>>;
+  clearPartitionQuarantine(
+    request: ClearPartitionQuarantine,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<ClearPartitionQuarantineResponse>>;
   getConnectedClientsForObserver(
     request: GetConnectedClientsForObserverRequest,
     context: CallContext & CallContextExt,
@@ -3748,6 +4047,10 @@ export interface ObserversClient<CallOptionsExt = {}> {
     request: DeepPartial<ClearObserverQuarantine>,
     options?: CallOptions & CallOptionsExt,
   ): Promise<Empty>;
+  clearPartitionQuarantine(
+    request: DeepPartial<ClearPartitionQuarantine>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<ClearPartitionQuarantineResponse>;
   getConnectedClientsForObserver(
     request: DeepPartial<GetConnectedClientsForObserverRequest>,
     options?: CallOptions & CallOptionsExt,

package/package.json

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