@cratis/chronicle.contracts 16.45.3 → 17.0.1

package/generated/observation_webhooks.ts

@@ -7,52 +7,125 @@
 /* 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.Observation.Webhooks";
 
-export enum ObserverOwner {
+export enum AuthorizationType {
   None = 0,
-  Client = 1,
-  Kernel = 2,
+  Basic = 1,
+  Bearer = 2,
+  OAuth = 3,
   UNRECOGNIZED = -1,
 }
 
-export function observerOwnerFromJSON(object: any): ObserverOwner {
+export function authorizationTypeFromJSON(object: any): AuthorizationType {
   switch (object) {
     case 0:
     case "None":
-      return ObserverOwner.None;
+      return AuthorizationType.None;
     case 1:
-    case "Client":
-      return ObserverOwner.Client;
+    case "Basic":
+      return AuthorizationType.Basic;
     case 2:
-    case "Kernel":
-      return ObserverOwner.Kernel;
+    case "Bearer":
+      return AuthorizationType.Bearer;
+    case 3:
+    case "OAuth":
+      return AuthorizationType.OAuth;
     case -1:
     case "UNRECOGNIZED":
     default:
-      return ObserverOwner.UNRECOGNIZED;
+      return AuthorizationType.UNRECOGNIZED;
   }
 }
 
-export function observerOwnerToJSON(object: ObserverOwner): string {
+export function authorizationTypeToJSON(object: AuthorizationType): string {
   switch (object) {
-    case ObserverOwner.None:
+    case AuthorizationType.None:
       return "None";
-    case ObserverOwner.Client:
-      return "Client";
-    case ObserverOwner.Kernel:
-      return "Kernel";
-    case ObserverOwner.UNRECOGNIZED:
+    case AuthorizationType.Basic:
+      return "Basic";
+    case AuthorizationType.Bearer:
+      return "Bearer";
+    case AuthorizationType.OAuth:
+      return "OAuth";
+    case AuthorizationType.UNRECOGNIZED:
     default:
       return "UNRECOGNIZED";
   }
 }
 
-export interface AddWebhooks {
+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 AddWebhookRequest {
+  EventStore: string;
+  Name: string;
+  Url: string;
+  EventSequenceId: string;
+  EventTypes: EventType[];
+  AuthorizationType: AuthorizationType;
+  BasicUsername: string;
+  BasicPassword: string;
+  BearerToken: string;
+  OAuthAuthority: string;
+  OAuthClientId: string;
+  OAuthClientSecret: string;
+  Headers: { [key: string]: string };
+  IsReplayable: boolean;
+  IsActive: boolean;
+}
+
+export interface AddWebhookRequest_HeadersEntry {
+  key: string;
+  value: string;
+}
+
+export interface AddWebhooksRequest {
   EventStore: string;
-  Owner: ObserverOwner;
   Webhooks: WebhookDefinition[];
 }
 
@@ -65,6 +138,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 EventType {
   Id: string;
   Generation: number;
@@ -75,90 +161,535 @@ export interface GetWebhooksRequest {
   EventStore: string;
 }
 
-export interface IEnumerableWebhookDefinition {
-  items: WebhookDefinition[];
-}
-
 export interface OAuthAuthorization {
   Authority: string;
   ClientId: string;
   ClientSecret: string;
 }
 
+export interface ObserveWebhooksRequest {
+  EventStore: string;
+}
+
 export interface OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization {
   Value0: BasicAuthorization | undefined;
   Value1: BearerTokenAuthorization | undefined;
   Value2: OAuthAuthorization | undefined;
 }
 
-export interface RemoveWebhooks {
+export interface QueryResultIEnumerableWebhookDetailsResponse {
+  /** 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: WebhookDetailsResponse[];
+}
+
+export interface RemoveWebhookRequest {
+  EventStore: string;
+  WebhookId: string;
+}
+
+export interface RemoveWebhooksRequest {
   EventStore: string;
   Webhooks: string[];
 }
 
-export interface TestOAuthAuthorizationRequest {
-  Authority: string;
-  ClientId: string;
-  ClientSecret: string;
+export interface ValidationResult {
+  /** default value could not be applied: Error */
+  Severity: ValidationResultSeverity;
+  Message: string;
+  Members: string[];
+}
+
+export interface WebhookDefinition {
+  EventSequenceId: string;
+  Identifier: string;
+  EventTypes: EventType[];
+  Target:
+    | WebhookTarget
+    | undefined;
+  /** default value could not be applied: True */
+  IsReplayable: boolean;
+  /** default value could not be applied: True */
+  IsActive: boolean;
+}
+
+export interface WebhookDetailsResponse {
+  Identifier: string;
+  Url: string;
+  EventSequenceId: string;
+  EventTypes: EventType[];
+  AuthorizationType: AuthorizationType;
+  Headers: { [key: string]: string };
+  IsReplayable: boolean;
+  IsActive: boolean;
+  Id: string;
+}
+
+export interface WebhookDetailsResponse_HeadersEntry {
+  key: string;
+  value: string;
+}
+
+export interface WebhookTarget {
+  Url: string;
+  Authorization: OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization | undefined;
+  Headers: { [key: string]: string };
+}
+
+export interface WebhookTarget_HeadersEntry {
+  key: string;
+  value: string;
+}
+
+function createBaseAddWebhookRequest(): AddWebhookRequest {
+  return {
+    EventStore: "",
+    Name: "",
+    Url: "",
+    EventSequenceId: "",
+    EventTypes: [],
+    AuthorizationType: 0,
+    BasicUsername: "",
+    BasicPassword: "",
+    BearerToken: "",
+    OAuthAuthority: "",
+    OAuthClientId: "",
+    OAuthClientSecret: "",
+    Headers: {},
+    IsReplayable: false,
+    IsActive: false,
+  };
+}
+
+export const AddWebhookRequest: MessageFns<AddWebhookRequest> = {
+  encode(message: AddWebhookRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.EventStore !== "") {
+      writer.uint32(10).string(message.EventStore);
+    }
+    if (message.Name !== "") {
+      writer.uint32(18).string(message.Name);
+    }
+    if (message.Url !== "") {
+      writer.uint32(26).string(message.Url);
+    }
+    if (message.EventSequenceId !== "") {
+      writer.uint32(34).string(message.EventSequenceId);
+    }
+    for (const v of message.EventTypes) {
+      EventType.encode(v!, writer.uint32(42).fork()).join();
+    }
+    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]) => {
+      AddWebhookRequest_HeadersEntry.encode({ key: key as any, value }, writer.uint32(106).fork()).join();
+    });
+    if (message.IsReplayable !== false) {
+      writer.uint32(112).bool(message.IsReplayable);
+    }
+    if (message.IsActive !== false) {
+      writer.uint32(120).bool(message.IsActive);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): AddWebhookRequest {
+    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 = createBaseAddWebhookRequest();
+      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.Name = reader.string();
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.Url = reader.string();
+            continue;
+          }
+          case 4: {
+            if (tag !== 34) {
+              break;
+            }
+
+            message.EventSequenceId = reader.string();
+            continue;
+          }
+          case 5: {
+            if (tag !== 42) {
+              break;
+            }
+
+            message.EventTypes.push(EventType.decode(reader, reader.uint32()));
+            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 = AddWebhookRequest_HeadersEntry.decode(reader, reader.uint32());
+            if (entry13.value !== undefined) {
+              message.Headers[entry13.key] = entry13.value;
+            }
+            continue;
+          }
+          case 14: {
+            if (tag !== 112) {
+              break;
+            }
+
+            message.IsReplayable = reader.bool();
+            continue;
+          }
+          case 15: {
+            if (tag !== 120) {
+              break;
+            }
+
+            message.IsActive = reader.bool();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): AddWebhookRequest {
+    return {
+      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+      Name: isSet(object.Name) ? globalThis.String(object.Name) : "",
+      Url: isSet(object.Url) ? globalThis.String(object.Url) : "",
+      EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
+      EventTypes: globalThis.Array.isArray(object?.EventTypes)
+        ? object.EventTypes.map((e: any) => EventType.fromJSON(e))
+        : [],
+      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;
+          },
+          {},
+        )
+        : {},
+      IsReplayable: isSet(object.IsReplayable) ? globalThis.Boolean(object.IsReplayable) : false,
+      IsActive: isSet(object.IsActive) ? globalThis.Boolean(object.IsActive) : false,
+    };
+  },
+
+  toJSON(message: AddWebhookRequest): unknown {
+    const obj: any = {};
+    if (message.EventStore !== "") {
+      obj.EventStore = message.EventStore;
+    }
+    if (message.Name !== "") {
+      obj.Name = message.Name;
+    }
+    if (message.Url !== "") {
+      obj.Url = message.Url;
+    }
+    if (message.EventSequenceId !== "") {
+      obj.EventSequenceId = message.EventSequenceId;
+    }
+    if (message.EventTypes?.length) {
+      obj.EventTypes = message.EventTypes.map((e) => EventType.toJSON(e));
+    }
+    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.IsReplayable !== false) {
+      obj.IsReplayable = message.IsReplayable;
+    }
+    if (message.IsActive !== false) {
+      obj.IsActive = message.IsActive;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<AddWebhookRequest>): AddWebhookRequest {
+    return AddWebhookRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<AddWebhookRequest>): AddWebhookRequest {
+    const message = createBaseAddWebhookRequest();
+    message.EventStore = object.EventStore ?? "";
+    message.Name = object.Name ?? "";
+    message.Url = object.Url ?? "";
+    message.EventSequenceId = object.EventSequenceId ?? "";
+    message.EventTypes = object.EventTypes?.map((e) => EventType.fromPartial(e)) || [];
+    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.IsReplayable = object.IsReplayable ?? false;
+    message.IsActive = object.IsActive ?? false;
+    return message;
+  },
+};
+
+function createBaseAddWebhookRequest_HeadersEntry(): AddWebhookRequest_HeadersEntry {
+  return { key: "", value: "" };
 }
 
-export interface TestOAuthAuthorizationResponse {
-  Success: boolean;
-  ErrorMessage: string;
-}
+export const AddWebhookRequest_HeadersEntry: MessageFns<AddWebhookRequest_HeadersEntry> = {
+  encode(message: AddWebhookRequest_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;
+  },
 
-export interface TestWebhookRequest {
-  Target: WebhookTarget | undefined;
-}
+  decode(input: BinaryReader | Uint8Array, length?: number): AddWebhookRequest_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 = createBaseAddWebhookRequest_HeadersEntry();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
 
-export interface TestWebhookResponse {
-  Success: boolean;
-  ErrorMessage: string;
-}
+            message.key = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
 
-export interface WebhookDefinition {
-  EventSequenceId: string;
-  Identifier: string;
-  EventTypes: EventType[];
-  Target:
-    | WebhookTarget
-    | undefined;
-  /** default value could not be applied: True */
-  IsReplayable: boolean;
-  /** default value could not be applied: True */
-  IsActive: boolean;
-}
+            message.value = reader.string();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
 
-export interface WebhookTarget {
-  Url: string;
-  Authorization: OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization | undefined;
-  Headers: { [key: string]: string };
-}
+  fromJSON(object: any): AddWebhookRequest_HeadersEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? globalThis.String(object.value) : "",
+    };
+  },
 
-export interface WebhookTarget_HeadersEntry {
-  key: string;
-  value: string;
-}
+  toJSON(message: AddWebhookRequest_HeadersEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<AddWebhookRequest_HeadersEntry>): AddWebhookRequest_HeadersEntry {
+    return AddWebhookRequest_HeadersEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<AddWebhookRequest_HeadersEntry>): AddWebhookRequest_HeadersEntry {
+    const message = createBaseAddWebhookRequest_HeadersEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  },
+};
 
-function createBaseAddWebhooks(): AddWebhooks {
-  return { EventStore: "", Owner: 0, Webhooks: [] };
+function createBaseAddWebhooksRequest(): AddWebhooksRequest {
+  return { EventStore: "", Webhooks: [] };
 }
 
-export const AddWebhooks: MessageFns<AddWebhooks> = {
-  encode(message: AddWebhooks, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const AddWebhooksRequest: MessageFns<AddWebhooksRequest> = {
+  encode(message: AddWebhooksRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.EventStore !== "") {
       writer.uint32(10).string(message.EventStore);
     }
-    if (message.Owner !== 0) {
-      writer.uint32(16).int32(message.Owner);
-    }
     for (const v of message.Webhooks) {
-      WebhookDefinition.encode(v!, writer.uint32(26).fork()).join();
+      WebhookDefinition.encode(v!, writer.uint32(18).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): AddWebhooks {
+  decode(input: BinaryReader | Uint8Array, length?: number): AddWebhooksRequest {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -167,7 +698,7 @@ export const AddWebhooks: MessageFns<AddWebhooks> = {
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseAddWebhooks();
+      const message = createBaseAddWebhooksRequest();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
@@ -180,15 +711,7 @@ export const AddWebhooks: MessageFns<AddWebhooks> = {
             continue;
           }
           case 2: {
-            if (tag !== 16) {
-              break;
-            }
-
-            message.Owner = reader.int32() as any;
-            continue;
-          }
-          case 3: {
-            if (tag !== 26) {
+            if (tag !== 18) {
               break;
             }
 
@@ -207,37 +730,32 @@ export const AddWebhooks: MessageFns<AddWebhooks> = {
     }
   },
 
-  fromJSON(object: any): AddWebhooks {
+  fromJSON(object: any): AddWebhooksRequest {
     return {
       EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
-      Owner: isSet(object.Owner) ? observerOwnerFromJSON(object.Owner) : 0,
       Webhooks: globalThis.Array.isArray(object?.Webhooks)
         ? object.Webhooks.map((e: any) => WebhookDefinition.fromJSON(e))
         : [],
     };
   },
 
-  toJSON(message: AddWebhooks): unknown {
+  toJSON(message: AddWebhooksRequest): unknown {
     const obj: any = {};
     if (message.EventStore !== "") {
       obj.EventStore = message.EventStore;
     }
-    if (message.Owner !== 0) {
-      obj.Owner = observerOwnerToJSON(message.Owner);
-    }
     if (message.Webhooks?.length) {
       obj.Webhooks = message.Webhooks.map((e) => WebhookDefinition.toJSON(e));
     }
     return obj;
   },
 
-  create(base?: DeepPartial<AddWebhooks>): AddWebhooks {
-    return AddWebhooks.fromPartial(base ?? {});
+  create(base?: DeepPartial<AddWebhooksRequest>): AddWebhooksRequest {
+    return AddWebhooksRequest.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<AddWebhooks>): AddWebhooks {
-    const message = createBaseAddWebhooks();
+  fromPartial(object: DeepPartial<AddWebhooksRequest>): AddWebhooksRequest {
+    const message = createBaseAddWebhooksRequest();
     message.EventStore = object.EventStore ?? "";
-    message.Owner = object.Owner ?? 0;
     message.Webhooks = object.Webhooks?.map((e) => WebhookDefinition.fromPartial(e)) || [];
     return message;
   },
@@ -395,6 +913,170 @@ export const BearerTokenAuthorization: MessageFns<BearerTokenAuthorization> = {
   },
 };
 
+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 createBaseEventType(): EventType {
   return { Id: "", Generation: 0, Tombstone: false };
 }
@@ -556,78 +1238,9 @@ export const GetWebhooksRequest: MessageFns<GetWebhooksRequest> = {
   create(base?: DeepPartial<GetWebhooksRequest>): GetWebhooksRequest {
     return GetWebhooksRequest.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<GetWebhooksRequest>): GetWebhooksRequest {
-    const message = createBaseGetWebhooksRequest();
-    message.EventStore = object.EventStore ?? "";
-    return message;
-  },
-};
-
-function createBaseIEnumerableWebhookDefinition(): IEnumerableWebhookDefinition {
-  return { items: [] };
-}
-
-export const IEnumerableWebhookDefinition: MessageFns<IEnumerableWebhookDefinition> = {
-  encode(message: IEnumerableWebhookDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    for (const v of message.items) {
-      WebhookDefinition.encode(v!, writer.uint32(10).fork()).join();
-    }
-    return writer;
-  },
-
-  decode(input: BinaryReader | Uint8Array, length?: number): IEnumerableWebhookDefinition {
-    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 = createBaseIEnumerableWebhookDefinition();
-      while (reader.pos < end) {
-        const tag = reader.uint32();
-        switch (tag >>> 3) {
-          case 1: {
-            if (tag !== 10) {
-              break;
-            }
-
-            message.items.push(WebhookDefinition.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): IEnumerableWebhookDefinition {
-    return {
-      items: globalThis.Array.isArray(object?.items) ? object.items.map((e: any) => WebhookDefinition.fromJSON(e)) : [],
-    };
-  },
-
-  toJSON(message: IEnumerableWebhookDefinition): unknown {
-    const obj: any = {};
-    if (message.items?.length) {
-      obj.items = message.items.map((e) => WebhookDefinition.toJSON(e));
-    }
-    return obj;
-  },
-
-  create(base?: DeepPartial<IEnumerableWebhookDefinition>): IEnumerableWebhookDefinition {
-    return IEnumerableWebhookDefinition.fromPartial(base ?? {});
-  },
-  fromPartial(object: DeepPartial<IEnumerableWebhookDefinition>): IEnumerableWebhookDefinition {
-    const message = createBaseIEnumerableWebhookDefinition();
-    message.items = object.items?.map((e) => WebhookDefinition.fromPartial(e)) || [];
+  fromPartial(object: DeepPartial<GetWebhooksRequest>): GetWebhooksRequest {
+    const message = createBaseGetWebhooksRequest();
+    message.EventStore = object.EventStore ?? "";
     return message;
   },
 };
@@ -733,6 +1346,73 @@ export const OAuthAuthorization: MessageFns<OAuthAuthorization> = {
   },
 };
 
+function createBaseObserveWebhooksRequest(): ObserveWebhooksRequest {
+  return { EventStore: "" };
+}
+
+export const ObserveWebhooksRequest: MessageFns<ObserveWebhooksRequest> = {
+  encode(message: ObserveWebhooksRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.EventStore !== "") {
+      writer.uint32(10).string(message.EventStore);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ObserveWebhooksRequest {
+    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 = createBaseObserveWebhooksRequest();
+      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): ObserveWebhooksRequest {
+    return { EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "" };
+  },
+
+  toJSON(message: ObserveWebhooksRequest): unknown {
+    const obj: any = {};
+    if (message.EventStore !== "") {
+      obj.EventStore = message.EventStore;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<ObserveWebhooksRequest>): ObserveWebhooksRequest {
+    return ObserveWebhooksRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<ObserveWebhooksRequest>): ObserveWebhooksRequest {
+    const message = createBaseObserveWebhooksRequest();
+    message.EventStore = object.EventStore ?? "";
+    return message;
+  },
+};
+
 function createBaseOneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization(): OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization {
   return { Value0: undefined, Value1: undefined, Value2: undefined };
 }
@@ -852,22 +1532,44 @@ export const OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization:
   },
 };
 
-function createBaseRemoveWebhooks(): RemoveWebhooks {
-  return { EventStore: "", Webhooks: [] };
+function createBaseQueryResultIEnumerableWebhookDetailsResponse(): QueryResultIEnumerableWebhookDetailsResponse {
+  return {
+    CorrelationId: undefined,
+    IsAuthorized: false,
+    ValidationResults: [],
+    ExceptionMessages: [],
+    ExceptionStackTrace: "",
+    Data: [],
+  };
 }
 
-export const RemoveWebhooks: MessageFns<RemoveWebhooks> = {
-  encode(message: RemoveWebhooks, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.EventStore !== "") {
-      writer.uint32(10).string(message.EventStore);
+export const QueryResultIEnumerableWebhookDetailsResponse: MessageFns<QueryResultIEnumerableWebhookDetailsResponse> = {
+  encode(
+    message: QueryResultIEnumerableWebhookDetailsResponse,
+    writer: BinaryWriter = new BinaryWriter(),
+  ): BinaryWriter {
+    if (message.CorrelationId !== undefined) {
+      Guid.encode(message.CorrelationId, writer.uint32(10).fork()).join();
     }
-    for (const v of message.Webhooks) {
-      writer.uint32(26).string(v!);
+    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) {
+      WebhookDetailsResponse.encode(v!, writer.uint32(50).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): RemoveWebhooks {
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryResultIEnumerableWebhookDetailsResponse {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -876,7 +1578,7 @@ export const RemoveWebhooks: MessageFns<RemoveWebhooks> = {
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseRemoveWebhooks();
+      const message = createBaseQueryResultIEnumerableWebhookDetailsResponse();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
@@ -885,7 +1587,15 @@ export const RemoveWebhooks: MessageFns<RemoveWebhooks> = {
               break;
             }
 
-            message.EventStore = reader.string();
+            message.CorrelationId = Guid.decode(reader, reader.uint32());
+            continue;
+          }
+          case 2: {
+            if (tag !== 16) {
+              break;
+            }
+
+            message.IsAuthorized = reader.bool();
             continue;
           }
           case 3: {
@@ -893,7 +1603,31 @@ export const RemoveWebhooks: MessageFns<RemoveWebhooks> = {
               break;
             }
 
-            message.Webhooks.push(reader.string());
+            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(WebhookDetailsResponse.decode(reader, reader.uint32()));
             continue;
           }
         }
@@ -908,54 +1642,83 @@ export const RemoveWebhooks: MessageFns<RemoveWebhooks> = {
     }
   },
 
-  fromJSON(object: any): RemoveWebhooks {
+  fromJSON(object: any): QueryResultIEnumerableWebhookDetailsResponse {
     return {
-      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
-      Webhooks: globalThis.Array.isArray(object?.Webhooks) ? object.Webhooks.map((e: any) => globalThis.String(e)) : [],
+      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) => WebhookDetailsResponse.fromJSON(e))
+        : [],
     };
   },
 
-  toJSON(message: RemoveWebhooks): unknown {
+  toJSON(message: QueryResultIEnumerableWebhookDetailsResponse): unknown {
     const obj: any = {};
-    if (message.EventStore !== "") {
-      obj.EventStore = message.EventStore;
+    if (message.CorrelationId !== undefined) {
+      obj.CorrelationId = Guid.toJSON(message.CorrelationId);
     }
-    if (message.Webhooks?.length) {
-      obj.Webhooks = message.Webhooks;
+    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) => WebhookDetailsResponse.toJSON(e));
     }
     return obj;
   },
 
-  create(base?: DeepPartial<RemoveWebhooks>): RemoveWebhooks {
-    return RemoveWebhooks.fromPartial(base ?? {});
+  create(
+    base?: DeepPartial<QueryResultIEnumerableWebhookDetailsResponse>,
+  ): QueryResultIEnumerableWebhookDetailsResponse {
+    return QueryResultIEnumerableWebhookDetailsResponse.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<RemoveWebhooks>): RemoveWebhooks {
-    const message = createBaseRemoveWebhooks();
-    message.EventStore = object.EventStore ?? "";
-    message.Webhooks = object.Webhooks?.map((e) => e) || [];
+  fromPartial(
+    object: DeepPartial<QueryResultIEnumerableWebhookDetailsResponse>,
+  ): QueryResultIEnumerableWebhookDetailsResponse {
+    const message = createBaseQueryResultIEnumerableWebhookDetailsResponse();
+    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) => WebhookDetailsResponse.fromPartial(e)) || [];
     return message;
   },
 };
 
-function createBaseTestOAuthAuthorizationRequest(): TestOAuthAuthorizationRequest {
-  return { Authority: "", ClientId: "", ClientSecret: "" };
+function createBaseRemoveWebhookRequest(): RemoveWebhookRequest {
+  return { EventStore: "", WebhookId: "" };
 }
 
-export const TestOAuthAuthorizationRequest: MessageFns<TestOAuthAuthorizationRequest> = {
-  encode(message: TestOAuthAuthorizationRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.Authority !== "") {
-      writer.uint32(10).string(message.Authority);
-    }
-    if (message.ClientId !== "") {
-      writer.uint32(18).string(message.ClientId);
+export const RemoveWebhookRequest: MessageFns<RemoveWebhookRequest> = {
+  encode(message: RemoveWebhookRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.EventStore !== "") {
+      writer.uint32(10).string(message.EventStore);
     }
-    if (message.ClientSecret !== "") {
-      writer.uint32(26).string(message.ClientSecret);
+    if (message.WebhookId !== "") {
+      writer.uint32(18).string(message.WebhookId);
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): TestOAuthAuthorizationRequest {
+  decode(input: BinaryReader | Uint8Array, length?: number): RemoveWebhookRequest {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -964,7 +1727,7 @@ export const TestOAuthAuthorizationRequest: MessageFns<TestOAuthAuthorizationReq
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseTestOAuthAuthorizationRequest();
+      const message = createBaseRemoveWebhookRequest();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
@@ -973,7 +1736,7 @@ export const TestOAuthAuthorizationRequest: MessageFns<TestOAuthAuthorizationReq
               break;
             }
 
-            message.Authority = reader.string();
+            message.EventStore = reader.string();
             continue;
           }
           case 2: {
@@ -981,15 +1744,7 @@ export const TestOAuthAuthorizationRequest: MessageFns<TestOAuthAuthorizationReq
               break;
             }
 
-            message.ClientId = reader.string();
-            continue;
-          }
-          case 3: {
-            if (tag !== 26) {
-              break;
-            }
-
-            message.ClientSecret = reader.string();
+            message.WebhookId = reader.string();
             continue;
           }
         }
@@ -1004,56 +1759,51 @@ export const TestOAuthAuthorizationRequest: MessageFns<TestOAuthAuthorizationReq
     }
   },
 
-  fromJSON(object: any): TestOAuthAuthorizationRequest {
+  fromJSON(object: any): RemoveWebhookRequest {
     return {
-      Authority: isSet(object.Authority) ? globalThis.String(object.Authority) : "",
-      ClientId: isSet(object.ClientId) ? globalThis.String(object.ClientId) : "",
-      ClientSecret: isSet(object.ClientSecret) ? globalThis.String(object.ClientSecret) : "",
+      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+      WebhookId: isSet(object.WebhookId) ? globalThis.String(object.WebhookId) : "",
     };
   },
 
-  toJSON(message: TestOAuthAuthorizationRequest): unknown {
+  toJSON(message: RemoveWebhookRequest): unknown {
     const obj: any = {};
-    if (message.Authority !== "") {
-      obj.Authority = message.Authority;
-    }
-    if (message.ClientId !== "") {
-      obj.ClientId = message.ClientId;
+    if (message.EventStore !== "") {
+      obj.EventStore = message.EventStore;
     }
-    if (message.ClientSecret !== "") {
-      obj.ClientSecret = message.ClientSecret;
+    if (message.WebhookId !== "") {
+      obj.WebhookId = message.WebhookId;
     }
     return obj;
   },
 
-  create(base?: DeepPartial<TestOAuthAuthorizationRequest>): TestOAuthAuthorizationRequest {
-    return TestOAuthAuthorizationRequest.fromPartial(base ?? {});
+  create(base?: DeepPartial<RemoveWebhookRequest>): RemoveWebhookRequest {
+    return RemoveWebhookRequest.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<TestOAuthAuthorizationRequest>): TestOAuthAuthorizationRequest {
-    const message = createBaseTestOAuthAuthorizationRequest();
-    message.Authority = object.Authority ?? "";
-    message.ClientId = object.ClientId ?? "";
-    message.ClientSecret = object.ClientSecret ?? "";
+  fromPartial(object: DeepPartial<RemoveWebhookRequest>): RemoveWebhookRequest {
+    const message = createBaseRemoveWebhookRequest();
+    message.EventStore = object.EventStore ?? "";
+    message.WebhookId = object.WebhookId ?? "";
     return message;
   },
 };
 
-function createBaseTestOAuthAuthorizationResponse(): TestOAuthAuthorizationResponse {
-  return { Success: false, ErrorMessage: "" };
+function createBaseRemoveWebhooksRequest(): RemoveWebhooksRequest {
+  return { EventStore: "", Webhooks: [] };
 }
 
-export const TestOAuthAuthorizationResponse: MessageFns<TestOAuthAuthorizationResponse> = {
-  encode(message: TestOAuthAuthorizationResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.Success !== false) {
-      writer.uint32(8).bool(message.Success);
+export const RemoveWebhooksRequest: MessageFns<RemoveWebhooksRequest> = {
+  encode(message: RemoveWebhooksRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.EventStore !== "") {
+      writer.uint32(10).string(message.EventStore);
     }
-    if (message.ErrorMessage !== "") {
-      writer.uint32(18).string(message.ErrorMessage);
+    for (const v of message.Webhooks) {
+      writer.uint32(18).string(v!);
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): TestOAuthAuthorizationResponse {
+  decode(input: BinaryReader | Uint8Array, length?: number): RemoveWebhooksRequest {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -1062,16 +1812,16 @@ export const TestOAuthAuthorizationResponse: MessageFns<TestOAuthAuthorizationRe
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseTestOAuthAuthorizationResponse();
+      const message = createBaseRemoveWebhooksRequest();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
           case 1: {
-            if (tag !== 8) {
+            if (tag !== 10) {
               break;
             }
 
-            message.Success = reader.bool();
+            message.EventStore = reader.string();
             continue;
           }
           case 2: {
@@ -1079,7 +1829,7 @@ export const TestOAuthAuthorizationResponse: MessageFns<TestOAuthAuthorizationRe
               break;
             }
 
-            message.ErrorMessage = reader.string();
+            message.Webhooks.push(reader.string());
             continue;
           }
         }
@@ -1094,48 +1844,54 @@ export const TestOAuthAuthorizationResponse: MessageFns<TestOAuthAuthorizationRe
     }
   },
 
-  fromJSON(object: any): TestOAuthAuthorizationResponse {
+  fromJSON(object: any): RemoveWebhooksRequest {
     return {
-      Success: isSet(object.Success) ? globalThis.Boolean(object.Success) : false,
-      ErrorMessage: isSet(object.ErrorMessage) ? globalThis.String(object.ErrorMessage) : "",
+      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+      Webhooks: globalThis.Array.isArray(object?.Webhooks) ? object.Webhooks.map((e: any) => globalThis.String(e)) : [],
     };
   },
 
-  toJSON(message: TestOAuthAuthorizationResponse): unknown {
+  toJSON(message: RemoveWebhooksRequest): unknown {
     const obj: any = {};
-    if (message.Success !== false) {
-      obj.Success = message.Success;
+    if (message.EventStore !== "") {
+      obj.EventStore = message.EventStore;
     }
-    if (message.ErrorMessage !== "") {
-      obj.ErrorMessage = message.ErrorMessage;
+    if (message.Webhooks?.length) {
+      obj.Webhooks = message.Webhooks;
     }
     return obj;
   },
 
-  create(base?: DeepPartial<TestOAuthAuthorizationResponse>): TestOAuthAuthorizationResponse {
-    return TestOAuthAuthorizationResponse.fromPartial(base ?? {});
+  create(base?: DeepPartial<RemoveWebhooksRequest>): RemoveWebhooksRequest {
+    return RemoveWebhooksRequest.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<TestOAuthAuthorizationResponse>): TestOAuthAuthorizationResponse {
-    const message = createBaseTestOAuthAuthorizationResponse();
-    message.Success = object.Success ?? false;
-    message.ErrorMessage = object.ErrorMessage ?? "";
+  fromPartial(object: DeepPartial<RemoveWebhooksRequest>): RemoveWebhooksRequest {
+    const message = createBaseRemoveWebhooksRequest();
+    message.EventStore = object.EventStore ?? "";
+    message.Webhooks = object.Webhooks?.map((e) => e) || [];
     return message;
   },
 };
 
-function createBaseTestWebhookRequest(): TestWebhookRequest {
-  return { Target: undefined };
+function createBaseValidationResult(): ValidationResult {
+  return { Severity: 0, Message: "", Members: [] };
 }
 
-export const TestWebhookRequest: MessageFns<TestWebhookRequest> = {
-  encode(message: TestWebhookRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.Target !== undefined) {
-      WebhookTarget.encode(message.Target, writer.uint32(10).fork()).join();
+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): TestWebhookRequest {
+  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) {
@@ -1144,16 +1900,32 @@ export const TestWebhookRequest: MessageFns<TestWebhookRequest> = {
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseTestWebhookRequest();
+      const message = createBaseValidationResult();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
           case 1: {
-            if (tag !== 10) {
+            if (tag !== 8) {
               break;
             }
 
-            message.Target = WebhookTarget.decode(reader, reader.uint32());
+            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;
           }
         }
@@ -1168,46 +1940,75 @@ export const TestWebhookRequest: MessageFns<TestWebhookRequest> = {
     }
   },
 
-  fromJSON(object: any): TestWebhookRequest {
-    return { Target: isSet(object.Target) ? WebhookTarget.fromJSON(object.Target) : undefined };
+  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: TestWebhookRequest): unknown {
+  toJSON(message: ValidationResult): unknown {
     const obj: any = {};
-    if (message.Target !== undefined) {
-      obj.Target = WebhookTarget.toJSON(message.Target);
+    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<TestWebhookRequest>): TestWebhookRequest {
-    return TestWebhookRequest.fromPartial(base ?? {});
+  create(base?: DeepPartial<ValidationResult>): ValidationResult {
+    return ValidationResult.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<TestWebhookRequest>): TestWebhookRequest {
-    const message = createBaseTestWebhookRequest();
-    message.Target = (object.Target !== undefined && object.Target !== null)
-      ? WebhookTarget.fromPartial(object.Target)
-      : undefined;
+  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;
   },
 };
 
-function createBaseTestWebhookResponse(): TestWebhookResponse {
-  return { Success: false, ErrorMessage: "" };
+function createBaseWebhookDefinition(): WebhookDefinition {
+  return {
+    EventSequenceId: "",
+    Identifier: "",
+    EventTypes: [],
+    Target: undefined,
+    IsReplayable: false,
+    IsActive: false,
+  };
 }
 
-export const TestWebhookResponse: MessageFns<TestWebhookResponse> = {
-  encode(message: TestWebhookResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.Success !== false) {
-      writer.uint32(8).bool(message.Success);
+export const WebhookDefinition: MessageFns<WebhookDefinition> = {
+  encode(message: WebhookDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.EventSequenceId !== "") {
+      writer.uint32(10).string(message.EventSequenceId);
+    }
+    if (message.Identifier !== "") {
+      writer.uint32(18).string(message.Identifier);
+    }
+    for (const v of message.EventTypes) {
+      EventType.encode(v!, writer.uint32(26).fork()).join();
+    }
+    if (message.Target !== undefined) {
+      WebhookTarget.encode(message.Target, writer.uint32(34).fork()).join();
+    }
+    if (message.IsReplayable !== false) {
+      writer.uint32(40).bool(message.IsReplayable);
     }
-    if (message.ErrorMessage !== "") {
-      writer.uint32(18).string(message.ErrorMessage);
+    if (message.IsActive !== false) {
+      writer.uint32(48).bool(message.IsActive);
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): TestWebhookResponse {
+  decode(input: BinaryReader | Uint8Array, length?: number): WebhookDefinition {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -1216,24 +2017,56 @@ export const TestWebhookResponse: MessageFns<TestWebhookResponse> = {
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseTestWebhookResponse();
+      const message = createBaseWebhookDefinition();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
           case 1: {
-            if (tag !== 8) {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.EventSequenceId = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.Identifier = reader.string();
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.EventTypes.push(EventType.decode(reader, reader.uint32()));
+            continue;
+          }
+          case 4: {
+            if (tag !== 34) {
               break;
             }
 
-            message.Success = reader.bool();
+            message.Target = WebhookTarget.decode(reader, reader.uint32());
             continue;
           }
-          case 2: {
-            if (tag !== 18) {
+          case 5: {
+            if (tag !== 40) {
+              break;
+            }
+
+            message.IsReplayable = reader.bool();
+            continue;
+          }
+          case 6: {
+            if (tag !== 48) {
               break;
             }
 
-            message.ErrorMessage = reader.string();
+            message.IsActive = reader.bool();
             continue;
           }
         }
@@ -1248,70 +2081,106 @@ export const TestWebhookResponse: MessageFns<TestWebhookResponse> = {
     }
   },
 
-  fromJSON(object: any): TestWebhookResponse {
+  fromJSON(object: any): WebhookDefinition {
     return {
-      Success: isSet(object.Success) ? globalThis.Boolean(object.Success) : false,
-      ErrorMessage: isSet(object.ErrorMessage) ? globalThis.String(object.ErrorMessage) : "",
+      EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
+      Identifier: isSet(object.Identifier) ? globalThis.String(object.Identifier) : "",
+      EventTypes: globalThis.Array.isArray(object?.EventTypes)
+        ? object.EventTypes.map((e: any) => EventType.fromJSON(e))
+        : [],
+      Target: isSet(object.Target) ? WebhookTarget.fromJSON(object.Target) : undefined,
+      IsReplayable: isSet(object.IsReplayable) ? globalThis.Boolean(object.IsReplayable) : false,
+      IsActive: isSet(object.IsActive) ? globalThis.Boolean(object.IsActive) : false,
     };
   },
 
-  toJSON(message: TestWebhookResponse): unknown {
+  toJSON(message: WebhookDefinition): unknown {
     const obj: any = {};
-    if (message.Success !== false) {
-      obj.Success = message.Success;
+    if (message.EventSequenceId !== "") {
+      obj.EventSequenceId = message.EventSequenceId;
+    }
+    if (message.Identifier !== "") {
+      obj.Identifier = message.Identifier;
+    }
+    if (message.EventTypes?.length) {
+      obj.EventTypes = message.EventTypes.map((e) => EventType.toJSON(e));
+    }
+    if (message.Target !== undefined) {
+      obj.Target = WebhookTarget.toJSON(message.Target);
+    }
+    if (message.IsReplayable !== false) {
+      obj.IsReplayable = message.IsReplayable;
     }
-    if (message.ErrorMessage !== "") {
-      obj.ErrorMessage = message.ErrorMessage;
+    if (message.IsActive !== false) {
+      obj.IsActive = message.IsActive;
     }
     return obj;
   },
 
-  create(base?: DeepPartial<TestWebhookResponse>): TestWebhookResponse {
-    return TestWebhookResponse.fromPartial(base ?? {});
+  create(base?: DeepPartial<WebhookDefinition>): WebhookDefinition {
+    return WebhookDefinition.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<TestWebhookResponse>): TestWebhookResponse {
-    const message = createBaseTestWebhookResponse();
-    message.Success = object.Success ?? false;
-    message.ErrorMessage = object.ErrorMessage ?? "";
+  fromPartial(object: DeepPartial<WebhookDefinition>): WebhookDefinition {
+    const message = createBaseWebhookDefinition();
+    message.EventSequenceId = object.EventSequenceId ?? "";
+    message.Identifier = object.Identifier ?? "";
+    message.EventTypes = object.EventTypes?.map((e) => EventType.fromPartial(e)) || [];
+    message.Target = (object.Target !== undefined && object.Target !== null)
+      ? WebhookTarget.fromPartial(object.Target)
+      : undefined;
+    message.IsReplayable = object.IsReplayable ?? false;
+    message.IsActive = object.IsActive ?? false;
     return message;
   },
 };
 
-function createBaseWebhookDefinition(): WebhookDefinition {
+function createBaseWebhookDetailsResponse(): WebhookDetailsResponse {
   return {
-    EventSequenceId: "",
     Identifier: "",
+    Url: "",
+    EventSequenceId: "",
     EventTypes: [],
-    Target: undefined,
+    AuthorizationType: 0,
+    Headers: {},
     IsReplayable: false,
     IsActive: false,
+    Id: "",
   };
 }
 
-export const WebhookDefinition: MessageFns<WebhookDefinition> = {
-  encode(message: WebhookDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.EventSequenceId !== "") {
-      writer.uint32(10).string(message.EventSequenceId);
-    }
+export const WebhookDetailsResponse: MessageFns<WebhookDetailsResponse> = {
+  encode(message: WebhookDetailsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.Identifier !== "") {
-      writer.uint32(18).string(message.Identifier);
+      writer.uint32(10).string(message.Identifier);
+    }
+    if (message.Url !== "") {
+      writer.uint32(18).string(message.Url);
+    }
+    if (message.EventSequenceId !== "") {
+      writer.uint32(26).string(message.EventSequenceId);
     }
     for (const v of message.EventTypes) {
-      EventType.encode(v!, writer.uint32(26).fork()).join();
+      EventType.encode(v!, writer.uint32(34).fork()).join();
     }
-    if (message.Target !== undefined) {
-      WebhookTarget.encode(message.Target, writer.uint32(34).fork()).join();
+    if (message.AuthorizationType !== 0) {
+      writer.uint32(40).int32(message.AuthorizationType);
     }
+    globalThis.Object.entries(message.Headers).forEach(([key, value]: [string, string]) => {
+      WebhookDetailsResponse_HeadersEntry.encode({ key: key as any, value }, writer.uint32(50).fork()).join();
+    });
     if (message.IsReplayable !== false) {
-      writer.uint32(40).bool(message.IsReplayable);
+      writer.uint32(56).bool(message.IsReplayable);
     }
     if (message.IsActive !== false) {
-      writer.uint32(48).bool(message.IsActive);
+      writer.uint32(64).bool(message.IsActive);
+    }
+    if (message.Id !== "") {
+      writer.uint32(74).string(message.Id);
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): WebhookDefinition {
+  decode(input: BinaryReader | Uint8Array, length?: number): WebhookDetailsResponse {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -1320,7 +2189,7 @@ export const WebhookDefinition: MessageFns<WebhookDefinition> = {
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseWebhookDefinition();
+      const message = createBaseWebhookDetailsResponse();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
@@ -1329,7 +2198,7 @@ export const WebhookDefinition: MessageFns<WebhookDefinition> = {
               break;
             }
 
-            message.EventSequenceId = reader.string();
+            message.Identifier = reader.string();
             continue;
           }
           case 2: {
@@ -1337,7 +2206,7 @@ export const WebhookDefinition: MessageFns<WebhookDefinition> = {
               break;
             }
 
-            message.Identifier = reader.string();
+            message.Url = reader.string();
             continue;
           }
           case 3: {
@@ -1345,7 +2214,7 @@ export const WebhookDefinition: MessageFns<WebhookDefinition> = {
               break;
             }
 
-            message.EventTypes.push(EventType.decode(reader, reader.uint32()));
+            message.EventSequenceId = reader.string();
             continue;
           }
           case 4: {
@@ -1353,7 +2222,7 @@ export const WebhookDefinition: MessageFns<WebhookDefinition> = {
               break;
             }
 
-            message.Target = WebhookTarget.decode(reader, reader.uint32());
+            message.EventTypes.push(EventType.decode(reader, reader.uint32()));
             continue;
           }
           case 5: {
@@ -1361,17 +2230,44 @@ export const WebhookDefinition: MessageFns<WebhookDefinition> = {
               break;
             }
 
-            message.IsReplayable = reader.bool();
+            message.AuthorizationType = reader.int32() as any;
             continue;
           }
           case 6: {
-            if (tag !== 48) {
+            if (tag !== 50) {
+              break;
+            }
+
+            const entry6 = WebhookDetailsResponse_HeadersEntry.decode(reader, reader.uint32());
+            if (entry6.value !== undefined) {
+              message.Headers[entry6.key] = entry6.value;
+            }
+            continue;
+          }
+          case 7: {
+            if (tag !== 56) {
+              break;
+            }
+
+            message.IsReplayable = reader.bool();
+            continue;
+          }
+          case 8: {
+            if (tag !== 64) {
               break;
             }
 
             message.IsActive = reader.bool();
             continue;
           }
+          case 9: {
+            if (tag !== 74) {
+              break;
+            }
+
+            message.Id = reader.string();
+            continue;
+          }
         }
         if ((tag & 7) === 4 || tag === 0) {
           break;
@@ -1384,32 +2280,60 @@ export const WebhookDefinition: MessageFns<WebhookDefinition> = {
     }
   },
 
-  fromJSON(object: any): WebhookDefinition {
+  fromJSON(object: any): WebhookDetailsResponse {
     return {
-      EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
       Identifier: isSet(object.Identifier) ? globalThis.String(object.Identifier) : "",
+      Url: isSet(object.Url) ? globalThis.String(object.Url) : "",
+      EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
       EventTypes: globalThis.Array.isArray(object?.EventTypes)
         ? object.EventTypes.map((e: any) => EventType.fromJSON(e))
         : [],
-      Target: isSet(object.Target) ? WebhookTarget.fromJSON(object.Target) : undefined,
+      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;
+          },
+          {},
+        )
+        : {},
       IsReplayable: isSet(object.IsReplayable) ? globalThis.Boolean(object.IsReplayable) : false,
       IsActive: isSet(object.IsActive) ? globalThis.Boolean(object.IsActive) : false,
+      Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
     };
   },
 
-  toJSON(message: WebhookDefinition): unknown {
+  toJSON(message: WebhookDetailsResponse): unknown {
     const obj: any = {};
-    if (message.EventSequenceId !== "") {
-      obj.EventSequenceId = message.EventSequenceId;
-    }
     if (message.Identifier !== "") {
       obj.Identifier = message.Identifier;
     }
+    if (message.Url !== "") {
+      obj.Url = message.Url;
+    }
+    if (message.EventSequenceId !== "") {
+      obj.EventSequenceId = message.EventSequenceId;
+    }
     if (message.EventTypes?.length) {
       obj.EventTypes = message.EventTypes.map((e) => EventType.toJSON(e));
     }
-    if (message.Target !== undefined) {
-      obj.Target = WebhookTarget.toJSON(message.Target);
+    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.IsReplayable !== false) {
       obj.IsReplayable = message.IsReplayable;
@@ -1417,22 +2341,119 @@ export const WebhookDefinition: MessageFns<WebhookDefinition> = {
     if (message.IsActive !== false) {
       obj.IsActive = message.IsActive;
     }
+    if (message.Id !== "") {
+      obj.Id = message.Id;
+    }
     return obj;
   },
 
-  create(base?: DeepPartial<WebhookDefinition>): WebhookDefinition {
-    return WebhookDefinition.fromPartial(base ?? {});
+  create(base?: DeepPartial<WebhookDetailsResponse>): WebhookDetailsResponse {
+    return WebhookDetailsResponse.fromPartial(base ?? {});
   },
-  fromPartial(object: DeepPartial<WebhookDefinition>): WebhookDefinition {
-    const message = createBaseWebhookDefinition();
-    message.EventSequenceId = object.EventSequenceId ?? "";
+  fromPartial(object: DeepPartial<WebhookDetailsResponse>): WebhookDetailsResponse {
+    const message = createBaseWebhookDetailsResponse();
     message.Identifier = object.Identifier ?? "";
+    message.Url = object.Url ?? "";
+    message.EventSequenceId = object.EventSequenceId ?? "";
     message.EventTypes = object.EventTypes?.map((e) => EventType.fromPartial(e)) || [];
-    message.Target = (object.Target !== undefined && object.Target !== null)
-      ? WebhookTarget.fromPartial(object.Target)
-      : undefined;
+    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.IsReplayable = object.IsReplayable ?? false;
     message.IsActive = object.IsActive ?? false;
+    message.Id = object.Id ?? "";
+    return message;
+  },
+};
+
+function createBaseWebhookDetailsResponse_HeadersEntry(): WebhookDetailsResponse_HeadersEntry {
+  return { key: "", value: "" };
+}
+
+export const WebhookDetailsResponse_HeadersEntry: MessageFns<WebhookDetailsResponse_HeadersEntry> = {
+  encode(message: WebhookDetailsResponse_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): WebhookDetailsResponse_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 = createBaseWebhookDetailsResponse_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): WebhookDetailsResponse_HeadersEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? globalThis.String(object.value) : "",
+    };
+  },
+
+  toJSON(message: WebhookDetailsResponse_HeadersEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<WebhookDetailsResponse_HeadersEntry>): WebhookDetailsResponse_HeadersEntry {
+    return WebhookDetailsResponse_HeadersEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<WebhookDetailsResponse_HeadersEntry>): WebhookDetailsResponse_HeadersEntry {
+    const message = createBaseWebhookDetailsResponse_HeadersEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
     return message;
   },
 };
@@ -1670,11 +2691,19 @@ export const WebhooksDefinition = {
   name: "Webhooks",
   fullName: "Cratis.Chronicle.Contracts.Observation.Webhooks.Webhooks",
   methods: {
-    add: {
-      name: "Add",
-      requestType: AddWebhooks as typeof AddWebhooks,
+    addWebhook: {
+      name: "AddWebhook",
+      requestType: AddWebhookRequest as typeof AddWebhookRequest,
+      requestStream: false,
+      responseType: CommandResult as typeof CommandResult,
+      responseStream: false,
+      options: {},
+    },
+    addWebhooks: {
+      name: "AddWebhooks",
+      requestType: AddWebhooksRequest as typeof AddWebhooksRequest,
       requestStream: false,
-      responseType: Empty as typeof Empty,
+      responseType: CommandResult as typeof CommandResult,
       responseStream: false,
       options: {},
     },
@@ -1682,39 +2711,31 @@ export const WebhooksDefinition = {
       name: "GetWebhooks",
       requestType: GetWebhooksRequest as typeof GetWebhooksRequest,
       requestStream: false,
-      responseType: IEnumerableWebhookDefinition as typeof IEnumerableWebhookDefinition,
+      responseType: QueryResultIEnumerableWebhookDetailsResponse as typeof QueryResultIEnumerableWebhookDetailsResponse,
       responseStream: false,
       options: {},
     },
     observeWebhooks: {
       name: "ObserveWebhooks",
-      requestType: GetWebhooksRequest as typeof GetWebhooksRequest,
+      requestType: ObserveWebhooksRequest as typeof ObserveWebhooksRequest,
       requestStream: false,
-      responseType: IEnumerableWebhookDefinition as typeof IEnumerableWebhookDefinition,
+      responseType: QueryResultIEnumerableWebhookDetailsResponse as typeof QueryResultIEnumerableWebhookDetailsResponse,
       responseStream: true,
       options: {},
     },
-    remove: {
-      name: "Remove",
-      requestType: RemoveWebhooks as typeof RemoveWebhooks,
-      requestStream: false,
-      responseType: Empty as typeof Empty,
-      responseStream: false,
-      options: {},
-    },
-    testOAuthAuthorization: {
-      name: "TestOAuthAuthorization",
-      requestType: TestOAuthAuthorizationRequest as typeof TestOAuthAuthorizationRequest,
+    removeWebhook: {
+      name: "RemoveWebhook",
+      requestType: RemoveWebhookRequest as typeof RemoveWebhookRequest,
       requestStream: false,
-      responseType: TestOAuthAuthorizationResponse as typeof TestOAuthAuthorizationResponse,
+      responseType: CommandResult as typeof CommandResult,
       responseStream: false,
       options: {},
     },
-    testWebhook: {
-      name: "TestWebhook",
-      requestType: TestWebhookRequest as typeof TestWebhookRequest,
+    removeWebhooks: {
+      name: "RemoveWebhooks",
+      requestType: RemoveWebhooksRequest as typeof RemoveWebhooksRequest,
       requestStream: false,
-      responseType: TestWebhookResponse as typeof TestWebhookResponse,
+      responseType: CommandResult as typeof CommandResult,
       responseStream: false,
       options: {},
     },
@@ -1722,45 +2743,45 @@ export const WebhooksDefinition = {
 } as const;
 
 export interface WebhooksServiceImplementation<CallContextExt = {}> {
-  add(request: AddWebhooks, context: CallContext & CallContextExt): Promise<DeepPartial<Empty>>;
+  addWebhook(request: AddWebhookRequest, context: CallContext & CallContextExt): Promise<DeepPartial<CommandResult>>;
+  addWebhooks(request: AddWebhooksRequest, context: CallContext & CallContextExt): Promise<DeepPartial<CommandResult>>;
   getWebhooks(
     request: GetWebhooksRequest,
     context: CallContext & CallContextExt,
-  ): Promise<DeepPartial<IEnumerableWebhookDefinition>>;
+  ): Promise<DeepPartial<QueryResultIEnumerableWebhookDetailsResponse>>;
   observeWebhooks(
-    request: GetWebhooksRequest,
+    request: ObserveWebhooksRequest,
     context: CallContext & CallContextExt,
-  ): ServerStreamingMethodResult<DeepPartial<IEnumerableWebhookDefinition>>;
-  remove(request: RemoveWebhooks, context: CallContext & CallContextExt): Promise<DeepPartial<Empty>>;
-  testOAuthAuthorization(
-    request: TestOAuthAuthorizationRequest,
+  ): ServerStreamingMethodResult<DeepPartial<QueryResultIEnumerableWebhookDetailsResponse>>;
+  removeWebhook(
+    request: RemoveWebhookRequest,
     context: CallContext & CallContextExt,
-  ): Promise<DeepPartial<TestOAuthAuthorizationResponse>>;
-  testWebhook(
-    request: TestWebhookRequest,
+  ): Promise<DeepPartial<CommandResult>>;
+  removeWebhooks(
+    request: RemoveWebhooksRequest,
     context: CallContext & CallContextExt,
-  ): Promise<DeepPartial<TestWebhookResponse>>;
+  ): Promise<DeepPartial<CommandResult>>;
 }
 
 export interface WebhooksClient<CallOptionsExt = {}> {
-  add(request: DeepPartial<AddWebhooks>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
+  addWebhook(request: DeepPartial<AddWebhookRequest>, options?: CallOptions & CallOptionsExt): Promise<CommandResult>;
+  addWebhooks(request: DeepPartial<AddWebhooksRequest>, options?: CallOptions & CallOptionsExt): Promise<CommandResult>;
   getWebhooks(
     request: DeepPartial<GetWebhooksRequest>,
     options?: CallOptions & CallOptionsExt,
-  ): Promise<IEnumerableWebhookDefinition>;
+  ): Promise<QueryResultIEnumerableWebhookDetailsResponse>;
   observeWebhooks(
-    request: DeepPartial<GetWebhooksRequest>,
+    request: DeepPartial<ObserveWebhooksRequest>,
     options?: CallOptions & CallOptionsExt,
-  ): AsyncIterable<IEnumerableWebhookDefinition>;
-  remove(request: DeepPartial<RemoveWebhooks>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
-  testOAuthAuthorization(
-    request: DeepPartial<TestOAuthAuthorizationRequest>,
+  ): AsyncIterable<QueryResultIEnumerableWebhookDetailsResponse>;
+  removeWebhook(
+    request: DeepPartial<RemoveWebhookRequest>,
     options?: CallOptions & CallOptionsExt,
-  ): Promise<TestOAuthAuthorizationResponse>;
-  testWebhook(
-    request: DeepPartial<TestWebhookRequest>,
+  ): Promise<CommandResult>;
+  removeWebhooks(
+    request: DeepPartial<RemoveWebhooksRequest>,
     options?: CallOptions & CallOptionsExt,
-  ): Promise<TestWebhookResponse>;
+  ): Promise<CommandResult>;
 }
 
 type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;