@cratis/chronicle.contracts 16.45.3 → 17.0.1

package/generated/externalservices.ts

@@ -7,10 +7,55 @@
 /* eslint-disable */
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
 import type { CallContext, CallOptions } from "nice-grpc-common";
-import { Empty } from "./google/protobuf/empty";
+import { Guid } from "./protobuf-net/bcl";
 
 export const protobufPackage = "Cratis.Chronicle.Contracts.ExternalServices";
 
+export enum AuthorizationType {
+  None = 0,
+  Basic = 1,
+  Bearer = 2,
+  OAuth = 3,
+  UNRECOGNIZED = -1,
+}
+
+export function authorizationTypeFromJSON(object: any): AuthorizationType {
+  switch (object) {
+    case 0:
+    case "None":
+      return AuthorizationType.None;
+    case 1:
+    case "Basic":
+      return AuthorizationType.Basic;
+    case 2:
+    case "Bearer":
+      return AuthorizationType.Bearer;
+    case 3:
+    case "OAuth":
+      return AuthorizationType.OAuth;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return AuthorizationType.UNRECOGNIZED;
+  }
+}
+
+export function authorizationTypeToJSON(object: AuthorizationType): string {
+  switch (object) {
+    case AuthorizationType.None:
+      return "None";
+    case AuthorizationType.Basic:
+      return "Basic";
+    case AuthorizationType.Bearer:
+      return "Bearer";
+    case AuthorizationType.OAuth:
+      return "OAuth";
+    case AuthorizationType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
 export enum ExternalServiceEndpointType {
   Http = 0,
   MsSql = 1,
@@ -50,7 +95,84 @@ export function externalServiceEndpointTypeToJSON(object: ExternalServiceEndpoin
   }
 }
 
-export interface AddExternalServices {
+export enum ValidationResultSeverity {
+  Unknown = 0,
+  Information = 1,
+  Warning = 2,
+  Error = 3,
+  UNRECOGNIZED = -1,
+}
+
+export function validationResultSeverityFromJSON(object: any): ValidationResultSeverity {
+  switch (object) {
+    case 0:
+    case "Unknown":
+      return ValidationResultSeverity.Unknown;
+    case 1:
+    case "Information":
+      return ValidationResultSeverity.Information;
+    case 2:
+    case "Warning":
+      return ValidationResultSeverity.Warning;
+    case 3:
+    case "Error":
+      return ValidationResultSeverity.Error;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return ValidationResultSeverity.UNRECOGNIZED;
+  }
+}
+
+export function validationResultSeverityToJSON(object: ValidationResultSeverity): string {
+  switch (object) {
+    case ValidationResultSeverity.Unknown:
+      return "Unknown";
+    case ValidationResultSeverity.Information:
+      return "Information";
+    case ValidationResultSeverity.Warning:
+      return "Warning";
+    case ValidationResultSeverity.Error:
+      return "Error";
+    case ValidationResultSeverity.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+export interface AddExternalServiceRequest {
+  EventStore: string;
+  Id: string;
+  Name: string;
+  EndpointType: ExternalServiceEndpointType;
+  Url: string;
+  AuthorizationType: AuthorizationType;
+  BasicUsername: string;
+  BasicPassword: string;
+  BearerToken: string;
+  OAuthAuthority: string;
+  OAuthClientId: string;
+  OAuthClientSecret: string;
+  Headers: { [key: string]: string };
+  Host: string;
+  Port: number;
+  Database: string;
+  Username: string;
+  Password: string;
+  Options: { [key: string]: string };
+}
+
+export interface AddExternalServiceRequest_HeadersEntry {
+  key: string;
+  value: string;
+}
+
+export interface AddExternalServiceRequest_OptionsEntry {
+  key: string;
+  value: string;
+}
+
+export interface AddExternalServicesRequest {
   EventStore: string;
   ExternalServices: ExternalServiceDefinition[];
 }
@@ -64,6 +186,19 @@ export interface BearerTokenAuthorization {
   Token: string;
 }
 
+export interface CommandResult {
+  /** default value could not be applied: 00000000-0000-0000-0000-000000000000 */
+  CorrelationId:
+    | Guid
+    | undefined;
+  /** default value could not be applied: True */
+  IsAuthorized: boolean;
+  ValidationResults: ValidationResult[];
+  ExceptionMessages: string[];
+  ExceptionStackTrace: string;
+  AuthorizationFailureReason: string;
+}
+
 export interface DatabaseEndpointConfiguration {
   Host: string;
   Port: number;
@@ -90,6 +225,30 @@ export interface ExternalServiceEndpoint {
   Database: DatabaseEndpointConfiguration | undefined;
 }
 
+export interface ExternalServiceResponse {
+  Id: string;
+  Name: string;
+  EndpointType: ExternalServiceEndpointType;
+  Url: string;
+  AuthorizationType: AuthorizationType;
+  Headers: { [key: string]: string };
+  Host: string;
+  Port: number;
+  Database: string;
+  Username: string;
+  Options: { [key: string]: string };
+}
+
+export interface ExternalServiceResponse_HeadersEntry {
+  key: string;
+  value: string;
+}
+
+export interface ExternalServiceResponse_OptionsEntry {
+  key: string;
+  value: string;
+}
+
 export interface GetExternalServicesRequest {
   EventStore: string;
 }
@@ -105,43 +264,139 @@ export interface HttpEndpointConfiguration_HeadersEntry {
   value: string;
 }
 
-export interface IEnumerableExternalServiceDefinition {
-  items: ExternalServiceDefinition[];
-}
-
 export interface OAuthAuthorization {
   Authority: string;
   ClientId: string;
   ClientSecret: string;
 }
 
+export interface ObserveExternalServicesRequest {
+  EventStore: string;
+}
+
 export interface OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization {
   Value0: BasicAuthorization | undefined;
   Value1: BearerTokenAuthorization | undefined;
   Value2: OAuthAuthorization | undefined;
 }
 
-export interface RemoveExternalServices {
+export interface QueryResultIEnumerableExternalServiceResponse {
+  /** default value could not be applied: 00000000-0000-0000-0000-000000000000 */
+  CorrelationId:
+    | Guid
+    | undefined;
+  /** default value could not be applied: True */
+  IsAuthorized: boolean;
+  ValidationResults: ValidationResult[];
+  ExceptionMessages: string[];
+  ExceptionStackTrace: string;
+  Data: ExternalServiceResponse[];
+}
+
+export interface RemoveExternalServiceRequest {
+  EventStore: string;
+  ExternalServiceId: string;
+}
+
+export interface RemoveExternalServicesRequest {
   EventStore: string;
   ExternalServices: string[];
 }
 
-function createBaseAddExternalServices(): AddExternalServices {
-  return { EventStore: "", ExternalServices: [] };
+export interface ValidationResult {
+  /** default value could not be applied: Error */
+  Severity: ValidationResultSeverity;
+  Message: string;
+  Members: string[];
+}
+
+function createBaseAddExternalServiceRequest(): AddExternalServiceRequest {
+  return {
+    EventStore: "",
+    Id: "",
+    Name: "",
+    EndpointType: 0,
+    Url: "",
+    AuthorizationType: 0,
+    BasicUsername: "",
+    BasicPassword: "",
+    BearerToken: "",
+    OAuthAuthority: "",
+    OAuthClientId: "",
+    OAuthClientSecret: "",
+    Headers: {},
+    Host: "",
+    Port: 0,
+    Database: "",
+    Username: "",
+    Password: "",
+    Options: {},
+  };
 }
 
-export const AddExternalServices: MessageFns<AddExternalServices> = {
-  encode(message: AddExternalServices, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const AddExternalServiceRequest: MessageFns<AddExternalServiceRequest> = {
+  encode(message: AddExternalServiceRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.EventStore !== "") {
       writer.uint32(10).string(message.EventStore);
     }
-    for (const v of message.ExternalServices) {
-      ExternalServiceDefinition.encode(v!, writer.uint32(18).fork()).join();
+    if (message.Id !== "") {
+      writer.uint32(18).string(message.Id);
     }
+    if (message.Name !== "") {
+      writer.uint32(26).string(message.Name);
+    }
+    if (message.EndpointType !== 0) {
+      writer.uint32(32).int32(message.EndpointType);
+    }
+    if (message.Url !== "") {
+      writer.uint32(42).string(message.Url);
+    }
+    if (message.AuthorizationType !== 0) {
+      writer.uint32(48).int32(message.AuthorizationType);
+    }
+    if (message.BasicUsername !== "") {
+      writer.uint32(58).string(message.BasicUsername);
+    }
+    if (message.BasicPassword !== "") {
+      writer.uint32(66).string(message.BasicPassword);
+    }
+    if (message.BearerToken !== "") {
+      writer.uint32(74).string(message.BearerToken);
+    }
+    if (message.OAuthAuthority !== "") {
+      writer.uint32(82).string(message.OAuthAuthority);
+    }
+    if (message.OAuthClientId !== "") {
+      writer.uint32(90).string(message.OAuthClientId);
+    }
+    if (message.OAuthClientSecret !== "") {
+      writer.uint32(98).string(message.OAuthClientSecret);
+    }
+    globalThis.Object.entries(message.Headers).forEach(([key, value]: [string, string]) => {
+      AddExternalServiceRequest_HeadersEntry.encode({ key: key as any, value }, writer.uint32(106).fork()).join();
+    });
+    if (message.Host !== "") {
+      writer.uint32(114).string(message.Host);
+    }
+    if (message.Port !== 0) {
+      writer.uint32(120).int32(message.Port);
+    }
+    if (message.Database !== "") {
+      writer.uint32(130).string(message.Database);
+    }
+    if (message.Username !== "") {
+      writer.uint32(138).string(message.Username);
+    }
+    if (message.Password !== "") {
+      writer.uint32(146).string(message.Password);
+    }
+    globalThis.Object.entries(message.Options).forEach(([key, value]: [string, string]) => {
+      AddExternalServiceRequest_OptionsEntry.encode({ key: key as any, value }, writer.uint32(154).fork()).join();
+    });
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): AddExternalServices {
+  decode(input: BinaryReader | Uint8Array, length?: number): AddExternalServiceRequest {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -150,7 +405,7 @@ export const AddExternalServices: MessageFns<AddExternalServices> = {
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseAddExternalServices();
+      const message = createBaseAddExternalServiceRequest();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
@@ -167,7 +422,149 @@ export const AddExternalServices: MessageFns<AddExternalServices> = {
               break;
             }
 
-            message.ExternalServices.push(ExternalServiceDefinition.decode(reader, reader.uint32()));
+            message.Id = reader.string();
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.Name = reader.string();
+            continue;
+          }
+          case 4: {
+            if (tag !== 32) {
+              break;
+            }
+
+            message.EndpointType = reader.int32() as any;
+            continue;
+          }
+          case 5: {
+            if (tag !== 42) {
+              break;
+            }
+
+            message.Url = reader.string();
+            continue;
+          }
+          case 6: {
+            if (tag !== 48) {
+              break;
+            }
+
+            message.AuthorizationType = reader.int32() as any;
+            continue;
+          }
+          case 7: {
+            if (tag !== 58) {
+              break;
+            }
+
+            message.BasicUsername = reader.string();
+            continue;
+          }
+          case 8: {
+            if (tag !== 66) {
+              break;
+            }
+
+            message.BasicPassword = reader.string();
+            continue;
+          }
+          case 9: {
+            if (tag !== 74) {
+              break;
+            }
+
+            message.BearerToken = reader.string();
+            continue;
+          }
+          case 10: {
+            if (tag !== 82) {
+              break;
+            }
+
+            message.OAuthAuthority = reader.string();
+            continue;
+          }
+          case 11: {
+            if (tag !== 90) {
+              break;
+            }
+
+            message.OAuthClientId = reader.string();
+            continue;
+          }
+          case 12: {
+            if (tag !== 98) {
+              break;
+            }
+
+            message.OAuthClientSecret = reader.string();
+            continue;
+          }
+          case 13: {
+            if (tag !== 106) {
+              break;
+            }
+
+            const entry13 = AddExternalServiceRequest_HeadersEntry.decode(reader, reader.uint32());
+            if (entry13.value !== undefined) {
+              message.Headers[entry13.key] = entry13.value;
+            }
+            continue;
+          }
+          case 14: {
+            if (tag !== 114) {
+              break;
+            }
+
+            message.Host = reader.string();
+            continue;
+          }
+          case 15: {
+            if (tag !== 120) {
+              break;
+            }
+
+            message.Port = reader.int32();
+            continue;
+          }
+          case 16: {
+            if (tag !== 130) {
+              break;
+            }
+
+            message.Database = reader.string();
+            continue;
+          }
+          case 17: {
+            if (tag !== 138) {
+              break;
+            }
+
+            message.Username = reader.string();
+            continue;
+          }
+          case 18: {
+            if (tag !== 146) {
+              break;
+            }
+
+            message.Password = reader.string();
+            continue;
+          }
+          case 19: {
+            if (tag !== 154) {
+              break;
+            }
+
+            const entry19 = AddExternalServiceRequest_OptionsEntry.decode(reader, reader.uint32());
+            if (entry19.value !== undefined) {
+              message.Options[entry19.key] = entry19.value;
+            }
             continue;
           }
         }
@@ -182,53 +579,1032 @@ export const AddExternalServices: MessageFns<AddExternalServices> = {
     }
   },
 
-  fromJSON(object: any): AddExternalServices {
+  fromJSON(object: any): AddExternalServiceRequest {
     return {
       EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
-      ExternalServices: globalThis.Array.isArray(object?.ExternalServices)
-        ? object.ExternalServices.map((e: any) => ExternalServiceDefinition.fromJSON(e))
-        : [],
-    };
-  },
-
-  toJSON(message: AddExternalServices): unknown {
-    const obj: any = {};
-    if (message.EventStore !== "") {
-      obj.EventStore = message.EventStore;
-    }
-    if (message.ExternalServices?.length) {
-      obj.ExternalServices = message.ExternalServices.map((e) => ExternalServiceDefinition.toJSON(e));
-    }
-    return obj;
-  },
-
-  create(base?: DeepPartial<AddExternalServices>): AddExternalServices {
-    return AddExternalServices.fromPartial(base ?? {});
-  },
-  fromPartial(object: DeepPartial<AddExternalServices>): AddExternalServices {
-    const message = createBaseAddExternalServices();
-    message.EventStore = object.EventStore ?? "";
-    message.ExternalServices = object.ExternalServices?.map((e) => ExternalServiceDefinition.fromPartial(e)) || [];
+      Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
+      Name: isSet(object.Name) ? globalThis.String(object.Name) : "",
+      EndpointType: isSet(object.EndpointType) ? externalServiceEndpointTypeFromJSON(object.EndpointType) : 0,
+      Url: isSet(object.Url) ? globalThis.String(object.Url) : "",
+      AuthorizationType: isSet(object.AuthorizationType) ? authorizationTypeFromJSON(object.AuthorizationType) : 0,
+      BasicUsername: isSet(object.BasicUsername) ? globalThis.String(object.BasicUsername) : "",
+      BasicPassword: isSet(object.BasicPassword) ? globalThis.String(object.BasicPassword) : "",
+      BearerToken: isSet(object.BearerToken) ? globalThis.String(object.BearerToken) : "",
+      OAuthAuthority: isSet(object.OAuthAuthority) ? globalThis.String(object.OAuthAuthority) : "",
+      OAuthClientId: isSet(object.OAuthClientId) ? globalThis.String(object.OAuthClientId) : "",
+      OAuthClientSecret: isSet(object.OAuthClientSecret) ? globalThis.String(object.OAuthClientSecret) : "",
+      Headers: isObject(object.Headers)
+        ? (globalThis.Object.entries(object.Headers) as [string, any][]).reduce(
+          (acc: { [key: string]: string }, [key, value]: [string, any]) => {
+            globalThis.Object.defineProperty(acc, key, {
+              value: globalThis.String(value),
+              enumerable: true,
+              configurable: true,
+              writable: true,
+            });
+            return acc;
+          },
+          {},
+        )
+        : {},
+      Host: isSet(object.Host) ? globalThis.String(object.Host) : "",
+      Port: isSet(object.Port) ? globalThis.Number(object.Port) : 0,
+      Database: isSet(object.Database) ? globalThis.String(object.Database) : "",
+      Username: isSet(object.Username) ? globalThis.String(object.Username) : "",
+      Password: isSet(object.Password) ? globalThis.String(object.Password) : "",
+      Options: isObject(object.Options)
+        ? (globalThis.Object.entries(object.Options) as [string, any][]).reduce(
+          (acc: { [key: string]: string }, [key, value]: [string, any]) => {
+            globalThis.Object.defineProperty(acc, key, {
+              value: globalThis.String(value),
+              enumerable: true,
+              configurable: true,
+              writable: true,
+            });
+            return acc;
+          },
+          {},
+        )
+        : {},
+    };
+  },
+
+  toJSON(message: AddExternalServiceRequest): unknown {
+    const obj: any = {};
+    if (message.EventStore !== "") {
+      obj.EventStore = message.EventStore;
+    }
+    if (message.Id !== "") {
+      obj.Id = message.Id;
+    }
+    if (message.Name !== "") {
+      obj.Name = message.Name;
+    }
+    if (message.EndpointType !== 0) {
+      obj.EndpointType = externalServiceEndpointTypeToJSON(message.EndpointType);
+    }
+    if (message.Url !== "") {
+      obj.Url = message.Url;
+    }
+    if (message.AuthorizationType !== 0) {
+      obj.AuthorizationType = authorizationTypeToJSON(message.AuthorizationType);
+    }
+    if (message.BasicUsername !== "") {
+      obj.BasicUsername = message.BasicUsername;
+    }
+    if (message.BasicPassword !== "") {
+      obj.BasicPassword = message.BasicPassword;
+    }
+    if (message.BearerToken !== "") {
+      obj.BearerToken = message.BearerToken;
+    }
+    if (message.OAuthAuthority !== "") {
+      obj.OAuthAuthority = message.OAuthAuthority;
+    }
+    if (message.OAuthClientId !== "") {
+      obj.OAuthClientId = message.OAuthClientId;
+    }
+    if (message.OAuthClientSecret !== "") {
+      obj.OAuthClientSecret = message.OAuthClientSecret;
+    }
+    if (message.Headers) {
+      const entries = globalThis.Object.entries(message.Headers) as [string, string][];
+      if (entries.length > 0) {
+        obj.Headers = {};
+        entries.forEach(([k, v]) => {
+          obj.Headers[k] = v;
+        });
+      }
+    }
+    if (message.Host !== "") {
+      obj.Host = message.Host;
+    }
+    if (message.Port !== 0) {
+      obj.Port = Math.round(message.Port);
+    }
+    if (message.Database !== "") {
+      obj.Database = message.Database;
+    }
+    if (message.Username !== "") {
+      obj.Username = message.Username;
+    }
+    if (message.Password !== "") {
+      obj.Password = message.Password;
+    }
+    if (message.Options) {
+      const entries = globalThis.Object.entries(message.Options) as [string, string][];
+      if (entries.length > 0) {
+        obj.Options = {};
+        entries.forEach(([k, v]) => {
+          obj.Options[k] = v;
+        });
+      }
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<AddExternalServiceRequest>): AddExternalServiceRequest {
+    return AddExternalServiceRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<AddExternalServiceRequest>): AddExternalServiceRequest {
+    const message = createBaseAddExternalServiceRequest();
+    message.EventStore = object.EventStore ?? "";
+    message.Id = object.Id ?? "";
+    message.Name = object.Name ?? "";
+    message.EndpointType = object.EndpointType ?? 0;
+    message.Url = object.Url ?? "";
+    message.AuthorizationType = object.AuthorizationType ?? 0;
+    message.BasicUsername = object.BasicUsername ?? "";
+    message.BasicPassword = object.BasicPassword ?? "";
+    message.BearerToken = object.BearerToken ?? "";
+    message.OAuthAuthority = object.OAuthAuthority ?? "";
+    message.OAuthClientId = object.OAuthClientId ?? "";
+    message.OAuthClientSecret = object.OAuthClientSecret ?? "";
+    message.Headers = (globalThis.Object.entries(object.Headers ?? {}) as [string, string][]).reduce(
+      (acc: { [key: string]: string }, [key, value]: [string, string]) => {
+        if (value !== undefined) {
+          acc[key] = globalThis.String(value);
+        }
+        return acc;
+      },
+      {},
+    );
+    message.Host = object.Host ?? "";
+    message.Port = object.Port ?? 0;
+    message.Database = object.Database ?? "";
+    message.Username = object.Username ?? "";
+    message.Password = object.Password ?? "";
+    message.Options = (globalThis.Object.entries(object.Options ?? {}) as [string, string][]).reduce(
+      (acc: { [key: string]: string }, [key, value]: [string, string]) => {
+        if (value !== undefined) {
+          acc[key] = globalThis.String(value);
+        }
+        return acc;
+      },
+      {},
+    );
+    return message;
+  },
+};
+
+function createBaseAddExternalServiceRequest_HeadersEntry(): AddExternalServiceRequest_HeadersEntry {
+  return { key: "", value: "" };
+}
+
+export const AddExternalServiceRequest_HeadersEntry: MessageFns<AddExternalServiceRequest_HeadersEntry> = {
+  encode(message: AddExternalServiceRequest_HeadersEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): AddExternalServiceRequest_HeadersEntry {
+    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 = createBaseAddExternalServiceRequest_HeadersEntry();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.key = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.value = 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): AddExternalServiceRequest_HeadersEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? globalThis.String(object.value) : "",
+    };
+  },
+
+  toJSON(message: AddExternalServiceRequest_HeadersEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<AddExternalServiceRequest_HeadersEntry>): AddExternalServiceRequest_HeadersEntry {
+    return AddExternalServiceRequest_HeadersEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<AddExternalServiceRequest_HeadersEntry>): AddExternalServiceRequest_HeadersEntry {
+    const message = createBaseAddExternalServiceRequest_HeadersEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  },
+};
+
+function createBaseAddExternalServiceRequest_OptionsEntry(): AddExternalServiceRequest_OptionsEntry {
+  return { key: "", value: "" };
+}
+
+export const AddExternalServiceRequest_OptionsEntry: MessageFns<AddExternalServiceRequest_OptionsEntry> = {
+  encode(message: AddExternalServiceRequest_OptionsEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): AddExternalServiceRequest_OptionsEntry {
+    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 = createBaseAddExternalServiceRequest_OptionsEntry();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.key = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.value = 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): AddExternalServiceRequest_OptionsEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? globalThis.String(object.value) : "",
+    };
+  },
+
+  toJSON(message: AddExternalServiceRequest_OptionsEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<AddExternalServiceRequest_OptionsEntry>): AddExternalServiceRequest_OptionsEntry {
+    return AddExternalServiceRequest_OptionsEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<AddExternalServiceRequest_OptionsEntry>): AddExternalServiceRequest_OptionsEntry {
+    const message = createBaseAddExternalServiceRequest_OptionsEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  },
+};
+
+function createBaseAddExternalServicesRequest(): AddExternalServicesRequest {
+  return { EventStore: "", ExternalServices: [] };
+}
+
+export const AddExternalServicesRequest: MessageFns<AddExternalServicesRequest> = {
+  encode(message: AddExternalServicesRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.EventStore !== "") {
+      writer.uint32(10).string(message.EventStore);
+    }
+    for (const v of message.ExternalServices) {
+      ExternalServiceDefinition.encode(v!, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): AddExternalServicesRequest {
+    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 = createBaseAddExternalServicesRequest();
+      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.ExternalServices.push(ExternalServiceDefinition.decode(reader, reader.uint32()));
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): AddExternalServicesRequest {
+    return {
+      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+      ExternalServices: globalThis.Array.isArray(object?.ExternalServices)
+        ? object.ExternalServices.map((e: any) => ExternalServiceDefinition.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: AddExternalServicesRequest): unknown {
+    const obj: any = {};
+    if (message.EventStore !== "") {
+      obj.EventStore = message.EventStore;
+    }
+    if (message.ExternalServices?.length) {
+      obj.ExternalServices = message.ExternalServices.map((e) => ExternalServiceDefinition.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<AddExternalServicesRequest>): AddExternalServicesRequest {
+    return AddExternalServicesRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<AddExternalServicesRequest>): AddExternalServicesRequest {
+    const message = createBaseAddExternalServicesRequest();
+    message.EventStore = object.EventStore ?? "";
+    message.ExternalServices = object.ExternalServices?.map((e) => ExternalServiceDefinition.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseBasicAuthorization(): BasicAuthorization {
+  return { Username: "", Password: "" };
+}
+
+export const BasicAuthorization: MessageFns<BasicAuthorization> = {
+  encode(message: BasicAuthorization, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.Username !== "") {
+      writer.uint32(10).string(message.Username);
+    }
+    if (message.Password !== "") {
+      writer.uint32(18).string(message.Password);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): BasicAuthorization {
+    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 = createBaseBasicAuthorization();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.Username = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.Password = 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): BasicAuthorization {
+    return {
+      Username: isSet(object.Username) ? globalThis.String(object.Username) : "",
+      Password: isSet(object.Password) ? globalThis.String(object.Password) : "",
+    };
+  },
+
+  toJSON(message: BasicAuthorization): unknown {
+    const obj: any = {};
+    if (message.Username !== "") {
+      obj.Username = message.Username;
+    }
+    if (message.Password !== "") {
+      obj.Password = message.Password;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<BasicAuthorization>): BasicAuthorization {
+    return BasicAuthorization.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<BasicAuthorization>): BasicAuthorization {
+    const message = createBaseBasicAuthorization();
+    message.Username = object.Username ?? "";
+    message.Password = object.Password ?? "";
+    return message;
+  },
+};
+
+function createBaseBearerTokenAuthorization(): BearerTokenAuthorization {
+  return { Token: "" };
+}
+
+export const BearerTokenAuthorization: MessageFns<BearerTokenAuthorization> = {
+  encode(message: BearerTokenAuthorization, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.Token !== "") {
+      writer.uint32(10).string(message.Token);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): BearerTokenAuthorization {
+    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 = createBaseBearerTokenAuthorization();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.Token = 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): BearerTokenAuthorization {
+    return { Token: isSet(object.Token) ? globalThis.String(object.Token) : "" };
+  },
+
+  toJSON(message: BearerTokenAuthorization): unknown {
+    const obj: any = {};
+    if (message.Token !== "") {
+      obj.Token = message.Token;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<BearerTokenAuthorization>): BearerTokenAuthorization {
+    return BearerTokenAuthorization.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<BearerTokenAuthorization>): BearerTokenAuthorization {
+    const message = createBaseBearerTokenAuthorization();
+    message.Token = object.Token ?? "";
+    return message;
+  },
+};
+
+function createBaseCommandResult(): CommandResult {
+  return {
+    CorrelationId: undefined,
+    IsAuthorized: false,
+    ValidationResults: [],
+    ExceptionMessages: [],
+    ExceptionStackTrace: "",
+    AuthorizationFailureReason: "",
+  };
+}
+
+export const CommandResult: MessageFns<CommandResult> = {
+  encode(message: CommandResult, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.CorrelationId !== undefined) {
+      Guid.encode(message.CorrelationId, writer.uint32(10).fork()).join();
+    }
+    if (message.IsAuthorized !== false) {
+      writer.uint32(16).bool(message.IsAuthorized);
+    }
+    for (const v of message.ValidationResults) {
+      ValidationResult.encode(v!, writer.uint32(26).fork()).join();
+    }
+    for (const v of message.ExceptionMessages) {
+      writer.uint32(34).string(v!);
+    }
+    if (message.ExceptionStackTrace !== "") {
+      writer.uint32(42).string(message.ExceptionStackTrace);
+    }
+    if (message.AuthorizationFailureReason !== "") {
+      writer.uint32(50).string(message.AuthorizationFailureReason);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CommandResult {
+    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 = createBaseCommandResult();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.CorrelationId = Guid.decode(reader, reader.uint32());
+            continue;
+          }
+          case 2: {
+            if (tag !== 16) {
+              break;
+            }
+
+            message.IsAuthorized = reader.bool();
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.ValidationResults.push(ValidationResult.decode(reader, reader.uint32()));
+            continue;
+          }
+          case 4: {
+            if (tag !== 34) {
+              break;
+            }
+
+            message.ExceptionMessages.push(reader.string());
+            continue;
+          }
+          case 5: {
+            if (tag !== 42) {
+              break;
+            }
+
+            message.ExceptionStackTrace = reader.string();
+            continue;
+          }
+          case 6: {
+            if (tag !== 50) {
+              break;
+            }
+
+            message.AuthorizationFailureReason = 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): CommandResult {
+    return {
+      CorrelationId: isSet(object.CorrelationId) ? Guid.fromJSON(object.CorrelationId) : undefined,
+      IsAuthorized: isSet(object.IsAuthorized) ? globalThis.Boolean(object.IsAuthorized) : false,
+      ValidationResults: globalThis.Array.isArray(object?.ValidationResults)
+        ? object.ValidationResults.map((e: any) => ValidationResult.fromJSON(e))
+        : [],
+      ExceptionMessages: globalThis.Array.isArray(object?.ExceptionMessages)
+        ? object.ExceptionMessages.map((e: any) => globalThis.String(e))
+        : [],
+      ExceptionStackTrace: isSet(object.ExceptionStackTrace) ? globalThis.String(object.ExceptionStackTrace) : "",
+      AuthorizationFailureReason: isSet(object.AuthorizationFailureReason)
+        ? globalThis.String(object.AuthorizationFailureReason)
+        : "",
+    };
+  },
+
+  toJSON(message: CommandResult): unknown {
+    const obj: any = {};
+    if (message.CorrelationId !== undefined) {
+      obj.CorrelationId = Guid.toJSON(message.CorrelationId);
+    }
+    if (message.IsAuthorized !== false) {
+      obj.IsAuthorized = message.IsAuthorized;
+    }
+    if (message.ValidationResults?.length) {
+      obj.ValidationResults = message.ValidationResults.map((e) => ValidationResult.toJSON(e));
+    }
+    if (message.ExceptionMessages?.length) {
+      obj.ExceptionMessages = message.ExceptionMessages;
+    }
+    if (message.ExceptionStackTrace !== "") {
+      obj.ExceptionStackTrace = message.ExceptionStackTrace;
+    }
+    if (message.AuthorizationFailureReason !== "") {
+      obj.AuthorizationFailureReason = message.AuthorizationFailureReason;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<CommandResult>): CommandResult {
+    return CommandResult.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<CommandResult>): CommandResult {
+    const message = createBaseCommandResult();
+    message.CorrelationId = (object.CorrelationId !== undefined && object.CorrelationId !== null)
+      ? Guid.fromPartial(object.CorrelationId)
+      : undefined;
+    message.IsAuthorized = object.IsAuthorized ?? false;
+    message.ValidationResults = object.ValidationResults?.map((e) => ValidationResult.fromPartial(e)) || [];
+    message.ExceptionMessages = object.ExceptionMessages?.map((e) => e) || [];
+    message.ExceptionStackTrace = object.ExceptionStackTrace ?? "";
+    message.AuthorizationFailureReason = object.AuthorizationFailureReason ?? "";
+    return message;
+  },
+};
+
+function createBaseDatabaseEndpointConfiguration(): DatabaseEndpointConfiguration {
+  return { Host: "", Port: 0, Database: "", Username: "", Password: "", Options: {} };
+}
+
+export const DatabaseEndpointConfiguration: MessageFns<DatabaseEndpointConfiguration> = {
+  encode(message: DatabaseEndpointConfiguration, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.Host !== "") {
+      writer.uint32(10).string(message.Host);
+    }
+    if (message.Port !== 0) {
+      writer.uint32(16).int32(message.Port);
+    }
+    if (message.Database !== "") {
+      writer.uint32(26).string(message.Database);
+    }
+    if (message.Username !== "") {
+      writer.uint32(34).string(message.Username);
+    }
+    if (message.Password !== "") {
+      writer.uint32(42).string(message.Password);
+    }
+    globalThis.Object.entries(message.Options).forEach(([key, value]: [string, string]) => {
+      DatabaseEndpointConfiguration_OptionsEntry.encode({ key: key as any, value }, writer.uint32(50).fork()).join();
+    });
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): DatabaseEndpointConfiguration {
+    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 = createBaseDatabaseEndpointConfiguration();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.Host = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 16) {
+              break;
+            }
+
+            message.Port = reader.int32();
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.Database = reader.string();
+            continue;
+          }
+          case 4: {
+            if (tag !== 34) {
+              break;
+            }
+
+            message.Username = reader.string();
+            continue;
+          }
+          case 5: {
+            if (tag !== 42) {
+              break;
+            }
+
+            message.Password = reader.string();
+            continue;
+          }
+          case 6: {
+            if (tag !== 50) {
+              break;
+            }
+
+            const entry6 = DatabaseEndpointConfiguration_OptionsEntry.decode(reader, reader.uint32());
+            if (entry6.value !== undefined) {
+              message.Options[entry6.key] = entry6.value;
+            }
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): DatabaseEndpointConfiguration {
+    return {
+      Host: isSet(object.Host) ? globalThis.String(object.Host) : "",
+      Port: isSet(object.Port) ? globalThis.Number(object.Port) : 0,
+      Database: isSet(object.Database) ? globalThis.String(object.Database) : "",
+      Username: isSet(object.Username) ? globalThis.String(object.Username) : "",
+      Password: isSet(object.Password) ? globalThis.String(object.Password) : "",
+      Options: isObject(object.Options)
+        ? (globalThis.Object.entries(object.Options) as [string, any][]).reduce(
+          (acc: { [key: string]: string }, [key, value]: [string, any]) => {
+            globalThis.Object.defineProperty(acc, key, {
+              value: globalThis.String(value),
+              enumerable: true,
+              configurable: true,
+              writable: true,
+            });
+            return acc;
+          },
+          {},
+        )
+        : {},
+    };
+  },
+
+  toJSON(message: DatabaseEndpointConfiguration): unknown {
+    const obj: any = {};
+    if (message.Host !== "") {
+      obj.Host = message.Host;
+    }
+    if (message.Port !== 0) {
+      obj.Port = Math.round(message.Port);
+    }
+    if (message.Database !== "") {
+      obj.Database = message.Database;
+    }
+    if (message.Username !== "") {
+      obj.Username = message.Username;
+    }
+    if (message.Password !== "") {
+      obj.Password = message.Password;
+    }
+    if (message.Options) {
+      const entries = globalThis.Object.entries(message.Options) as [string, string][];
+      if (entries.length > 0) {
+        obj.Options = {};
+        entries.forEach(([k, v]) => {
+          obj.Options[k] = v;
+        });
+      }
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<DatabaseEndpointConfiguration>): DatabaseEndpointConfiguration {
+    return DatabaseEndpointConfiguration.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<DatabaseEndpointConfiguration>): DatabaseEndpointConfiguration {
+    const message = createBaseDatabaseEndpointConfiguration();
+    message.Host = object.Host ?? "";
+    message.Port = object.Port ?? 0;
+    message.Database = object.Database ?? "";
+    message.Username = object.Username ?? "";
+    message.Password = object.Password ?? "";
+    message.Options = (globalThis.Object.entries(object.Options ?? {}) as [string, string][]).reduce(
+      (acc: { [key: string]: string }, [key, value]: [string, string]) => {
+        if (value !== undefined) {
+          acc[key] = globalThis.String(value);
+        }
+        return acc;
+      },
+      {},
+    );
+    return message;
+  },
+};
+
+function createBaseDatabaseEndpointConfiguration_OptionsEntry(): DatabaseEndpointConfiguration_OptionsEntry {
+  return { key: "", value: "" };
+}
+
+export const DatabaseEndpointConfiguration_OptionsEntry: MessageFns<DatabaseEndpointConfiguration_OptionsEntry> = {
+  encode(message: DatabaseEndpointConfiguration_OptionsEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): DatabaseEndpointConfiguration_OptionsEntry {
+    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 = createBaseDatabaseEndpointConfiguration_OptionsEntry();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.key = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.value = 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): DatabaseEndpointConfiguration_OptionsEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? globalThis.String(object.value) : "",
+    };
+  },
+
+  toJSON(message: DatabaseEndpointConfiguration_OptionsEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<DatabaseEndpointConfiguration_OptionsEntry>): DatabaseEndpointConfiguration_OptionsEntry {
+    return DatabaseEndpointConfiguration_OptionsEntry.fromPartial(base ?? {});
+  },
+  fromPartial(
+    object: DeepPartial<DatabaseEndpointConfiguration_OptionsEntry>,
+  ): DatabaseEndpointConfiguration_OptionsEntry {
+    const message = createBaseDatabaseEndpointConfiguration_OptionsEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
     return message;
   },
 };
 
-function createBaseBasicAuthorization(): BasicAuthorization {
-  return { Username: "", Password: "" };
+function createBaseExternalServiceDefinition(): ExternalServiceDefinition {
+  return { Id: "", Name: "", Endpoint: undefined };
 }
 
-export const BasicAuthorization: MessageFns<BasicAuthorization> = {
-  encode(message: BasicAuthorization, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.Username !== "") {
-      writer.uint32(10).string(message.Username);
+export const ExternalServiceDefinition: MessageFns<ExternalServiceDefinition> = {
+  encode(message: ExternalServiceDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.Id !== "") {
+      writer.uint32(10).string(message.Id);
     }
-    if (message.Password !== "") {
-      writer.uint32(18).string(message.Password);
+    if (message.Name !== "") {
+      writer.uint32(18).string(message.Name);
+    }
+    if (message.Endpoint !== undefined) {
+      ExternalServiceEndpoint.encode(message.Endpoint, writer.uint32(26).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): BasicAuthorization {
+  decode(input: BinaryReader | Uint8Array, length?: number): ExternalServiceDefinition {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -237,7 +1613,7 @@ export const BasicAuthorization: MessageFns<BasicAuthorization> = {
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseBasicAuthorization();
+      const message = createBaseExternalServiceDefinition();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
@@ -246,7 +1622,7 @@ export const BasicAuthorization: MessageFns<BasicAuthorization> = {
               break;
             }
 
-            message.Username = reader.string();
+            message.Id = reader.string();
             continue;
           }
           case 2: {
@@ -254,7 +1630,15 @@ export const BasicAuthorization: MessageFns<BasicAuthorization> = {
               break;
             }
 
-            message.Password = reader.string();
+            message.Name = reader.string();
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.Endpoint = ExternalServiceEndpoint.decode(reader, reader.uint32());
             continue;
           }
         }
@@ -269,48 +1653,61 @@ export const BasicAuthorization: MessageFns<BasicAuthorization> = {
     }
   },
 
-  fromJSON(object: any): BasicAuthorization {
+  fromJSON(object: any): ExternalServiceDefinition {
     return {
-      Username: isSet(object.Username) ? globalThis.String(object.Username) : "",
-      Password: isSet(object.Password) ? globalThis.String(object.Password) : "",
+      Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
+      Name: isSet(object.Name) ? globalThis.String(object.Name) : "",
+      Endpoint: isSet(object.Endpoint) ? ExternalServiceEndpoint.fromJSON(object.Endpoint) : undefined,
     };
   },
 
-  toJSON(message: BasicAuthorization): unknown {
+  toJSON(message: ExternalServiceDefinition): unknown {
     const obj: any = {};
-    if (message.Username !== "") {
-      obj.Username = message.Username;
+    if (message.Id !== "") {
+      obj.Id = message.Id;
     }
-    if (message.Password !== "") {
-      obj.Password = message.Password;
+    if (message.Name !== "") {
+      obj.Name = message.Name;
+    }
+    if (message.Endpoint !== undefined) {
+      obj.Endpoint = ExternalServiceEndpoint.toJSON(message.Endpoint);
     }
     return obj;
   },
 
-  create(base?: DeepPartial<BasicAuthorization>): BasicAuthorization {
-    return BasicAuthorization.fromPartial(base ?? {});
+  create(base?: DeepPartial<ExternalServiceDefinition>): ExternalServiceDefinition {
+    return ExternalServiceDefinition.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<BasicAuthorization>): BasicAuthorization {
-    const message = createBaseBasicAuthorization();
-    message.Username = object.Username ?? "";
-    message.Password = object.Password ?? "";
+  fromPartial(object: DeepPartial<ExternalServiceDefinition>): ExternalServiceDefinition {
+    const message = createBaseExternalServiceDefinition();
+    message.Id = object.Id ?? "";
+    message.Name = object.Name ?? "";
+    message.Endpoint = (object.Endpoint !== undefined && object.Endpoint !== null)
+      ? ExternalServiceEndpoint.fromPartial(object.Endpoint)
+      : undefined;
     return message;
   },
 };
 
-function createBaseBearerTokenAuthorization(): BearerTokenAuthorization {
-  return { Token: "" };
+function createBaseExternalServiceEndpoint(): ExternalServiceEndpoint {
+  return { Type: 0, Http: undefined, Database: undefined };
 }
 
-export const BearerTokenAuthorization: MessageFns<BearerTokenAuthorization> = {
-  encode(message: BearerTokenAuthorization, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.Token !== "") {
-      writer.uint32(10).string(message.Token);
+export const ExternalServiceEndpoint: MessageFns<ExternalServiceEndpoint> = {
+  encode(message: ExternalServiceEndpoint, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.Type !== 0) {
+      writer.uint32(8).int32(message.Type);
+    }
+    if (message.Http !== undefined) {
+      HttpEndpointConfiguration.encode(message.Http, writer.uint32(18).fork()).join();
+    }
+    if (message.Database !== undefined) {
+      DatabaseEndpointConfiguration.encode(message.Database, writer.uint32(26).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): BearerTokenAuthorization {
+  decode(input: BinaryReader | Uint8Array, length?: number): ExternalServiceEndpoint {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -319,16 +1716,32 @@ export const BearerTokenAuthorization: MessageFns<BearerTokenAuthorization> = {
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseBearerTokenAuthorization();
+      const message = createBaseExternalServiceEndpoint();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
           case 1: {
-            if (tag !== 10) {
+            if (tag !== 8) {
               break;
             }
 
-            message.Token = reader.string();
+            message.Type = reader.int32() as any;
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.Http = HttpEndpointConfiguration.decode(reader, reader.uint32());
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.Database = DatabaseEndpointConfiguration.decode(reader, reader.uint32());
             continue;
           }
         }
@@ -343,56 +1756,99 @@ export const BearerTokenAuthorization: MessageFns<BearerTokenAuthorization> = {
     }
   },
 
-  fromJSON(object: any): BearerTokenAuthorization {
-    return { Token: isSet(object.Token) ? globalThis.String(object.Token) : "" };
+  fromJSON(object: any): ExternalServiceEndpoint {
+    return {
+      Type: isSet(object.Type) ? externalServiceEndpointTypeFromJSON(object.Type) : 0,
+      Http: isSet(object.Http) ? HttpEndpointConfiguration.fromJSON(object.Http) : undefined,
+      Database: isSet(object.Database) ? DatabaseEndpointConfiguration.fromJSON(object.Database) : undefined,
+    };
   },
 
-  toJSON(message: BearerTokenAuthorization): unknown {
+  toJSON(message: ExternalServiceEndpoint): unknown {
     const obj: any = {};
-    if (message.Token !== "") {
-      obj.Token = message.Token;
+    if (message.Type !== 0) {
+      obj.Type = externalServiceEndpointTypeToJSON(message.Type);
+    }
+    if (message.Http !== undefined) {
+      obj.Http = HttpEndpointConfiguration.toJSON(message.Http);
+    }
+    if (message.Database !== undefined) {
+      obj.Database = DatabaseEndpointConfiguration.toJSON(message.Database);
     }
     return obj;
   },
 
-  create(base?: DeepPartial<BearerTokenAuthorization>): BearerTokenAuthorization {
-    return BearerTokenAuthorization.fromPartial(base ?? {});
+  create(base?: DeepPartial<ExternalServiceEndpoint>): ExternalServiceEndpoint {
+    return ExternalServiceEndpoint.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<BearerTokenAuthorization>): BearerTokenAuthorization {
-    const message = createBaseBearerTokenAuthorization();
-    message.Token = object.Token ?? "";
+  fromPartial(object: DeepPartial<ExternalServiceEndpoint>): ExternalServiceEndpoint {
+    const message = createBaseExternalServiceEndpoint();
+    message.Type = object.Type ?? 0;
+    message.Http = (object.Http !== undefined && object.Http !== null)
+      ? HttpEndpointConfiguration.fromPartial(object.Http)
+      : undefined;
+    message.Database = (object.Database !== undefined && object.Database !== null)
+      ? DatabaseEndpointConfiguration.fromPartial(object.Database)
+      : undefined;
     return message;
   },
 };
 
-function createBaseDatabaseEndpointConfiguration(): DatabaseEndpointConfiguration {
-  return { Host: "", Port: 0, Database: "", Username: "", Password: "", Options: {} };
+function createBaseExternalServiceResponse(): ExternalServiceResponse {
+  return {
+    Id: "",
+    Name: "",
+    EndpointType: 0,
+    Url: "",
+    AuthorizationType: 0,
+    Headers: {},
+    Host: "",
+    Port: 0,
+    Database: "",
+    Username: "",
+    Options: {},
+  };
 }
 
-export const DatabaseEndpointConfiguration: MessageFns<DatabaseEndpointConfiguration> = {
-  encode(message: DatabaseEndpointConfiguration, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const ExternalServiceResponse: MessageFns<ExternalServiceResponse> = {
+  encode(message: ExternalServiceResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.Id !== "") {
+      writer.uint32(10).string(message.Id);
+    }
+    if (message.Name !== "") {
+      writer.uint32(18).string(message.Name);
+    }
+    if (message.EndpointType !== 0) {
+      writer.uint32(24).int32(message.EndpointType);
+    }
+    if (message.Url !== "") {
+      writer.uint32(34).string(message.Url);
+    }
+    if (message.AuthorizationType !== 0) {
+      writer.uint32(40).int32(message.AuthorizationType);
+    }
+    globalThis.Object.entries(message.Headers).forEach(([key, value]: [string, string]) => {
+      ExternalServiceResponse_HeadersEntry.encode({ key: key as any, value }, writer.uint32(50).fork()).join();
+    });
     if (message.Host !== "") {
-      writer.uint32(10).string(message.Host);
+      writer.uint32(58).string(message.Host);
     }
     if (message.Port !== 0) {
-      writer.uint32(16).int32(message.Port);
+      writer.uint32(64).int32(message.Port);
     }
     if (message.Database !== "") {
-      writer.uint32(26).string(message.Database);
+      writer.uint32(74).string(message.Database);
     }
     if (message.Username !== "") {
-      writer.uint32(34).string(message.Username);
-    }
-    if (message.Password !== "") {
-      writer.uint32(42).string(message.Password);
+      writer.uint32(82).string(message.Username);
     }
     globalThis.Object.entries(message.Options).forEach(([key, value]: [string, string]) => {
-      DatabaseEndpointConfiguration_OptionsEntry.encode({ key: key as any, value }, writer.uint32(50).fork()).join();
+      ExternalServiceResponse_OptionsEntry.encode({ key: key as any, value }, writer.uint32(90).fork()).join();
     });
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): DatabaseEndpointConfiguration {
+  decode(input: BinaryReader | Uint8Array, length?: number): ExternalServiceResponse {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -401,7 +1857,7 @@ export const DatabaseEndpointConfiguration: MessageFns<DatabaseEndpointConfigura
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseDatabaseEndpointConfiguration();
+      const message = createBaseExternalServiceResponse();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
@@ -410,23 +1866,23 @@ export const DatabaseEndpointConfiguration: MessageFns<DatabaseEndpointConfigura
               break;
             }
 
-            message.Host = reader.string();
+            message.Id = reader.string();
             continue;
           }
           case 2: {
-            if (tag !== 16) {
+            if (tag !== 18) {
               break;
             }
 
-            message.Port = reader.int32();
+            message.Name = reader.string();
             continue;
           }
           case 3: {
-            if (tag !== 26) {
+            if (tag !== 24) {
               break;
             }
 
-            message.Database = reader.string();
+            message.EndpointType = reader.int32() as any;
             continue;
           }
           case 4: {
@@ -434,15 +1890,15 @@ export const DatabaseEndpointConfiguration: MessageFns<DatabaseEndpointConfigura
               break;
             }
 
-            message.Username = reader.string();
+            message.Url = reader.string();
             continue;
           }
           case 5: {
-            if (tag !== 42) {
+            if (tag !== 40) {
               break;
             }
 
-            message.Password = reader.string();
+            message.AuthorizationType = reader.int32() as any;
             continue;
           }
           case 6: {
@@ -450,9 +1906,52 @@ export const DatabaseEndpointConfiguration: MessageFns<DatabaseEndpointConfigura
               break;
             }
 
-            const entry6 = DatabaseEndpointConfiguration_OptionsEntry.decode(reader, reader.uint32());
+            const entry6 = ExternalServiceResponse_HeadersEntry.decode(reader, reader.uint32());
             if (entry6.value !== undefined) {
-              message.Options[entry6.key] = entry6.value;
+              message.Headers[entry6.key] = entry6.value;
+            }
+            continue;
+          }
+          case 7: {
+            if (tag !== 58) {
+              break;
+            }
+
+            message.Host = reader.string();
+            continue;
+          }
+          case 8: {
+            if (tag !== 64) {
+              break;
+            }
+
+            message.Port = reader.int32();
+            continue;
+          }
+          case 9: {
+            if (tag !== 74) {
+              break;
+            }
+
+            message.Database = reader.string();
+            continue;
+          }
+          case 10: {
+            if (tag !== 82) {
+              break;
+            }
+
+            message.Username = reader.string();
+            continue;
+          }
+          case 11: {
+            if (tag !== 90) {
+              break;
+            }
+
+            const entry11 = ExternalServiceResponse_OptionsEntry.decode(reader, reader.uint32());
+            if (entry11.value !== undefined) {
+              message.Options[entry11.key] = entry11.value;
             }
             continue;
           }
@@ -468,13 +1967,31 @@ export const DatabaseEndpointConfiguration: MessageFns<DatabaseEndpointConfigura
     }
   },
 
-  fromJSON(object: any): DatabaseEndpointConfiguration {
+  fromJSON(object: any): ExternalServiceResponse {
     return {
+      Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
+      Name: isSet(object.Name) ? globalThis.String(object.Name) : "",
+      EndpointType: isSet(object.EndpointType) ? externalServiceEndpointTypeFromJSON(object.EndpointType) : 0,
+      Url: isSet(object.Url) ? globalThis.String(object.Url) : "",
+      AuthorizationType: isSet(object.AuthorizationType) ? authorizationTypeFromJSON(object.AuthorizationType) : 0,
+      Headers: isObject(object.Headers)
+        ? (globalThis.Object.entries(object.Headers) as [string, any][]).reduce(
+          (acc: { [key: string]: string }, [key, value]: [string, any]) => {
+            globalThis.Object.defineProperty(acc, key, {
+              value: globalThis.String(value),
+              enumerable: true,
+              configurable: true,
+              writable: true,
+            });
+            return acc;
+          },
+          {},
+        )
+        : {},
       Host: isSet(object.Host) ? globalThis.String(object.Host) : "",
       Port: isSet(object.Port) ? globalThis.Number(object.Port) : 0,
       Database: isSet(object.Database) ? globalThis.String(object.Database) : "",
       Username: isSet(object.Username) ? globalThis.String(object.Username) : "",
-      Password: isSet(object.Password) ? globalThis.String(object.Password) : "",
       Options: isObject(object.Options)
         ? (globalThis.Object.entries(object.Options) as [string, any][]).reduce(
           (acc: { [key: string]: string }, [key, value]: [string, any]) => {
@@ -492,8 +2009,32 @@ export const DatabaseEndpointConfiguration: MessageFns<DatabaseEndpointConfigura
     };
   },
 
-  toJSON(message: DatabaseEndpointConfiguration): unknown {
+  toJSON(message: ExternalServiceResponse): unknown {
     const obj: any = {};
+    if (message.Id !== "") {
+      obj.Id = message.Id;
+    }
+    if (message.Name !== "") {
+      obj.Name = message.Name;
+    }
+    if (message.EndpointType !== 0) {
+      obj.EndpointType = externalServiceEndpointTypeToJSON(message.EndpointType);
+    }
+    if (message.Url !== "") {
+      obj.Url = message.Url;
+    }
+    if (message.AuthorizationType !== 0) {
+      obj.AuthorizationType = authorizationTypeToJSON(message.AuthorizationType);
+    }
+    if (message.Headers) {
+      const entries = globalThis.Object.entries(message.Headers) as [string, string][];
+      if (entries.length > 0) {
+        obj.Headers = {};
+        entries.forEach(([k, v]) => {
+          obj.Headers[k] = v;
+        });
+      }
+    }
     if (message.Host !== "") {
       obj.Host = message.Host;
     }
@@ -506,9 +2047,6 @@ export const DatabaseEndpointConfiguration: MessageFns<DatabaseEndpointConfigura
     if (message.Username !== "") {
       obj.Username = message.Username;
     }
-    if (message.Password !== "") {
-      obj.Password = message.Password;
-    }
     if (message.Options) {
       const entries = globalThis.Object.entries(message.Options) as [string, string][];
       if (entries.length > 0) {
@@ -521,16 +2059,29 @@ export const DatabaseEndpointConfiguration: MessageFns<DatabaseEndpointConfigura
     return obj;
   },
 
-  create(base?: DeepPartial<DatabaseEndpointConfiguration>): DatabaseEndpointConfiguration {
-    return DatabaseEndpointConfiguration.fromPartial(base ?? {});
+  create(base?: DeepPartial<ExternalServiceResponse>): ExternalServiceResponse {
+    return ExternalServiceResponse.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<DatabaseEndpointConfiguration>): DatabaseEndpointConfiguration {
-    const message = createBaseDatabaseEndpointConfiguration();
+  fromPartial(object: DeepPartial<ExternalServiceResponse>): ExternalServiceResponse {
+    const message = createBaseExternalServiceResponse();
+    message.Id = object.Id ?? "";
+    message.Name = object.Name ?? "";
+    message.EndpointType = object.EndpointType ?? 0;
+    message.Url = object.Url ?? "";
+    message.AuthorizationType = object.AuthorizationType ?? 0;
+    message.Headers = (globalThis.Object.entries(object.Headers ?? {}) as [string, string][]).reduce(
+      (acc: { [key: string]: string }, [key, value]: [string, string]) => {
+        if (value !== undefined) {
+          acc[key] = globalThis.String(value);
+        }
+        return acc;
+      },
+      {},
+    );
     message.Host = object.Host ?? "";
     message.Port = object.Port ?? 0;
     message.Database = object.Database ?? "";
     message.Username = object.Username ?? "";
-    message.Password = object.Password ?? "";
     message.Options = (globalThis.Object.entries(object.Options ?? {}) as [string, string][]).reduce(
       (acc: { [key: string]: string }, [key, value]: [string, string]) => {
         if (value !== undefined) {
@@ -544,12 +2095,12 @@ export const DatabaseEndpointConfiguration: MessageFns<DatabaseEndpointConfigura
   },
 };
 
-function createBaseDatabaseEndpointConfiguration_OptionsEntry(): DatabaseEndpointConfiguration_OptionsEntry {
+function createBaseExternalServiceResponse_HeadersEntry(): ExternalServiceResponse_HeadersEntry {
   return { key: "", value: "" };
 }
 
-export const DatabaseEndpointConfiguration_OptionsEntry: MessageFns<DatabaseEndpointConfiguration_OptionsEntry> = {
-  encode(message: DatabaseEndpointConfiguration_OptionsEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const ExternalServiceResponse_HeadersEntry: MessageFns<ExternalServiceResponse_HeadersEntry> = {
+  encode(message: ExternalServiceResponse_HeadersEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.key !== "") {
       writer.uint32(10).string(message.key);
     }
@@ -559,7 +2110,7 @@ export const DatabaseEndpointConfiguration_OptionsEntry: MessageFns<DatabaseEndp
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): DatabaseEndpointConfiguration_OptionsEntry {
+  decode(input: BinaryReader | Uint8Array, length?: number): ExternalServiceResponse_HeadersEntry {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -568,7 +2119,7 @@ export const DatabaseEndpointConfiguration_OptionsEntry: MessageFns<DatabaseEndp
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseDatabaseEndpointConfiguration_OptionsEntry();
+      const message = createBaseExternalServiceResponse_HeadersEntry();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
@@ -600,14 +2151,14 @@ export const DatabaseEndpointConfiguration_OptionsEntry: MessageFns<DatabaseEndp
     }
   },
 
-  fromJSON(object: any): DatabaseEndpointConfiguration_OptionsEntry {
+  fromJSON(object: any): ExternalServiceResponse_HeadersEntry {
     return {
       key: isSet(object.key) ? globalThis.String(object.key) : "",
       value: isSet(object.value) ? globalThis.String(object.value) : "",
     };
   },
 
-  toJSON(message: DatabaseEndpointConfiguration_OptionsEntry): unknown {
+  toJSON(message: ExternalServiceResponse_HeadersEntry): unknown {
     const obj: any = {};
     if (message.key !== "") {
       obj.key = message.key;
@@ -618,38 +2169,33 @@ export const DatabaseEndpointConfiguration_OptionsEntry: MessageFns<DatabaseEndp
     return obj;
   },
 
-  create(base?: DeepPartial<DatabaseEndpointConfiguration_OptionsEntry>): DatabaseEndpointConfiguration_OptionsEntry {
-    return DatabaseEndpointConfiguration_OptionsEntry.fromPartial(base ?? {});
+  create(base?: DeepPartial<ExternalServiceResponse_HeadersEntry>): ExternalServiceResponse_HeadersEntry {
+    return ExternalServiceResponse_HeadersEntry.fromPartial(base ?? {});
   },
-  fromPartial(
-    object: DeepPartial<DatabaseEndpointConfiguration_OptionsEntry>,
-  ): DatabaseEndpointConfiguration_OptionsEntry {
-    const message = createBaseDatabaseEndpointConfiguration_OptionsEntry();
+  fromPartial(object: DeepPartial<ExternalServiceResponse_HeadersEntry>): ExternalServiceResponse_HeadersEntry {
+    const message = createBaseExternalServiceResponse_HeadersEntry();
     message.key = object.key ?? "";
     message.value = object.value ?? "";
     return message;
   },
 };
 
-function createBaseExternalServiceDefinition(): ExternalServiceDefinition {
-  return { Id: "", Name: "", Endpoint: undefined };
+function createBaseExternalServiceResponse_OptionsEntry(): ExternalServiceResponse_OptionsEntry {
+  return { key: "", value: "" };
 }
 
-export const ExternalServiceDefinition: MessageFns<ExternalServiceDefinition> = {
-  encode(message: ExternalServiceDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.Id !== "") {
-      writer.uint32(10).string(message.Id);
-    }
-    if (message.Name !== "") {
-      writer.uint32(18).string(message.Name);
+export const ExternalServiceResponse_OptionsEntry: MessageFns<ExternalServiceResponse_OptionsEntry> = {
+  encode(message: ExternalServiceResponse_OptionsEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
     }
-    if (message.Endpoint !== undefined) {
-      ExternalServiceEndpoint.encode(message.Endpoint, writer.uint32(26).fork()).join();
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): ExternalServiceDefinition {
+  decode(input: BinaryReader | Uint8Array, length?: number): ExternalServiceResponse_OptionsEntry {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -658,7 +2204,7 @@ export const ExternalServiceDefinition: MessageFns<ExternalServiceDefinition> =
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseExternalServiceDefinition();
+      const message = createBaseExternalServiceResponse_OptionsEntry();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
@@ -667,110 +2213,7 @@ export const ExternalServiceDefinition: MessageFns<ExternalServiceDefinition> =
               break;
             }
 
-            message.Id = reader.string();
-            continue;
-          }
-          case 2: {
-            if (tag !== 18) {
-              break;
-            }
-
-            message.Name = reader.string();
-            continue;
-          }
-          case 3: {
-            if (tag !== 26) {
-              break;
-            }
-
-            message.Endpoint = ExternalServiceEndpoint.decode(reader, reader.uint32());
-            continue;
-          }
-        }
-        if ((tag & 7) === 4 || tag === 0) {
-          break;
-        }
-        reader.skip(tag & 7);
-      }
-      return message;
-    } finally {
-      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
-    }
-  },
-
-  fromJSON(object: any): ExternalServiceDefinition {
-    return {
-      Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
-      Name: isSet(object.Name) ? globalThis.String(object.Name) : "",
-      Endpoint: isSet(object.Endpoint) ? ExternalServiceEndpoint.fromJSON(object.Endpoint) : undefined,
-    };
-  },
-
-  toJSON(message: ExternalServiceDefinition): unknown {
-    const obj: any = {};
-    if (message.Id !== "") {
-      obj.Id = message.Id;
-    }
-    if (message.Name !== "") {
-      obj.Name = message.Name;
-    }
-    if (message.Endpoint !== undefined) {
-      obj.Endpoint = ExternalServiceEndpoint.toJSON(message.Endpoint);
-    }
-    return obj;
-  },
-
-  create(base?: DeepPartial<ExternalServiceDefinition>): ExternalServiceDefinition {
-    return ExternalServiceDefinition.fromPartial(base ?? {});
-  },
-  fromPartial(object: DeepPartial<ExternalServiceDefinition>): ExternalServiceDefinition {
-    const message = createBaseExternalServiceDefinition();
-    message.Id = object.Id ?? "";
-    message.Name = object.Name ?? "";
-    message.Endpoint = (object.Endpoint !== undefined && object.Endpoint !== null)
-      ? ExternalServiceEndpoint.fromPartial(object.Endpoint)
-      : undefined;
-    return message;
-  },
-};
-
-function createBaseExternalServiceEndpoint(): ExternalServiceEndpoint {
-  return { Type: 0, Http: undefined, Database: undefined };
-}
-
-export const ExternalServiceEndpoint: MessageFns<ExternalServiceEndpoint> = {
-  encode(message: ExternalServiceEndpoint, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.Type !== 0) {
-      writer.uint32(8).int32(message.Type);
-    }
-    if (message.Http !== undefined) {
-      HttpEndpointConfiguration.encode(message.Http, writer.uint32(18).fork()).join();
-    }
-    if (message.Database !== undefined) {
-      DatabaseEndpointConfiguration.encode(message.Database, writer.uint32(26).fork()).join();
-    }
-    return writer;
-  },
-
-  decode(input: BinaryReader | Uint8Array, length?: number): ExternalServiceEndpoint {
-    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 = createBaseExternalServiceEndpoint();
-      while (reader.pos < end) {
-        const tag = reader.uint32();
-        switch (tag >>> 3) {
-          case 1: {
-            if (tag !== 8) {
-              break;
-            }
-
-            message.Type = reader.int32() as any;
+            message.key = reader.string();
             continue;
           }
           case 2: {
@@ -778,15 +2221,7 @@ export const ExternalServiceEndpoint: MessageFns<ExternalServiceEndpoint> = {
               break;
             }
 
-            message.Http = HttpEndpointConfiguration.decode(reader, reader.uint32());
-            continue;
-          }
-          case 3: {
-            if (tag !== 26) {
-              break;
-            }
-
-            message.Database = DatabaseEndpointConfiguration.decode(reader, reader.uint32());
+            message.value = reader.string();
             continue;
           }
         }
@@ -801,40 +2236,31 @@ export const ExternalServiceEndpoint: MessageFns<ExternalServiceEndpoint> = {
     }
   },
 
-  fromJSON(object: any): ExternalServiceEndpoint {
+  fromJSON(object: any): ExternalServiceResponse_OptionsEntry {
     return {
-      Type: isSet(object.Type) ? externalServiceEndpointTypeFromJSON(object.Type) : 0,
-      Http: isSet(object.Http) ? HttpEndpointConfiguration.fromJSON(object.Http) : undefined,
-      Database: isSet(object.Database) ? DatabaseEndpointConfiguration.fromJSON(object.Database) : undefined,
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? globalThis.String(object.value) : "",
     };
   },
 
-  toJSON(message: ExternalServiceEndpoint): unknown {
+  toJSON(message: ExternalServiceResponse_OptionsEntry): unknown {
     const obj: any = {};
-    if (message.Type !== 0) {
-      obj.Type = externalServiceEndpointTypeToJSON(message.Type);
-    }
-    if (message.Http !== undefined) {
-      obj.Http = HttpEndpointConfiguration.toJSON(message.Http);
+    if (message.key !== "") {
+      obj.key = message.key;
     }
-    if (message.Database !== undefined) {
-      obj.Database = DatabaseEndpointConfiguration.toJSON(message.Database);
+    if (message.value !== "") {
+      obj.value = message.value;
     }
     return obj;
   },
 
-  create(base?: DeepPartial<ExternalServiceEndpoint>): ExternalServiceEndpoint {
-    return ExternalServiceEndpoint.fromPartial(base ?? {});
+  create(base?: DeepPartial<ExternalServiceResponse_OptionsEntry>): ExternalServiceResponse_OptionsEntry {
+    return ExternalServiceResponse_OptionsEntry.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<ExternalServiceEndpoint>): ExternalServiceEndpoint {
-    const message = createBaseExternalServiceEndpoint();
-    message.Type = object.Type ?? 0;
-    message.Http = (object.Http !== undefined && object.Http !== null)
-      ? HttpEndpointConfiguration.fromPartial(object.Http)
-      : undefined;
-    message.Database = (object.Database !== undefined && object.Database !== null)
-      ? DatabaseEndpointConfiguration.fromPartial(object.Database)
-      : undefined;
+  fromPartial(object: DeepPartial<ExternalServiceResponse_OptionsEntry>): ExternalServiceResponse_OptionsEntry {
+    const message = createBaseExternalServiceResponse_OptionsEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
     return message;
   },
 };
@@ -1124,83 +2550,12 @@ export const HttpEndpointConfiguration_HeadersEntry: MessageFns<HttpEndpointConf
   },
 
   create(base?: DeepPartial<HttpEndpointConfiguration_HeadersEntry>): HttpEndpointConfiguration_HeadersEntry {
-    return HttpEndpointConfiguration_HeadersEntry.fromPartial(base ?? {});
-  },
-  fromPartial(object: DeepPartial<HttpEndpointConfiguration_HeadersEntry>): HttpEndpointConfiguration_HeadersEntry {
-    const message = createBaseHttpEndpointConfiguration_HeadersEntry();
-    message.key = object.key ?? "";
-    message.value = object.value ?? "";
-    return message;
-  },
-};
-
-function createBaseIEnumerableExternalServiceDefinition(): IEnumerableExternalServiceDefinition {
-  return { items: [] };
-}
-
-export const IEnumerableExternalServiceDefinition: MessageFns<IEnumerableExternalServiceDefinition> = {
-  encode(message: IEnumerableExternalServiceDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    for (const v of message.items) {
-      ExternalServiceDefinition.encode(v!, writer.uint32(10).fork()).join();
-    }
-    return writer;
-  },
-
-  decode(input: BinaryReader | Uint8Array, length?: number): IEnumerableExternalServiceDefinition {
-    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 = createBaseIEnumerableExternalServiceDefinition();
-      while (reader.pos < end) {
-        const tag = reader.uint32();
-        switch (tag >>> 3) {
-          case 1: {
-            if (tag !== 10) {
-              break;
-            }
-
-            message.items.push(ExternalServiceDefinition.decode(reader, reader.uint32()));
-            continue;
-          }
-        }
-        if ((tag & 7) === 4 || tag === 0) {
-          break;
-        }
-        reader.skip(tag & 7);
-      }
-      return message;
-    } finally {
-      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
-    }
-  },
-
-  fromJSON(object: any): IEnumerableExternalServiceDefinition {
-    return {
-      items: globalThis.Array.isArray(object?.items)
-        ? object.items.map((e: any) => ExternalServiceDefinition.fromJSON(e))
-        : [],
-    };
-  },
-
-  toJSON(message: IEnumerableExternalServiceDefinition): unknown {
-    const obj: any = {};
-    if (message.items?.length) {
-      obj.items = message.items.map((e) => ExternalServiceDefinition.toJSON(e));
-    }
-    return obj;
-  },
-
-  create(base?: DeepPartial<IEnumerableExternalServiceDefinition>): IEnumerableExternalServiceDefinition {
-    return IEnumerableExternalServiceDefinition.fromPartial(base ?? {});
+    return HttpEndpointConfiguration_HeadersEntry.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<IEnumerableExternalServiceDefinition>): IEnumerableExternalServiceDefinition {
-    const message = createBaseIEnumerableExternalServiceDefinition();
-    message.items = object.items?.map((e) => ExternalServiceDefinition.fromPartial(e)) || [];
+  fromPartial(object: DeepPartial<HttpEndpointConfiguration_HeadersEntry>): HttpEndpointConfiguration_HeadersEntry {
+    const message = createBaseHttpEndpointConfiguration_HeadersEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
     return message;
   },
 };
@@ -1306,6 +2661,73 @@ export const OAuthAuthorization: MessageFns<OAuthAuthorization> = {
   },
 };
 
+function createBaseObserveExternalServicesRequest(): ObserveExternalServicesRequest {
+  return { EventStore: "" };
+}
+
+export const ObserveExternalServicesRequest: MessageFns<ObserveExternalServicesRequest> = {
+  encode(message: ObserveExternalServicesRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.EventStore !== "") {
+      writer.uint32(10).string(message.EventStore);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ObserveExternalServicesRequest {
+    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 = createBaseObserveExternalServicesRequest();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.EventStore = 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): ObserveExternalServicesRequest {
+    return { EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "" };
+  },
+
+  toJSON(message: ObserveExternalServicesRequest): unknown {
+    const obj: any = {};
+    if (message.EventStore !== "") {
+      obj.EventStore = message.EventStore;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<ObserveExternalServicesRequest>): ObserveExternalServicesRequest {
+    return ObserveExternalServicesRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ObserveExternalServicesRequest>): ObserveExternalServicesRequest {
+    const message = createBaseObserveExternalServicesRequest();
+    message.EventStore = object.EventStore ?? "";
+    return message;
+  },
+};
+
 function createBaseOneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization(): OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization {
   return { Value0: undefined, Value1: undefined, Value2: undefined };
 }
@@ -1425,12 +2847,269 @@ export const OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization:
   },
 };
 
-function createBaseRemoveExternalServices(): RemoveExternalServices {
+function createBaseQueryResultIEnumerableExternalServiceResponse(): QueryResultIEnumerableExternalServiceResponse {
+  return {
+    CorrelationId: undefined,
+    IsAuthorized: false,
+    ValidationResults: [],
+    ExceptionMessages: [],
+    ExceptionStackTrace: "",
+    Data: [],
+  };
+}
+
+export const QueryResultIEnumerableExternalServiceResponse: MessageFns<QueryResultIEnumerableExternalServiceResponse> =
+  {
+    encode(
+      message: QueryResultIEnumerableExternalServiceResponse,
+      writer: BinaryWriter = new BinaryWriter(),
+    ): BinaryWriter {
+      if (message.CorrelationId !== undefined) {
+        Guid.encode(message.CorrelationId, writer.uint32(10).fork()).join();
+      }
+      if (message.IsAuthorized !== false) {
+        writer.uint32(16).bool(message.IsAuthorized);
+      }
+      for (const v of message.ValidationResults) {
+        ValidationResult.encode(v!, writer.uint32(26).fork()).join();
+      }
+      for (const v of message.ExceptionMessages) {
+        writer.uint32(34).string(v!);
+      }
+      if (message.ExceptionStackTrace !== "") {
+        writer.uint32(42).string(message.ExceptionStackTrace);
+      }
+      for (const v of message.Data) {
+        ExternalServiceResponse.encode(v!, writer.uint32(50).fork()).join();
+      }
+      return writer;
+    },
+
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryResultIEnumerableExternalServiceResponse {
+      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 = createBaseQueryResultIEnumerableExternalServiceResponse();
+        while (reader.pos < end) {
+          const tag = reader.uint32();
+          switch (tag >>> 3) {
+            case 1: {
+              if (tag !== 10) {
+                break;
+              }
+
+              message.CorrelationId = Guid.decode(reader, reader.uint32());
+              continue;
+            }
+            case 2: {
+              if (tag !== 16) {
+                break;
+              }
+
+              message.IsAuthorized = reader.bool();
+              continue;
+            }
+            case 3: {
+              if (tag !== 26) {
+                break;
+              }
+
+              message.ValidationResults.push(ValidationResult.decode(reader, reader.uint32()));
+              continue;
+            }
+            case 4: {
+              if (tag !== 34) {
+                break;
+              }
+
+              message.ExceptionMessages.push(reader.string());
+              continue;
+            }
+            case 5: {
+              if (tag !== 42) {
+                break;
+              }
+
+              message.ExceptionStackTrace = reader.string();
+              continue;
+            }
+            case 6: {
+              if (tag !== 50) {
+                break;
+              }
+
+              message.Data.push(ExternalServiceResponse.decode(reader, reader.uint32()));
+              continue;
+            }
+          }
+          if ((tag & 7) === 4 || tag === 0) {
+            break;
+          }
+          reader.skip(tag & 7);
+        }
+        return message;
+      } finally {
+        (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+      }
+    },
+
+    fromJSON(object: any): QueryResultIEnumerableExternalServiceResponse {
+      return {
+        CorrelationId: isSet(object.CorrelationId) ? Guid.fromJSON(object.CorrelationId) : undefined,
+        IsAuthorized: isSet(object.IsAuthorized) ? globalThis.Boolean(object.IsAuthorized) : false,
+        ValidationResults: globalThis.Array.isArray(object?.ValidationResults)
+          ? object.ValidationResults.map((e: any) => ValidationResult.fromJSON(e))
+          : [],
+        ExceptionMessages: globalThis.Array.isArray(object?.ExceptionMessages)
+          ? object.ExceptionMessages.map((e: any) => globalThis.String(e))
+          : [],
+        ExceptionStackTrace: isSet(object.ExceptionStackTrace) ? globalThis.String(object.ExceptionStackTrace) : "",
+        Data: globalThis.Array.isArray(object?.Data)
+          ? object.Data.map((e: any) => ExternalServiceResponse.fromJSON(e))
+          : [],
+      };
+    },
+
+    toJSON(message: QueryResultIEnumerableExternalServiceResponse): unknown {
+      const obj: any = {};
+      if (message.CorrelationId !== undefined) {
+        obj.CorrelationId = Guid.toJSON(message.CorrelationId);
+      }
+      if (message.IsAuthorized !== false) {
+        obj.IsAuthorized = message.IsAuthorized;
+      }
+      if (message.ValidationResults?.length) {
+        obj.ValidationResults = message.ValidationResults.map((e) => ValidationResult.toJSON(e));
+      }
+      if (message.ExceptionMessages?.length) {
+        obj.ExceptionMessages = message.ExceptionMessages;
+      }
+      if (message.ExceptionStackTrace !== "") {
+        obj.ExceptionStackTrace = message.ExceptionStackTrace;
+      }
+      if (message.Data?.length) {
+        obj.Data = message.Data.map((e) => ExternalServiceResponse.toJSON(e));
+      }
+      return obj;
+    },
+
+    create(
+      base?: DeepPartial<QueryResultIEnumerableExternalServiceResponse>,
+    ): QueryResultIEnumerableExternalServiceResponse {
+      return QueryResultIEnumerableExternalServiceResponse.fromPartial(base ?? {});
+    },
+    fromPartial(
+      object: DeepPartial<QueryResultIEnumerableExternalServiceResponse>,
+    ): QueryResultIEnumerableExternalServiceResponse {
+      const message = createBaseQueryResultIEnumerableExternalServiceResponse();
+      message.CorrelationId = (object.CorrelationId !== undefined && object.CorrelationId !== null)
+        ? Guid.fromPartial(object.CorrelationId)
+        : undefined;
+      message.IsAuthorized = object.IsAuthorized ?? false;
+      message.ValidationResults = object.ValidationResults?.map((e) => ValidationResult.fromPartial(e)) || [];
+      message.ExceptionMessages = object.ExceptionMessages?.map((e) => e) || [];
+      message.ExceptionStackTrace = object.ExceptionStackTrace ?? "";
+      message.Data = object.Data?.map((e) => ExternalServiceResponse.fromPartial(e)) || [];
+      return message;
+    },
+  };
+
+function createBaseRemoveExternalServiceRequest(): RemoveExternalServiceRequest {
+  return { EventStore: "", ExternalServiceId: "" };
+}
+
+export const RemoveExternalServiceRequest: MessageFns<RemoveExternalServiceRequest> = {
+  encode(message: RemoveExternalServiceRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.EventStore !== "") {
+      writer.uint32(10).string(message.EventStore);
+    }
+    if (message.ExternalServiceId !== "") {
+      writer.uint32(18).string(message.ExternalServiceId);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): RemoveExternalServiceRequest {
+    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 = createBaseRemoveExternalServiceRequest();
+      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.ExternalServiceId = 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): RemoveExternalServiceRequest {
+    return {
+      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+      ExternalServiceId: isSet(object.ExternalServiceId) ? globalThis.String(object.ExternalServiceId) : "",
+    };
+  },
+
+  toJSON(message: RemoveExternalServiceRequest): unknown {
+    const obj: any = {};
+    if (message.EventStore !== "") {
+      obj.EventStore = message.EventStore;
+    }
+    if (message.ExternalServiceId !== "") {
+      obj.ExternalServiceId = message.ExternalServiceId;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<RemoveExternalServiceRequest>): RemoveExternalServiceRequest {
+    return RemoveExternalServiceRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<RemoveExternalServiceRequest>): RemoveExternalServiceRequest {
+    const message = createBaseRemoveExternalServiceRequest();
+    message.EventStore = object.EventStore ?? "";
+    message.ExternalServiceId = object.ExternalServiceId ?? "";
+    return message;
+  },
+};
+
+function createBaseRemoveExternalServicesRequest(): RemoveExternalServicesRequest {
   return { EventStore: "", ExternalServices: [] };
 }
 
-export const RemoveExternalServices: MessageFns<RemoveExternalServices> = {
-  encode(message: RemoveExternalServices, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const RemoveExternalServicesRequest: MessageFns<RemoveExternalServicesRequest> = {
+  encode(message: RemoveExternalServicesRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.EventStore !== "") {
       writer.uint32(10).string(message.EventStore);
     }
@@ -1440,7 +3119,7 @@ export const RemoveExternalServices: MessageFns<RemoveExternalServices> = {
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): RemoveExternalServices {
+  decode(input: BinaryReader | Uint8Array, length?: number): RemoveExternalServicesRequest {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -1449,7 +3128,7 @@ export const RemoveExternalServices: MessageFns<RemoveExternalServices> = {
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseRemoveExternalServices();
+      const message = createBaseRemoveExternalServicesRequest();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
@@ -1481,7 +3160,7 @@ export const RemoveExternalServices: MessageFns<RemoveExternalServices> = {
     }
   },
 
-  fromJSON(object: any): RemoveExternalServices {
+  fromJSON(object: any): RemoveExternalServicesRequest {
     return {
       EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
       ExternalServices: globalThis.Array.isArray(object?.ExternalServices)
@@ -1490,7 +3169,7 @@ export const RemoveExternalServices: MessageFns<RemoveExternalServices> = {
     };
   },
 
-  toJSON(message: RemoveExternalServices): unknown {
+  toJSON(message: RemoveExternalServicesRequest): unknown {
     const obj: any = {};
     if (message.EventStore !== "") {
       obj.EventStore = message.EventStore;
@@ -1501,27 +3180,136 @@ export const RemoveExternalServices: MessageFns<RemoveExternalServices> = {
     return obj;
   },
 
-  create(base?: DeepPartial<RemoveExternalServices>): RemoveExternalServices {
-    return RemoveExternalServices.fromPartial(base ?? {});
+  create(base?: DeepPartial<RemoveExternalServicesRequest>): RemoveExternalServicesRequest {
+    return RemoveExternalServicesRequest.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<RemoveExternalServices>): RemoveExternalServices {
-    const message = createBaseRemoveExternalServices();
+  fromPartial(object: DeepPartial<RemoveExternalServicesRequest>): RemoveExternalServicesRequest {
+    const message = createBaseRemoveExternalServicesRequest();
     message.EventStore = object.EventStore ?? "";
     message.ExternalServices = object.ExternalServices?.map((e) => e) || [];
     return message;
   },
 };
 
+function createBaseValidationResult(): ValidationResult {
+  return { Severity: 0, Message: "", Members: [] };
+}
+
+export const ValidationResult: MessageFns<ValidationResult> = {
+  encode(message: ValidationResult, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.Severity !== 0) {
+      writer.uint32(8).int32(message.Severity);
+    }
+    if (message.Message !== "") {
+      writer.uint32(18).string(message.Message);
+    }
+    for (const v of message.Members) {
+      writer.uint32(26).string(v!);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ValidationResult {
+    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 = createBaseValidationResult();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 8) {
+              break;
+            }
+
+            message.Severity = reader.int32() as any;
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.Message = reader.string();
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.Members.push(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): ValidationResult {
+    return {
+      Severity: isSet(object.Severity) ? validationResultSeverityFromJSON(object.Severity) : 0,
+      Message: isSet(object.Message) ? globalThis.String(object.Message) : "",
+      Members: globalThis.Array.isArray(object?.Members) ? object.Members.map((e: any) => globalThis.String(e)) : [],
+    };
+  },
+
+  toJSON(message: ValidationResult): unknown {
+    const obj: any = {};
+    if (message.Severity !== 0) {
+      obj.Severity = validationResultSeverityToJSON(message.Severity);
+    }
+    if (message.Message !== "") {
+      obj.Message = message.Message;
+    }
+    if (message.Members?.length) {
+      obj.Members = message.Members;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<ValidationResult>): ValidationResult {
+    return ValidationResult.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ValidationResult>): ValidationResult {
+    const message = createBaseValidationResult();
+    message.Severity = object.Severity ?? 0;
+    message.Message = object.Message ?? "";
+    message.Members = object.Members?.map((e) => e) || [];
+    return message;
+  },
+};
+
 export type ExternalServicesDefinition = typeof ExternalServicesDefinition;
 export const ExternalServicesDefinition = {
   name: "ExternalServices",
   fullName: "Cratis.Chronicle.Contracts.ExternalServices.ExternalServices",
   methods: {
-    add: {
-      name: "Add",
-      requestType: AddExternalServices as typeof AddExternalServices,
+    addExternalService: {
+      name: "AddExternalService",
+      requestType: AddExternalServiceRequest as typeof AddExternalServiceRequest,
+      requestStream: false,
+      responseType: CommandResult as typeof CommandResult,
+      responseStream: false,
+      options: {},
+    },
+    addExternalServices: {
+      name: "AddExternalServices",
+      requestType: AddExternalServicesRequest as typeof AddExternalServicesRequest,
       requestStream: false,
-      responseType: Empty as typeof Empty,
+      responseType: CommandResult as typeof CommandResult,
       responseStream: false,
       options: {},
     },
@@ -1529,23 +3317,33 @@ export const ExternalServicesDefinition = {
       name: "GetExternalServices",
       requestType: GetExternalServicesRequest as typeof GetExternalServicesRequest,
       requestStream: false,
-      responseType: IEnumerableExternalServiceDefinition as typeof IEnumerableExternalServiceDefinition,
+      responseType:
+        QueryResultIEnumerableExternalServiceResponse as typeof QueryResultIEnumerableExternalServiceResponse,
       responseStream: false,
       options: {},
     },
     observeExternalServices: {
       name: "ObserveExternalServices",
-      requestType: GetExternalServicesRequest as typeof GetExternalServicesRequest,
+      requestType: ObserveExternalServicesRequest as typeof ObserveExternalServicesRequest,
       requestStream: false,
-      responseType: IEnumerableExternalServiceDefinition as typeof IEnumerableExternalServiceDefinition,
+      responseType:
+        QueryResultIEnumerableExternalServiceResponse as typeof QueryResultIEnumerableExternalServiceResponse,
       responseStream: true,
       options: {},
     },
-    remove: {
-      name: "Remove",
-      requestType: RemoveExternalServices as typeof RemoveExternalServices,
+    removeExternalService: {
+      name: "RemoveExternalService",
+      requestType: RemoveExternalServiceRequest as typeof RemoveExternalServiceRequest,
+      requestStream: false,
+      responseType: CommandResult as typeof CommandResult,
+      responseStream: false,
+      options: {},
+    },
+    removeExternalServices: {
+      name: "RemoveExternalServices",
+      requestType: RemoveExternalServicesRequest as typeof RemoveExternalServicesRequest,
       requestStream: false,
-      responseType: Empty as typeof Empty,
+      responseType: CommandResult as typeof CommandResult,
       responseStream: false,
       options: {},
     },
@@ -1553,29 +3351,57 @@ export const ExternalServicesDefinition = {
 } as const;
 
 export interface ExternalServicesServiceImplementation<CallContextExt = {}> {
-  add(request: AddExternalServices, context: CallContext & CallContextExt): Promise<DeepPartial<Empty>>;
+  addExternalService(
+    request: AddExternalServiceRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<CommandResult>>;
+  addExternalServices(
+    request: AddExternalServicesRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<CommandResult>>;
   getExternalServices(
     request: GetExternalServicesRequest,
     context: CallContext & CallContextExt,
-  ): Promise<DeepPartial<IEnumerableExternalServiceDefinition>>;
+  ): Promise<DeepPartial<QueryResultIEnumerableExternalServiceResponse>>;
   observeExternalServices(
-    request: GetExternalServicesRequest,
+    request: ObserveExternalServicesRequest,
+    context: CallContext & CallContextExt,
+  ): ServerStreamingMethodResult<DeepPartial<QueryResultIEnumerableExternalServiceResponse>>;
+  removeExternalService(
+    request: RemoveExternalServiceRequest,
     context: CallContext & CallContextExt,
-  ): ServerStreamingMethodResult<DeepPartial<IEnumerableExternalServiceDefinition>>;
-  remove(request: RemoveExternalServices, context: CallContext & CallContextExt): Promise<DeepPartial<Empty>>;
+  ): Promise<DeepPartial<CommandResult>>;
+  removeExternalServices(
+    request: RemoveExternalServicesRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<CommandResult>>;
 }
 
 export interface ExternalServicesClient<CallOptionsExt = {}> {
-  add(request: DeepPartial<AddExternalServices>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
+  addExternalService(
+    request: DeepPartial<AddExternalServiceRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<CommandResult>;
+  addExternalServices(
+    request: DeepPartial<AddExternalServicesRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<CommandResult>;
   getExternalServices(
     request: DeepPartial<GetExternalServicesRequest>,
     options?: CallOptions & CallOptionsExt,
-  ): Promise<IEnumerableExternalServiceDefinition>;
+  ): Promise<QueryResultIEnumerableExternalServiceResponse>;
   observeExternalServices(
-    request: DeepPartial<GetExternalServicesRequest>,
+    request: DeepPartial<ObserveExternalServicesRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): AsyncIterable<QueryResultIEnumerableExternalServiceResponse>;
+  removeExternalService(
+    request: DeepPartial<RemoveExternalServiceRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<CommandResult>;
+  removeExternalServices(
+    request: DeepPartial<RemoveExternalServicesRequest>,
     options?: CallOptions & CallOptionsExt,
-  ): AsyncIterable<IEnumerableExternalServiceDefinition>;
-  remove(request: DeepPartial<RemoveExternalServices>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
+  ): Promise<CommandResult>;
 }
 
 type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;