@cratis/chronicle.contracts 19.115.3 → 19.116.0

package/generated/sequences.ts

@@ -823,6 +823,7 @@ export interface AppendedEventResponse {
   Revisions: EventRevision[];
   GenerationalContent: KeyValuePairInt32String[];
   RevisedGeneration: number;
+  ErasedProperties: string[];
 }
 
 export interface AppendedEventsRequest {
@@ -1205,6 +1206,15 @@ export interface FromSequenceNumberRequest {
   EventTypeIds: string;
 }
 
+export interface FromSequenceNumberWithErasedPropertiesRequest {
+  EventStore: string;
+  Namespace: string;
+  EventSequenceId: string;
+  FromEventSequenceNumber: bigint;
+  EventSourceId: string;
+  EventTypeIds: string;
+}
+
 export interface HasEventsForEventSourceIdRequest {
   EventStore: string;
   Namespace: string;
@@ -5812,6 +5822,7 @@ function createBaseAppendedEventResponse(): AppendedEventResponse {
     Revisions: [],
     GenerationalContent: [],
     RevisedGeneration: 0,
+    ErasedProperties: [],
   };
 }
 
@@ -5838,6 +5849,9 @@ export const AppendedEventResponse: MessageFns<AppendedEventResponse> = {
     if (message.RevisedGeneration !== 0) {
       writer.uint32(56).uint32(message.RevisedGeneration);
     }
+    for (const v of message.ErasedProperties) {
+      writer.uint32(66).string(v!);
+    }
     return writer;
   },
 
@@ -5910,6 +5924,14 @@ export const AppendedEventResponse: MessageFns<AppendedEventResponse> = {
             message.RevisedGeneration = reader.uint32();
             continue;
           }
+          case 8: {
+            if (tag !== 66) {
+              break;
+            }
+
+            message.ErasedProperties.push(reader.string());
+            continue;
+          }
         }
         if ((tag & 7) === 4 || tag === 0) {
           break;
@@ -5935,6 +5957,9 @@ export const AppendedEventResponse: MessageFns<AppendedEventResponse> = {
         ? object.GenerationalContent.map((e: any) => KeyValuePairInt32String.fromJSON(e))
         : [],
       RevisedGeneration: isSet(object.RevisedGeneration) ? globalThis.Number(object.RevisedGeneration) : 0,
+      ErasedProperties: globalThis.Array.isArray(object?.ErasedProperties)
+        ? object.ErasedProperties.map((e: any) => globalThis.String(e))
+        : [],
     };
   },
 
@@ -5961,6 +5986,9 @@ export const AppendedEventResponse: MessageFns<AppendedEventResponse> = {
     if (message.RevisedGeneration !== 0) {
       obj.RevisedGeneration = Math.round(message.RevisedGeneration);
     }
+    if (message.ErasedProperties?.length) {
+      obj.ErasedProperties = message.ErasedProperties;
+    }
     return obj;
   },
 
@@ -5978,6 +6006,7 @@ export const AppendedEventResponse: MessageFns<AppendedEventResponse> = {
     message.Revisions = object.Revisions?.map((e) => EventRevision.fromPartial(e)) || [];
     message.GenerationalContent = object.GenerationalContent?.map((e) => KeyValuePairInt32String.fromPartial(e)) || [];
     message.RevisedGeneration = object.RevisedGeneration ?? 0;
+    message.ErasedProperties = object.ErasedProperties?.map((e) => e) || [];
     return message;
   },
 };
@@ -12565,6 +12594,178 @@ export const FromSequenceNumberRequest: MessageFns<FromSequenceNumberRequest> =
   },
 };
 
+function createBaseFromSequenceNumberWithErasedPropertiesRequest(): FromSequenceNumberWithErasedPropertiesRequest {
+  return {
+    EventStore: "",
+    Namespace: "",
+    EventSequenceId: "",
+    FromEventSequenceNumber: 0n,
+    EventSourceId: "",
+    EventTypeIds: "",
+  };
+}
+
+export const FromSequenceNumberWithErasedPropertiesRequest: MessageFns<FromSequenceNumberWithErasedPropertiesRequest> =
+  {
+    encode(
+      message: FromSequenceNumberWithErasedPropertiesRequest,
+      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.FromEventSequenceNumber !== 0n) {
+        if (BigInt.asUintN(64, message.FromEventSequenceNumber) !== message.FromEventSequenceNumber) {
+          throw new globalThis.Error(
+            "value provided for field message.FromEventSequenceNumber of type uint64 too large",
+          );
+        }
+        writer.uint32(32).uint64(message.FromEventSequenceNumber);
+      }
+      if (message.EventSourceId !== "") {
+        writer.uint32(42).string(message.EventSourceId);
+      }
+      if (message.EventTypeIds !== "") {
+        writer.uint32(50).string(message.EventTypeIds);
+      }
+      return writer;
+    },
+
+    decode(input: BinaryReader | Uint8Array, length?: number): FromSequenceNumberWithErasedPropertiesRequest {
+      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 = createBaseFromSequenceNumberWithErasedPropertiesRequest();
+        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.FromEventSequenceNumber = reader.uint64() as bigint;
+              continue;
+            }
+            case 5: {
+              if (tag !== 42) {
+                break;
+              }
+
+              message.EventSourceId = reader.string();
+              continue;
+            }
+            case 6: {
+              if (tag !== 50) {
+                break;
+              }
+
+              message.EventTypeIds = 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): FromSequenceNumberWithErasedPropertiesRequest {
+      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) : "",
+        FromEventSequenceNumber: isSet(object.FromEventSequenceNumber) ? BigInt(object.FromEventSequenceNumber) : 0n,
+        EventSourceId: isSet(object.EventSourceId) ? globalThis.String(object.EventSourceId) : "",
+        EventTypeIds: isSet(object.EventTypeIds) ? globalThis.String(object.EventTypeIds) : "",
+      };
+    },
+
+    toJSON(message: FromSequenceNumberWithErasedPropertiesRequest): 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.FromEventSequenceNumber !== 0n) {
+        obj.FromEventSequenceNumber = message.FromEventSequenceNumber.toString();
+      }
+      if (message.EventSourceId !== "") {
+        obj.EventSourceId = message.EventSourceId;
+      }
+      if (message.EventTypeIds !== "") {
+        obj.EventTypeIds = message.EventTypeIds;
+      }
+      return obj;
+    },
+
+    create(
+      base?: DeepPartial<FromSequenceNumberWithErasedPropertiesRequest>,
+    ): FromSequenceNumberWithErasedPropertiesRequest {
+      return FromSequenceNumberWithErasedPropertiesRequest.fromPartial(base ?? {});
+    },
+    fromPartial(
+      object: DeepPartial<FromSequenceNumberWithErasedPropertiesRequest>,
+    ): FromSequenceNumberWithErasedPropertiesRequest {
+      const message = createBaseFromSequenceNumberWithErasedPropertiesRequest();
+      message.EventStore = object.EventStore ?? "";
+      message.Namespace = object.Namespace ?? "";
+      message.EventSequenceId = object.EventSequenceId ?? "";
+      message.FromEventSequenceNumber =
+        (object.FromEventSequenceNumber !== undefined && object.FromEventSequenceNumber !== null)
+          ? BigInt(object.FromEventSequenceNumber)
+          : 0n;
+      message.EventSourceId = object.EventSourceId ?? "";
+      message.EventTypeIds = object.EventTypeIds ?? "";
+      return message;
+    },
+  };
+
 function createBaseHasEventsForEventSourceIdRequest(): HasEventsForEventSourceIdRequest {
   return { EventStore: "", Namespace: "", EventSequenceId: "", EventSourceId: "" };
 }
@@ -19099,6 +19300,15 @@ export const EventSequencesDefinition = {
       responseStream: false,
       options: {},
     },
+    fromSequenceNumberWithErasedProperties: {
+      name: "FromSequenceNumberWithErasedProperties",
+      requestType:
+        FromSequenceNumberWithErasedPropertiesRequest as typeof FromSequenceNumberWithErasedPropertiesRequest,
+      requestStream: false,
+      responseType: QueryResultIEnumerableAppendedEventResponse as typeof QueryResultIEnumerableAppendedEventResponse,
+      responseStream: false,
+      options: {},
+    },
     hasEventsForEventSourceId: {
       name: "HasEventsForEventSourceId",
       requestType: HasEventsForEventSourceIdRequest as typeof HasEventsForEventSourceIdRequest,
@@ -19301,6 +19511,10 @@ export interface EventSequencesServiceImplementation<CallContextExt = {}> {
     request: FromSequenceNumberRequest,
     context: CallContext & CallContextExt,
   ): Promise<DeepPartial<QueryResultIEnumerableAppendedEventResponse>>;
+  fromSequenceNumberWithErasedProperties(
+    request: FromSequenceNumberWithErasedPropertiesRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<QueryResultIEnumerableAppendedEventResponse>>;
   hasEventsForEventSourceId(
     request: HasEventsForEventSourceIdRequest,
     context: CallContext & CallContextExt,
@@ -19434,6 +19648,10 @@ export interface EventSequencesClient<CallOptionsExt = {}> {
     request: DeepPartial<FromSequenceNumberRequest>,
     options?: CallOptions & CallOptionsExt,
   ): Promise<QueryResultIEnumerableAppendedEventResponse>;
+  fromSequenceNumberWithErasedProperties(
+    request: DeepPartial<FromSequenceNumberWithErasedPropertiesRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<QueryResultIEnumerableAppendedEventResponse>;
   hasEventsForEventSourceId(
     request: DeepPartial<HasEventsForEventSourceIdRequest>,
     options?: CallOptions & CallOptionsExt,

package/package.json

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