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

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

export const protobufPackage = "Cratis.Chronicle.Contracts.Projections";

export enum AutoMap {
  Inherit = 0,
  Disabled = 1,
  Enabled = 2,
  UNRECOGNIZED = -1,
}

export function autoMapFromJSON(object: any): AutoMap {
  switch (object) {
    case 0:
    case "Inherit":
      return AutoMap.Inherit;
    case 1:
    case "Disabled":
      return AutoMap.Disabled;
    case 2:
    case "Enabled":
      return AutoMap.Enabled;
    case -1:
    case "UNRECOGNIZED":
    default:
      return AutoMap.UNRECOGNIZED;
  }
}

export function autoMapToJSON(object: AutoMap): string {
  switch (object) {
    case AutoMap.Inherit:
      return "Inherit";
    case AutoMap.Disabled:
      return "Disabled";
    case AutoMap.Enabled:
      return "Enabled";
    case AutoMap.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export enum ProjectionOwner {
  PROJECTION_OWNER_None = 0,
  PROJECTION_OWNER_Client = 1,
  PROJECTION_OWNER_Server = 2,
  UNRECOGNIZED = -1,
}

export function projectionOwnerFromJSON(object: any): ProjectionOwner {
  switch (object) {
    case 0:
    case "PROJECTION_OWNER_None":
      return ProjectionOwner.PROJECTION_OWNER_None;
    case 1:
    case "PROJECTION_OWNER_Client":
      return ProjectionOwner.PROJECTION_OWNER_Client;
    case 2:
    case "PROJECTION_OWNER_Server":
      return ProjectionOwner.PROJECTION_OWNER_Server;
    case -1:
    case "UNRECOGNIZED":
    default:
      return ProjectionOwner.UNRECOGNIZED;
  }
}

export function projectionOwnerToJSON(object: ProjectionOwner): string {
  switch (object) {
    case ProjectionOwner.PROJECTION_OWNER_None:
      return "PROJECTION_OWNER_None";
    case ProjectionOwner.PROJECTION_OWNER_Client:
      return "PROJECTION_OWNER_Client";
    case ProjectionOwner.PROJECTION_OWNER_Server:
      return "PROJECTION_OWNER_Server";
    case ProjectionOwner.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export enum ReadModelObserverType {
  NotSet = 0,
  Reducer = 1,
  Projection = 2,
  UNRECOGNIZED = -1,
}

export function readModelObserverTypeFromJSON(object: any): ReadModelObserverType {
  switch (object) {
    case 0:
    case "NotSet":
      return ReadModelObserverType.NotSet;
    case 1:
    case "Reducer":
      return ReadModelObserverType.Reducer;
    case 2:
    case "Projection":
      return ReadModelObserverType.Projection;
    case -1:
    case "UNRECOGNIZED":
    default:
      return ReadModelObserverType.UNRECOGNIZED;
  }
}

export function readModelObserverTypeToJSON(object: ReadModelObserverType): string {
  switch (object) {
    case ReadModelObserverType.NotSet:
      return "NotSet";
    case ReadModelObserverType.Reducer:
      return "Reducer";
    case ReadModelObserverType.Projection:
      return "Projection";
    case ReadModelObserverType.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export enum ReadModelOwner {
  READ_MODEL_OWNER_None = 0,
  READ_MODEL_OWNER_Client = 1,
  READ_MODEL_OWNER_Server = 2,
  UNRECOGNIZED = -1,
}

export function readModelOwnerFromJSON(object: any): ReadModelOwner {
  switch (object) {
    case 0:
    case "READ_MODEL_OWNER_None":
      return ReadModelOwner.READ_MODEL_OWNER_None;
    case 1:
    case "READ_MODEL_OWNER_Client":
      return ReadModelOwner.READ_MODEL_OWNER_Client;
    case 2:
    case "READ_MODEL_OWNER_Server":
      return ReadModelOwner.READ_MODEL_OWNER_Server;
    case -1:
    case "UNRECOGNIZED":
    default:
      return ReadModelOwner.UNRECOGNIZED;
  }
}

export function readModelOwnerToJSON(object: ReadModelOwner): string {
  switch (object) {
    case ReadModelOwner.READ_MODEL_OWNER_None:
      return "READ_MODEL_OWNER_None";
    case ReadModelOwner.READ_MODEL_OWNER_Client:
      return "READ_MODEL_OWNER_Client";
    case ReadModelOwner.READ_MODEL_OWNER_Server:
      return "READ_MODEL_OWNER_Server";
    case ReadModelOwner.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export enum ReadModelSource {
  Unknown = 0,
  Code = 1,
  User = 2,
  UNRECOGNIZED = -1,
}

export function readModelSourceFromJSON(object: any): ReadModelSource {
  switch (object) {
    case 0:
    case "Unknown":
      return ReadModelSource.Unknown;
    case 1:
    case "Code":
      return ReadModelSource.Code;
    case 2:
    case "User":
      return ReadModelSource.User;
    case -1:
    case "UNRECOGNIZED":
    default:
      return ReadModelSource.UNRECOGNIZED;
  }
}

export function readModelSourceToJSON(object: ReadModelSource): string {
  switch (object) {
    case ReadModelSource.Unknown:
      return "Unknown";
    case ReadModelSource.Code:
      return "Code";
    case ReadModelSource.User:
      return "User";
    case ReadModelSource.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export interface ChildrenDefinition {
  IdentifiedBy: string;
  From: KeyValuePairEventTypeFromDefinition[];
  Join: KeyValuePairEventTypeJoinDefinition[];
  Children: { [key: string]: ChildrenDefinition };
  All: FromEveryDefinition | undefined;
  FromEventProperty: FromEventPropertyDefinition | undefined;
  RemovedWith: KeyValuePairEventTypeRemovedWithDefinition[];
  RemovedWithJoin: KeyValuePairEventTypeRemovedWithJoinDefinition[];
  AutoMap: AutoMap;
  Nested: { [key: string]: ChildrenDefinition };
  NoAutoMapProperties: string[];
}

export interface ChildrenDefinition_ChildrenEntry {
  key: string;
  value: ChildrenDefinition | undefined;
}

export interface ChildrenDefinition_NestedEntry {
  key: string;
  value: ChildrenDefinition | undefined;
}

export interface DraftReadModelDefinition {
  ContainerName: string;
  Schema: string;
  Identifier: string;
  DisplayName: string;
}

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

export interface FromDefinition {
  Properties: { [key: string]: string };
  Key: string;
  ParentKey: string;
}

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

export interface FromDerivativesDefinition {
  EventTypes: EventType[];
  From: FromDefinition | undefined;
}

export interface FromEventPropertyDefinition {
  Event: EventType | undefined;
  PropertyExpression: string;
}

export interface FromEveryDefinition {
  Properties: { [key: string]: string };
  IncludeChildren: boolean;
  AutoMap: AutoMap;
}

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

export interface GetAllDeclarationsRequest {
  EventStore: string;
}

export interface GetAllDefinitionsRequest {
  EventStore: string;
}

export interface IEnumerableProjectionDefinition {
  items: ProjectionDefinition[];
}

export interface IEnumerableProjectionWithDeclaration {
  items: ProjectionWithDeclaration[];
}

export interface IndexDefinition {
  PropertyPath: string;
}

export interface JoinDefinition {
  On: string;
  Properties: { [key: string]: string };
  Key: string;
}

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

export interface KeyValuePairEventTypeFromDefinition {
  Key: EventType | undefined;
  Value: FromDefinition | undefined;
}

export interface KeyValuePairEventTypeJoinDefinition {
  Key: EventType | undefined;
  Value: JoinDefinition | undefined;
}

export interface KeyValuePairEventTypeRemovedWithDefinition {
  Key: EventType | undefined;
  Value: RemovedWithDefinition | undefined;
}

export interface KeyValuePairEventTypeRemovedWithJoinDefinition {
  Key: EventType | undefined;
  Value: RemovedWithJoinDefinition | undefined;
}

export interface OneOfProjectionPreviewProjectionDeclarationParsingErrors {
  Value0: ProjectionPreview | undefined;
  Value1: ProjectionDeclarationParsingErrors | undefined;
}

export interface PreviewProjectionRequest {
  EventStore: string;
  Namespace: string;
  /** default value could not be applied: event-log */
  EventSequenceId: string;
  Declaration: string;
  DraftReadModel: DraftReadModelDefinition | undefined;
}

export interface ProjectionDeclarationParsingErrors {
  Errors: ProjectionDeclarationSyntaxError[];
}

export interface ProjectionDeclarationSyntaxError {
  Message: string;
  Line: number;
  Column: number;
}

export interface ProjectionDefinition {
  EventSequenceId: string;
  Identifier: string;
  ReadModel: string;
  IsActive: boolean;
  IsRewindable: boolean;
  InitialModelState: string;
  From: KeyValuePairEventTypeFromDefinition[];
  Join: KeyValuePairEventTypeJoinDefinition[];
  Children: { [key: string]: ChildrenDefinition };
  FromEvery: FromDerivativesDefinition[];
  All: FromEveryDefinition | undefined;
  FromEventProperty: FromEventPropertyDefinition | undefined;
  RemovedWith: KeyValuePairEventTypeRemovedWithDefinition[];
  RemovedWithJoin: KeyValuePairEventTypeRemovedWithJoinDefinition[];
  LastUpdated: SerializableDateTimeOffset | undefined;
  Tags: string[];
  AutoMap: AutoMap;
  Nested: { [key: string]: ChildrenDefinition };
  SubscribesToAllEvents: boolean;
  NoAutoMapProperties: string[];
}

export interface ProjectionDefinition_ChildrenEntry {
  key: string;
  value: ChildrenDefinition | undefined;
}

export interface ProjectionDefinition_NestedEntry {
  key: string;
  value: ChildrenDefinition | undefined;
}

export interface ProjectionPreview {
  ReadModelEntries: string[];
  ReadModel: ReadModelDefinition | undefined;
}

export interface ProjectionWithDeclaration {
  Identifier: string;
  ContainerName: string;
  Declaration: string;
}

export interface ReadModelDefinition {
  Type: ReadModelType | undefined;
  ContainerName: string;
  DisplayName: string;
  Sink: SinkDefinition | undefined;
  Schema: string;
  Indexes: IndexDefinition[];
  ObserverType: ReadModelObserverType;
  ObserverIdentifier: string;
  Owner: ReadModelOwner;
  Source: ReadModelSource;
}

export interface ReadModelType {
  Identifier: string;
  Generation: number;
}

export interface RegisterRequest {
  EventStore: string;
  Owner: ProjectionOwner;
  Projections: ProjectionDefinition[];
  FullSet: boolean;
}

export interface RemovedWithDefinition {
  Key: string;
  ParentKey: string;
}

export interface RemovedWithJoinDefinition {
  Key: string;
}

export interface SaveProjectionRequest {
  EventStore: string;
  Namespace: string;
  /** default value could not be applied: event-log */
  EventSequenceId: string;
  Declaration: string;
  DraftReadModel: DraftReadModelDefinition | undefined;
}

export interface SaveProjectionResult {
  Errors: ProjectionDeclarationSyntaxError[];
}

/** 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 SinkDefinition {
  /** default value could not be applied: 00000000-0000-0000-0000-000000000000 */
  ConfigurationId: Guid | undefined;
  TypeId: string;
}

function createBaseChildrenDefinition(): ChildrenDefinition {
  return {
    IdentifiedBy: "",
    From: [],
    Join: [],
    Children: {},
    All: undefined,
    FromEventProperty: undefined,
    RemovedWith: [],
    RemovedWithJoin: [],
    AutoMap: 0,
    Nested: {},
    NoAutoMapProperties: [],
  };
}

export const ChildrenDefinition: MessageFns<ChildrenDefinition> = {
  encode(message: ChildrenDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.IdentifiedBy !== "") {
      writer.uint32(10).string(message.IdentifiedBy);
    }
    for (const v of message.From) {
      KeyValuePairEventTypeFromDefinition.encode(v!, writer.uint32(18).fork()).join();
    }
    for (const v of message.Join) {
      KeyValuePairEventTypeJoinDefinition.encode(v!, writer.uint32(26).fork()).join();
    }
    globalThis.Object.entries(message.Children).forEach(([key, value]: [string, ChildrenDefinition]) => {
      ChildrenDefinition_ChildrenEntry.encode({ key: key as any, value }, writer.uint32(34).fork()).join();
    });
    if (message.All !== undefined) {
      FromEveryDefinition.encode(message.All, writer.uint32(42).fork()).join();
    }
    if (message.FromEventProperty !== undefined) {
      FromEventPropertyDefinition.encode(message.FromEventProperty, writer.uint32(50).fork()).join();
    }
    for (const v of message.RemovedWith) {
      KeyValuePairEventTypeRemovedWithDefinition.encode(v!, writer.uint32(58).fork()).join();
    }
    for (const v of message.RemovedWithJoin) {
      KeyValuePairEventTypeRemovedWithJoinDefinition.encode(v!, writer.uint32(66).fork()).join();
    }
    if (message.AutoMap !== 0) {
      writer.uint32(72).int32(message.AutoMap);
    }
    globalThis.Object.entries(message.Nested).forEach(([key, value]: [string, ChildrenDefinition]) => {
      ChildrenDefinition_NestedEntry.encode({ key: key as any, value }, writer.uint32(82).fork()).join();
    });
    for (const v of message.NoAutoMapProperties) {
      writer.uint32(90).string(v!);
    }
    return writer;
  },

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

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

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

            message.Join.push(KeyValuePairEventTypeJoinDefinition.decode(reader, reader.uint32()));
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }

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

            message.All = FromEveryDefinition.decode(reader, reader.uint32());
            continue;
          }
          case 6: {
            if (tag !== 50) {
              break;
            }

            message.FromEventProperty = FromEventPropertyDefinition.decode(reader, reader.uint32());
            continue;
          }
          case 7: {
            if (tag !== 58) {
              break;
            }

            message.RemovedWith.push(KeyValuePairEventTypeRemovedWithDefinition.decode(reader, reader.uint32()));
            continue;
          }
          case 8: {
            if (tag !== 66) {
              break;
            }

            message.RemovedWithJoin.push(
              KeyValuePairEventTypeRemovedWithJoinDefinition.decode(reader, reader.uint32()),
            );
            continue;
          }
          case 9: {
            if (tag !== 72) {
              break;
            }

            message.AutoMap = reader.int32() as any;
            continue;
          }
          case 10: {
            if (tag !== 82) {
              break;
            }

            const entry10 = ChildrenDefinition_NestedEntry.decode(reader, reader.uint32());
            if (entry10.value !== undefined) {
              message.Nested[entry10.key] = entry10.value;
            }
            continue;
          }
          case 11: {
            if (tag !== 90) {
              break;
            }

            message.NoAutoMapProperties.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): ChildrenDefinition {
    return {
      IdentifiedBy: isSet(object.IdentifiedBy) ? globalThis.String(object.IdentifiedBy) : "",
      From: globalThis.Array.isArray(object?.From)
        ? object.From.map((e: any) => KeyValuePairEventTypeFromDefinition.fromJSON(e))
        : [],
      Join: globalThis.Array.isArray(object?.Join)
        ? object.Join.map((e: any) => KeyValuePairEventTypeJoinDefinition.fromJSON(e))
        : [],
      Children: isObject(object.Children)
        ? (globalThis.Object.entries(object.Children) as [string, any][]).reduce(
          (acc: { [key: string]: ChildrenDefinition }, [key, value]: [string, any]) => {
            globalThis.Object.defineProperty(acc, key, {
              value: ChildrenDefinition.fromJSON(value),
              enumerable: true,
              configurable: true,
              writable: true,
            });
            return acc;
          },
          {},
        )
        : {},
      All: isSet(object.All) ? FromEveryDefinition.fromJSON(object.All) : undefined,
      FromEventProperty: isSet(object.FromEventProperty)
        ? FromEventPropertyDefinition.fromJSON(object.FromEventProperty)
        : undefined,
      RemovedWith: globalThis.Array.isArray(object?.RemovedWith)
        ? object.RemovedWith.map((e: any) => KeyValuePairEventTypeRemovedWithDefinition.fromJSON(e))
        : [],
      RemovedWithJoin: globalThis.Array.isArray(object?.RemovedWithJoin)
        ? object.RemovedWithJoin.map((e: any) => KeyValuePairEventTypeRemovedWithJoinDefinition.fromJSON(e))
        : [],
      AutoMap: isSet(object.AutoMap) ? autoMapFromJSON(object.AutoMap) : 0,
      Nested: isObject(object.Nested)
        ? (globalThis.Object.entries(object.Nested) as [string, any][]).reduce(
          (acc: { [key: string]: ChildrenDefinition }, [key, value]: [string, any]) => {
            globalThis.Object.defineProperty(acc, key, {
              value: ChildrenDefinition.fromJSON(value),
              enumerable: true,
              configurable: true,
              writable: true,
            });
            return acc;
          },
          {},
        )
        : {},
      NoAutoMapProperties: globalThis.Array.isArray(object?.NoAutoMapProperties)
        ? object.NoAutoMapProperties.map((e: any) => globalThis.String(e))
        : [],
    };
  },

  toJSON(message: ChildrenDefinition): unknown {
    const obj: any = {};
    if (message.IdentifiedBy !== "") {
      obj.IdentifiedBy = message.IdentifiedBy;
    }
    if (message.From?.length) {
      obj.From = message.From.map((e) => KeyValuePairEventTypeFromDefinition.toJSON(e));
    }
    if (message.Join?.length) {
      obj.Join = message.Join.map((e) => KeyValuePairEventTypeJoinDefinition.toJSON(e));
    }
    if (message.Children) {
      const entries = globalThis.Object.entries(message.Children) as [string, ChildrenDefinition][];
      if (entries.length > 0) {
        obj.Children = {};
        entries.forEach(([k, v]) => {
          obj.Children[k] = ChildrenDefinition.toJSON(v);
        });
      }
    }
    if (message.All !== undefined) {
      obj.All = FromEveryDefinition.toJSON(message.All);
    }
    if (message.FromEventProperty !== undefined) {
      obj.FromEventProperty = FromEventPropertyDefinition.toJSON(message.FromEventProperty);
    }
    if (message.RemovedWith?.length) {
      obj.RemovedWith = message.RemovedWith.map((e) => KeyValuePairEventTypeRemovedWithDefinition.toJSON(e));
    }
    if (message.RemovedWithJoin?.length) {
      obj.RemovedWithJoin = message.RemovedWithJoin.map((e) =>
        KeyValuePairEventTypeRemovedWithJoinDefinition.toJSON(e)
      );
    }
    if (message.AutoMap !== 0) {
      obj.AutoMap = autoMapToJSON(message.AutoMap);
    }
    if (message.Nested) {
      const entries = globalThis.Object.entries(message.Nested) as [string, ChildrenDefinition][];
      if (entries.length > 0) {
        obj.Nested = {};
        entries.forEach(([k, v]) => {
          obj.Nested[k] = ChildrenDefinition.toJSON(v);
        });
      }
    }
    if (message.NoAutoMapProperties?.length) {
      obj.NoAutoMapProperties = message.NoAutoMapProperties;
    }
    return obj;
  },

  create(base?: DeepPartial<ChildrenDefinition>): ChildrenDefinition {
    return ChildrenDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ChildrenDefinition>): ChildrenDefinition {
    const message = createBaseChildrenDefinition();
    message.IdentifiedBy = object.IdentifiedBy ?? "";
    message.From = object.From?.map((e) => KeyValuePairEventTypeFromDefinition.fromPartial(e)) || [];
    message.Join = object.Join?.map((e) => KeyValuePairEventTypeJoinDefinition.fromPartial(e)) || [];
    message.Children = (globalThis.Object.entries(object.Children ?? {}) as [string, ChildrenDefinition][]).reduce(
      (acc: { [key: string]: ChildrenDefinition }, [key, value]: [string, ChildrenDefinition]) => {
        if (value !== undefined) {
          acc[key] = ChildrenDefinition.fromPartial(value);
        }
        return acc;
      },
      {},
    );
    message.All = (object.All !== undefined && object.All !== null)
      ? FromEveryDefinition.fromPartial(object.All)
      : undefined;
    message.FromEventProperty = (object.FromEventProperty !== undefined && object.FromEventProperty !== null)
      ? FromEventPropertyDefinition.fromPartial(object.FromEventProperty)
      : undefined;
    message.RemovedWith = object.RemovedWith?.map((e) => KeyValuePairEventTypeRemovedWithDefinition.fromPartial(e)) ||
      [];
    message.RemovedWithJoin =
      object.RemovedWithJoin?.map((e) => KeyValuePairEventTypeRemovedWithJoinDefinition.fromPartial(e)) || [];
    message.AutoMap = object.AutoMap ?? 0;
    message.Nested = (globalThis.Object.entries(object.Nested ?? {}) as [string, ChildrenDefinition][]).reduce(
      (acc: { [key: string]: ChildrenDefinition }, [key, value]: [string, ChildrenDefinition]) => {
        if (value !== undefined) {
          acc[key] = ChildrenDefinition.fromPartial(value);
        }
        return acc;
      },
      {},
    );
    message.NoAutoMapProperties = object.NoAutoMapProperties?.map((e) => e) || [];
    return message;
  },
};

function createBaseChildrenDefinition_ChildrenEntry(): ChildrenDefinition_ChildrenEntry {
  return { key: "", value: undefined };
}

export const ChildrenDefinition_ChildrenEntry: MessageFns<ChildrenDefinition_ChildrenEntry> = {
  encode(message: ChildrenDefinition_ChildrenEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.key !== "") {
      writer.uint32(10).string(message.key);
    }
    if (message.value !== undefined) {
      ChildrenDefinition.encode(message.value, writer.uint32(18).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ChildrenDefinition_ChildrenEntry {
    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 = createBaseChildrenDefinition_ChildrenEntry();
      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 = ChildrenDefinition.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): ChildrenDefinition_ChildrenEntry {
    return {
      key: isSet(object.key) ? globalThis.String(object.key) : "",
      value: isSet(object.value) ? ChildrenDefinition.fromJSON(object.value) : undefined,
    };
  },

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

  create(base?: DeepPartial<ChildrenDefinition_ChildrenEntry>): ChildrenDefinition_ChildrenEntry {
    return ChildrenDefinition_ChildrenEntry.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ChildrenDefinition_ChildrenEntry>): ChildrenDefinition_ChildrenEntry {
    const message = createBaseChildrenDefinition_ChildrenEntry();
    message.key = object.key ?? "";
    message.value = (object.value !== undefined && object.value !== null)
      ? ChildrenDefinition.fromPartial(object.value)
      : undefined;
    return message;
  },
};

function createBaseChildrenDefinition_NestedEntry(): ChildrenDefinition_NestedEntry {
  return { key: "", value: undefined };
}

export const ChildrenDefinition_NestedEntry: MessageFns<ChildrenDefinition_NestedEntry> = {
  encode(message: ChildrenDefinition_NestedEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.key !== "") {
      writer.uint32(10).string(message.key);
    }
    if (message.value !== undefined) {
      ChildrenDefinition.encode(message.value, writer.uint32(18).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ChildrenDefinition_NestedEntry {
    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 = createBaseChildrenDefinition_NestedEntry();
      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 = ChildrenDefinition.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): ChildrenDefinition_NestedEntry {
    return {
      key: isSet(object.key) ? globalThis.String(object.key) : "",
      value: isSet(object.value) ? ChildrenDefinition.fromJSON(object.value) : undefined,
    };
  },

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

  create(base?: DeepPartial<ChildrenDefinition_NestedEntry>): ChildrenDefinition_NestedEntry {
    return ChildrenDefinition_NestedEntry.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ChildrenDefinition_NestedEntry>): ChildrenDefinition_NestedEntry {
    const message = createBaseChildrenDefinition_NestedEntry();
    message.key = object.key ?? "";
    message.value = (object.value !== undefined && object.value !== null)
      ? ChildrenDefinition.fromPartial(object.value)
      : undefined;
    return message;
  },
};

function createBaseDraftReadModelDefinition(): DraftReadModelDefinition {
  return { ContainerName: "", Schema: "", Identifier: "", DisplayName: "" };
}

export const DraftReadModelDefinition: MessageFns<DraftReadModelDefinition> = {
  encode(message: DraftReadModelDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.ContainerName !== "") {
      writer.uint32(10).string(message.ContainerName);
    }
    if (message.Schema !== "") {
      writer.uint32(18).string(message.Schema);
    }
    if (message.Identifier !== "") {
      writer.uint32(26).string(message.Identifier);
    }
    if (message.DisplayName !== "") {
      writer.uint32(34).string(message.DisplayName);
    }
    return writer;
  },

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

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

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

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

            message.DisplayName = 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): DraftReadModelDefinition {
    return {
      ContainerName: isSet(object.ContainerName) ? globalThis.String(object.ContainerName) : "",
      Schema: isSet(object.Schema) ? globalThis.String(object.Schema) : "",
      Identifier: isSet(object.Identifier) ? globalThis.String(object.Identifier) : "",
      DisplayName: isSet(object.DisplayName) ? globalThis.String(object.DisplayName) : "",
    };
  },

  toJSON(message: DraftReadModelDefinition): unknown {
    const obj: any = {};
    if (message.ContainerName !== "") {
      obj.ContainerName = message.ContainerName;
    }
    if (message.Schema !== "") {
      obj.Schema = message.Schema;
    }
    if (message.Identifier !== "") {
      obj.Identifier = message.Identifier;
    }
    if (message.DisplayName !== "") {
      obj.DisplayName = message.DisplayName;
    }
    return obj;
  },

  create(base?: DeepPartial<DraftReadModelDefinition>): DraftReadModelDefinition {
    return DraftReadModelDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<DraftReadModelDefinition>): DraftReadModelDefinition {
    const message = createBaseDraftReadModelDefinition();
    message.ContainerName = object.ContainerName ?? "";
    message.Schema = object.Schema ?? "";
    message.Identifier = object.Identifier ?? "";
    message.DisplayName = object.DisplayName ?? "";
    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 createBaseFromDefinition(): FromDefinition {
  return { Properties: {}, Key: "", ParentKey: "" };
}

export const FromDefinition: MessageFns<FromDefinition> = {
  encode(message: FromDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    globalThis.Object.entries(message.Properties).forEach(([key, value]: [string, string]) => {
      FromDefinition_PropertiesEntry.encode({ key: key as any, value }, writer.uint32(10).fork()).join();
    });
    if (message.Key !== "") {
      writer.uint32(18).string(message.Key);
    }
    if (message.ParentKey !== "") {
      writer.uint32(26).string(message.ParentKey);
    }
    return writer;
  },

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

            const entry1 = FromDefinition_PropertiesEntry.decode(reader, reader.uint32());
            if (entry1.value !== undefined) {
              message.Properties[entry1.key] = entry1.value;
            }
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

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

            message.ParentKey = 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): FromDefinition {
    return {
      Properties: isObject(object.Properties)
        ? (globalThis.Object.entries(object.Properties) 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;
          },
          {},
        )
        : {},
      Key: isSet(object.Key) ? globalThis.String(object.Key) : "",
      ParentKey: isSet(object.ParentKey) ? globalThis.String(object.ParentKey) : "",
    };
  },

  toJSON(message: FromDefinition): unknown {
    const obj: any = {};
    if (message.Properties) {
      const entries = globalThis.Object.entries(message.Properties) as [string, string][];
      if (entries.length > 0) {
        obj.Properties = {};
        entries.forEach(([k, v]) => {
          obj.Properties[k] = v;
        });
      }
    }
    if (message.Key !== "") {
      obj.Key = message.Key;
    }
    if (message.ParentKey !== "") {
      obj.ParentKey = message.ParentKey;
    }
    return obj;
  },

  create(base?: DeepPartial<FromDefinition>): FromDefinition {
    return FromDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<FromDefinition>): FromDefinition {
    const message = createBaseFromDefinition();
    message.Properties = (globalThis.Object.entries(object.Properties ?? {}) as [string, string][]).reduce(
      (acc: { [key: string]: string }, [key, value]: [string, string]) => {
        if (value !== undefined) {
          acc[key] = globalThis.String(value);
        }
        return acc;
      },
      {},
    );
    message.Key = object.Key ?? "";
    message.ParentKey = object.ParentKey ?? "";
    return message;
  },
};

function createBaseFromDefinition_PropertiesEntry(): FromDefinition_PropertiesEntry {
  return { key: "", value: "" };
}

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

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

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

function createBaseFromDerivativesDefinition(): FromDerivativesDefinition {
  return { EventTypes: [], From: undefined };
}

export const FromDerivativesDefinition: MessageFns<FromDerivativesDefinition> = {
  encode(message: FromDerivativesDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.EventTypes) {
      EventType.encode(v!, writer.uint32(10).fork()).join();
    }
    if (message.From !== undefined) {
      FromDefinition.encode(message.From, writer.uint32(18).fork()).join();
    }
    return writer;
  },

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

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

            message.From = FromDefinition.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): FromDerivativesDefinition {
    return {
      EventTypes: globalThis.Array.isArray(object?.EventTypes)
        ? object.EventTypes.map((e: any) => EventType.fromJSON(e))
        : [],
      From: isSet(object.From) ? FromDefinition.fromJSON(object.From) : undefined,
    };
  },

  toJSON(message: FromDerivativesDefinition): unknown {
    const obj: any = {};
    if (message.EventTypes?.length) {
      obj.EventTypes = message.EventTypes.map((e) => EventType.toJSON(e));
    }
    if (message.From !== undefined) {
      obj.From = FromDefinition.toJSON(message.From);
    }
    return obj;
  },

  create(base?: DeepPartial<FromDerivativesDefinition>): FromDerivativesDefinition {
    return FromDerivativesDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<FromDerivativesDefinition>): FromDerivativesDefinition {
    const message = createBaseFromDerivativesDefinition();
    message.EventTypes = object.EventTypes?.map((e) => EventType.fromPartial(e)) || [];
    message.From = (object.From !== undefined && object.From !== null)
      ? FromDefinition.fromPartial(object.From)
      : undefined;
    return message;
  },
};

function createBaseFromEventPropertyDefinition(): FromEventPropertyDefinition {
  return { Event: undefined, PropertyExpression: "" };
}

export const FromEventPropertyDefinition: MessageFns<FromEventPropertyDefinition> = {
  encode(message: FromEventPropertyDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Event !== undefined) {
      EventType.encode(message.Event, writer.uint32(10).fork()).join();
    }
    if (message.PropertyExpression !== "") {
      writer.uint32(18).string(message.PropertyExpression);
    }
    return writer;
  },

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

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

            message.PropertyExpression = 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): FromEventPropertyDefinition {
    return {
      Event: isSet(object.Event) ? EventType.fromJSON(object.Event) : undefined,
      PropertyExpression: isSet(object.PropertyExpression) ? globalThis.String(object.PropertyExpression) : "",
    };
  },

  toJSON(message: FromEventPropertyDefinition): unknown {
    const obj: any = {};
    if (message.Event !== undefined) {
      obj.Event = EventType.toJSON(message.Event);
    }
    if (message.PropertyExpression !== "") {
      obj.PropertyExpression = message.PropertyExpression;
    }
    return obj;
  },

  create(base?: DeepPartial<FromEventPropertyDefinition>): FromEventPropertyDefinition {
    return FromEventPropertyDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<FromEventPropertyDefinition>): FromEventPropertyDefinition {
    const message = createBaseFromEventPropertyDefinition();
    message.Event = (object.Event !== undefined && object.Event !== null)
      ? EventType.fromPartial(object.Event)
      : undefined;
    message.PropertyExpression = object.PropertyExpression ?? "";
    return message;
  },
};

function createBaseFromEveryDefinition(): FromEveryDefinition {
  return { Properties: {}, IncludeChildren: false, AutoMap: 0 };
}

export const FromEveryDefinition: MessageFns<FromEveryDefinition> = {
  encode(message: FromEveryDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    globalThis.Object.entries(message.Properties).forEach(([key, value]: [string, string]) => {
      FromEveryDefinition_PropertiesEntry.encode({ key: key as any, value }, writer.uint32(10).fork()).join();
    });
    if (message.IncludeChildren !== false) {
      writer.uint32(16).bool(message.IncludeChildren);
    }
    if (message.AutoMap !== 0) {
      writer.uint32(24).int32(message.AutoMap);
    }
    return writer;
  },

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

            const entry1 = FromEveryDefinition_PropertiesEntry.decode(reader, reader.uint32());
            if (entry1.value !== undefined) {
              message.Properties[entry1.key] = entry1.value;
            }
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }

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

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

  fromJSON(object: any): FromEveryDefinition {
    return {
      Properties: isObject(object.Properties)
        ? (globalThis.Object.entries(object.Properties) 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;
          },
          {},
        )
        : {},
      IncludeChildren: isSet(object.IncludeChildren) ? globalThis.Boolean(object.IncludeChildren) : false,
      AutoMap: isSet(object.AutoMap) ? autoMapFromJSON(object.AutoMap) : 0,
    };
  },

  toJSON(message: FromEveryDefinition): unknown {
    const obj: any = {};
    if (message.Properties) {
      const entries = globalThis.Object.entries(message.Properties) as [string, string][];
      if (entries.length > 0) {
        obj.Properties = {};
        entries.forEach(([k, v]) => {
          obj.Properties[k] = v;
        });
      }
    }
    if (message.IncludeChildren !== false) {
      obj.IncludeChildren = message.IncludeChildren;
    }
    if (message.AutoMap !== 0) {
      obj.AutoMap = autoMapToJSON(message.AutoMap);
    }
    return obj;
  },

  create(base?: DeepPartial<FromEveryDefinition>): FromEveryDefinition {
    return FromEveryDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<FromEveryDefinition>): FromEveryDefinition {
    const message = createBaseFromEveryDefinition();
    message.Properties = (globalThis.Object.entries(object.Properties ?? {}) as [string, string][]).reduce(
      (acc: { [key: string]: string }, [key, value]: [string, string]) => {
        if (value !== undefined) {
          acc[key] = globalThis.String(value);
        }
        return acc;
      },
      {},
    );
    message.IncludeChildren = object.IncludeChildren ?? false;
    message.AutoMap = object.AutoMap ?? 0;
    return message;
  },
};

function createBaseFromEveryDefinition_PropertiesEntry(): FromEveryDefinition_PropertiesEntry {
  return { key: "", value: "" };
}

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

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

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

function createBaseGetAllDeclarationsRequest(): GetAllDeclarationsRequest {
  return { EventStore: "" };
}

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

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

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

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

function createBaseGetAllDefinitionsRequest(): GetAllDefinitionsRequest {
  return { EventStore: "" };
}

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

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

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

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

function createBaseIEnumerableProjectionDefinition(): IEnumerableProjectionDefinition {
  return { items: [] };
}

export const IEnumerableProjectionDefinition: MessageFns<IEnumerableProjectionDefinition> = {
  encode(message: IEnumerableProjectionDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.items) {
      ProjectionDefinition.encode(v!, writer.uint32(10).fork()).join();
    }
    return writer;
  },

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

            message.items.push(ProjectionDefinition.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): IEnumerableProjectionDefinition {
    return {
      items: globalThis.Array.isArray(object?.items)
        ? object.items.map((e: any) => ProjectionDefinition.fromJSON(e))
        : [],
    };
  },

  toJSON(message: IEnumerableProjectionDefinition): unknown {
    const obj: any = {};
    if (message.items?.length) {
      obj.items = message.items.map((e) => ProjectionDefinition.toJSON(e));
    }
    return obj;
  },

  create(base?: DeepPartial<IEnumerableProjectionDefinition>): IEnumerableProjectionDefinition {
    return IEnumerableProjectionDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<IEnumerableProjectionDefinition>): IEnumerableProjectionDefinition {
    const message = createBaseIEnumerableProjectionDefinition();
    message.items = object.items?.map((e) => ProjectionDefinition.fromPartial(e)) || [];
    return message;
  },
};

function createBaseIEnumerableProjectionWithDeclaration(): IEnumerableProjectionWithDeclaration {
  return { items: [] };
}

export const IEnumerableProjectionWithDeclaration: MessageFns<IEnumerableProjectionWithDeclaration> = {
  encode(message: IEnumerableProjectionWithDeclaration, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.items) {
      ProjectionWithDeclaration.encode(v!, writer.uint32(10).fork()).join();
    }
    return writer;
  },

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

            message.items.push(ProjectionWithDeclaration.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): IEnumerableProjectionWithDeclaration {
    return {
      items: globalThis.Array.isArray(object?.items)
        ? object.items.map((e: any) => ProjectionWithDeclaration.fromJSON(e))
        : [],
    };
  },

  toJSON(message: IEnumerableProjectionWithDeclaration): unknown {
    const obj: any = {};
    if (message.items?.length) {
      obj.items = message.items.map((e) => ProjectionWithDeclaration.toJSON(e));
    }
    return obj;
  },

  create(base?: DeepPartial<IEnumerableProjectionWithDeclaration>): IEnumerableProjectionWithDeclaration {
    return IEnumerableProjectionWithDeclaration.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<IEnumerableProjectionWithDeclaration>): IEnumerableProjectionWithDeclaration {
    const message = createBaseIEnumerableProjectionWithDeclaration();
    message.items = object.items?.map((e) => ProjectionWithDeclaration.fromPartial(e)) || [];
    return message;
  },
};

function createBaseIndexDefinition(): IndexDefinition {
  return { PropertyPath: "" };
}

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

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

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

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

  create(base?: DeepPartial<IndexDefinition>): IndexDefinition {
    return IndexDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<IndexDefinition>): IndexDefinition {
    const message = createBaseIndexDefinition();
    message.PropertyPath = object.PropertyPath ?? "";
    return message;
  },
};

function createBaseJoinDefinition(): JoinDefinition {
  return { On: "", Properties: {}, Key: "" };
}

export const JoinDefinition: MessageFns<JoinDefinition> = {
  encode(message: JoinDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.On !== "") {
      writer.uint32(10).string(message.On);
    }
    globalThis.Object.entries(message.Properties).forEach(([key, value]: [string, string]) => {
      JoinDefinition_PropertiesEntry.encode({ key: key as any, value }, writer.uint32(18).fork()).join();
    });
    if (message.Key !== "") {
      writer.uint32(26).string(message.Key);
    }
    return writer;
  },

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

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

            const entry2 = JoinDefinition_PropertiesEntry.decode(reader, reader.uint32());
            if (entry2.value !== undefined) {
              message.Properties[entry2.key] = entry2.value;
            }
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.Key = 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): JoinDefinition {
    return {
      On: isSet(object.On) ? globalThis.String(object.On) : "",
      Properties: isObject(object.Properties)
        ? (globalThis.Object.entries(object.Properties) 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;
          },
          {},
        )
        : {},
      Key: isSet(object.Key) ? globalThis.String(object.Key) : "",
    };
  },

  toJSON(message: JoinDefinition): unknown {
    const obj: any = {};
    if (message.On !== "") {
      obj.On = message.On;
    }
    if (message.Properties) {
      const entries = globalThis.Object.entries(message.Properties) as [string, string][];
      if (entries.length > 0) {
        obj.Properties = {};
        entries.forEach(([k, v]) => {
          obj.Properties[k] = v;
        });
      }
    }
    if (message.Key !== "") {
      obj.Key = message.Key;
    }
    return obj;
  },

  create(base?: DeepPartial<JoinDefinition>): JoinDefinition {
    return JoinDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<JoinDefinition>): JoinDefinition {
    const message = createBaseJoinDefinition();
    message.On = object.On ?? "";
    message.Properties = (globalThis.Object.entries(object.Properties ?? {}) as [string, string][]).reduce(
      (acc: { [key: string]: string }, [key, value]: [string, string]) => {
        if (value !== undefined) {
          acc[key] = globalThis.String(value);
        }
        return acc;
      },
      {},
    );
    message.Key = object.Key ?? "";
    return message;
  },
};

function createBaseJoinDefinition_PropertiesEntry(): JoinDefinition_PropertiesEntry {
  return { key: "", value: "" };
}

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

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

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

function createBaseKeyValuePairEventTypeFromDefinition(): KeyValuePairEventTypeFromDefinition {
  return { Key: undefined, Value: undefined };
}

export const KeyValuePairEventTypeFromDefinition: MessageFns<KeyValuePairEventTypeFromDefinition> = {
  encode(message: KeyValuePairEventTypeFromDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Key !== undefined) {
      EventType.encode(message.Key, writer.uint32(10).fork()).join();
    }
    if (message.Value !== undefined) {
      FromDefinition.encode(message.Value, writer.uint32(18).fork()).join();
    }
    return writer;
  },

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

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

            message.Value = FromDefinition.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): KeyValuePairEventTypeFromDefinition {
    return {
      Key: isSet(object.Key) ? EventType.fromJSON(object.Key) : undefined,
      Value: isSet(object.Value) ? FromDefinition.fromJSON(object.Value) : undefined,
    };
  },

  toJSON(message: KeyValuePairEventTypeFromDefinition): unknown {
    const obj: any = {};
    if (message.Key !== undefined) {
      obj.Key = EventType.toJSON(message.Key);
    }
    if (message.Value !== undefined) {
      obj.Value = FromDefinition.toJSON(message.Value);
    }
    return obj;
  },

  create(base?: DeepPartial<KeyValuePairEventTypeFromDefinition>): KeyValuePairEventTypeFromDefinition {
    return KeyValuePairEventTypeFromDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<KeyValuePairEventTypeFromDefinition>): KeyValuePairEventTypeFromDefinition {
    const message = createBaseKeyValuePairEventTypeFromDefinition();
    message.Key = (object.Key !== undefined && object.Key !== null) ? EventType.fromPartial(object.Key) : undefined;
    message.Value = (object.Value !== undefined && object.Value !== null)
      ? FromDefinition.fromPartial(object.Value)
      : undefined;
    return message;
  },
};

function createBaseKeyValuePairEventTypeJoinDefinition(): KeyValuePairEventTypeJoinDefinition {
  return { Key: undefined, Value: undefined };
}

export const KeyValuePairEventTypeJoinDefinition: MessageFns<KeyValuePairEventTypeJoinDefinition> = {
  encode(message: KeyValuePairEventTypeJoinDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Key !== undefined) {
      EventType.encode(message.Key, writer.uint32(10).fork()).join();
    }
    if (message.Value !== undefined) {
      JoinDefinition.encode(message.Value, writer.uint32(18).fork()).join();
    }
    return writer;
  },

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

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

            message.Value = JoinDefinition.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): KeyValuePairEventTypeJoinDefinition {
    return {
      Key: isSet(object.Key) ? EventType.fromJSON(object.Key) : undefined,
      Value: isSet(object.Value) ? JoinDefinition.fromJSON(object.Value) : undefined,
    };
  },

  toJSON(message: KeyValuePairEventTypeJoinDefinition): unknown {
    const obj: any = {};
    if (message.Key !== undefined) {
      obj.Key = EventType.toJSON(message.Key);
    }
    if (message.Value !== undefined) {
      obj.Value = JoinDefinition.toJSON(message.Value);
    }
    return obj;
  },

  create(base?: DeepPartial<KeyValuePairEventTypeJoinDefinition>): KeyValuePairEventTypeJoinDefinition {
    return KeyValuePairEventTypeJoinDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<KeyValuePairEventTypeJoinDefinition>): KeyValuePairEventTypeJoinDefinition {
    const message = createBaseKeyValuePairEventTypeJoinDefinition();
    message.Key = (object.Key !== undefined && object.Key !== null) ? EventType.fromPartial(object.Key) : undefined;
    message.Value = (object.Value !== undefined && object.Value !== null)
      ? JoinDefinition.fromPartial(object.Value)
      : undefined;
    return message;
  },
};

function createBaseKeyValuePairEventTypeRemovedWithDefinition(): KeyValuePairEventTypeRemovedWithDefinition {
  return { Key: undefined, Value: undefined };
}

export const KeyValuePairEventTypeRemovedWithDefinition: MessageFns<KeyValuePairEventTypeRemovedWithDefinition> = {
  encode(message: KeyValuePairEventTypeRemovedWithDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Key !== undefined) {
      EventType.encode(message.Key, writer.uint32(10).fork()).join();
    }
    if (message.Value !== undefined) {
      RemovedWithDefinition.encode(message.Value, writer.uint32(18).fork()).join();
    }
    return writer;
  },

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

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

            message.Value = RemovedWithDefinition.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): KeyValuePairEventTypeRemovedWithDefinition {
    return {
      Key: isSet(object.Key) ? EventType.fromJSON(object.Key) : undefined,
      Value: isSet(object.Value) ? RemovedWithDefinition.fromJSON(object.Value) : undefined,
    };
  },

  toJSON(message: KeyValuePairEventTypeRemovedWithDefinition): unknown {
    const obj: any = {};
    if (message.Key !== undefined) {
      obj.Key = EventType.toJSON(message.Key);
    }
    if (message.Value !== undefined) {
      obj.Value = RemovedWithDefinition.toJSON(message.Value);
    }
    return obj;
  },

  create(base?: DeepPartial<KeyValuePairEventTypeRemovedWithDefinition>): KeyValuePairEventTypeRemovedWithDefinition {
    return KeyValuePairEventTypeRemovedWithDefinition.fromPartial(base ?? {});
  },
  fromPartial(
    object: DeepPartial<KeyValuePairEventTypeRemovedWithDefinition>,
  ): KeyValuePairEventTypeRemovedWithDefinition {
    const message = createBaseKeyValuePairEventTypeRemovedWithDefinition();
    message.Key = (object.Key !== undefined && object.Key !== null) ? EventType.fromPartial(object.Key) : undefined;
    message.Value = (object.Value !== undefined && object.Value !== null)
      ? RemovedWithDefinition.fromPartial(object.Value)
      : undefined;
    return message;
  },
};

function createBaseKeyValuePairEventTypeRemovedWithJoinDefinition(): KeyValuePairEventTypeRemovedWithJoinDefinition {
  return { Key: undefined, Value: undefined };
}

export const KeyValuePairEventTypeRemovedWithJoinDefinition: MessageFns<
  KeyValuePairEventTypeRemovedWithJoinDefinition
> = {
  encode(
    message: KeyValuePairEventTypeRemovedWithJoinDefinition,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.Key !== undefined) {
      EventType.encode(message.Key, writer.uint32(10).fork()).join();
    }
    if (message.Value !== undefined) {
      RemovedWithJoinDefinition.encode(message.Value, writer.uint32(18).fork()).join();
    }
    return writer;
  },

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

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

            message.Value = RemovedWithJoinDefinition.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): KeyValuePairEventTypeRemovedWithJoinDefinition {
    return {
      Key: isSet(object.Key) ? EventType.fromJSON(object.Key) : undefined,
      Value: isSet(object.Value) ? RemovedWithJoinDefinition.fromJSON(object.Value) : undefined,
    };
  },

  toJSON(message: KeyValuePairEventTypeRemovedWithJoinDefinition): unknown {
    const obj: any = {};
    if (message.Key !== undefined) {
      obj.Key = EventType.toJSON(message.Key);
    }
    if (message.Value !== undefined) {
      obj.Value = RemovedWithJoinDefinition.toJSON(message.Value);
    }
    return obj;
  },

  create(
    base?: DeepPartial<KeyValuePairEventTypeRemovedWithJoinDefinition>,
  ): KeyValuePairEventTypeRemovedWithJoinDefinition {
    return KeyValuePairEventTypeRemovedWithJoinDefinition.fromPartial(base ?? {});
  },
  fromPartial(
    object: DeepPartial<KeyValuePairEventTypeRemovedWithJoinDefinition>,
  ): KeyValuePairEventTypeRemovedWithJoinDefinition {
    const message = createBaseKeyValuePairEventTypeRemovedWithJoinDefinition();
    message.Key = (object.Key !== undefined && object.Key !== null) ? EventType.fromPartial(object.Key) : undefined;
    message.Value = (object.Value !== undefined && object.Value !== null)
      ? RemovedWithJoinDefinition.fromPartial(object.Value)
      : undefined;
    return message;
  },
};

function createBaseOneOfProjectionPreviewProjectionDeclarationParsingErrors(): OneOfProjectionPreviewProjectionDeclarationParsingErrors {
  return { Value0: undefined, Value1: undefined };
}

export const OneOfProjectionPreviewProjectionDeclarationParsingErrors: MessageFns<
  OneOfProjectionPreviewProjectionDeclarationParsingErrors
> = {
  encode(
    message: OneOfProjectionPreviewProjectionDeclarationParsingErrors,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.Value0 !== undefined) {
      ProjectionPreview.encode(message.Value0, writer.uint32(10).fork()).join();
    }
    if (message.Value1 !== undefined) {
      ProjectionDeclarationParsingErrors.encode(message.Value1, writer.uint32(18).fork()).join();
    }
    return writer;
  },

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

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

            message.Value1 = ProjectionDeclarationParsingErrors.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): OneOfProjectionPreviewProjectionDeclarationParsingErrors {
    return {
      Value0: isSet(object.Value0) ? ProjectionPreview.fromJSON(object.Value0) : undefined,
      Value1: isSet(object.Value1) ? ProjectionDeclarationParsingErrors.fromJSON(object.Value1) : undefined,
    };
  },

  toJSON(message: OneOfProjectionPreviewProjectionDeclarationParsingErrors): unknown {
    const obj: any = {};
    if (message.Value0 !== undefined) {
      obj.Value0 = ProjectionPreview.toJSON(message.Value0);
    }
    if (message.Value1 !== undefined) {
      obj.Value1 = ProjectionDeclarationParsingErrors.toJSON(message.Value1);
    }
    return obj;
  },

  create(
    base?: DeepPartial<OneOfProjectionPreviewProjectionDeclarationParsingErrors>,
  ): OneOfProjectionPreviewProjectionDeclarationParsingErrors {
    return OneOfProjectionPreviewProjectionDeclarationParsingErrors.fromPartial(base ?? {});
  },
  fromPartial(
    object: DeepPartial<OneOfProjectionPreviewProjectionDeclarationParsingErrors>,
  ): OneOfProjectionPreviewProjectionDeclarationParsingErrors {
    const message = createBaseOneOfProjectionPreviewProjectionDeclarationParsingErrors();
    message.Value0 = (object.Value0 !== undefined && object.Value0 !== null)
      ? ProjectionPreview.fromPartial(object.Value0)
      : undefined;
    message.Value1 = (object.Value1 !== undefined && object.Value1 !== null)
      ? ProjectionDeclarationParsingErrors.fromPartial(object.Value1)
      : undefined;
    return message;
  },
};

function createBasePreviewProjectionRequest(): PreviewProjectionRequest {
  return { EventStore: "", Namespace: "", EventSequenceId: "", Declaration: "", DraftReadModel: undefined };
}

export const PreviewProjectionRequest: MessageFns<PreviewProjectionRequest> = {
  encode(message: PreviewProjectionRequest, 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.EventSequenceId !== "") {
      writer.uint32(26).string(message.EventSequenceId);
    }
    if (message.Declaration !== "") {
      writer.uint32(34).string(message.Declaration);
    }
    if (message.DraftReadModel !== undefined) {
      DraftReadModelDefinition.encode(message.DraftReadModel, writer.uint32(42).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): PreviewProjectionRequest {
    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 = createBasePreviewProjectionRequest();
      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.EventSequenceId = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }

            message.Declaration = reader.string();
            continue;
          }
          case 5: {
            if (tag !== 42) {
              break;
            }

            message.DraftReadModel = DraftReadModelDefinition.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): PreviewProjectionRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
      Declaration: isSet(object.Declaration) ? globalThis.String(object.Declaration) : "",
      DraftReadModel: isSet(object.DraftReadModel)
        ? DraftReadModelDefinition.fromJSON(object.DraftReadModel)
        : undefined,
    };
  },

  toJSON(message: PreviewProjectionRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Namespace !== "") {
      obj.Namespace = message.Namespace;
    }
    if (message.EventSequenceId !== "") {
      obj.EventSequenceId = message.EventSequenceId;
    }
    if (message.Declaration !== "") {
      obj.Declaration = message.Declaration;
    }
    if (message.DraftReadModel !== undefined) {
      obj.DraftReadModel = DraftReadModelDefinition.toJSON(message.DraftReadModel);
    }
    return obj;
  },

  create(base?: DeepPartial<PreviewProjectionRequest>): PreviewProjectionRequest {
    return PreviewProjectionRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<PreviewProjectionRequest>): PreviewProjectionRequest {
    const message = createBasePreviewProjectionRequest();
    message.EventStore = object.EventStore ?? "";
    message.Namespace = object.Namespace ?? "";
    message.EventSequenceId = object.EventSequenceId ?? "";
    message.Declaration = object.Declaration ?? "";
    message.DraftReadModel = (object.DraftReadModel !== undefined && object.DraftReadModel !== null)
      ? DraftReadModelDefinition.fromPartial(object.DraftReadModel)
      : undefined;
    return message;
  },
};

function createBaseProjectionDeclarationParsingErrors(): ProjectionDeclarationParsingErrors {
  return { Errors: [] };
}

export const ProjectionDeclarationParsingErrors: MessageFns<ProjectionDeclarationParsingErrors> = {
  encode(message: ProjectionDeclarationParsingErrors, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.Errors) {
      ProjectionDeclarationSyntaxError.encode(v!, writer.uint32(10).fork()).join();
    }
    return writer;
  },

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

            message.Errors.push(ProjectionDeclarationSyntaxError.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): ProjectionDeclarationParsingErrors {
    return {
      Errors: globalThis.Array.isArray(object?.Errors)
        ? object.Errors.map((e: any) => ProjectionDeclarationSyntaxError.fromJSON(e))
        : [],
    };
  },

  toJSON(message: ProjectionDeclarationParsingErrors): unknown {
    const obj: any = {};
    if (message.Errors?.length) {
      obj.Errors = message.Errors.map((e) => ProjectionDeclarationSyntaxError.toJSON(e));
    }
    return obj;
  },

  create(base?: DeepPartial<ProjectionDeclarationParsingErrors>): ProjectionDeclarationParsingErrors {
    return ProjectionDeclarationParsingErrors.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ProjectionDeclarationParsingErrors>): ProjectionDeclarationParsingErrors {
    const message = createBaseProjectionDeclarationParsingErrors();
    message.Errors = object.Errors?.map((e) => ProjectionDeclarationSyntaxError.fromPartial(e)) || [];
    return message;
  },
};

function createBaseProjectionDeclarationSyntaxError(): ProjectionDeclarationSyntaxError {
  return { Message: "", Line: 0, Column: 0 };
}

export const ProjectionDeclarationSyntaxError: MessageFns<ProjectionDeclarationSyntaxError> = {
  encode(message: ProjectionDeclarationSyntaxError, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Message !== "") {
      writer.uint32(10).string(message.Message);
    }
    if (message.Line !== 0) {
      writer.uint32(16).int32(message.Line);
    }
    if (message.Column !== 0) {
      writer.uint32(24).int32(message.Column);
    }
    return writer;
  },

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

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

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

            message.Column = 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): ProjectionDeclarationSyntaxError {
    return {
      Message: isSet(object.Message) ? globalThis.String(object.Message) : "",
      Line: isSet(object.Line) ? globalThis.Number(object.Line) : 0,
      Column: isSet(object.Column) ? globalThis.Number(object.Column) : 0,
    };
  },

  toJSON(message: ProjectionDeclarationSyntaxError): unknown {
    const obj: any = {};
    if (message.Message !== "") {
      obj.Message = message.Message;
    }
    if (message.Line !== 0) {
      obj.Line = Math.round(message.Line);
    }
    if (message.Column !== 0) {
      obj.Column = Math.round(message.Column);
    }
    return obj;
  },

  create(base?: DeepPartial<ProjectionDeclarationSyntaxError>): ProjectionDeclarationSyntaxError {
    return ProjectionDeclarationSyntaxError.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ProjectionDeclarationSyntaxError>): ProjectionDeclarationSyntaxError {
    const message = createBaseProjectionDeclarationSyntaxError();
    message.Message = object.Message ?? "";
    message.Line = object.Line ?? 0;
    message.Column = object.Column ?? 0;
    return message;
  },
};

function createBaseProjectionDefinition(): ProjectionDefinition {
  return {
    EventSequenceId: "",
    Identifier: "",
    ReadModel: "",
    IsActive: false,
    IsRewindable: false,
    InitialModelState: "",
    From: [],
    Join: [],
    Children: {},
    FromEvery: [],
    All: undefined,
    FromEventProperty: undefined,
    RemovedWith: [],
    RemovedWithJoin: [],
    LastUpdated: undefined,
    Tags: [],
    AutoMap: 0,
    Nested: {},
    SubscribesToAllEvents: false,
    NoAutoMapProperties: [],
  };
}

export const ProjectionDefinition: MessageFns<ProjectionDefinition> = {
  encode(message: ProjectionDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventSequenceId !== "") {
      writer.uint32(10).string(message.EventSequenceId);
    }
    if (message.Identifier !== "") {
      writer.uint32(18).string(message.Identifier);
    }
    if (message.ReadModel !== "") {
      writer.uint32(26).string(message.ReadModel);
    }
    if (message.IsActive !== false) {
      writer.uint32(32).bool(message.IsActive);
    }
    if (message.IsRewindable !== false) {
      writer.uint32(40).bool(message.IsRewindable);
    }
    if (message.InitialModelState !== "") {
      writer.uint32(50).string(message.InitialModelState);
    }
    for (const v of message.From) {
      KeyValuePairEventTypeFromDefinition.encode(v!, writer.uint32(58).fork()).join();
    }
    for (const v of message.Join) {
      KeyValuePairEventTypeJoinDefinition.encode(v!, writer.uint32(66).fork()).join();
    }
    globalThis.Object.entries(message.Children).forEach(([key, value]: [string, ChildrenDefinition]) => {
      ProjectionDefinition_ChildrenEntry.encode({ key: key as any, value }, writer.uint32(74).fork()).join();
    });
    for (const v of message.FromEvery) {
      FromDerivativesDefinition.encode(v!, writer.uint32(82).fork()).join();
    }
    if (message.All !== undefined) {
      FromEveryDefinition.encode(message.All, writer.uint32(90).fork()).join();
    }
    if (message.FromEventProperty !== undefined) {
      FromEventPropertyDefinition.encode(message.FromEventProperty, writer.uint32(98).fork()).join();
    }
    for (const v of message.RemovedWith) {
      KeyValuePairEventTypeRemovedWithDefinition.encode(v!, writer.uint32(106).fork()).join();
    }
    for (const v of message.RemovedWithJoin) {
      KeyValuePairEventTypeRemovedWithJoinDefinition.encode(v!, writer.uint32(114).fork()).join();
    }
    if (message.LastUpdated !== undefined) {
      SerializableDateTimeOffset.encode(message.LastUpdated, writer.uint32(122).fork()).join();
    }
    for (const v of message.Tags) {
      writer.uint32(130).string(v!);
    }
    if (message.AutoMap !== 0) {
      writer.uint32(136).int32(message.AutoMap);
    }
    globalThis.Object.entries(message.Nested).forEach(([key, value]: [string, ChildrenDefinition]) => {
      ProjectionDefinition_NestedEntry.encode({ key: key as any, value }, writer.uint32(146).fork()).join();
    });
    if (message.SubscribesToAllEvents !== false) {
      writer.uint32(152).bool(message.SubscribesToAllEvents);
    }
    for (const v of message.NoAutoMapProperties) {
      writer.uint32(162).string(v!);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ProjectionDefinition {
    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 = createBaseProjectionDefinition();
      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.ReadModel = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }

            message.IsActive = reader.bool();
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }

            message.IsRewindable = reader.bool();
            continue;
          }
          case 6: {
            if (tag !== 50) {
              break;
            }

            message.InitialModelState = reader.string();
            continue;
          }
          case 7: {
            if (tag !== 58) {
              break;
            }

            message.From.push(KeyValuePairEventTypeFromDefinition.decode(reader, reader.uint32()));
            continue;
          }
          case 8: {
            if (tag !== 66) {
              break;
            }

            message.Join.push(KeyValuePairEventTypeJoinDefinition.decode(reader, reader.uint32()));
            continue;
          }
          case 9: {
            if (tag !== 74) {
              break;
            }

            const entry9 = ProjectionDefinition_ChildrenEntry.decode(reader, reader.uint32());
            if (entry9.value !== undefined) {
              message.Children[entry9.key] = entry9.value;
            }
            continue;
          }
          case 10: {
            if (tag !== 82) {
              break;
            }

            message.FromEvery.push(FromDerivativesDefinition.decode(reader, reader.uint32()));
            continue;
          }
          case 11: {
            if (tag !== 90) {
              break;
            }

            message.All = FromEveryDefinition.decode(reader, reader.uint32());
            continue;
          }
          case 12: {
            if (tag !== 98) {
              break;
            }

            message.FromEventProperty = FromEventPropertyDefinition.decode(reader, reader.uint32());
            continue;
          }
          case 13: {
            if (tag !== 106) {
              break;
            }

            message.RemovedWith.push(KeyValuePairEventTypeRemovedWithDefinition.decode(reader, reader.uint32()));
            continue;
          }
          case 14: {
            if (tag !== 114) {
              break;
            }

            message.RemovedWithJoin.push(
              KeyValuePairEventTypeRemovedWithJoinDefinition.decode(reader, reader.uint32()),
            );
            continue;
          }
          case 15: {
            if (tag !== 122) {
              break;
            }

            message.LastUpdated = SerializableDateTimeOffset.decode(reader, reader.uint32());
            continue;
          }
          case 16: {
            if (tag !== 130) {
              break;
            }

            message.Tags.push(reader.string());
            continue;
          }
          case 17: {
            if (tag !== 136) {
              break;
            }

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

            const entry18 = ProjectionDefinition_NestedEntry.decode(reader, reader.uint32());
            if (entry18.value !== undefined) {
              message.Nested[entry18.key] = entry18.value;
            }
            continue;
          }
          case 19: {
            if (tag !== 152) {
              break;
            }

            message.SubscribesToAllEvents = reader.bool();
            continue;
          }
          case 20: {
            if (tag !== 162) {
              break;
            }

            message.NoAutoMapProperties.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): ProjectionDefinition {
    return {
      EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
      Identifier: isSet(object.Identifier) ? globalThis.String(object.Identifier) : "",
      ReadModel: isSet(object.ReadModel) ? globalThis.String(object.ReadModel) : "",
      IsActive: isSet(object.IsActive) ? globalThis.Boolean(object.IsActive) : false,
      IsRewindable: isSet(object.IsRewindable) ? globalThis.Boolean(object.IsRewindable) : false,
      InitialModelState: isSet(object.InitialModelState) ? globalThis.String(object.InitialModelState) : "",
      From: globalThis.Array.isArray(object?.From)
        ? object.From.map((e: any) => KeyValuePairEventTypeFromDefinition.fromJSON(e))
        : [],
      Join: globalThis.Array.isArray(object?.Join)
        ? object.Join.map((e: any) => KeyValuePairEventTypeJoinDefinition.fromJSON(e))
        : [],
      Children: isObject(object.Children)
        ? (globalThis.Object.entries(object.Children) as [string, any][]).reduce(
          (acc: { [key: string]: ChildrenDefinition }, [key, value]: [string, any]) => {
            globalThis.Object.defineProperty(acc, key, {
              value: ChildrenDefinition.fromJSON(value),
              enumerable: true,
              configurable: true,
              writable: true,
            });
            return acc;
          },
          {},
        )
        : {},
      FromEvery: globalThis.Array.isArray(object?.FromEvery)
        ? object.FromEvery.map((e: any) => FromDerivativesDefinition.fromJSON(e))
        : [],
      All: isSet(object.All) ? FromEveryDefinition.fromJSON(object.All) : undefined,
      FromEventProperty: isSet(object.FromEventProperty)
        ? FromEventPropertyDefinition.fromJSON(object.FromEventProperty)
        : undefined,
      RemovedWith: globalThis.Array.isArray(object?.RemovedWith)
        ? object.RemovedWith.map((e: any) => KeyValuePairEventTypeRemovedWithDefinition.fromJSON(e))
        : [],
      RemovedWithJoin: globalThis.Array.isArray(object?.RemovedWithJoin)
        ? object.RemovedWithJoin.map((e: any) => KeyValuePairEventTypeRemovedWithJoinDefinition.fromJSON(e))
        : [],
      LastUpdated: isSet(object.LastUpdated) ? SerializableDateTimeOffset.fromJSON(object.LastUpdated) : undefined,
      Tags: globalThis.Array.isArray(object?.Tags) ? object.Tags.map((e: any) => globalThis.String(e)) : [],
      AutoMap: isSet(object.AutoMap) ? autoMapFromJSON(object.AutoMap) : 0,
      Nested: isObject(object.Nested)
        ? (globalThis.Object.entries(object.Nested) as [string, any][]).reduce(
          (acc: { [key: string]: ChildrenDefinition }, [key, value]: [string, any]) => {
            globalThis.Object.defineProperty(acc, key, {
              value: ChildrenDefinition.fromJSON(value),
              enumerable: true,
              configurable: true,
              writable: true,
            });
            return acc;
          },
          {},
        )
        : {},
      SubscribesToAllEvents: isSet(object.SubscribesToAllEvents)
        ? globalThis.Boolean(object.SubscribesToAllEvents)
        : false,
      NoAutoMapProperties: globalThis.Array.isArray(object?.NoAutoMapProperties)
        ? object.NoAutoMapProperties.map((e: any) => globalThis.String(e))
        : [],
    };
  },

  toJSON(message: ProjectionDefinition): unknown {
    const obj: any = {};
    if (message.EventSequenceId !== "") {
      obj.EventSequenceId = message.EventSequenceId;
    }
    if (message.Identifier !== "") {
      obj.Identifier = message.Identifier;
    }
    if (message.ReadModel !== "") {
      obj.ReadModel = message.ReadModel;
    }
    if (message.IsActive !== false) {
      obj.IsActive = message.IsActive;
    }
    if (message.IsRewindable !== false) {
      obj.IsRewindable = message.IsRewindable;
    }
    if (message.InitialModelState !== "") {
      obj.InitialModelState = message.InitialModelState;
    }
    if (message.From?.length) {
      obj.From = message.From.map((e) => KeyValuePairEventTypeFromDefinition.toJSON(e));
    }
    if (message.Join?.length) {
      obj.Join = message.Join.map((e) => KeyValuePairEventTypeJoinDefinition.toJSON(e));
    }
    if (message.Children) {
      const entries = globalThis.Object.entries(message.Children) as [string, ChildrenDefinition][];
      if (entries.length > 0) {
        obj.Children = {};
        entries.forEach(([k, v]) => {
          obj.Children[k] = ChildrenDefinition.toJSON(v);
        });
      }
    }
    if (message.FromEvery?.length) {
      obj.FromEvery = message.FromEvery.map((e) => FromDerivativesDefinition.toJSON(e));
    }
    if (message.All !== undefined) {
      obj.All = FromEveryDefinition.toJSON(message.All);
    }
    if (message.FromEventProperty !== undefined) {
      obj.FromEventProperty = FromEventPropertyDefinition.toJSON(message.FromEventProperty);
    }
    if (message.RemovedWith?.length) {
      obj.RemovedWith = message.RemovedWith.map((e) => KeyValuePairEventTypeRemovedWithDefinition.toJSON(e));
    }
    if (message.RemovedWithJoin?.length) {
      obj.RemovedWithJoin = message.RemovedWithJoin.map((e) =>
        KeyValuePairEventTypeRemovedWithJoinDefinition.toJSON(e)
      );
    }
    if (message.LastUpdated !== undefined) {
      obj.LastUpdated = SerializableDateTimeOffset.toJSON(message.LastUpdated);
    }
    if (message.Tags?.length) {
      obj.Tags = message.Tags;
    }
    if (message.AutoMap !== 0) {
      obj.AutoMap = autoMapToJSON(message.AutoMap);
    }
    if (message.Nested) {
      const entries = globalThis.Object.entries(message.Nested) as [string, ChildrenDefinition][];
      if (entries.length > 0) {
        obj.Nested = {};
        entries.forEach(([k, v]) => {
          obj.Nested[k] = ChildrenDefinition.toJSON(v);
        });
      }
    }
    if (message.SubscribesToAllEvents !== false) {
      obj.SubscribesToAllEvents = message.SubscribesToAllEvents;
    }
    if (message.NoAutoMapProperties?.length) {
      obj.NoAutoMapProperties = message.NoAutoMapProperties;
    }
    return obj;
  },

  create(base?: DeepPartial<ProjectionDefinition>): ProjectionDefinition {
    return ProjectionDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ProjectionDefinition>): ProjectionDefinition {
    const message = createBaseProjectionDefinition();
    message.EventSequenceId = object.EventSequenceId ?? "";
    message.Identifier = object.Identifier ?? "";
    message.ReadModel = object.ReadModel ?? "";
    message.IsActive = object.IsActive ?? false;
    message.IsRewindable = object.IsRewindable ?? false;
    message.InitialModelState = object.InitialModelState ?? "";
    message.From = object.From?.map((e) => KeyValuePairEventTypeFromDefinition.fromPartial(e)) || [];
    message.Join = object.Join?.map((e) => KeyValuePairEventTypeJoinDefinition.fromPartial(e)) || [];
    message.Children = (globalThis.Object.entries(object.Children ?? {}) as [string, ChildrenDefinition][]).reduce(
      (acc: { [key: string]: ChildrenDefinition }, [key, value]: [string, ChildrenDefinition]) => {
        if (value !== undefined) {
          acc[key] = ChildrenDefinition.fromPartial(value);
        }
        return acc;
      },
      {},
    );
    message.FromEvery = object.FromEvery?.map((e) => FromDerivativesDefinition.fromPartial(e)) || [];
    message.All = (object.All !== undefined && object.All !== null)
      ? FromEveryDefinition.fromPartial(object.All)
      : undefined;
    message.FromEventProperty = (object.FromEventProperty !== undefined && object.FromEventProperty !== null)
      ? FromEventPropertyDefinition.fromPartial(object.FromEventProperty)
      : undefined;
    message.RemovedWith = object.RemovedWith?.map((e) => KeyValuePairEventTypeRemovedWithDefinition.fromPartial(e)) ||
      [];
    message.RemovedWithJoin =
      object.RemovedWithJoin?.map((e) => KeyValuePairEventTypeRemovedWithJoinDefinition.fromPartial(e)) || [];
    message.LastUpdated = (object.LastUpdated !== undefined && object.LastUpdated !== null)
      ? SerializableDateTimeOffset.fromPartial(object.LastUpdated)
      : undefined;
    message.Tags = object.Tags?.map((e) => e) || [];
    message.AutoMap = object.AutoMap ?? 0;
    message.Nested = (globalThis.Object.entries(object.Nested ?? {}) as [string, ChildrenDefinition][]).reduce(
      (acc: { [key: string]: ChildrenDefinition }, [key, value]: [string, ChildrenDefinition]) => {
        if (value !== undefined) {
          acc[key] = ChildrenDefinition.fromPartial(value);
        }
        return acc;
      },
      {},
    );
    message.SubscribesToAllEvents = object.SubscribesToAllEvents ?? false;
    message.NoAutoMapProperties = object.NoAutoMapProperties?.map((e) => e) || [];
    return message;
  },
};

function createBaseProjectionDefinition_ChildrenEntry(): ProjectionDefinition_ChildrenEntry {
  return { key: "", value: undefined };
}

export const ProjectionDefinition_ChildrenEntry: MessageFns<ProjectionDefinition_ChildrenEntry> = {
  encode(message: ProjectionDefinition_ChildrenEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.key !== "") {
      writer.uint32(10).string(message.key);
    }
    if (message.value !== undefined) {
      ChildrenDefinition.encode(message.value, writer.uint32(18).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ProjectionDefinition_ChildrenEntry {
    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 = createBaseProjectionDefinition_ChildrenEntry();
      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 = ChildrenDefinition.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): ProjectionDefinition_ChildrenEntry {
    return {
      key: isSet(object.key) ? globalThis.String(object.key) : "",
      value: isSet(object.value) ? ChildrenDefinition.fromJSON(object.value) : undefined,
    };
  },

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

  create(base?: DeepPartial<ProjectionDefinition_ChildrenEntry>): ProjectionDefinition_ChildrenEntry {
    return ProjectionDefinition_ChildrenEntry.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ProjectionDefinition_ChildrenEntry>): ProjectionDefinition_ChildrenEntry {
    const message = createBaseProjectionDefinition_ChildrenEntry();
    message.key = object.key ?? "";
    message.value = (object.value !== undefined && object.value !== null)
      ? ChildrenDefinition.fromPartial(object.value)
      : undefined;
    return message;
  },
};

function createBaseProjectionDefinition_NestedEntry(): ProjectionDefinition_NestedEntry {
  return { key: "", value: undefined };
}

export const ProjectionDefinition_NestedEntry: MessageFns<ProjectionDefinition_NestedEntry> = {
  encode(message: ProjectionDefinition_NestedEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.key !== "") {
      writer.uint32(10).string(message.key);
    }
    if (message.value !== undefined) {
      ChildrenDefinition.encode(message.value, writer.uint32(18).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ProjectionDefinition_NestedEntry {
    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 = createBaseProjectionDefinition_NestedEntry();
      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 = ChildrenDefinition.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): ProjectionDefinition_NestedEntry {
    return {
      key: isSet(object.key) ? globalThis.String(object.key) : "",
      value: isSet(object.value) ? ChildrenDefinition.fromJSON(object.value) : undefined,
    };
  },

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

  create(base?: DeepPartial<ProjectionDefinition_NestedEntry>): ProjectionDefinition_NestedEntry {
    return ProjectionDefinition_NestedEntry.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ProjectionDefinition_NestedEntry>): ProjectionDefinition_NestedEntry {
    const message = createBaseProjectionDefinition_NestedEntry();
    message.key = object.key ?? "";
    message.value = (object.value !== undefined && object.value !== null)
      ? ChildrenDefinition.fromPartial(object.value)
      : undefined;
    return message;
  },
};

function createBaseProjectionPreview(): ProjectionPreview {
  return { ReadModelEntries: [], ReadModel: undefined };
}

export const ProjectionPreview: MessageFns<ProjectionPreview> = {
  encode(message: ProjectionPreview, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.ReadModelEntries) {
      writer.uint32(10).string(v!);
    }
    if (message.ReadModel !== undefined) {
      ReadModelDefinition.encode(message.ReadModel, writer.uint32(18).fork()).join();
    }
    return writer;
  },

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

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

            message.ReadModel = ReadModelDefinition.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): ProjectionPreview {
    return {
      ReadModelEntries: globalThis.Array.isArray(object?.ReadModelEntries)
        ? object.ReadModelEntries.map((e: any) => globalThis.String(e))
        : [],
      ReadModel: isSet(object.ReadModel) ? ReadModelDefinition.fromJSON(object.ReadModel) : undefined,
    };
  },

  toJSON(message: ProjectionPreview): unknown {
    const obj: any = {};
    if (message.ReadModelEntries?.length) {
      obj.ReadModelEntries = message.ReadModelEntries;
    }
    if (message.ReadModel !== undefined) {
      obj.ReadModel = ReadModelDefinition.toJSON(message.ReadModel);
    }
    return obj;
  },

  create(base?: DeepPartial<ProjectionPreview>): ProjectionPreview {
    return ProjectionPreview.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ProjectionPreview>): ProjectionPreview {
    const message = createBaseProjectionPreview();
    message.ReadModelEntries = object.ReadModelEntries?.map((e) => e) || [];
    message.ReadModel = (object.ReadModel !== undefined && object.ReadModel !== null)
      ? ReadModelDefinition.fromPartial(object.ReadModel)
      : undefined;
    return message;
  },
};

function createBaseProjectionWithDeclaration(): ProjectionWithDeclaration {
  return { Identifier: "", ContainerName: "", Declaration: "" };
}

export const ProjectionWithDeclaration: MessageFns<ProjectionWithDeclaration> = {
  encode(message: ProjectionWithDeclaration, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Identifier !== "") {
      writer.uint32(10).string(message.Identifier);
    }
    if (message.ContainerName !== "") {
      writer.uint32(18).string(message.ContainerName);
    }
    if (message.Declaration !== "") {
      writer.uint32(26).string(message.Declaration);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): ProjectionWithDeclaration {
    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 = createBaseProjectionWithDeclaration();
      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.ContainerName = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.Declaration = 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): ProjectionWithDeclaration {
    return {
      Identifier: isSet(object.Identifier) ? globalThis.String(object.Identifier) : "",
      ContainerName: isSet(object.ContainerName) ? globalThis.String(object.ContainerName) : "",
      Declaration: isSet(object.Declaration) ? globalThis.String(object.Declaration) : "",
    };
  },

  toJSON(message: ProjectionWithDeclaration): unknown {
    const obj: any = {};
    if (message.Identifier !== "") {
      obj.Identifier = message.Identifier;
    }
    if (message.ContainerName !== "") {
      obj.ContainerName = message.ContainerName;
    }
    if (message.Declaration !== "") {
      obj.Declaration = message.Declaration;
    }
    return obj;
  },

  create(base?: DeepPartial<ProjectionWithDeclaration>): ProjectionWithDeclaration {
    return ProjectionWithDeclaration.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ProjectionWithDeclaration>): ProjectionWithDeclaration {
    const message = createBaseProjectionWithDeclaration();
    message.Identifier = object.Identifier ?? "";
    message.ContainerName = object.ContainerName ?? "";
    message.Declaration = object.Declaration ?? "";
    return message;
  },
};

function createBaseReadModelDefinition(): ReadModelDefinition {
  return {
    Type: undefined,
    ContainerName: "",
    DisplayName: "",
    Sink: undefined,
    Schema: "",
    Indexes: [],
    ObserverType: 0,
    ObserverIdentifier: "",
    Owner: 0,
    Source: 0,
  };
}

export const ReadModelDefinition: MessageFns<ReadModelDefinition> = {
  encode(message: ReadModelDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Type !== undefined) {
      ReadModelType.encode(message.Type, writer.uint32(10).fork()).join();
    }
    if (message.ContainerName !== "") {
      writer.uint32(18).string(message.ContainerName);
    }
    if (message.DisplayName !== "") {
      writer.uint32(26).string(message.DisplayName);
    }
    if (message.Sink !== undefined) {
      SinkDefinition.encode(message.Sink, writer.uint32(34).fork()).join();
    }
    if (message.Schema !== "") {
      writer.uint32(42).string(message.Schema);
    }
    for (const v of message.Indexes) {
      IndexDefinition.encode(v!, writer.uint32(50).fork()).join();
    }
    if (message.ObserverType !== 0) {
      writer.uint32(56).int32(message.ObserverType);
    }
    if (message.ObserverIdentifier !== "") {
      writer.uint32(66).string(message.ObserverIdentifier);
    }
    if (message.Owner !== 0) {
      writer.uint32(72).int32(message.Owner);
    }
    if (message.Source !== 0) {
      writer.uint32(80).int32(message.Source);
    }
    return writer;
  },

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

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

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

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

            message.Sink = SinkDefinition.decode(reader, reader.uint32());
            continue;
          }
          case 5: {
            if (tag !== 42) {
              break;
            }

            message.Schema = reader.string();
            continue;
          }
          case 6: {
            if (tag !== 50) {
              break;
            }

            message.Indexes.push(IndexDefinition.decode(reader, reader.uint32()));
            continue;
          }
          case 7: {
            if (tag !== 56) {
              break;
            }

            message.ObserverType = reader.int32() as any;
            continue;
          }
          case 8: {
            if (tag !== 66) {
              break;
            }

            message.ObserverIdentifier = reader.string();
            continue;
          }
          case 9: {
            if (tag !== 72) {
              break;
            }

            message.Owner = reader.int32() as any;
            continue;
          }
          case 10: {
            if (tag !== 80) {
              break;
            }

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

  fromJSON(object: any): ReadModelDefinition {
    return {
      Type: isSet(object.Type) ? ReadModelType.fromJSON(object.Type) : undefined,
      ContainerName: isSet(object.ContainerName) ? globalThis.String(object.ContainerName) : "",
      DisplayName: isSet(object.DisplayName) ? globalThis.String(object.DisplayName) : "",
      Sink: isSet(object.Sink) ? SinkDefinition.fromJSON(object.Sink) : undefined,
      Schema: isSet(object.Schema) ? globalThis.String(object.Schema) : "",
      Indexes: globalThis.Array.isArray(object?.Indexes)
        ? object.Indexes.map((e: any) => IndexDefinition.fromJSON(e))
        : [],
      ObserverType: isSet(object.ObserverType) ? readModelObserverTypeFromJSON(object.ObserverType) : 0,
      ObserverIdentifier: isSet(object.ObserverIdentifier) ? globalThis.String(object.ObserverIdentifier) : "",
      Owner: isSet(object.Owner) ? readModelOwnerFromJSON(object.Owner) : 0,
      Source: isSet(object.Source) ? readModelSourceFromJSON(object.Source) : 0,
    };
  },

  toJSON(message: ReadModelDefinition): unknown {
    const obj: any = {};
    if (message.Type !== undefined) {
      obj.Type = ReadModelType.toJSON(message.Type);
    }
    if (message.ContainerName !== "") {
      obj.ContainerName = message.ContainerName;
    }
    if (message.DisplayName !== "") {
      obj.DisplayName = message.DisplayName;
    }
    if (message.Sink !== undefined) {
      obj.Sink = SinkDefinition.toJSON(message.Sink);
    }
    if (message.Schema !== "") {
      obj.Schema = message.Schema;
    }
    if (message.Indexes?.length) {
      obj.Indexes = message.Indexes.map((e) => IndexDefinition.toJSON(e));
    }
    if (message.ObserverType !== 0) {
      obj.ObserverType = readModelObserverTypeToJSON(message.ObserverType);
    }
    if (message.ObserverIdentifier !== "") {
      obj.ObserverIdentifier = message.ObserverIdentifier;
    }
    if (message.Owner !== 0) {
      obj.Owner = readModelOwnerToJSON(message.Owner);
    }
    if (message.Source !== 0) {
      obj.Source = readModelSourceToJSON(message.Source);
    }
    return obj;
  },

  create(base?: DeepPartial<ReadModelDefinition>): ReadModelDefinition {
    return ReadModelDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ReadModelDefinition>): ReadModelDefinition {
    const message = createBaseReadModelDefinition();
    message.Type = (object.Type !== undefined && object.Type !== null)
      ? ReadModelType.fromPartial(object.Type)
      : undefined;
    message.ContainerName = object.ContainerName ?? "";
    message.DisplayName = object.DisplayName ?? "";
    message.Sink = (object.Sink !== undefined && object.Sink !== null)
      ? SinkDefinition.fromPartial(object.Sink)
      : undefined;
    message.Schema = object.Schema ?? "";
    message.Indexes = object.Indexes?.map((e) => IndexDefinition.fromPartial(e)) || [];
    message.ObserverType = object.ObserverType ?? 0;
    message.ObserverIdentifier = object.ObserverIdentifier ?? "";
    message.Owner = object.Owner ?? 0;
    message.Source = object.Source ?? 0;
    return message;
  },
};

function createBaseReadModelType(): ReadModelType {
  return { Identifier: "", Generation: 0 };
}

export const ReadModelType: MessageFns<ReadModelType> = {
  encode(message: ReadModelType, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Identifier !== "") {
      writer.uint32(10).string(message.Identifier);
    }
    if (message.Generation !== 0) {
      writer.uint32(16).uint32(message.Generation);
    }
    return writer;
  },

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

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

  toJSON(message: ReadModelType): unknown {
    const obj: any = {};
    if (message.Identifier !== "") {
      obj.Identifier = message.Identifier;
    }
    if (message.Generation !== 0) {
      obj.Generation = Math.round(message.Generation);
    }
    return obj;
  },

  create(base?: DeepPartial<ReadModelType>): ReadModelType {
    return ReadModelType.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<ReadModelType>): ReadModelType {
    const message = createBaseReadModelType();
    message.Identifier = object.Identifier ?? "";
    message.Generation = object.Generation ?? 0;
    return message;
  },
};

function createBaseRegisterRequest(): RegisterRequest {
  return { EventStore: "", Owner: 0, Projections: [], FullSet: false };
}

export const RegisterRequest: MessageFns<RegisterRequest> = {
  encode(message: RegisterRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    if (message.Owner !== 0) {
      writer.uint32(16).int32(message.Owner);
    }
    for (const v of message.Projections) {
      ProjectionDefinition.encode(v!, writer.uint32(26).fork()).join();
    }
    if (message.FullSet !== false) {
      writer.uint32(32).bool(message.FullSet);
    }
    return writer;
  },

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

            message.Owner = reader.int32() as any;
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }

            message.Projections.push(ProjectionDefinition.decode(reader, reader.uint32()));
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }

            message.FullSet = 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): RegisterRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Owner: isSet(object.Owner) ? projectionOwnerFromJSON(object.Owner) : 0,
      Projections: globalThis.Array.isArray(object?.Projections)
        ? object.Projections.map((e: any) => ProjectionDefinition.fromJSON(e))
        : [],
      FullSet: isSet(object.FullSet) ? globalThis.Boolean(object.FullSet) : false,
    };
  },

  toJSON(message: RegisterRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Owner !== 0) {
      obj.Owner = projectionOwnerToJSON(message.Owner);
    }
    if (message.Projections?.length) {
      obj.Projections = message.Projections.map((e) => ProjectionDefinition.toJSON(e));
    }
    if (message.FullSet !== false) {
      obj.FullSet = message.FullSet;
    }
    return obj;
  },

  create(base?: DeepPartial<RegisterRequest>): RegisterRequest {
    return RegisterRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<RegisterRequest>): RegisterRequest {
    const message = createBaseRegisterRequest();
    message.EventStore = object.EventStore ?? "";
    message.Owner = object.Owner ?? 0;
    message.Projections = object.Projections?.map((e) => ProjectionDefinition.fromPartial(e)) || [];
    message.FullSet = object.FullSet ?? false;
    return message;
  },
};

function createBaseRemovedWithDefinition(): RemovedWithDefinition {
  return { Key: "", ParentKey: "" };
}

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

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

  toJSON(message: RemovedWithDefinition): unknown {
    const obj: any = {};
    if (message.Key !== "") {
      obj.Key = message.Key;
    }
    if (message.ParentKey !== "") {
      obj.ParentKey = message.ParentKey;
    }
    return obj;
  },

  create(base?: DeepPartial<RemovedWithDefinition>): RemovedWithDefinition {
    return RemovedWithDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<RemovedWithDefinition>): RemovedWithDefinition {
    const message = createBaseRemovedWithDefinition();
    message.Key = object.Key ?? "";
    message.ParentKey = object.ParentKey ?? "";
    return message;
  },
};

function createBaseRemovedWithJoinDefinition(): RemovedWithJoinDefinition {
  return { Key: "" };
}

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

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

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

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

  create(base?: DeepPartial<RemovedWithJoinDefinition>): RemovedWithJoinDefinition {
    return RemovedWithJoinDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<RemovedWithJoinDefinition>): RemovedWithJoinDefinition {
    const message = createBaseRemovedWithJoinDefinition();
    message.Key = object.Key ?? "";
    return message;
  },
};

function createBaseSaveProjectionRequest(): SaveProjectionRequest {
  return { EventStore: "", Namespace: "", EventSequenceId: "", Declaration: "", DraftReadModel: undefined };
}

export const SaveProjectionRequest: MessageFns<SaveProjectionRequest> = {
  encode(message: SaveProjectionRequest, 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.EventSequenceId !== "") {
      writer.uint32(26).string(message.EventSequenceId);
    }
    if (message.Declaration !== "") {
      writer.uint32(34).string(message.Declaration);
    }
    if (message.DraftReadModel !== undefined) {
      DraftReadModelDefinition.encode(message.DraftReadModel, writer.uint32(42).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): SaveProjectionRequest {
    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 = createBaseSaveProjectionRequest();
      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.EventSequenceId = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }

            message.Declaration = reader.string();
            continue;
          }
          case 5: {
            if (tag !== 42) {
              break;
            }

            message.DraftReadModel = DraftReadModelDefinition.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): SaveProjectionRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Namespace: isSet(object.Namespace) ? globalThis.String(object.Namespace) : "",
      EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
      Declaration: isSet(object.Declaration) ? globalThis.String(object.Declaration) : "",
      DraftReadModel: isSet(object.DraftReadModel)
        ? DraftReadModelDefinition.fromJSON(object.DraftReadModel)
        : undefined,
    };
  },

  toJSON(message: SaveProjectionRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Namespace !== "") {
      obj.Namespace = message.Namespace;
    }
    if (message.EventSequenceId !== "") {
      obj.EventSequenceId = message.EventSequenceId;
    }
    if (message.Declaration !== "") {
      obj.Declaration = message.Declaration;
    }
    if (message.DraftReadModel !== undefined) {
      obj.DraftReadModel = DraftReadModelDefinition.toJSON(message.DraftReadModel);
    }
    return obj;
  },

  create(base?: DeepPartial<SaveProjectionRequest>): SaveProjectionRequest {
    return SaveProjectionRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<SaveProjectionRequest>): SaveProjectionRequest {
    const message = createBaseSaveProjectionRequest();
    message.EventStore = object.EventStore ?? "";
    message.Namespace = object.Namespace ?? "";
    message.EventSequenceId = object.EventSequenceId ?? "";
    message.Declaration = object.Declaration ?? "";
    message.DraftReadModel = (object.DraftReadModel !== undefined && object.DraftReadModel !== null)
      ? DraftReadModelDefinition.fromPartial(object.DraftReadModel)
      : undefined;
    return message;
  },
};

function createBaseSaveProjectionResult(): SaveProjectionResult {
  return { Errors: [] };
}

export const SaveProjectionResult: MessageFns<SaveProjectionResult> = {
  encode(message: SaveProjectionResult, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.Errors) {
      ProjectionDeclarationSyntaxError.encode(v!, writer.uint32(10).fork()).join();
    }
    return writer;
  },

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

            message.Errors.push(ProjectionDeclarationSyntaxError.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): SaveProjectionResult {
    return {
      Errors: globalThis.Array.isArray(object?.Errors)
        ? object.Errors.map((e: any) => ProjectionDeclarationSyntaxError.fromJSON(e))
        : [],
    };
  },

  toJSON(message: SaveProjectionResult): unknown {
    const obj: any = {};
    if (message.Errors?.length) {
      obj.Errors = message.Errors.map((e) => ProjectionDeclarationSyntaxError.toJSON(e));
    }
    return obj;
  },

  create(base?: DeepPartial<SaveProjectionResult>): SaveProjectionResult {
    return SaveProjectionResult.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<SaveProjectionResult>): SaveProjectionResult {
    const message = createBaseSaveProjectionResult();
    message.Errors = object.Errors?.map((e) => ProjectionDeclarationSyntaxError.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 createBaseSinkDefinition(): SinkDefinition {
  return { ConfigurationId: undefined, TypeId: "" };
}

export const SinkDefinition: MessageFns<SinkDefinition> = {
  encode(message: SinkDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.ConfigurationId !== undefined) {
      Guid.encode(message.ConfigurationId, writer.uint32(10).fork()).join();
    }
    if (message.TypeId !== "") {
      writer.uint32(18).string(message.TypeId);
    }
    return writer;
  },

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

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

            message.TypeId = 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): SinkDefinition {
    return {
      ConfigurationId: isSet(object.ConfigurationId) ? Guid.fromJSON(object.ConfigurationId) : undefined,
      TypeId: isSet(object.TypeId) ? globalThis.String(object.TypeId) : "",
    };
  },

  toJSON(message: SinkDefinition): unknown {
    const obj: any = {};
    if (message.ConfigurationId !== undefined) {
      obj.ConfigurationId = Guid.toJSON(message.ConfigurationId);
    }
    if (message.TypeId !== "") {
      obj.TypeId = message.TypeId;
    }
    return obj;
  },

  create(base?: DeepPartial<SinkDefinition>): SinkDefinition {
    return SinkDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<SinkDefinition>): SinkDefinition {
    const message = createBaseSinkDefinition();
    message.ConfigurationId = (object.ConfigurationId !== undefined && object.ConfigurationId !== null)
      ? Guid.fromPartial(object.ConfigurationId)
      : undefined;
    message.TypeId = object.TypeId ?? "";
    return message;
  },
};

export type ProjectionsDefinition = typeof ProjectionsDefinition;
export const ProjectionsDefinition = {
  name: "Projections",
  fullName: "Cratis.Chronicle.Contracts.Projections.Projections",
  methods: {
    getAllDeclarations: {
      name: "GetAllDeclarations",
      requestType: GetAllDeclarationsRequest as typeof GetAllDeclarationsRequest,
      requestStream: false,
      responseType: IEnumerableProjectionWithDeclaration as typeof IEnumerableProjectionWithDeclaration,
      responseStream: false,
      options: {},
    },
    getAllDefinitions: {
      name: "GetAllDefinitions",
      requestType: GetAllDefinitionsRequest as typeof GetAllDefinitionsRequest,
      requestStream: false,
      responseType: IEnumerableProjectionDefinition as typeof IEnumerableProjectionDefinition,
      responseStream: false,
      options: {},
    },
    preview: {
      name: "Preview",
      requestType: PreviewProjectionRequest as typeof PreviewProjectionRequest,
      requestStream: false,
      responseType:
        OneOfProjectionPreviewProjectionDeclarationParsingErrors as typeof OneOfProjectionPreviewProjectionDeclarationParsingErrors,
      responseStream: false,
      options: {},
    },
    register: {
      name: "Register",
      requestType: RegisterRequest as typeof RegisterRequest,
      requestStream: false,
      responseType: Empty as typeof Empty,
      responseStream: false,
      options: {},
    },
    save: {
      name: "Save",
      requestType: SaveProjectionRequest as typeof SaveProjectionRequest,
      requestStream: false,
      responseType: SaveProjectionResult as typeof SaveProjectionResult,
      responseStream: false,
      options: {},
    },
  },
} as const;

export interface ProjectionsServiceImplementation<CallContextExt = {}> {
  getAllDeclarations(
    request: GetAllDeclarationsRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<IEnumerableProjectionWithDeclaration>>;
  getAllDefinitions(
    request: GetAllDefinitionsRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<IEnumerableProjectionDefinition>>;
  preview(
    request: PreviewProjectionRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<OneOfProjectionPreviewProjectionDeclarationParsingErrors>>;
  register(request: RegisterRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Empty>>;
  save(
    request: SaveProjectionRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<SaveProjectionResult>>;
}

export interface ProjectionsClient<CallOptionsExt = {}> {
  getAllDeclarations(
    request: DeepPartial<GetAllDeclarationsRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<IEnumerableProjectionWithDeclaration>;
  getAllDefinitions(
    request: DeepPartial<GetAllDefinitionsRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<IEnumerableProjectionDefinition>;
  preview(
    request: DeepPartial<PreviewProjectionRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<OneOfProjectionPreviewProjectionDeclarationParsingErrors>;
  register(request: DeepPartial<RegisterRequest>, options?: CallOptions & CallOptionsExt): Promise<Empty>;
  save(
    request: DeepPartial<SaveProjectionRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<SaveProjectionResult>;
}

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