// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// versions:
//   protoc-gen-ts_proto  v2.12.4
//   protoc               v5.28.3
// source: observation_webhooks.proto

/* eslint-disable */
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import type { CallContext, CallOptions } from "nice-grpc-common";
import { Guid } from "./protobuf-net/bcl";

export const protobufPackage = "Cratis.Chronicle.Contracts.Observation.Webhooks";

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 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;
  Webhooks: WebhookDefinition[];
}

export interface BasicAuthorization {
  Username: string;
  Password: string;
}

export interface BearerTokenAuthorization {
  Token: string;
}

export interface CommandResult {
  /** default value could not be applied: 00000000-0000-0000-0000-000000000000 */
  CorrelationId: Guid | undefined;
  IsAuthorized: boolean;
  ValidationResults: ValidationResult[];
  ExceptionMessages: string[];
  ExceptionStackTrace: string;
  AuthorizationFailureReason: string;
}

export interface EventType {
  Id: string;
  Generation: number;
  Tombstone: boolean;
}

export interface GetWebhooksRequest {
  EventStore: string;
}

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 QueryResultIEnumerableWebhookDetailsResponse {
  /** default value could not be applied: 00000000-0000-0000-0000-000000000000 */
  CorrelationId: Guid | undefined;
  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 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 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;
  },

  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;
            }

            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): AddWebhookRequest_HeadersEntry {
    return {
      key: isSet(object.key) ? globalThis.String(object.key) : "",
      value: isSet(object.value) ? globalThis.String(object.value) : "",
    };
  },

  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 createBaseAddWebhooksRequest(): AddWebhooksRequest {
  return { EventStore: "", Webhooks: [] };
}

export const AddWebhooksRequest: MessageFns<AddWebhooksRequest> = {
  encode(message: AddWebhooksRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    for (const v of message.Webhooks) {
      WebhookDefinition.encode(v!, writer.uint32(18).fork()).join();
    }
    return writer;
  },

  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) {
      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 = createBaseAddWebhooksRequest();
      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.Webhooks.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): AddWebhooksRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Webhooks: globalThis.Array.isArray(object?.Webhooks)
        ? object.Webhooks.map((e: any) => WebhookDefinition.fromJSON(e))
        : [],
    };
  },

  toJSON(message: AddWebhooksRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Webhooks?.length) {
      obj.Webhooks = message.Webhooks.map((e) => WebhookDefinition.toJSON(e));
    }
    return obj;
  },

  create(base?: DeepPartial<AddWebhooksRequest>): AddWebhooksRequest {
    return AddWebhooksRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<AddWebhooksRequest>): AddWebhooksRequest {
    const message = createBaseAddWebhooksRequest();
    message.EventStore = object.EventStore ?? "";
    message.Webhooks = object.Webhooks?.map((e) => WebhookDefinition.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 createBaseEventType(): EventType {
  return { Id: "", Generation: 0, Tombstone: false };
}

export const EventType: MessageFns<EventType> = {
  encode(message: EventType, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Id !== "") {
      writer.uint32(10).string(message.Id);
    }
    if (message.Generation !== 0) {
      writer.uint32(16).uint32(message.Generation);
    }
    if (message.Tombstone !== false) {
      writer.uint32(24).bool(message.Tombstone);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): EventType {
    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 = createBaseEventType();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.Id = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }

            message.Generation = reader.uint32();
            continue;
          }
          case 3: {
            if (tag !== 24) {
              break;
            }

            message.Tombstone = 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): EventType {
    return {
      Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
      Generation: isSet(object.Generation) ? globalThis.Number(object.Generation) : 0,
      Tombstone: isSet(object.Tombstone) ? globalThis.Boolean(object.Tombstone) : false,
    };
  },

  toJSON(message: EventType): unknown {
    const obj: any = {};
    if (message.Id !== "") {
      obj.Id = message.Id;
    }
    if (message.Generation !== 0) {
      obj.Generation = Math.round(message.Generation);
    }
    if (message.Tombstone !== false) {
      obj.Tombstone = message.Tombstone;
    }
    return obj;
  },

  create(base?: DeepPartial<EventType>): EventType {
    return EventType.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<EventType>): EventType {
    const message = createBaseEventType();
    message.Id = object.Id ?? "";
    message.Generation = object.Generation ?? 0;
    message.Tombstone = object.Tombstone ?? false;
    return message;
  },
};

function createBaseGetWebhooksRequest(): GetWebhooksRequest {
  return { EventStore: "" };
}

export const GetWebhooksRequest: MessageFns<GetWebhooksRequest> = {
  encode(message: GetWebhooksRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): GetWebhooksRequest {
    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 = createBaseGetWebhooksRequest();
      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): GetWebhooksRequest {
    return { EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "" };
  },

  toJSON(message: GetWebhooksRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    return obj;
  },

  create(base?: DeepPartial<GetWebhooksRequest>): GetWebhooksRequest {
    return GetWebhooksRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<GetWebhooksRequest>): GetWebhooksRequest {
    const message = createBaseGetWebhooksRequest();
    message.EventStore = object.EventStore ?? "";
    return message;
  },
};

function createBaseOAuthAuthorization(): OAuthAuthorization {
  return { Authority: "", ClientId: "", ClientSecret: "" };
}

export const OAuthAuthorization: MessageFns<OAuthAuthorization> = {
  encode(message: OAuthAuthorization, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Authority !== "") {
      writer.uint32(10).string(message.Authority);
    }
    if (message.ClientId !== "") {
      writer.uint32(18).string(message.ClientId);
    }
    if (message.ClientSecret !== "") {
      writer.uint32(26).string(message.ClientSecret);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): OAuthAuthorization {
    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 = createBaseOAuthAuthorization();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.Authority = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.ClientId = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.ClientSecret = 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): OAuthAuthorization {
    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) : "",
    };
  },

  toJSON(message: OAuthAuthorization): unknown {
    const obj: any = {};
    if (message.Authority !== "") {
      obj.Authority = message.Authority;
    }
    if (message.ClientId !== "") {
      obj.ClientId = message.ClientId;
    }
    if (message.ClientSecret !== "") {
      obj.ClientSecret = message.ClientSecret;
    }
    return obj;
  },

  create(base?: DeepPartial<OAuthAuthorization>): OAuthAuthorization {
    return OAuthAuthorization.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<OAuthAuthorization>): OAuthAuthorization {
    const message = createBaseOAuthAuthorization();
    message.Authority = object.Authority ?? "";
    message.ClientId = object.ClientId ?? "";
    message.ClientSecret = object.ClientSecret ?? "";
    return message;
  },
};

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 };
}

export const OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization: MessageFns<
  OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization
> = {
  encode(
    message: OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.Value0 !== undefined) {
      BasicAuthorization.encode(message.Value0, writer.uint32(10).fork()).join();
    }
    if (message.Value1 !== undefined) {
      BearerTokenAuthorization.encode(message.Value1, writer.uint32(18).fork()).join();
    }
    if (message.Value2 !== undefined) {
      OAuthAuthorization.encode(message.Value2, writer.uint32(26).fork()).join();
    }
    return writer;
  },

  decode(
    input: BinaryReader | Uint8Array,
    length?: number,
  ): OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization {
    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 = createBaseOneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.Value0 = BasicAuthorization.decode(reader, reader.uint32());
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.Value1 = BearerTokenAuthorization.decode(reader, reader.uint32());
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.Value2 = OAuthAuthorization.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): OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization {
    return {
      Value0: isSet(object.Value0) ? BasicAuthorization.fromJSON(object.Value0) : undefined,
      Value1: isSet(object.Value1) ? BearerTokenAuthorization.fromJSON(object.Value1) : undefined,
      Value2: isSet(object.Value2) ? OAuthAuthorization.fromJSON(object.Value2) : undefined,
    };
  },

  toJSON(message: OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization): unknown {
    const obj: any = {};
    if (message.Value0 !== undefined) {
      obj.Value0 = BasicAuthorization.toJSON(message.Value0);
    }
    if (message.Value1 !== undefined) {
      obj.Value1 = BearerTokenAuthorization.toJSON(message.Value1);
    }
    if (message.Value2 !== undefined) {
      obj.Value2 = OAuthAuthorization.toJSON(message.Value2);
    }
    return obj;
  },

  create(
    base?: DeepPartial<OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization>,
  ): OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization {
    return OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization.fromPartial(base ?? {});
  },
  fromPartial(
    object: DeepPartial<OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization>,
  ): OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization {
    const message = createBaseOneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization();
    message.Value0 = (object.Value0 !== undefined && object.Value0 !== null)
      ? BasicAuthorization.fromPartial(object.Value0)
      : undefined;
    message.Value1 = (object.Value1 !== undefined && object.Value1 !== null)
      ? BearerTokenAuthorization.fromPartial(object.Value1)
      : undefined;
    message.Value2 = (object.Value2 !== undefined && object.Value2 !== null)
      ? OAuthAuthorization.fromPartial(object.Value2)
      : undefined;
    return message;
  },
};

function createBaseQueryResultIEnumerableWebhookDetailsResponse(): QueryResultIEnumerableWebhookDetailsResponse {
  return {
    CorrelationId: undefined,
    IsAuthorized: false,
    ValidationResults: [],
    ExceptionMessages: [],
    ExceptionStackTrace: "",
    Data: [],
  };
}

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();
    }
    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): QueryResultIEnumerableWebhookDetailsResponse {
    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 = createBaseQueryResultIEnumerableWebhookDetailsResponse();
      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(WebhookDetailsResponse.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): QueryResultIEnumerableWebhookDetailsResponse {
    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) => WebhookDetailsResponse.fromJSON(e))
        : [],
    };
  },

  toJSON(message: QueryResultIEnumerableWebhookDetailsResponse): 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) => WebhookDetailsResponse.toJSON(e));
    }
    return obj;
  },

  create(
    base?: DeepPartial<QueryResultIEnumerableWebhookDetailsResponse>,
  ): QueryResultIEnumerableWebhookDetailsResponse {
    return QueryResultIEnumerableWebhookDetailsResponse.fromPartial(base ?? {});
  },
  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 createBaseRemoveWebhookRequest(): RemoveWebhookRequest {
  return { EventStore: "", WebhookId: "" };
}

export const RemoveWebhookRequest: MessageFns<RemoveWebhookRequest> = {
  encode(message: RemoveWebhookRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    if (message.WebhookId !== "") {
      writer.uint32(18).string(message.WebhookId);
    }
    return writer;
  },

  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) {
      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 = createBaseRemoveWebhookRequest();
      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.WebhookId = 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): RemoveWebhookRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      WebhookId: isSet(object.WebhookId) ? globalThis.String(object.WebhookId) : "",
    };
  },

  toJSON(message: RemoveWebhookRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.WebhookId !== "") {
      obj.WebhookId = message.WebhookId;
    }
    return obj;
  },

  create(base?: DeepPartial<RemoveWebhookRequest>): RemoveWebhookRequest {
    return RemoveWebhookRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<RemoveWebhookRequest>): RemoveWebhookRequest {
    const message = createBaseRemoveWebhookRequest();
    message.EventStore = object.EventStore ?? "";
    message.WebhookId = object.WebhookId ?? "";
    return message;
  },
};

function createBaseRemoveWebhooksRequest(): RemoveWebhooksRequest {
  return { EventStore: "", Webhooks: [] };
}

export const RemoveWebhooksRequest: MessageFns<RemoveWebhooksRequest> = {
  encode(message: RemoveWebhooksRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    for (const v of message.Webhooks) {
      writer.uint32(18).string(v!);
    }
    return writer;
  },

  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) {
      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 = createBaseRemoveWebhooksRequest();
      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.Webhooks.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): RemoveWebhooksRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Webhooks: globalThis.Array.isArray(object?.Webhooks) ? object.Webhooks.map((e: any) => globalThis.String(e)) : [],
    };
  },

  toJSON(message: RemoveWebhooksRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Webhooks?.length) {
      obj.Webhooks = message.Webhooks;
    }
    return obj;
  },

  create(base?: DeepPartial<RemoveWebhooksRequest>): RemoveWebhooksRequest {
    return RemoveWebhooksRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<RemoveWebhooksRequest>): RemoveWebhooksRequest {
    const message = createBaseRemoveWebhooksRequest();
    message.EventStore = object.EventStore ?? "";
    message.Webhooks = object.Webhooks?.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;
  },
};

function createBaseWebhookDefinition(): WebhookDefinition {
  return {
    EventSequenceId: "",
    Identifier: "",
    EventTypes: [],
    Target: undefined,
    IsReplayable: false,
    IsActive: false,
  };
}

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.IsActive !== false) {
      writer.uint32(48).bool(message.IsActive);
    }
    return writer;
  },

  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) {
      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 = createBaseWebhookDefinition();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            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.Target = WebhookTarget.decode(reader, reader.uint32());
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }

            message.IsReplayable = reader.bool();
            continue;
          }
          case 6: {
            if (tag !== 48) {
              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): WebhookDefinition {
    return {
      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: WebhookDefinition): unknown {
    const obj: any = {};
    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.IsActive !== false) {
      obj.IsActive = message.IsActive;
    }
    return obj;
  },

  create(base?: DeepPartial<WebhookDefinition>): WebhookDefinition {
    return WebhookDefinition.fromPartial(base ?? {});
  },
  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 createBaseWebhookDetailsResponse(): WebhookDetailsResponse {
  return {
    Identifier: "",
    Url: "",
    EventSequenceId: "",
    EventTypes: [],
    AuthorizationType: 0,
    Headers: {},
    IsReplayable: false,
    IsActive: false,
    Id: "",
  };
}

export const WebhookDetailsResponse: MessageFns<WebhookDetailsResponse> = {
  encode(message: WebhookDetailsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (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(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(56).bool(message.IsReplayable);
    }
    if (message.IsActive !== false) {
      writer.uint32(64).bool(message.IsActive);
    }
    if (message.Id !== "") {
      writer.uint32(74).string(message.Id);
    }
    return writer;
  },

  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) {
      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();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.Identifier = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.Url = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.EventSequenceId = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }

            message.EventTypes.push(EventType.decode(reader, reader.uint32()));
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }

            message.AuthorizationType = reader.int32() as any;
            continue;
          }
          case 6: {
            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;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): WebhookDetailsResponse {
    return {
      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))
        : [],
      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: WebhookDetailsResponse): unknown {
    const obj: any = {};
    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.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;
    }
    if (message.IsActive !== false) {
      obj.IsActive = message.IsActive;
    }
    if (message.Id !== "") {
      obj.Id = message.Id;
    }
    return obj;
  },

  create(base?: DeepPartial<WebhookDetailsResponse>): WebhookDetailsResponse {
    return WebhookDetailsResponse.fromPartial(base ?? {});
  },
  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.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;
  },
};

function createBaseWebhookTarget(): WebhookTarget {
  return { Url: "", Authorization: undefined, Headers: {} };
}

export const WebhookTarget: MessageFns<WebhookTarget> = {
  encode(message: WebhookTarget, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Url !== "") {
      writer.uint32(10).string(message.Url);
    }
    if (message.Authorization !== undefined) {
      OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization.encode(
        message.Authorization,
        writer.uint32(18).fork(),
      ).join();
    }
    globalThis.Object.entries(message.Headers).forEach(([key, value]: [string, string]) => {
      WebhookTarget_HeadersEntry.encode({ key: key as any, value }, writer.uint32(26).fork()).join();
    });
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): WebhookTarget {
    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 = createBaseWebhookTarget();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.Url = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.Authorization = OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization.decode(
              reader,
              reader.uint32(),
            );
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            const entry3 = WebhookTarget_HeadersEntry.decode(reader, reader.uint32());
            if (entry3.value !== undefined) {
              message.Headers[entry3.key] = entry3.value;
            }
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): WebhookTarget {
    return {
      Url: isSet(object.Url) ? globalThis.String(object.Url) : "",
      Authorization: isSet(object.Authorization)
        ? OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization.fromJSON(object.Authorization)
        : undefined,
      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;
          },
          {},
        )
        : {},
    };
  },

  toJSON(message: WebhookTarget): unknown {
    const obj: any = {};
    if (message.Url !== "") {
      obj.Url = message.Url;
    }
    if (message.Authorization !== undefined) {
      obj.Authorization = OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization.toJSON(
        message.Authorization,
      );
    }
    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;
        });
      }
    }
    return obj;
  },

  create(base?: DeepPartial<WebhookTarget>): WebhookTarget {
    return WebhookTarget.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<WebhookTarget>): WebhookTarget {
    const message = createBaseWebhookTarget();
    message.Url = object.Url ?? "";
    message.Authorization = (object.Authorization !== undefined && object.Authorization !== null)
      ? OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization.fromPartial(object.Authorization)
      : undefined;
    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;
      },
      {},
    );
    return message;
  },
};

function createBaseWebhookTarget_HeadersEntry(): WebhookTarget_HeadersEntry {
  return { key: "", value: "" };
}

export const WebhookTarget_HeadersEntry: MessageFns<WebhookTarget_HeadersEntry> = {
  encode(message: WebhookTarget_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): WebhookTarget_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 = createBaseWebhookTarget_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): WebhookTarget_HeadersEntry {
    return {
      key: isSet(object.key) ? globalThis.String(object.key) : "",
      value: isSet(object.value) ? globalThis.String(object.value) : "",
    };
  },

  toJSON(message: WebhookTarget_HeadersEntry): unknown {
    const obj: any = {};
    if (message.key !== "") {
      obj.key = message.key;
    }
    if (message.value !== "") {
      obj.value = message.value;
    }
    return obj;
  },

  create(base?: DeepPartial<WebhookTarget_HeadersEntry>): WebhookTarget_HeadersEntry {
    return WebhookTarget_HeadersEntry.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<WebhookTarget_HeadersEntry>): WebhookTarget_HeadersEntry {
    const message = createBaseWebhookTarget_HeadersEntry();
    message.key = object.key ?? "";
    message.value = object.value ?? "";
    return message;
  },
};

export type WebhooksDefinition = typeof WebhooksDefinition;
export const WebhooksDefinition = {
  name: "Webhooks",
  fullName: "Cratis.Chronicle.Contracts.Observation.Webhooks.Webhooks",
  methods: {
    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: CommandResult as typeof CommandResult,
      responseStream: false,
      options: {},
    },
    getWebhooks: {
      name: "GetWebhooks",
      requestType: GetWebhooksRequest as typeof GetWebhooksRequest,
      requestStream: false,
      responseType: QueryResultIEnumerableWebhookDetailsResponse as typeof QueryResultIEnumerableWebhookDetailsResponse,
      responseStream: false,
      options: {},
    },
    observeWebhooks: {
      name: "ObserveWebhooks",
      requestType: ObserveWebhooksRequest as typeof ObserveWebhooksRequest,
      requestStream: false,
      responseType: QueryResultIEnumerableWebhookDetailsResponse as typeof QueryResultIEnumerableWebhookDetailsResponse,
      responseStream: true,
      options: {},
    },
    removeWebhook: {
      name: "RemoveWebhook",
      requestType: RemoveWebhookRequest as typeof RemoveWebhookRequest,
      requestStream: false,
      responseType: CommandResult as typeof CommandResult,
      responseStream: false,
      options: {},
    },
    removeWebhooks: {
      name: "RemoveWebhooks",
      requestType: RemoveWebhooksRequest as typeof RemoveWebhooksRequest,
      requestStream: false,
      responseType: CommandResult as typeof CommandResult,
      responseStream: false,
      options: {},
    },
  },
} as const;

export interface WebhooksServiceImplementation<CallContextExt = {}> {
  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<QueryResultIEnumerableWebhookDetailsResponse>>;
  observeWebhooks(
    request: ObserveWebhooksRequest,
    context: CallContext & CallContextExt,
  ): ServerStreamingMethodResult<DeepPartial<QueryResultIEnumerableWebhookDetailsResponse>>;
  removeWebhook(
    request: RemoveWebhookRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<CommandResult>>;
  removeWebhooks(
    request: RemoveWebhooksRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<CommandResult>>;
}

export interface WebhooksClient<CallOptionsExt = {}> {
  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<QueryResultIEnumerableWebhookDetailsResponse>;
  observeWebhooks(
    request: DeepPartial<ObserveWebhooksRequest>,
    options?: CallOptions & CallOptionsExt,
  ): AsyncIterable<QueryResultIEnumerableWebhookDetailsResponse>;
  removeWebhook(
    request: DeepPartial<RemoveWebhookRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<CommandResult>;
  removeWebhooks(
    request: DeepPartial<RemoveWebhooksRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<CommandResult>;
}

type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;

export type DeepPartial<T> = T extends bigint ? string | number | bigint
  : T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
  : Partial<T>;

function isObject(value: any): boolean {
  return typeof value === "object" && value !== null;
}

function isSet(value: any): boolean {
  return value !== null && value !== undefined;
}

export type ServerStreamingMethodResult<Response> = { [Symbol.asyncIterator](): AsyncIterator<Response, void> };

export interface MessageFns<T> {
  encode(message: T, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): T;
  fromJSON(object: any): T;
  toJSON(message: T): unknown;
  create(base?: DeepPartial<T>): T;
  fromPartial(object: DeepPartial<T>): T;
}