// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// versions:
//   protoc-gen-ts_proto  v2.12.4
//   protoc               v5.28.3
// source: patterns.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.Patterns";

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 AllPatternScopesRequest {
  EventStore: string;
  Namespace: string;
}

export interface AllPatternsRequest {
  EventStore: string;
  Namespace: string;
}

export interface BehaviorPatternDetailsResponse {
  Id: string;
  GroupingKey: string;
  Facets: { [key: string]: string };
  Confidence: number;
  Support: number;
  Occurrences: bigint;
  Weight: number;
  Specificity: number;
  FirstSeen: SerializableDateTimeOffset | undefined;
  LastSeen: SerializableDateTimeOffset | undefined;
}

export interface BehaviorPatternDetailsResponse_FacetsEntry {
  key: string;
  value: string;
}

export interface MatchingPatternsRequest {
  EventStore: string;
  Namespace: string;
  GroupingKey: string;
  Context: { [key: string]: string };
  MinimumConfidence: number;
  MaximumResults: number;
}

export interface MatchingPatternsRequest_ContextEntry {
  key: string;
  value: string;
}

export interface PatternScopeResponse {
  Id: string;
  Name: string;
  UserName: string;
}

export interface PatternsForScopeRequest {
  EventStore: string;
  Namespace: string;
  GroupingKey: string;
}

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

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

/** Represents a DateTimeOffset value as an ISO 8601 string (e.g., "2024-01-15T12:30:00.0000000+02:00"). */
export interface SerializableDateTimeOffset {
  Value: string;
}

export interface UsualActionsRequest {
  EventStore: string;
  Namespace: string;
  GroupingKey: string;
  Context: { [key: string]: string };
  MinimumConfidence: number;
  MaximumResults: number;
}

export interface UsualActionsRequest_ContextEntry {
  key: string;
  value: string;
}

export interface ValidationResult {
  /** default value could not be applied: Error */
  Severity: ValidationResultSeverity;
  Message: string;
  Members: string[];
}

function createBaseAllPatternScopesRequest(): AllPatternScopesRequest {
  return { EventStore: "", Namespace: "" };
}

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

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

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

            message.Namespace = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): AllPatternScopesRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
    };
  },

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

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

function createBaseAllPatternsRequest(): AllPatternsRequest {
  return { EventStore: "", Namespace: "" };
}

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

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

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

            message.Namespace = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): AllPatternsRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
    };
  },

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

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

function createBaseBehaviorPatternDetailsResponse(): BehaviorPatternDetailsResponse {
  return {
    Id: "",
    GroupingKey: "",
    Facets: {},
    Confidence: 0,
    Support: 0,
    Occurrences: 0n,
    Weight: 0,
    Specificity: 0,
    FirstSeen: undefined,
    LastSeen: undefined,
  };
}

export const BehaviorPatternDetailsResponse: MessageFns<BehaviorPatternDetailsResponse> = {
  encode(message: BehaviorPatternDetailsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Id !== "") {
      writer.uint32(10).string(message.Id);
    }
    if (message.GroupingKey !== "") {
      writer.uint32(18).string(message.GroupingKey);
    }
    globalThis.Object.entries(message.Facets).forEach(([key, value]: [string, string]) => {
      BehaviorPatternDetailsResponse_FacetsEntry.encode({ key: key as any, value }, writer.uint32(26).fork()).join();
    });
    if (message.Confidence !== 0) {
      writer.uint32(33).double(message.Confidence);
    }
    if (message.Support !== 0) {
      writer.uint32(41).double(message.Support);
    }
    if (message.Occurrences !== 0n) {
      if (BigInt.asIntN(64, message.Occurrences) !== message.Occurrences) {
        throw new globalThis.Error("value provided for field message.Occurrences of type int64 too large");
      }
      writer.uint32(48).int64(message.Occurrences);
    }
    if (message.Weight !== 0) {
      writer.uint32(57).double(message.Weight);
    }
    if (message.Specificity !== 0) {
      writer.uint32(64).int32(message.Specificity);
    }
    if (message.FirstSeen !== undefined) {
      SerializableDateTimeOffset.encode(message.FirstSeen, writer.uint32(74).fork()).join();
    }
    if (message.LastSeen !== undefined) {
      SerializableDateTimeOffset.encode(message.LastSeen, writer.uint32(82).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): BehaviorPatternDetailsResponse {
    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 = createBaseBehaviorPatternDetailsResponse();
      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 !== 18) {
              break;
            }

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

            const entry3 = BehaviorPatternDetailsResponse_FacetsEntry.decode(reader, reader.uint32());
            if (entry3.value !== undefined) {
              message.Facets[entry3.key] = entry3.value;
            }
            continue;
          }
          case 4: {
            if (tag !== 33) {
              break;
            }

            message.Confidence = reader.double();
            continue;
          }
          case 5: {
            if (tag !== 41) {
              break;
            }

            message.Support = reader.double();
            continue;
          }
          case 6: {
            if (tag !== 48) {
              break;
            }

            message.Occurrences = reader.int64() as bigint;
            continue;
          }
          case 7: {
            if (tag !== 57) {
              break;
            }

            message.Weight = reader.double();
            continue;
          }
          case 8: {
            if (tag !== 64) {
              break;
            }

            message.Specificity = reader.int32();
            continue;
          }
          case 9: {
            if (tag !== 74) {
              break;
            }

            message.FirstSeen = SerializableDateTimeOffset.decode(reader, reader.uint32());
            continue;
          }
          case 10: {
            if (tag !== 82) {
              break;
            }

            message.LastSeen = SerializableDateTimeOffset.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): BehaviorPatternDetailsResponse {
    return {
      Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
      GroupingKey: isSet(object.GroupingKey) ? globalThis.String(object.GroupingKey) : "",
      Facets: isObject(object.Facets)
        ? (globalThis.Object.entries(object.Facets) 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;
          },
          {},
        )
        : {},
      Confidence: isSet(object.Confidence) ? globalThis.Number(object.Confidence) : 0,
      Support: isSet(object.Support) ? globalThis.Number(object.Support) : 0,
      Occurrences: isSet(object.Occurrences) ? BigInt(object.Occurrences) : 0n,
      Weight: isSet(object.Weight) ? globalThis.Number(object.Weight) : 0,
      Specificity: isSet(object.Specificity) ? globalThis.Number(object.Specificity) : 0,
      FirstSeen: isSet(object.FirstSeen) ? SerializableDateTimeOffset.fromJSON(object.FirstSeen) : undefined,
      LastSeen: isSet(object.LastSeen) ? SerializableDateTimeOffset.fromJSON(object.LastSeen) : undefined,
    };
  },

  toJSON(message: BehaviorPatternDetailsResponse): unknown {
    const obj: any = {};
    if (message.Id !== "") {
      obj.Id = message.Id;
    }
    if (message.GroupingKey !== "") {
      obj.GroupingKey = message.GroupingKey;
    }
    if (message.Facets) {
      const entries = globalThis.Object.entries(message.Facets) as [string, string][];
      if (entries.length > 0) {
        obj.Facets = {};
        entries.forEach(([k, v]) => {
          obj.Facets[k] = v;
        });
      }
    }
    if (message.Confidence !== 0) {
      obj.Confidence = message.Confidence;
    }
    if (message.Support !== 0) {
      obj.Support = message.Support;
    }
    if (message.Occurrences !== 0n) {
      obj.Occurrences = message.Occurrences.toString();
    }
    if (message.Weight !== 0) {
      obj.Weight = message.Weight;
    }
    if (message.Specificity !== 0) {
      obj.Specificity = Math.round(message.Specificity);
    }
    if (message.FirstSeen !== undefined) {
      obj.FirstSeen = SerializableDateTimeOffset.toJSON(message.FirstSeen);
    }
    if (message.LastSeen !== undefined) {
      obj.LastSeen = SerializableDateTimeOffset.toJSON(message.LastSeen);
    }
    return obj;
  },

  create(base?: DeepPartial<BehaviorPatternDetailsResponse>): BehaviorPatternDetailsResponse {
    return BehaviorPatternDetailsResponse.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<BehaviorPatternDetailsResponse>): BehaviorPatternDetailsResponse {
    const message = createBaseBehaviorPatternDetailsResponse();
    message.Id = object.Id ?? "";
    message.GroupingKey = object.GroupingKey ?? "";
    message.Facets = (globalThis.Object.entries(object.Facets ?? {}) as [string, string][]).reduce(
      (acc: { [key: string]: string }, [key, value]: [string, string]) => {
        if (value !== undefined) {
          acc[key] = globalThis.String(value);
        }
        return acc;
      },
      {},
    );
    message.Confidence = object.Confidence ?? 0;
    message.Support = object.Support ?? 0;
    message.Occurrences = (object.Occurrences !== undefined && object.Occurrences !== null)
      ? BigInt(object.Occurrences)
      : 0n;
    message.Weight = object.Weight ?? 0;
    message.Specificity = object.Specificity ?? 0;
    message.FirstSeen = (object.FirstSeen !== undefined && object.FirstSeen !== null)
      ? SerializableDateTimeOffset.fromPartial(object.FirstSeen)
      : undefined;
    message.LastSeen = (object.LastSeen !== undefined && object.LastSeen !== null)
      ? SerializableDateTimeOffset.fromPartial(object.LastSeen)
      : undefined;
    return message;
  },
};

function createBaseBehaviorPatternDetailsResponse_FacetsEntry(): BehaviorPatternDetailsResponse_FacetsEntry {
  return { key: "", value: "" };
}

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

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

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

function createBaseMatchingPatternsRequest(): MatchingPatternsRequest {
  return { EventStore: "", Namespace: "", GroupingKey: "", Context: {}, MinimumConfidence: 0, MaximumResults: 0 };
}

export const MatchingPatternsRequest: MessageFns<MatchingPatternsRequest> = {
  encode(message: MatchingPatternsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    if (message.Namespace !== "") {
      writer.uint32(18).string(message.Namespace);
    }
    if (message.GroupingKey !== "") {
      writer.uint32(26).string(message.GroupingKey);
    }
    globalThis.Object.entries(message.Context).forEach(([key, value]: [string, string]) => {
      MatchingPatternsRequest_ContextEntry.encode({ key: key as any, value }, writer.uint32(34).fork()).join();
    });
    if (message.MinimumConfidence !== 0) {
      writer.uint32(41).double(message.MinimumConfidence);
    }
    if (message.MaximumResults !== 0) {
      writer.uint32(48).int32(message.MaximumResults);
    }
    return writer;
  },

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

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

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

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

            const entry4 = MatchingPatternsRequest_ContextEntry.decode(reader, reader.uint32());
            if (entry4.value !== undefined) {
              message.Context[entry4.key] = entry4.value;
            }
            continue;
          }
          case 5: {
            if (tag !== 41) {
              break;
            }

            message.MinimumConfidence = reader.double();
            continue;
          }
          case 6: {
            if (tag !== 48) {
              break;
            }

            message.MaximumResults = reader.int32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): MatchingPatternsRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      GroupingKey: isSet(object.GroupingKey) ? globalThis.String(object.GroupingKey) : "",
      Context: isObject(object.Context)
        ? (globalThis.Object.entries(object.Context) 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;
          },
          {},
        )
        : {},
      MinimumConfidence: isSet(object.MinimumConfidence) ? globalThis.Number(object.MinimumConfidence) : 0,
      MaximumResults: isSet(object.MaximumResults) ? globalThis.Number(object.MaximumResults) : 0,
    };
  },

  toJSON(message: MatchingPatternsRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Namespace !== "") {
      obj.Namespace = message.Namespace;
    }
    if (message.GroupingKey !== "") {
      obj.GroupingKey = message.GroupingKey;
    }
    if (message.Context) {
      const entries = globalThis.Object.entries(message.Context) as [string, string][];
      if (entries.length > 0) {
        obj.Context = {};
        entries.forEach(([k, v]) => {
          obj.Context[k] = v;
        });
      }
    }
    if (message.MinimumConfidence !== 0) {
      obj.MinimumConfidence = message.MinimumConfidence;
    }
    if (message.MaximumResults !== 0) {
      obj.MaximumResults = Math.round(message.MaximumResults);
    }
    return obj;
  },

  create(base?: DeepPartial<MatchingPatternsRequest>): MatchingPatternsRequest {
    return MatchingPatternsRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<MatchingPatternsRequest>): MatchingPatternsRequest {
    const message = createBaseMatchingPatternsRequest();
    message.EventStore = object.EventStore ?? "";
    message.Namespace = object.Namespace ?? "";
    message.GroupingKey = object.GroupingKey ?? "";
    message.Context = (globalThis.Object.entries(object.Context ?? {}) as [string, string][]).reduce(
      (acc: { [key: string]: string }, [key, value]: [string, string]) => {
        if (value !== undefined) {
          acc[key] = globalThis.String(value);
        }
        return acc;
      },
      {},
    );
    message.MinimumConfidence = object.MinimumConfidence ?? 0;
    message.MaximumResults = object.MaximumResults ?? 0;
    return message;
  },
};

function createBaseMatchingPatternsRequest_ContextEntry(): MatchingPatternsRequest_ContextEntry {
  return { key: "", value: "" };
}

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

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

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

function createBasePatternScopeResponse(): PatternScopeResponse {
  return { Id: "", Name: "", UserName: "" };
}

export const PatternScopeResponse: MessageFns<PatternScopeResponse> = {
  encode(message: PatternScopeResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Id !== "") {
      writer.uint32(10).string(message.Id);
    }
    if (message.Name !== "") {
      writer.uint32(18).string(message.Name);
    }
    if (message.UserName !== "") {
      writer.uint32(26).string(message.UserName);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): PatternScopeResponse {
    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 = createBasePatternScopeResponse();
      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 !== 18) {
              break;
            }

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

            message.UserName = 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): PatternScopeResponse {
    return {
      Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
      Name: isSet(object.Name) ? globalThis.String(object.Name) : "",
      UserName: isSet(object.UserName) ? globalThis.String(object.UserName) : "",
    };
  },

  toJSON(message: PatternScopeResponse): unknown {
    const obj: any = {};
    if (message.Id !== "") {
      obj.Id = message.Id;
    }
    if (message.Name !== "") {
      obj.Name = message.Name;
    }
    if (message.UserName !== "") {
      obj.UserName = message.UserName;
    }
    return obj;
  },

  create(base?: DeepPartial<PatternScopeResponse>): PatternScopeResponse {
    return PatternScopeResponse.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<PatternScopeResponse>): PatternScopeResponse {
    const message = createBasePatternScopeResponse();
    message.Id = object.Id ?? "";
    message.Name = object.Name ?? "";
    message.UserName = object.UserName ?? "";
    return message;
  },
};

function createBasePatternsForScopeRequest(): PatternsForScopeRequest {
  return { EventStore: "", Namespace: "", GroupingKey: "" };
}

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

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

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

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

            message.GroupingKey = 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): PatternsForScopeRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      GroupingKey: isSet(object.GroupingKey) ? globalThis.String(object.GroupingKey) : "",
    };
  },

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

  create(base?: DeepPartial<PatternsForScopeRequest>): PatternsForScopeRequest {
    return PatternsForScopeRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<PatternsForScopeRequest>): PatternsForScopeRequest {
    const message = createBasePatternsForScopeRequest();
    message.EventStore = object.EventStore ?? "";
    message.Namespace = object.Namespace ?? "";
    message.GroupingKey = object.GroupingKey ?? "";
    return message;
  },
};

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

export const QueryResultIEnumerableBehaviorPatternDetailsResponse: MessageFns<
  QueryResultIEnumerableBehaviorPatternDetailsResponse
> = {
  encode(
    message: QueryResultIEnumerableBehaviorPatternDetailsResponse,
    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) {
      BehaviorPatternDetailsResponse.encode(v!, writer.uint32(50).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryResultIEnumerableBehaviorPatternDetailsResponse {
    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 = createBaseQueryResultIEnumerableBehaviorPatternDetailsResponse();
      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(BehaviorPatternDetailsResponse.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): QueryResultIEnumerableBehaviorPatternDetailsResponse {
    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) => BehaviorPatternDetailsResponse.fromJSON(e))
        : [],
    };
  },

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

  create(
    base?: DeepPartial<QueryResultIEnumerableBehaviorPatternDetailsResponse>,
  ): QueryResultIEnumerableBehaviorPatternDetailsResponse {
    return QueryResultIEnumerableBehaviorPatternDetailsResponse.fromPartial(base ?? {});
  },
  fromPartial(
    object: DeepPartial<QueryResultIEnumerableBehaviorPatternDetailsResponse>,
  ): QueryResultIEnumerableBehaviorPatternDetailsResponse {
    const message = createBaseQueryResultIEnumerableBehaviorPatternDetailsResponse();
    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) => BehaviorPatternDetailsResponse.fromPartial(e)) || [];
    return message;
  },
};

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

export const QueryResultIEnumerablePatternScopeResponse: MessageFns<QueryResultIEnumerablePatternScopeResponse> = {
  encode(message: QueryResultIEnumerablePatternScopeResponse, 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) {
      PatternScopeResponse.encode(v!, writer.uint32(50).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): QueryResultIEnumerablePatternScopeResponse {
    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 = createBaseQueryResultIEnumerablePatternScopeResponse();
      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(PatternScopeResponse.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): QueryResultIEnumerablePatternScopeResponse {
    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) => PatternScopeResponse.fromJSON(e)) : [],
    };
  },

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

  create(base?: DeepPartial<QueryResultIEnumerablePatternScopeResponse>): QueryResultIEnumerablePatternScopeResponse {
    return QueryResultIEnumerablePatternScopeResponse.fromPartial(base ?? {});
  },
  fromPartial(
    object: DeepPartial<QueryResultIEnumerablePatternScopeResponse>,
  ): QueryResultIEnumerablePatternScopeResponse {
    const message = createBaseQueryResultIEnumerablePatternScopeResponse();
    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) => PatternScopeResponse.fromPartial(e)) || [];
    return message;
  },
};

function createBaseSerializableDateTimeOffset(): SerializableDateTimeOffset {
  return { Value: "" };
}

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

  decode(input: BinaryReader | Uint8Array, length?: number): SerializableDateTimeOffset {
    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 = createBaseSerializableDateTimeOffset();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              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): SerializableDateTimeOffset {
    return { Value: isSet(object.Value) ? globalThis.String(object.Value) : "" };
  },

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

  create(base?: DeepPartial<SerializableDateTimeOffset>): SerializableDateTimeOffset {
    return SerializableDateTimeOffset.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<SerializableDateTimeOffset>): SerializableDateTimeOffset {
    const message = createBaseSerializableDateTimeOffset();
    message.Value = object.Value ?? "";
    return message;
  },
};

function createBaseUsualActionsRequest(): UsualActionsRequest {
  return { EventStore: "", Namespace: "", GroupingKey: "", Context: {}, MinimumConfidence: 0, MaximumResults: 0 };
}

export const UsualActionsRequest: MessageFns<UsualActionsRequest> = {
  encode(message: UsualActionsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    if (message.Namespace !== "") {
      writer.uint32(18).string(message.Namespace);
    }
    if (message.GroupingKey !== "") {
      writer.uint32(26).string(message.GroupingKey);
    }
    globalThis.Object.entries(message.Context).forEach(([key, value]: [string, string]) => {
      UsualActionsRequest_ContextEntry.encode({ key: key as any, value }, writer.uint32(34).fork()).join();
    });
    if (message.MinimumConfidence !== 0) {
      writer.uint32(41).double(message.MinimumConfidence);
    }
    if (message.MaximumResults !== 0) {
      writer.uint32(48).int32(message.MaximumResults);
    }
    return writer;
  },

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

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

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

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

            const entry4 = UsualActionsRequest_ContextEntry.decode(reader, reader.uint32());
            if (entry4.value !== undefined) {
              message.Context[entry4.key] = entry4.value;
            }
            continue;
          }
          case 5: {
            if (tag !== 41) {
              break;
            }

            message.MinimumConfidence = reader.double();
            continue;
          }
          case 6: {
            if (tag !== 48) {
              break;
            }

            message.MaximumResults = reader.int32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): UsualActionsRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      GroupingKey: isSet(object.GroupingKey) ? globalThis.String(object.GroupingKey) : "",
      Context: isObject(object.Context)
        ? (globalThis.Object.entries(object.Context) 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;
          },
          {},
        )
        : {},
      MinimumConfidence: isSet(object.MinimumConfidence) ? globalThis.Number(object.MinimumConfidence) : 0,
      MaximumResults: isSet(object.MaximumResults) ? globalThis.Number(object.MaximumResults) : 0,
    };
  },

  toJSON(message: UsualActionsRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Namespace !== "") {
      obj.Namespace = message.Namespace;
    }
    if (message.GroupingKey !== "") {
      obj.GroupingKey = message.GroupingKey;
    }
    if (message.Context) {
      const entries = globalThis.Object.entries(message.Context) as [string, string][];
      if (entries.length > 0) {
        obj.Context = {};
        entries.forEach(([k, v]) => {
          obj.Context[k] = v;
        });
      }
    }
    if (message.MinimumConfidence !== 0) {
      obj.MinimumConfidence = message.MinimumConfidence;
    }
    if (message.MaximumResults !== 0) {
      obj.MaximumResults = Math.round(message.MaximumResults);
    }
    return obj;
  },

  create(base?: DeepPartial<UsualActionsRequest>): UsualActionsRequest {
    return UsualActionsRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<UsualActionsRequest>): UsualActionsRequest {
    const message = createBaseUsualActionsRequest();
    message.EventStore = object.EventStore ?? "";
    message.Namespace = object.Namespace ?? "";
    message.GroupingKey = object.GroupingKey ?? "";
    message.Context = (globalThis.Object.entries(object.Context ?? {}) as [string, string][]).reduce(
      (acc: { [key: string]: string }, [key, value]: [string, string]) => {
        if (value !== undefined) {
          acc[key] = globalThis.String(value);
        }
        return acc;
      },
      {},
    );
    message.MinimumConfidence = object.MinimumConfidence ?? 0;
    message.MaximumResults = object.MaximumResults ?? 0;
    return message;
  },
};

function createBaseUsualActionsRequest_ContextEntry(): UsualActionsRequest_ContextEntry {
  return { key: "", value: "" };
}

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

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

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

function createBaseValidationResult(): ValidationResult {
  return { Severity: 0, Message: "", Members: [] };
}

export const ValidationResult: MessageFns<ValidationResult> = {
  encode(message: ValidationResult, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Severity !== 0) {
      writer.uint32(8).int32(message.Severity);
    }
    if (message.Message !== "") {
      writer.uint32(18).string(message.Message);
    }
    for (const v of message.Members) {
      writer.uint32(26).string(v!);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ValidationResult {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
    if (previousRecursionDepth >= 100) {
      throw new globalThis.Error("protobuf decode recursion limit exceeded");
    }
    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
    try {
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseValidationResult();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }

            message.Severity = reader.int32() as any;
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

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

            message.Members.push(reader.string());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    } finally {
      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
    }
  },

  fromJSON(object: any): ValidationResult {
    return {
      Severity: isSet(object.Severity) ? validationResultSeverityFromJSON(object.Severity) : 0,
      Message: isSet(object.Message) ? globalThis.String(object.Message) : "",
      Members: globalThis.Array.isArray(object?.Members) ? object.Members.map((e: any) => globalThis.String(e)) : [],
    };
  },

  toJSON(message: ValidationResult): unknown {
    const obj: any = {};
    if (message.Severity !== 0) {
      obj.Severity = validationResultSeverityToJSON(message.Severity);
    }
    if (message.Message !== "") {
      obj.Message = message.Message;
    }
    if (message.Members?.length) {
      obj.Members = message.Members;
    }
    return obj;
  },

  create(base?: DeepPartial<ValidationResult>): ValidationResult {
    return ValidationResult.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ValidationResult>): ValidationResult {
    const message = createBaseValidationResult();
    message.Severity = object.Severity ?? 0;
    message.Message = object.Message ?? "";
    message.Members = object.Members?.map((e) => e) || [];
    return message;
  },
};

export type PatternsDefinition = typeof PatternsDefinition;
export const PatternsDefinition = {
  name: "Patterns",
  fullName: "Cratis.Chronicle.Contracts.Patterns.Patterns",
  methods: {
    allPatterns: {
      name: "AllPatterns",
      requestType: AllPatternsRequest as typeof AllPatternsRequest,
      requestStream: false,
      responseType:
        QueryResultIEnumerableBehaviorPatternDetailsResponse as typeof QueryResultIEnumerableBehaviorPatternDetailsResponse,
      responseStream: false,
      options: {},
    },
    allPatternScopes: {
      name: "AllPatternScopes",
      requestType: AllPatternScopesRequest as typeof AllPatternScopesRequest,
      requestStream: false,
      responseType: QueryResultIEnumerablePatternScopeResponse as typeof QueryResultIEnumerablePatternScopeResponse,
      responseStream: false,
      options: {},
    },
    matchingPatterns: {
      name: "MatchingPatterns",
      requestType: MatchingPatternsRequest as typeof MatchingPatternsRequest,
      requestStream: false,
      responseType:
        QueryResultIEnumerableBehaviorPatternDetailsResponse as typeof QueryResultIEnumerableBehaviorPatternDetailsResponse,
      responseStream: false,
      options: {},
    },
    patternsForScope: {
      name: "PatternsForScope",
      requestType: PatternsForScopeRequest as typeof PatternsForScopeRequest,
      requestStream: false,
      responseType:
        QueryResultIEnumerableBehaviorPatternDetailsResponse as typeof QueryResultIEnumerableBehaviorPatternDetailsResponse,
      responseStream: false,
      options: {},
    },
    usualActions: {
      name: "UsualActions",
      requestType: UsualActionsRequest as typeof UsualActionsRequest,
      requestStream: false,
      responseType:
        QueryResultIEnumerableBehaviorPatternDetailsResponse as typeof QueryResultIEnumerableBehaviorPatternDetailsResponse,
      responseStream: false,
      options: {},
    },
  },
} as const;

export interface PatternsServiceImplementation<CallContextExt = {}> {
  allPatterns(
    request: AllPatternsRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<QueryResultIEnumerableBehaviorPatternDetailsResponse>>;
  allPatternScopes(
    request: AllPatternScopesRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<QueryResultIEnumerablePatternScopeResponse>>;
  matchingPatterns(
    request: MatchingPatternsRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<QueryResultIEnumerableBehaviorPatternDetailsResponse>>;
  patternsForScope(
    request: PatternsForScopeRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<QueryResultIEnumerableBehaviorPatternDetailsResponse>>;
  usualActions(
    request: UsualActionsRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<QueryResultIEnumerableBehaviorPatternDetailsResponse>>;
}

export interface PatternsClient<CallOptionsExt = {}> {
  allPatterns(
    request: DeepPartial<AllPatternsRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<QueryResultIEnumerableBehaviorPatternDetailsResponse>;
  allPatternScopes(
    request: DeepPartial<AllPatternScopesRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<QueryResultIEnumerablePatternScopeResponse>;
  matchingPatterns(
    request: DeepPartial<MatchingPatternsRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<QueryResultIEnumerableBehaviorPatternDetailsResponse>;
  patternsForScope(
    request: DeepPartial<PatternsForScopeRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<QueryResultIEnumerableBehaviorPatternDetailsResponse>;
  usualActions(
    request: DeepPartial<UsualActionsRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<QueryResultIEnumerableBehaviorPatternDetailsResponse>;
}

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