@cratis/chronicle.contracts 16.45.3 → 17.0.1

package/generated/clients.ts

@@ -11,6 +11,20 @@ import { Empty } from "./google/protobuf/empty";
 
 export const protobufPackage = "Cratis.Chronicle.Contracts.Clients";
 
+export interface CompatibilityRequest {
+  ClientType: string;
+  ClientVersion: string;
+  ProtocolVersion: string;
+  DescriptorSet: Buffer;
+}
+
+export interface CompatibilityResponse {
+  IsCompatible: boolean;
+  Incompatibilities: string[];
+  ServerVersion: string;
+  ServerProtocolVersion: string;
+}
+
 export interface ConnectRequest {
   ConnectionId: string;
   ClientVersion: string;
@@ -50,6 +64,242 @@ export interface SerializableDateTimeOffset {
   Value: string;
 }
 
+function createBaseCompatibilityRequest(): CompatibilityRequest {
+  return { ClientType: "", ClientVersion: "", ProtocolVersion: "", DescriptorSet: Buffer.alloc(0) };
+}
+
+export const CompatibilityRequest: MessageFns<CompatibilityRequest> = {
+  encode(message: CompatibilityRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.ClientType !== "") {
+      writer.uint32(10).string(message.ClientType);
+    }
+    if (message.ClientVersion !== "") {
+      writer.uint32(18).string(message.ClientVersion);
+    }
+    if (message.ProtocolVersion !== "") {
+      writer.uint32(26).string(message.ProtocolVersion);
+    }
+    if (message.DescriptorSet.length !== 0) {
+      writer.uint32(34).bytes(message.DescriptorSet);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CompatibilityRequest {
+    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 = createBaseCompatibilityRequest();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.ClientType = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.ClientVersion = reader.string();
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.ProtocolVersion = reader.string();
+            continue;
+          }
+          case 4: {
+            if (tag !== 34) {
+              break;
+            }
+
+            message.DescriptorSet = Buffer.from(reader.bytes());
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): CompatibilityRequest {
+    return {
+      ClientType: isSet(object.ClientType) ? globalThis.String(object.ClientType) : "",
+      ClientVersion: isSet(object.ClientVersion) ? globalThis.String(object.ClientVersion) : "",
+      ProtocolVersion: isSet(object.ProtocolVersion) ? globalThis.String(object.ProtocolVersion) : "",
+      DescriptorSet: isSet(object.DescriptorSet) ? Buffer.from(bytesFromBase64(object.DescriptorSet)) : Buffer.alloc(0),
+    };
+  },
+
+  toJSON(message: CompatibilityRequest): unknown {
+    const obj: any = {};
+    if (message.ClientType !== "") {
+      obj.ClientType = message.ClientType;
+    }
+    if (message.ClientVersion !== "") {
+      obj.ClientVersion = message.ClientVersion;
+    }
+    if (message.ProtocolVersion !== "") {
+      obj.ProtocolVersion = message.ProtocolVersion;
+    }
+    if (message.DescriptorSet.length !== 0) {
+      obj.DescriptorSet = base64FromBytes(message.DescriptorSet);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<CompatibilityRequest>): CompatibilityRequest {
+    return CompatibilityRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<CompatibilityRequest>): CompatibilityRequest {
+    const message = createBaseCompatibilityRequest();
+    message.ClientType = object.ClientType ?? "";
+    message.ClientVersion = object.ClientVersion ?? "";
+    message.ProtocolVersion = object.ProtocolVersion ?? "";
+    message.DescriptorSet = object.DescriptorSet ?? Buffer.alloc(0);
+    return message;
+  },
+};
+
+function createBaseCompatibilityResponse(): CompatibilityResponse {
+  return { IsCompatible: false, Incompatibilities: [], ServerVersion: "", ServerProtocolVersion: "" };
+}
+
+export const CompatibilityResponse: MessageFns<CompatibilityResponse> = {
+  encode(message: CompatibilityResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.IsCompatible !== false) {
+      writer.uint32(8).bool(message.IsCompatible);
+    }
+    for (const v of message.Incompatibilities) {
+      writer.uint32(18).string(v!);
+    }
+    if (message.ServerVersion !== "") {
+      writer.uint32(26).string(message.ServerVersion);
+    }
+    if (message.ServerProtocolVersion !== "") {
+      writer.uint32(34).string(message.ServerProtocolVersion);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CompatibilityResponse {
+    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 = createBaseCompatibilityResponse();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 8) {
+              break;
+            }
+
+            message.IsCompatible = reader.bool();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.Incompatibilities.push(reader.string());
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.ServerVersion = reader.string();
+            continue;
+          }
+          case 4: {
+            if (tag !== 34) {
+              break;
+            }
+
+            message.ServerProtocolVersion = 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): CompatibilityResponse {
+    return {
+      IsCompatible: isSet(object.IsCompatible) ? globalThis.Boolean(object.IsCompatible) : false,
+      Incompatibilities: globalThis.Array.isArray(object?.Incompatibilities)
+        ? object.Incompatibilities.map((e: any) => globalThis.String(e))
+        : [],
+      ServerVersion: isSet(object.ServerVersion) ? globalThis.String(object.ServerVersion) : "",
+      ServerProtocolVersion: isSet(object.ServerProtocolVersion) ? globalThis.String(object.ServerProtocolVersion) : "",
+    };
+  },
+
+  toJSON(message: CompatibilityResponse): unknown {
+    const obj: any = {};
+    if (message.IsCompatible !== false) {
+      obj.IsCompatible = message.IsCompatible;
+    }
+    if (message.Incompatibilities?.length) {
+      obj.Incompatibilities = message.Incompatibilities;
+    }
+    if (message.ServerVersion !== "") {
+      obj.ServerVersion = message.ServerVersion;
+    }
+    if (message.ServerProtocolVersion !== "") {
+      obj.ServerProtocolVersion = message.ServerProtocolVersion;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<CompatibilityResponse>): CompatibilityResponse {
+    return CompatibilityResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<CompatibilityResponse>): CompatibilityResponse {
+    const message = createBaseCompatibilityResponse();
+    message.IsCompatible = object.IsCompatible ?? false;
+    message.Incompatibilities = object.Incompatibilities?.map((e) => e) || [];
+    message.ServerVersion = object.ServerVersion ?? "";
+    message.ServerProtocolVersion = object.ServerProtocolVersion ?? "";
+    return message;
+  },
+};
+
 function createBaseConnectRequest(): ConnectRequest {
   return {
     ConnectionId: "",
@@ -711,6 +961,14 @@ export const ConnectionServiceDefinition = {
   name: "ConnectionService",
   fullName: "Cratis.Chronicle.Contracts.Clients.ConnectionService",
   methods: {
+    checkCompatibility: {
+      name: "CheckCompatibility",
+      requestType: CompatibilityRequest as typeof CompatibilityRequest,
+      requestStream: false,
+      responseType: CompatibilityResponse as typeof CompatibilityResponse,
+      responseStream: false,
+      options: {},
+    },
     connect: {
       name: "Connect",
       requestType: ConnectRequest as typeof ConnectRequest,
@@ -755,6 +1013,10 @@ export const ConnectionServiceDefinition = {
 } as const;
 
 export interface ConnectionServiceImplementation<CallContextExt = {}> {
+  checkCompatibility(
+    request: CompatibilityRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<CompatibilityResponse>>;
   connect(
     request: ConnectRequest,
     context: CallContext & CallContextExt,
@@ -772,6 +1034,10 @@ export interface ConnectionServiceImplementation<CallContextExt = {}> {
 }
 
 export interface ConnectionServiceClient<CallOptionsExt = {}> {
+  checkCompatibility(
+    request: DeepPartial<CompatibilityRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<CompatibilityResponse>;
   connect(
     request: DeepPartial<ConnectRequest>,
     options?: CallOptions & CallOptionsExt,
@@ -791,6 +1057,14 @@ export interface ConnectionServiceClient<CallOptionsExt = {}> {
   ): AsyncIterable<IEnumerableConnectedClient>;
 }
 
+function bytesFromBase64(b64: string): Uint8Array {
+  return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+}
+
+function base64FromBytes(arr: Uint8Array): string {
+  return globalThis.Buffer.from(arr).toString("base64");
+}
+
 type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
 
 export type DeepPartial<T> = T extends bigint ? string | number | bigint