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

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

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

export enum EventTypeOwner {
  None = 0,
  Client = 1,
  Server = 2,
  UNRECOGNIZED = -1,
}

export function eventTypeOwnerFromJSON(object: any): EventTypeOwner {
  switch (object) {
    case 0:
    case "None":
      return EventTypeOwner.None;
    case 1:
    case "Client":
      return EventTypeOwner.Client;
    case 2:
    case "Server":
      return EventTypeOwner.Server;
    case -1:
    case "UNRECOGNIZED":
    default:
      return EventTypeOwner.UNRECOGNIZED;
  }
}

export function eventTypeOwnerToJSON(object: EventTypeOwner): string {
  switch (object) {
    case EventTypeOwner.None:
      return "None";
    case EventTypeOwner.Client:
      return "Client";
    case EventTypeOwner.Server:
      return "Server";
    case EventTypeOwner.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export enum EventTypeSource {
  EVENT_TYPE_SOURCE_Unknown = 0,
  Code = 1,
  User = 2,
  UNRECOGNIZED = -1,
}

export function eventTypeSourceFromJSON(object: any): EventTypeSource {
  switch (object) {
    case 0:
    case "EVENT_TYPE_SOURCE_Unknown":
      return EventTypeSource.EVENT_TYPE_SOURCE_Unknown;
    case 1:
    case "Code":
      return EventTypeSource.Code;
    case 2:
    case "User":
      return EventTypeSource.User;
    case -1:
    case "UNRECOGNIZED":
    default:
      return EventTypeSource.UNRECOGNIZED;
  }
}

export function eventTypeSourceToJSON(object: EventTypeSource): string {
  switch (object) {
    case EventTypeSource.EVENT_TYPE_SOURCE_Unknown:
      return "EVENT_TYPE_SOURCE_Unknown";
    case EventTypeSource.Code:
      return "Code";
    case EventTypeSource.User:
      return "User";
    case EventTypeSource.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export enum ValidationResultSeverity {
  VALIDATION_RESULT_SEVERITY_Unknown = 0,
  Information = 1,
  Warning = 2,
  Error = 3,
  UNRECOGNIZED = -1,
}

export function validationResultSeverityFromJSON(object: any): ValidationResultSeverity {
  switch (object) {
    case 0:
    case "VALIDATION_RESULT_SEVERITY_Unknown":
      return ValidationResultSeverity.VALIDATION_RESULT_SEVERITY_Unknown;
    case 1:
    case "Information":
      return ValidationResultSeverity.Information;
    case 2:
    case "Warning":
      return ValidationResultSeverity.Warning;
    case 3:
    case "Error":
      return ValidationResultSeverity.Error;
    case -1:
    case "UNRECOGNIZED":
    default:
      return ValidationResultSeverity.UNRECOGNIZED;
  }
}

export function validationResultSeverityToJSON(object: ValidationResultSeverity): string {
  switch (object) {
    case ValidationResultSeverity.VALIDATION_RESULT_SEVERITY_Unknown:
      return "VALIDATION_RESULT_SEVERITY_Unknown";
    case ValidationResultSeverity.Information:
      return "Information";
    case ValidationResultSeverity.Warning:
      return "Warning";
    case ValidationResultSeverity.Error:
      return "Error";
    case ValidationResultSeverity.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export interface AllEventTypeGenerationsRequest {
  EventStore: string;
  EventTypeId: string;
}

export interface AllEventTypesRequest {
  EventStore: string;
}

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

export interface CreateEventTypeRequest {
  EventStore: string;
  Name: string;
}

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

export interface EventTypeDetailsResponse {
  Type: EventType | undefined;
  Owner: EventTypeOwner;
  Source: EventTypeSource;
  Schema: string;
  Id: string;
}

export interface EventTypeGenerationDefinition {
  Generation: number;
  Schema: string;
}

export interface EventTypeMigrationDefinition {
  FromGeneration: number;
  ToGeneration: number;
  Operations: EventTypeMigrationOperation[];
  UpcastJmesPath: string;
  DowncastJmesPath: string;
}

export interface EventTypeMigrationOperation {
  Operation: string;
  Details: string;
}

export interface EventTypeRegistration {
  Type: EventType | undefined;
  Schema: string;
  Generations: EventTypeGenerationDefinition[];
  Migrations: EventTypeMigrationDefinition[];
  EventStore: string;
}

export interface ObserveEventTypesRequest {
  EventStore: string;
}

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

export interface RegisterEventTypesRequest {
  EventStore: string;
  Types: EventTypeRegistration[];
  DisableValidation: boolean;
}

export interface RegisterSingleEventTypeRequest {
  EventStore: string;
  Type: EventTypeRegistration | undefined;
}

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

function createBaseAllEventTypeGenerationsRequest(): AllEventTypeGenerationsRequest {
  return { EventStore: "", EventTypeId: "" };
}

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

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

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

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

function createBaseAllEventTypesRequest(): AllEventTypesRequest {
  return { EventStore: "" };
}

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

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

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

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

function createBaseCommandResult(): CommandResult {
  return {
    CorrelationId: undefined,
    IsAuthorized: false,
    ValidationResults: [],
    ExceptionMessages: [],
    ExceptionStackTrace: "",
    AuthorizationFailureReason: "",
  };
}

export const CommandResult: MessageFns<CommandResult> = {
  encode(message: CommandResult, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.CorrelationId !== undefined) {
      Guid.encode(message.CorrelationId, writer.uint32(10).fork()).join();
    }
    if (message.IsAuthorized !== false) {
      writer.uint32(16).bool(message.IsAuthorized);
    }
    for (const v of message.ValidationResults) {
      ValidationResult.encode(v!, writer.uint32(26).fork()).join();
    }
    for (const v of message.ExceptionMessages) {
      writer.uint32(34).string(v!);
    }
    if (message.ExceptionStackTrace !== "") {
      writer.uint32(42).string(message.ExceptionStackTrace);
    }
    if (message.AuthorizationFailureReason !== "") {
      writer.uint32(50).string(message.AuthorizationFailureReason);
    }
    return writer;
  },

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

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

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

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

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

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

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

  fromJSON(object: any): CommandResult {
    return {
      CorrelationId: isSet(object.CorrelationId) ? Guid.fromJSON(object.CorrelationId) : undefined,
      IsAuthorized: isSet(object.IsAuthorized) ? globalThis.Boolean(object.IsAuthorized) : false,
      ValidationResults: globalThis.Array.isArray(object?.ValidationResults)
        ? object.ValidationResults.map((e: any) => ValidationResult.fromJSON(e))
        : [],
      ExceptionMessages: globalThis.Array.isArray(object?.ExceptionMessages)
        ? object.ExceptionMessages.map((e: any) => globalThis.String(e))
        : [],
      ExceptionStackTrace: isSet(object.ExceptionStackTrace) ? globalThis.String(object.ExceptionStackTrace) : "",
      AuthorizationFailureReason: isSet(object.AuthorizationFailureReason)
        ? globalThis.String(object.AuthorizationFailureReason)
        : "",
    };
  },

  toJSON(message: CommandResult): unknown {
    const obj: any = {};
    if (message.CorrelationId !== undefined) {
      obj.CorrelationId = Guid.toJSON(message.CorrelationId);
    }
    if (message.IsAuthorized !== false) {
      obj.IsAuthorized = message.IsAuthorized;
    }
    if (message.ValidationResults?.length) {
      obj.ValidationResults = message.ValidationResults.map((e) => ValidationResult.toJSON(e));
    }
    if (message.ExceptionMessages?.length) {
      obj.ExceptionMessages = message.ExceptionMessages;
    }
    if (message.ExceptionStackTrace !== "") {
      obj.ExceptionStackTrace = message.ExceptionStackTrace;
    }
    if (message.AuthorizationFailureReason !== "") {
      obj.AuthorizationFailureReason = message.AuthorizationFailureReason;
    }
    return obj;
  },

  create(base?: DeepPartial<CommandResult>): CommandResult {
    return CommandResult.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<CommandResult>): CommandResult {
    const message = createBaseCommandResult();
    message.CorrelationId = (object.CorrelationId !== undefined && object.CorrelationId !== null)
      ? Guid.fromPartial(object.CorrelationId)
      : undefined;
    message.IsAuthorized = object.IsAuthorized ?? false;
    message.ValidationResults = object.ValidationResults?.map((e) => ValidationResult.fromPartial(e)) || [];
    message.ExceptionMessages = object.ExceptionMessages?.map((e) => e) || [];
    message.ExceptionStackTrace = object.ExceptionStackTrace ?? "";
    message.AuthorizationFailureReason = object.AuthorizationFailureReason ?? "";
    return message;
  },
};

function createBaseCreateEventTypeRequest(): CreateEventTypeRequest {
  return { EventStore: "", Name: "" };
}

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

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

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

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

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

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

  create(base?: DeepPartial<CreateEventTypeRequest>): CreateEventTypeRequest {
    return CreateEventTypeRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<CreateEventTypeRequest>): CreateEventTypeRequest {
    const message = createBaseCreateEventTypeRequest();
    message.EventStore = object.EventStore ?? "";
    message.Name = object.Name ?? "";
    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 createBaseEventTypeDetailsResponse(): EventTypeDetailsResponse {
  return { Type: undefined, Owner: 0, Source: 0, Schema: "", Id: "" };
}

export const EventTypeDetailsResponse: MessageFns<EventTypeDetailsResponse> = {
  encode(message: EventTypeDetailsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Type !== undefined) {
      EventType.encode(message.Type, writer.uint32(10).fork()).join();
    }
    if (message.Owner !== 0) {
      writer.uint32(16).int32(message.Owner);
    }
    if (message.Source !== 0) {
      writer.uint32(24).int32(message.Source);
    }
    if (message.Schema !== "") {
      writer.uint32(34).string(message.Schema);
    }
    if (message.Id !== "") {
      writer.uint32(42).string(message.Id);
    }
    return writer;
  },

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

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

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

            message.Source = reader.int32() as any;
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }

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

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

  fromJSON(object: any): EventTypeDetailsResponse {
    return {
      Type: isSet(object.Type) ? EventType.fromJSON(object.Type) : undefined,
      Owner: isSet(object.Owner) ? eventTypeOwnerFromJSON(object.Owner) : 0,
      Source: isSet(object.Source) ? eventTypeSourceFromJSON(object.Source) : 0,
      Schema: isSet(object.Schema) ? globalThis.String(object.Schema) : "",
      Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
    };
  },

  toJSON(message: EventTypeDetailsResponse): unknown {
    const obj: any = {};
    if (message.Type !== undefined) {
      obj.Type = EventType.toJSON(message.Type);
    }
    if (message.Owner !== 0) {
      obj.Owner = eventTypeOwnerToJSON(message.Owner);
    }
    if (message.Source !== 0) {
      obj.Source = eventTypeSourceToJSON(message.Source);
    }
    if (message.Schema !== "") {
      obj.Schema = message.Schema;
    }
    if (message.Id !== "") {
      obj.Id = message.Id;
    }
    return obj;
  },

  create(base?: DeepPartial<EventTypeDetailsResponse>): EventTypeDetailsResponse {
    return EventTypeDetailsResponse.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<EventTypeDetailsResponse>): EventTypeDetailsResponse {
    const message = createBaseEventTypeDetailsResponse();
    message.Type = (object.Type !== undefined && object.Type !== null) ? EventType.fromPartial(object.Type) : undefined;
    message.Owner = object.Owner ?? 0;
    message.Source = object.Source ?? 0;
    message.Schema = object.Schema ?? "";
    message.Id = object.Id ?? "";
    return message;
  },
};

function createBaseEventTypeGenerationDefinition(): EventTypeGenerationDefinition {
  return { Generation: 0, Schema: "" };
}

export const EventTypeGenerationDefinition: MessageFns<EventTypeGenerationDefinition> = {
  encode(message: EventTypeGenerationDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Generation !== 0) {
      writer.uint32(8).uint32(message.Generation);
    }
    if (message.Schema !== "") {
      writer.uint32(18).string(message.Schema);
    }
    return writer;
  },

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

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

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

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

  create(base?: DeepPartial<EventTypeGenerationDefinition>): EventTypeGenerationDefinition {
    return EventTypeGenerationDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<EventTypeGenerationDefinition>): EventTypeGenerationDefinition {
    const message = createBaseEventTypeGenerationDefinition();
    message.Generation = object.Generation ?? 0;
    message.Schema = object.Schema ?? "";
    return message;
  },
};

function createBaseEventTypeMigrationDefinition(): EventTypeMigrationDefinition {
  return { FromGeneration: 0, ToGeneration: 0, Operations: [], UpcastJmesPath: "", DowncastJmesPath: "" };
}

export const EventTypeMigrationDefinition: MessageFns<EventTypeMigrationDefinition> = {
  encode(message: EventTypeMigrationDefinition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.FromGeneration !== 0) {
      writer.uint32(8).uint32(message.FromGeneration);
    }
    if (message.ToGeneration !== 0) {
      writer.uint32(16).uint32(message.ToGeneration);
    }
    for (const v of message.Operations) {
      EventTypeMigrationOperation.encode(v!, writer.uint32(26).fork()).join();
    }
    if (message.UpcastJmesPath !== "") {
      writer.uint32(34).string(message.UpcastJmesPath);
    }
    if (message.DowncastJmesPath !== "") {
      writer.uint32(42).string(message.DowncastJmesPath);
    }
    return writer;
  },

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

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

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

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

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

            message.DowncastJmesPath = 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): EventTypeMigrationDefinition {
    return {
      FromGeneration: isSet(object.FromGeneration) ? globalThis.Number(object.FromGeneration) : 0,
      ToGeneration: isSet(object.ToGeneration) ? globalThis.Number(object.ToGeneration) : 0,
      Operations: globalThis.Array.isArray(object?.Operations)
        ? object.Operations.map((e: any) => EventTypeMigrationOperation.fromJSON(e))
        : [],
      UpcastJmesPath: isSet(object.UpcastJmesPath) ? globalThis.String(object.UpcastJmesPath) : "",
      DowncastJmesPath: isSet(object.DowncastJmesPath) ? globalThis.String(object.DowncastJmesPath) : "",
    };
  },

  toJSON(message: EventTypeMigrationDefinition): unknown {
    const obj: any = {};
    if (message.FromGeneration !== 0) {
      obj.FromGeneration = Math.round(message.FromGeneration);
    }
    if (message.ToGeneration !== 0) {
      obj.ToGeneration = Math.round(message.ToGeneration);
    }
    if (message.Operations?.length) {
      obj.Operations = message.Operations.map((e) => EventTypeMigrationOperation.toJSON(e));
    }
    if (message.UpcastJmesPath !== "") {
      obj.UpcastJmesPath = message.UpcastJmesPath;
    }
    if (message.DowncastJmesPath !== "") {
      obj.DowncastJmesPath = message.DowncastJmesPath;
    }
    return obj;
  },

  create(base?: DeepPartial<EventTypeMigrationDefinition>): EventTypeMigrationDefinition {
    return EventTypeMigrationDefinition.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<EventTypeMigrationDefinition>): EventTypeMigrationDefinition {
    const message = createBaseEventTypeMigrationDefinition();
    message.FromGeneration = object.FromGeneration ?? 0;
    message.ToGeneration = object.ToGeneration ?? 0;
    message.Operations = object.Operations?.map((e) => EventTypeMigrationOperation.fromPartial(e)) || [];
    message.UpcastJmesPath = object.UpcastJmesPath ?? "";
    message.DowncastJmesPath = object.DowncastJmesPath ?? "";
    return message;
  },
};

function createBaseEventTypeMigrationOperation(): EventTypeMigrationOperation {
  return { Operation: "", Details: "" };
}

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

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

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

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

  toJSON(message: EventTypeMigrationOperation): unknown {
    const obj: any = {};
    if (message.Operation !== "") {
      obj.Operation = message.Operation;
    }
    if (message.Details !== "") {
      obj.Details = message.Details;
    }
    return obj;
  },

  create(base?: DeepPartial<EventTypeMigrationOperation>): EventTypeMigrationOperation {
    return EventTypeMigrationOperation.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<EventTypeMigrationOperation>): EventTypeMigrationOperation {
    const message = createBaseEventTypeMigrationOperation();
    message.Operation = object.Operation ?? "";
    message.Details = object.Details ?? "";
    return message;
  },
};

function createBaseEventTypeRegistration(): EventTypeRegistration {
  return { Type: undefined, Schema: "", Generations: [], Migrations: [], EventStore: "" };
}

export const EventTypeRegistration: MessageFns<EventTypeRegistration> = {
  encode(message: EventTypeRegistration, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.Type !== undefined) {
      EventType.encode(message.Type, writer.uint32(10).fork()).join();
    }
    if (message.Schema !== "") {
      writer.uint32(18).string(message.Schema);
    }
    for (const v of message.Generations) {
      EventTypeGenerationDefinition.encode(v!, writer.uint32(26).fork()).join();
    }
    for (const v of message.Migrations) {
      EventTypeMigrationDefinition.encode(v!, writer.uint32(34).fork()).join();
    }
    if (message.EventStore !== "") {
      writer.uint32(42).string(message.EventStore);
    }
    return writer;
  },

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

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

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

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

            message.Migrations.push(EventTypeMigrationDefinition.decode(reader, reader.uint32()));
            continue;
          }
          case 5: {
            if (tag !== 42) {
              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): EventTypeRegistration {
    return {
      Type: isSet(object.Type) ? EventType.fromJSON(object.Type) : undefined,
      Schema: isSet(object.Schema) ? globalThis.String(object.Schema) : "",
      Generations: globalThis.Array.isArray(object?.Generations)
        ? object.Generations.map((e: any) => EventTypeGenerationDefinition.fromJSON(e))
        : [],
      Migrations: globalThis.Array.isArray(object?.Migrations)
        ? object.Migrations.map((e: any) => EventTypeMigrationDefinition.fromJSON(e))
        : [],
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
    };
  },

  toJSON(message: EventTypeRegistration): unknown {
    const obj: any = {};
    if (message.Type !== undefined) {
      obj.Type = EventType.toJSON(message.Type);
    }
    if (message.Schema !== "") {
      obj.Schema = message.Schema;
    }
    if (message.Generations?.length) {
      obj.Generations = message.Generations.map((e) => EventTypeGenerationDefinition.toJSON(e));
    }
    if (message.Migrations?.length) {
      obj.Migrations = message.Migrations.map((e) => EventTypeMigrationDefinition.toJSON(e));
    }
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    return obj;
  },

  create(base?: DeepPartial<EventTypeRegistration>): EventTypeRegistration {
    return EventTypeRegistration.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<EventTypeRegistration>): EventTypeRegistration {
    const message = createBaseEventTypeRegistration();
    message.Type = (object.Type !== undefined && object.Type !== null) ? EventType.fromPartial(object.Type) : undefined;
    message.Schema = object.Schema ?? "";
    message.Generations = object.Generations?.map((e) => EventTypeGenerationDefinition.fromPartial(e)) || [];
    message.Migrations = object.Migrations?.map((e) => EventTypeMigrationDefinition.fromPartial(e)) || [];
    message.EventStore = object.EventStore ?? "";
    return message;
  },
};

function createBaseObserveEventTypesRequest(): ObserveEventTypesRequest {
  return { EventStore: "" };
}

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

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

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

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

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

export const QueryResultIEnumerableEventTypeDetailsResponse: MessageFns<
  QueryResultIEnumerableEventTypeDetailsResponse
> = {
  encode(
    message: QueryResultIEnumerableEventTypeDetailsResponse,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.CorrelationId !== undefined) {
      Guid.encode(message.CorrelationId, writer.uint32(10).fork()).join();
    }
    if (message.IsAuthorized !== false) {
      writer.uint32(16).bool(message.IsAuthorized);
    }
    for (const v of message.ValidationResults) {
      ValidationResult.encode(v!, writer.uint32(26).fork()).join();
    }
    for (const v of message.ExceptionMessages) {
      writer.uint32(34).string(v!);
    }
    if (message.ExceptionStackTrace !== "") {
      writer.uint32(42).string(message.ExceptionStackTrace);
    }
    for (const v of message.Data) {
      EventTypeDetailsResponse.encode(v!, writer.uint32(50).fork()).join();
    }
    return writer;
  },

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

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

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

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

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

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

            message.Data.push(EventTypeDetailsResponse.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): QueryResultIEnumerableEventTypeDetailsResponse {
    return {
      CorrelationId: isSet(object.CorrelationId) ? Guid.fromJSON(object.CorrelationId) : undefined,
      IsAuthorized: isSet(object.IsAuthorized) ? globalThis.Boolean(object.IsAuthorized) : false,
      ValidationResults: globalThis.Array.isArray(object?.ValidationResults)
        ? object.ValidationResults.map((e: any) => ValidationResult.fromJSON(e))
        : [],
      ExceptionMessages: globalThis.Array.isArray(object?.ExceptionMessages)
        ? object.ExceptionMessages.map((e: any) => globalThis.String(e))
        : [],
      ExceptionStackTrace: isSet(object.ExceptionStackTrace) ? globalThis.String(object.ExceptionStackTrace) : "",
      Data: globalThis.Array.isArray(object?.Data)
        ? object.Data.map((e: any) => EventTypeDetailsResponse.fromJSON(e))
        : [],
    };
  },

  toJSON(message: QueryResultIEnumerableEventTypeDetailsResponse): unknown {
    const obj: any = {};
    if (message.CorrelationId !== undefined) {
      obj.CorrelationId = Guid.toJSON(message.CorrelationId);
    }
    if (message.IsAuthorized !== false) {
      obj.IsAuthorized = message.IsAuthorized;
    }
    if (message.ValidationResults?.length) {
      obj.ValidationResults = message.ValidationResults.map((e) => ValidationResult.toJSON(e));
    }
    if (message.ExceptionMessages?.length) {
      obj.ExceptionMessages = message.ExceptionMessages;
    }
    if (message.ExceptionStackTrace !== "") {
      obj.ExceptionStackTrace = message.ExceptionStackTrace;
    }
    if (message.Data?.length) {
      obj.Data = message.Data.map((e) => EventTypeDetailsResponse.toJSON(e));
    }
    return obj;
  },

  create(
    base?: DeepPartial<QueryResultIEnumerableEventTypeDetailsResponse>,
  ): QueryResultIEnumerableEventTypeDetailsResponse {
    return QueryResultIEnumerableEventTypeDetailsResponse.fromPartial(base ?? {});
  },
  fromPartial(
    object: DeepPartial<QueryResultIEnumerableEventTypeDetailsResponse>,
  ): QueryResultIEnumerableEventTypeDetailsResponse {
    const message = createBaseQueryResultIEnumerableEventTypeDetailsResponse();
    message.CorrelationId = (object.CorrelationId !== undefined && object.CorrelationId !== null)
      ? Guid.fromPartial(object.CorrelationId)
      : undefined;
    message.IsAuthorized = object.IsAuthorized ?? false;
    message.ValidationResults = object.ValidationResults?.map((e) => ValidationResult.fromPartial(e)) || [];
    message.ExceptionMessages = object.ExceptionMessages?.map((e) => e) || [];
    message.ExceptionStackTrace = object.ExceptionStackTrace ?? "";
    message.Data = object.Data?.map((e) => EventTypeDetailsResponse.fromPartial(e)) || [];
    return message;
  },
};

function createBaseRegisterEventTypesRequest(): RegisterEventTypesRequest {
  return { EventStore: "", Types: [], DisableValidation: false };
}

export const RegisterEventTypesRequest: MessageFns<RegisterEventTypesRequest> = {
  encode(message: RegisterEventTypesRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    for (const v of message.Types) {
      EventTypeRegistration.encode(v!, writer.uint32(18).fork()).join();
    }
    if (message.DisableValidation !== false) {
      writer.uint32(24).bool(message.DisableValidation);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): RegisterEventTypesRequest {
    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 = createBaseRegisterEventTypesRequest();
      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.Types.push(EventTypeRegistration.decode(reader, reader.uint32()));
            continue;
          }
          case 3: {
            if (tag !== 24) {
              break;
            }

            message.DisableValidation = 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): RegisterEventTypesRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Types: globalThis.Array.isArray(object?.Types)
        ? object.Types.map((e: any) => EventTypeRegistration.fromJSON(e))
        : [],
      DisableValidation: isSet(object.DisableValidation) ? globalThis.Boolean(object.DisableValidation) : false,
    };
  },

  toJSON(message: RegisterEventTypesRequest): unknown {
    const obj: any = {};
    if (message.EventStore !== "") {
      obj.EventStore = message.EventStore;
    }
    if (message.Types?.length) {
      obj.Types = message.Types.map((e) => EventTypeRegistration.toJSON(e));
    }
    if (message.DisableValidation !== false) {
      obj.DisableValidation = message.DisableValidation;
    }
    return obj;
  },

  create(base?: DeepPartial<RegisterEventTypesRequest>): RegisterEventTypesRequest {
    return RegisterEventTypesRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<RegisterEventTypesRequest>): RegisterEventTypesRequest {
    const message = createBaseRegisterEventTypesRequest();
    message.EventStore = object.EventStore ?? "";
    message.Types = object.Types?.map((e) => EventTypeRegistration.fromPartial(e)) || [];
    message.DisableValidation = object.DisableValidation ?? false;
    return message;
  },
};

function createBaseRegisterSingleEventTypeRequest(): RegisterSingleEventTypeRequest {
  return { EventStore: "", Type: undefined };
}

export const RegisterSingleEventTypeRequest: MessageFns<RegisterSingleEventTypeRequest> = {
  encode(message: RegisterSingleEventTypeRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.EventStore !== "") {
      writer.uint32(10).string(message.EventStore);
    }
    if (message.Type !== undefined) {
      EventTypeRegistration.encode(message.Type, writer.uint32(18).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): RegisterSingleEventTypeRequest {
    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 = createBaseRegisterSingleEventTypeRequest();
      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.Type = EventTypeRegistration.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): RegisterSingleEventTypeRequest {
    return {
      EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
      Type: isSet(object.Type) ? EventTypeRegistration.fromJSON(object.Type) : undefined,
    };
  },

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

  create(base?: DeepPartial<RegisterSingleEventTypeRequest>): RegisterSingleEventTypeRequest {
    return RegisterSingleEventTypeRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<RegisterSingleEventTypeRequest>): RegisterSingleEventTypeRequest {
    const message = createBaseRegisterSingleEventTypeRequest();
    message.EventStore = object.EventStore ?? "";
    message.Type = (object.Type !== undefined && object.Type !== null)
      ? EventTypeRegistration.fromPartial(object.Type)
      : undefined;
    return message;
  },
};

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

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

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

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

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

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

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

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

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

export type EventTypesDefinition = typeof EventTypesDefinition;
export const EventTypesDefinition = {
  name: "EventTypes",
  fullName: "Cratis.Chronicle.Contracts.EventTypes.EventTypes",
  methods: {
    allEventTypeGenerations: {
      name: "AllEventTypeGenerations",
      requestType: AllEventTypeGenerationsRequest as typeof AllEventTypeGenerationsRequest,
      requestStream: false,
      responseType:
        QueryResultIEnumerableEventTypeDetailsResponse as typeof QueryResultIEnumerableEventTypeDetailsResponse,
      responseStream: false,
      options: {},
    },
    allEventTypes: {
      name: "AllEventTypes",
      requestType: AllEventTypesRequest as typeof AllEventTypesRequest,
      requestStream: false,
      responseType:
        QueryResultIEnumerableEventTypeDetailsResponse as typeof QueryResultIEnumerableEventTypeDetailsResponse,
      responseStream: false,
      options: {},
    },
    createEventType: {
      name: "CreateEventType",
      requestType: CreateEventTypeRequest as typeof CreateEventTypeRequest,
      requestStream: false,
      responseType: CommandResult as typeof CommandResult,
      responseStream: false,
      options: {},
    },
    observeEventTypes: {
      name: "ObserveEventTypes",
      requestType: ObserveEventTypesRequest as typeof ObserveEventTypesRequest,
      requestStream: false,
      responseType:
        QueryResultIEnumerableEventTypeDetailsResponse as typeof QueryResultIEnumerableEventTypeDetailsResponse,
      responseStream: true,
      options: {},
    },
    registerEventTypes: {
      name: "RegisterEventTypes",
      requestType: RegisterEventTypesRequest as typeof RegisterEventTypesRequest,
      requestStream: false,
      responseType: CommandResult as typeof CommandResult,
      responseStream: false,
      options: {},
    },
    registerSingleEventType: {
      name: "RegisterSingleEventType",
      requestType: RegisterSingleEventTypeRequest as typeof RegisterSingleEventTypeRequest,
      requestStream: false,
      responseType: CommandResult as typeof CommandResult,
      responseStream: false,
      options: {},
    },
  },
} as const;

export interface EventTypesServiceImplementation<CallContextExt = {}> {
  allEventTypeGenerations(
    request: AllEventTypeGenerationsRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<QueryResultIEnumerableEventTypeDetailsResponse>>;
  allEventTypes(
    request: AllEventTypesRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<QueryResultIEnumerableEventTypeDetailsResponse>>;
  createEventType(
    request: CreateEventTypeRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<CommandResult>>;
  observeEventTypes(
    request: ObserveEventTypesRequest,
    context: CallContext & CallContextExt,
  ): ServerStreamingMethodResult<DeepPartial<QueryResultIEnumerableEventTypeDetailsResponse>>;
  registerEventTypes(
    request: RegisterEventTypesRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<CommandResult>>;
  registerSingleEventType(
    request: RegisterSingleEventTypeRequest,
    context: CallContext & CallContextExt,
  ): Promise<DeepPartial<CommandResult>>;
}

export interface EventTypesClient<CallOptionsExt = {}> {
  allEventTypeGenerations(
    request: DeepPartial<AllEventTypeGenerationsRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<QueryResultIEnumerableEventTypeDetailsResponse>;
  allEventTypes(
    request: DeepPartial<AllEventTypesRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<QueryResultIEnumerableEventTypeDetailsResponse>;
  createEventType(
    request: DeepPartial<CreateEventTypeRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<CommandResult>;
  observeEventTypes(
    request: DeepPartial<ObserveEventTypesRequest>,
    options?: CallOptions & CallOptionsExt,
  ): AsyncIterable<QueryResultIEnumerableEventTypeDetailsResponse>;
  registerEventTypes(
    request: DeepPartial<RegisterEventTypesRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<CommandResult>;
  registerSingleEventType(
    request: DeepPartial<RegisterSingleEventTypeRequest>,
    options?: CallOptions & CallOptionsExt,
  ): Promise<CommandResult>;
}

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

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

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

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

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