// @generated by protoc-gen-es v1.10.0 with parameter "target=ts"
// @generated from file core/shared.proto (package api, syntax proto3)
/* eslint-disable */
// @ts-nocheck

import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { Area, DimensionLess, Length, Volume, Weight } from "./unitOfMeasures_pb.js";

/**
 * @generated from enum api.ResponseStatus
 */
export enum ResponseStatus {
  /**
   * @generated from enum value: RESPONSESTATUS_UNKNOWN = 0;
   */
  RESPONSESTATUS_UNKNOWN = 0,

  /**
   * @generated from enum value: OK = 1;
   */
  OK = 1,

  /**
   * @generated from enum value: INTERNAL_ERROR = 2;
   */
  INTERNAL_ERROR = 2,

  /**
   * @generated from enum value: PAYLOAD_INCORRECT = 3;
   */
  PAYLOAD_INCORRECT = 3,

  /**
   * @generated from enum value: OBJECT_ID_NOT_FOUND = 4;
   */
  OBJECT_ID_NOT_FOUND = 4,

  /**
   * @generated from enum value: PROJECT_NOT_FOUND = 5;
   */
  PROJECT_NOT_FOUND = 5,

  /**
   * @generated from enum value: UNAUTHORIZED = 6;
   */
  UNAUTHORIZED = 6,

  /**
   * @generated from enum value: TIMEOUT = 7;
   */
  TIMEOUT = 7,
}
// Retrieve enum metadata with: proto3.getEnumType(ResponseStatus)
proto3.util.setEnumType(ResponseStatus, "api.ResponseStatus", [
  { no: 0, name: "RESPONSESTATUS_UNKNOWN" },
  { no: 1, name: "OK" },
  { no: 2, name: "INTERNAL_ERROR" },
  { no: 3, name: "PAYLOAD_INCORRECT" },
  { no: 4, name: "OBJECT_ID_NOT_FOUND" },
  { no: 5, name: "PROJECT_NOT_FOUND" },
  { no: 6, name: "UNAUTHORIZED" },
  { no: 7, name: "TIMEOUT" },
]);

/**
 * @generated from message api.RequestHeader
 */
export class RequestHeader extends Message<RequestHeader> {
  /**
   * string Author = 2 [(validate.rules).string.min_len = 1];
   * string Sync = 3 [(grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {description: "(Not use yet) Wait the event request to be applied"}];
   *
   * @generated from field: string Project = 1;
   */
  Project = "";

  constructor(data?: PartialMessage<RequestHeader>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.RequestHeader";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestHeader {
    return new RequestHeader().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestHeader {
    return new RequestHeader().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestHeader {
    return new RequestHeader().fromJsonString(jsonString, options);
  }

  static equals(a: RequestHeader | PlainMessage<RequestHeader> | undefined, b: RequestHeader | PlainMessage<RequestHeader> | undefined): boolean {
    return proto3.util.equals(RequestHeader, a, b);
  }
}

/**
 * Header for all requests on project resource
 *
 * @generated from message api.RequestProjectHeader
 */
export class RequestProjectHeader extends Message<RequestProjectHeader> {
  /**
   * @generated from field: string ProjectID = 1;
   */
  ProjectID = "";

  constructor(data?: PartialMessage<RequestProjectHeader>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.RequestProjectHeader";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "ProjectID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestProjectHeader {
    return new RequestProjectHeader().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestProjectHeader {
    return new RequestProjectHeader().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestProjectHeader {
    return new RequestProjectHeader().fromJsonString(jsonString, options);
  }

  static equals(a: RequestProjectHeader | PlainMessage<RequestProjectHeader> | undefined, b: RequestProjectHeader | PlainMessage<RequestProjectHeader> | undefined): boolean {
    return proto3.util.equals(RequestProjectHeader, a, b);
  }
}

/**
 * Header for all requests on project resource
 *
 * @generated from message api.RequestOrganisationHeader
 */
export class RequestOrganisationHeader extends Message<RequestOrganisationHeader> {
  /**
   * @generated from field: string OrganisationID = 1;
   */
  OrganisationID = "";

  constructor(data?: PartialMessage<RequestOrganisationHeader>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.RequestOrganisationHeader";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "OrganisationID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestOrganisationHeader {
    return new RequestOrganisationHeader().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestOrganisationHeader {
    return new RequestOrganisationHeader().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestOrganisationHeader {
    return new RequestOrganisationHeader().fromJsonString(jsonString, options);
  }

  static equals(a: RequestOrganisationHeader | PlainMessage<RequestOrganisationHeader> | undefined, b: RequestOrganisationHeader | PlainMessage<RequestOrganisationHeader> | undefined): boolean {
    return proto3.util.equals(RequestOrganisationHeader, a, b);
  }
}

/**
 * Header for all requests on bucket resources
 *
 * @generated from message api.RequestBucketHeader
 */
export class RequestBucketHeader extends Message<RequestBucketHeader> {
  /**
   * @generated from field: string BucketID = 1;
   */
  BucketID = "";

  constructor(data?: PartialMessage<RequestBucketHeader>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.RequestBucketHeader";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "BucketID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestBucketHeader {
    return new RequestBucketHeader().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestBucketHeader {
    return new RequestBucketHeader().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestBucketHeader {
    return new RequestBucketHeader().fromJsonString(jsonString, options);
  }

  static equals(a: RequestBucketHeader | PlainMessage<RequestBucketHeader> | undefined, b: RequestBucketHeader | PlainMessage<RequestBucketHeader> | undefined): boolean {
    return proto3.util.equals(RequestBucketHeader, a, b);
  }
}

/**
 * Header for all requests on partnerApp resources
 *
 * @generated from message api.RequestPartnerAppHeader
 */
export class RequestPartnerAppHeader extends Message<RequestPartnerAppHeader> {
  /**
   * @generated from field: string PartnerAppID = 1;
   */
  PartnerAppID = "";

  constructor(data?: PartialMessage<RequestPartnerAppHeader>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.RequestPartnerAppHeader";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "PartnerAppID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestPartnerAppHeader {
    return new RequestPartnerAppHeader().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestPartnerAppHeader {
    return new RequestPartnerAppHeader().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestPartnerAppHeader {
    return new RequestPartnerAppHeader().fromJsonString(jsonString, options);
  }

  static equals(a: RequestPartnerAppHeader | PlainMessage<RequestPartnerAppHeader> | undefined, b: RequestPartnerAppHeader | PlainMessage<RequestPartnerAppHeader> | undefined): boolean {
    return proto3.util.equals(RequestPartnerAppHeader, a, b);
  }
}

/**
 * Header for all response messages
 *
 * @generated from message api.ResponseHeader
 */
export class ResponseHeader extends Message<ResponseHeader> {
  constructor(data?: PartialMessage<ResponseHeader>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ResponseHeader";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResponseHeader {
    return new ResponseHeader().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResponseHeader {
    return new ResponseHeader().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResponseHeader {
    return new ResponseHeader().fromJsonString(jsonString, options);
  }

  static equals(a: ResponseHeader | PlainMessage<ResponseHeader> | undefined, b: ResponseHeader | PlainMessage<ResponseHeader> | undefined): boolean {
    return proto3.util.equals(ResponseHeader, a, b);
  }
}

/**
 * Header for all query messages
 *
 * @generated from message api.QueryHeader
 */
export class QueryHeader extends Message<QueryHeader> {
  /**
   * @generated from field: string Project = 1;
   */
  Project = "";

  /**
   * string Author = 2;
   *
   * @generated from field: string PagingState = 3;
   */
  PagingState = "";

  /**
   * @generated from field: string Limit = 4;
   */
  Limit = "";

  /**
   * @generated from field: bool LocalizedLabel = 5;
   */
  LocalizedLabel = false;

  constructor(data?: PartialMessage<QueryHeader>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.QueryHeader";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "PagingState", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "Limit", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "LocalizedLabel", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryHeader {
    return new QueryHeader().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryHeader {
    return new QueryHeader().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryHeader {
    return new QueryHeader().fromJsonString(jsonString, options);
  }

  static equals(a: QueryHeader | PlainMessage<QueryHeader> | undefined, b: QueryHeader | PlainMessage<QueryHeader> | undefined): boolean {
    return proto3.util.equals(QueryHeader, a, b);
  }
}

/**
 * Header for all query project messages
 *
 * @generated from message api.QueryProjectHeader
 */
export class QueryProjectHeader extends Message<QueryProjectHeader> {
  /**
   * @generated from field: string ProjectID = 1;
   */
  ProjectID = "";

  /**
   * @generated from field: string PagingState = 3;
   */
  PagingState = "";

  /**
   * @generated from field: string Limit = 4;
   */
  Limit = "";

  /**
   * @generated from field: bool LocalizedLabel = 5;
   */
  LocalizedLabel = false;

  constructor(data?: PartialMessage<QueryProjectHeader>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.QueryProjectHeader";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "ProjectID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "PagingState", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "Limit", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "LocalizedLabel", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryProjectHeader {
    return new QueryProjectHeader().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryProjectHeader {
    return new QueryProjectHeader().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryProjectHeader {
    return new QueryProjectHeader().fromJsonString(jsonString, options);
  }

  static equals(a: QueryProjectHeader | PlainMessage<QueryProjectHeader> | undefined, b: QueryProjectHeader | PlainMessage<QueryProjectHeader> | undefined): boolean {
    return proto3.util.equals(QueryProjectHeader, a, b);
  }
}

/**
 * @generated from message api.ResultHeader
 */
export class ResultHeader extends Message<ResultHeader> {
  /**
   * @generated from field: string PagingState = 1;
   */
  PagingState = "";

  constructor(data?: PartialMessage<ResultHeader>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ResultHeader";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "PagingState", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResultHeader {
    return new ResultHeader().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResultHeader {
    return new ResultHeader().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResultHeader {
    return new ResultHeader().fromJsonString(jsonString, options);
  }

  static equals(a: ResultHeader | PlainMessage<ResultHeader> | undefined, b: ResultHeader | PlainMessage<ResultHeader> | undefined): boolean {
    return proto3.util.equals(ResultHeader, a, b);
  }
}

/**
 * Header for all command messages
 *
 * @generated from message api.CommandHeader
 */
export class CommandHeader extends Message<CommandHeader> {
  /**
   * @generated from field: string ActionCommand = 1;
   */
  ActionCommand = "";

  /**
   * @generated from field: api.DateTime CommandTS = 2;
   */
  CommandTS?: DateTime;

  /**
   * @generated from field: string Project = 3;
   */
  Project = "";

  /**
   * @generated from field: string FromDomain = 4;
   */
  FromDomain = "";

  /**
   * @generated from field: string FromObject = 5;
   */
  FromObject = "";

  /**
   * @generated from field: string FromRule = 6;
   */
  FromRule = "";

  constructor(data?: PartialMessage<CommandHeader>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.CommandHeader";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "ActionCommand", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "CommandTS", kind: "message", T: DateTime },
    { no: 3, name: "Project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "FromDomain", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "FromObject", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 6, name: "FromRule", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CommandHeader {
    return new CommandHeader().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CommandHeader {
    return new CommandHeader().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CommandHeader {
    return new CommandHeader().fromJsonString(jsonString, options);
  }

  static equals(a: CommandHeader | PlainMessage<CommandHeader> | undefined, b: CommandHeader | PlainMessage<CommandHeader> | undefined): boolean {
    return proto3.util.equals(CommandHeader, a, b);
  }
}

/**
 * Header for all event messages
 *
 * @generated from message api.EventHeader
 */
export class EventHeader extends Message<EventHeader> {
  /**
   * @generated from field: string InputEvent = 1;
   */
  InputEvent = "";

  /**
   * @generated from field: api.DateTime EventTS = 2;
   */
  EventTS?: DateTime;

  /**
   * @generated from field: string Project = 3;
   */
  Project = "";

  /**
   * @generated from field: string Author = 4;
   */
  Author = "";

  /**
   * @generated from field: string EventID = 5;
   */
  EventID = "";

  constructor(data?: PartialMessage<EventHeader>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.EventHeader";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "InputEvent", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "EventTS", kind: "message", T: DateTime },
    { no: 3, name: "Project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "Author", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "EventID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EventHeader {
    return new EventHeader().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EventHeader {
    return new EventHeader().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EventHeader {
    return new EventHeader().fromJsonString(jsonString, options);
  }

  static equals(a: EventHeader | PlainMessage<EventHeader> | undefined, b: EventHeader | PlainMessage<EventHeader> | undefined): boolean {
    return proto3.util.equals(EventHeader, a, b);
  }
}

/**
 * Generic Object structures
 *
 * @generated from message api.EntityID
 */
export class EntityID extends Message<EntityID> {
  /**
   * string UuID = 1 [(grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {read_only: true, description: "Internal identifier"}, (validate.rules).string.unauthorized = true];
   *
   * @generated from field: string RefID = 2;
   */
  RefID = "";

  constructor(data?: PartialMessage<EntityID>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.EntityID";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 2, name: "RefID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EntityID {
    return new EntityID().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EntityID {
    return new EntityID().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EntityID {
    return new EntityID().fromJsonString(jsonString, options);
  }

  static equals(a: EntityID | PlainMessage<EntityID> | undefined, b: EntityID | PlainMessage<EntityID> | undefined): boolean {
    return proto3.util.equals(EntityID, a, b);
  }
}

/**
 * @generated from message api.GenericObject
 */
export class GenericObject extends Message<GenericObject> {
  /**
   * @generated from field: api.EventHeader LastEventHeader = 1;
   */
  LastEventHeader?: EventHeader;

  /**
   * @generated from field: api.GenericObjectPayload Payload = 2;
   */
  Payload?: GenericObjectPayload;

  constructor(data?: PartialMessage<GenericObject>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.GenericObject";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "LastEventHeader", kind: "message", T: EventHeader },
    { no: 2, name: "Payload", kind: "message", T: GenericObjectPayload },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GenericObject {
    return new GenericObject().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GenericObject {
    return new GenericObject().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GenericObject {
    return new GenericObject().fromJsonString(jsonString, options);
  }

  static equals(a: GenericObject | PlainMessage<GenericObject> | undefined, b: GenericObject | PlainMessage<GenericObject> | undefined): boolean {
    return proto3.util.equals(GenericObject, a, b);
  }
}

/**
 * @generated from message api.GenericObjectPayload
 */
export class GenericObjectPayload extends Message<GenericObjectPayload> {
  /**
   * @generated from field: api.EntityID ID = 1;
   */
  ID?: EntityID;

  constructor(data?: PartialMessage<GenericObjectPayload>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.GenericObjectPayload";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "ID", kind: "message", T: EntityID },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GenericObjectPayload {
    return new GenericObjectPayload().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GenericObjectPayload {
    return new GenericObjectPayload().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GenericObjectPayload {
    return new GenericObjectPayload().fromJsonString(jsonString, options);
  }

  static equals(a: GenericObjectPayload | PlainMessage<GenericObjectPayload> | undefined, b: GenericObjectPayload | PlainMessage<GenericObjectPayload> | undefined): boolean {
    return proto3.util.equals(GenericObjectPayload, a, b);
  }
}

/**
 * Common structures
 *
 * @generated from message api.DateTime
 */
export class DateTime extends Message<DateTime> {
  /**
   * UTC date/time in ISO 8601 format with time zone (accepted tzd formats: [+01:00, -01:00, Z])
   *
   * @generated from field: string DateTime = 1;
   */
  DateTime = "";

  /**
   * Time zone from where the author emits the event
   *
   * @generated from field: string AuthorTimeZone = 2;
   */
  AuthorTimeZone = "";

  constructor(data?: PartialMessage<DateTime>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.DateTime";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "DateTime", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "AuthorTimeZone", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DateTime {
    return new DateTime().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DateTime {
    return new DateTime().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DateTime {
    return new DateTime().fromJsonString(jsonString, options);
  }

  static equals(a: DateTime | PlainMessage<DateTime> | undefined, b: DateTime | PlainMessage<DateTime> | undefined): boolean {
    return proto3.util.equals(DateTime, a, b);
  }
}

/**
 * @generated from message api.ValueType
 */
export class ValueType extends Message<ValueType> {
  /**
   * @generated from oneof api.ValueType.ValueType
   */
  ValueType: {
    /**
     * @generated from field: string String = 1;
     */
    value: string;
    case: "String";
  } | {
    /**
     * @generated from field: int64 Int = 2;
     */
    value: bigint;
    case: "Int";
  } | {
    /**
     * @generated from field: float Float = 3;
     */
    value: number;
    case: "Float";
  } | {
    /**
     * @generated from field: bool Bool = 4;
     */
    value: boolean;
    case: "Bool";
  } | {
    /**
     * @generated from field: api.DateTime Timestamp = 5;
     */
    value: DateTime;
    case: "Timestamp";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<ValueType>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ValueType";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "String", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "ValueType" },
    { no: 2, name: "Int", kind: "scalar", T: 3 /* ScalarType.INT64 */, oneof: "ValueType" },
    { no: 3, name: "Float", kind: "scalar", T: 2 /* ScalarType.FLOAT */, oneof: "ValueType" },
    { no: 4, name: "Bool", kind: "scalar", T: 8 /* ScalarType.BOOL */, oneof: "ValueType" },
    { no: 5, name: "Timestamp", kind: "message", T: DateTime, oneof: "ValueType" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ValueType {
    return new ValueType().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ValueType {
    return new ValueType().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ValueType {
    return new ValueType().fromJsonString(jsonString, options);
  }

  static equals(a: ValueType | PlainMessage<ValueType> | undefined, b: ValueType | PlainMessage<ValueType> | undefined): boolean {
    return proto3.util.equals(ValueType, a, b);
  }
}

/**
 * @generated from message api.QuantityLength
 */
export class QuantityLength extends Message<QuantityLength> {
  /**
   * @generated from field: float Value = 1;
   */
  Value = 0;

  /**
   * @generated from field: api.Length Unit = 2;
   */
  Unit = Length.LENGTH_UNKNOWN;

  constructor(data?: PartialMessage<QuantityLength>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.QuantityLength";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Value", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 2, name: "Unit", kind: "enum", T: proto3.getEnumType(Length) },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QuantityLength {
    return new QuantityLength().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QuantityLength {
    return new QuantityLength().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QuantityLength {
    return new QuantityLength().fromJsonString(jsonString, options);
  }

  static equals(a: QuantityLength | PlainMessage<QuantityLength> | undefined, b: QuantityLength | PlainMessage<QuantityLength> | undefined): boolean {
    return proto3.util.equals(QuantityLength, a, b);
  }
}

/**
 * @generated from message api.QuantityVolume
 */
export class QuantityVolume extends Message<QuantityVolume> {
  /**
   * @generated from field: float Value = 1;
   */
  Value = 0;

  /**
   * @generated from field: api.Volume Unit = 2;
   */
  Unit = Volume.VOLUME_UNKNOWN;

  constructor(data?: PartialMessage<QuantityVolume>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.QuantityVolume";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Value", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 2, name: "Unit", kind: "enum", T: proto3.getEnumType(Volume) },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QuantityVolume {
    return new QuantityVolume().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QuantityVolume {
    return new QuantityVolume().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QuantityVolume {
    return new QuantityVolume().fromJsonString(jsonString, options);
  }

  static equals(a: QuantityVolume | PlainMessage<QuantityVolume> | undefined, b: QuantityVolume | PlainMessage<QuantityVolume> | undefined): boolean {
    return proto3.util.equals(QuantityVolume, a, b);
  }
}

/**
 * @generated from message api.QuantityWeight
 */
export class QuantityWeight extends Message<QuantityWeight> {
  /**
   * @generated from field: float Value = 1;
   */
  Value = 0;

  /**
   * @generated from field: api.Weight Unit = 2;
   */
  Unit = Weight.WEIGHT_UNKNOWN;

  constructor(data?: PartialMessage<QuantityWeight>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.QuantityWeight";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Value", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 2, name: "Unit", kind: "enum", T: proto3.getEnumType(Weight) },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QuantityWeight {
    return new QuantityWeight().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QuantityWeight {
    return new QuantityWeight().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QuantityWeight {
    return new QuantityWeight().fromJsonString(jsonString, options);
  }

  static equals(a: QuantityWeight | PlainMessage<QuantityWeight> | undefined, b: QuantityWeight | PlainMessage<QuantityWeight> | undefined): boolean {
    return proto3.util.equals(QuantityWeight, a, b);
  }
}

/**
 * @generated from message api.QuantityArea
 */
export class QuantityArea extends Message<QuantityArea> {
  /**
   * @generated from field: float Value = 1;
   */
  Value = 0;

  /**
   * @generated from field: api.Area Unit = 2;
   */
  Unit = Area.AREA_UNKNOWN;

  constructor(data?: PartialMessage<QuantityArea>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.QuantityArea";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Value", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 2, name: "Unit", kind: "enum", T: proto3.getEnumType(Area) },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QuantityArea {
    return new QuantityArea().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QuantityArea {
    return new QuantityArea().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QuantityArea {
    return new QuantityArea().fromJsonString(jsonString, options);
  }

  static equals(a: QuantityArea | PlainMessage<QuantityArea> | undefined, b: QuantityArea | PlainMessage<QuantityArea> | undefined): boolean {
    return proto3.util.equals(QuantityArea, a, b);
  }
}

/**
 * @generated from message api.QuantityUnit
 */
export class QuantityUnit extends Message<QuantityUnit> {
  /**
   * @generated from field: float Value = 1;
   */
  Value = 0;

  /**
   * @generated from field: api.DimensionLess Unit = 2;
   */
  Unit = DimensionLess.DIMENSIONLESS_UNKNOWN;

  constructor(data?: PartialMessage<QuantityUnit>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.QuantityUnit";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Value", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 2, name: "Unit", kind: "enum", T: proto3.getEnumType(DimensionLess) },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QuantityUnit {
    return new QuantityUnit().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QuantityUnit {
    return new QuantityUnit().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QuantityUnit {
    return new QuantityUnit().fromJsonString(jsonString, options);
  }

  static equals(a: QuantityUnit | PlainMessage<QuantityUnit> | undefined, b: QuantityUnit | PlainMessage<QuantityUnit> | undefined): boolean {
    return proto3.util.equals(QuantityUnit, a, b);
  }
}

/**
 * Domain description
 *
 * RequestProjectHeader Header = 1;
 *
 * @generated from message api.DomainDescriptionRequest
 */
export class DomainDescriptionRequest extends Message<DomainDescriptionRequest> {
  constructor(data?: PartialMessage<DomainDescriptionRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.DomainDescriptionRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DomainDescriptionRequest {
    return new DomainDescriptionRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DomainDescriptionRequest {
    return new DomainDescriptionRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DomainDescriptionRequest {
    return new DomainDescriptionRequest().fromJsonString(jsonString, options);
  }

  static equals(a: DomainDescriptionRequest | PlainMessage<DomainDescriptionRequest> | undefined, b: DomainDescriptionRequest | PlainMessage<DomainDescriptionRequest> | undefined): boolean {
    return proto3.util.equals(DomainDescriptionRequest, a, b);
  }
}

/**
 * @generated from message api.DomainDescriptionResponse
 */
export class DomainDescriptionResponse extends Message<DomainDescriptionResponse> {
  /**
   * @generated from field: api.ResponseHeader Header = 1;
   */
  Header?: ResponseHeader;

  /**
   * @generated from field: api.DomainDescription Payload = 2;
   */
  Payload?: DomainDescription;

  constructor(data?: PartialMessage<DomainDescriptionResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.DomainDescriptionResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: ResponseHeader },
    { no: 2, name: "Payload", kind: "message", T: DomainDescription },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DomainDescriptionResponse {
    return new DomainDescriptionResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DomainDescriptionResponse {
    return new DomainDescriptionResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DomainDescriptionResponse {
    return new DomainDescriptionResponse().fromJsonString(jsonString, options);
  }

  static equals(a: DomainDescriptionResponse | PlainMessage<DomainDescriptionResponse> | undefined, b: DomainDescriptionResponse | PlainMessage<DomainDescriptionResponse> | undefined): boolean {
    return proto3.util.equals(DomainDescriptionResponse, a, b);
  }
}

/**
 * @generated from message api.DomainDescription
 */
export class DomainDescription extends Message<DomainDescription> {
  /**
   * @generated from field: string Name = 1;
   */
  Name = "";

  /**
   * @generated from field: repeated api.ObjectDescription ObjectDescription = 2;
   */
  ObjectDescription: ObjectDescription[] = [];

  constructor(data?: PartialMessage<DomainDescription>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.DomainDescription";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "ObjectDescription", kind: "message", T: ObjectDescription, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DomainDescription {
    return new DomainDescription().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DomainDescription {
    return new DomainDescription().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DomainDescription {
    return new DomainDescription().fromJsonString(jsonString, options);
  }

  static equals(a: DomainDescription | PlainMessage<DomainDescription> | undefined, b: DomainDescription | PlainMessage<DomainDescription> | undefined): boolean {
    return proto3.util.equals(DomainDescription, a, b);
  }
}

/**
 * @generated from message api.ObjectDescription
 */
export class ObjectDescription extends Message<ObjectDescription> {
  /**
   * @generated from field: string Name = 1;
   */
  Name = "";

  /**
   * @generated from field: repeated api.ObjectAction ApiAction = 2;
   */
  ApiAction: ObjectAction[] = [];

  /**
   * @generated from field: string PayloadJSON = 3;
   */
  PayloadJSON = "";

  /**
   * @generated from field: repeated api.ObjectAction ApiInput = 4;
   */
  ApiInput: ObjectAction[] = [];

  /**
   * @generated from field: repeated api.ObjectAction ApiQuery = 5;
   */
  ApiQuery: ObjectAction[] = [];

  constructor(data?: PartialMessage<ObjectDescription>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ObjectDescription";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "ApiAction", kind: "message", T: ObjectAction, repeated: true },
    { no: 3, name: "PayloadJSON", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "ApiInput", kind: "message", T: ObjectAction, repeated: true },
    { no: 5, name: "ApiQuery", kind: "message", T: ObjectAction, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ObjectDescription {
    return new ObjectDescription().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ObjectDescription {
    return new ObjectDescription().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ObjectDescription {
    return new ObjectDescription().fromJsonString(jsonString, options);
  }

  static equals(a: ObjectDescription | PlainMessage<ObjectDescription> | undefined, b: ObjectDescription | PlainMessage<ObjectDescription> | undefined): boolean {
    return proto3.util.equals(ObjectDescription, a, b);
  }
}

/**
 * @generated from message api.ObjectAction
 */
export class ObjectAction extends Message<ObjectAction> {
  /**
   * @generated from field: string Name = 1;
   */
  Name = "";

  /**
   * @generated from field: string JsonTemplate = 2;
   */
  JsonTemplate = "";

  constructor(data?: PartialMessage<ObjectAction>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ObjectAction";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "JsonTemplate", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ObjectAction {
    return new ObjectAction().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ObjectAction {
    return new ObjectAction().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ObjectAction {
    return new ObjectAction().fromJsonString(jsonString, options);
  }

  static equals(a: ObjectAction | PlainMessage<ObjectAction> | undefined, b: ObjectAction | PlainMessage<ObjectAction> | undefined): boolean {
    return proto3.util.equals(ObjectAction, a, b);
  }
}

/**
 * *
 * Message to store metadata definition
 *
 * @generated from message api.MetadataElement
 */
export class MetadataElement extends Message<MetadataElement> {
  /**
   * @generated from field: string Key = 1;
   */
  Key = "";

  /**
   * @generated from field: api.ValueType Value = 2;
   */
  Value?: ValueType;

  constructor(data?: PartialMessage<MetadataElement>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.MetadataElement";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Key", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "Value", kind: "message", T: ValueType },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MetadataElement {
    return new MetadataElement().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MetadataElement {
    return new MetadataElement().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MetadataElement {
    return new MetadataElement().fromJsonString(jsonString, options);
  }

  static equals(a: MetadataElement | PlainMessage<MetadataElement> | undefined, b: MetadataElement | PlainMessage<MetadataElement> | undefined): boolean {
    return proto3.util.equals(MetadataElement, a, b);
  }
}

/**
 * Filter on a simple value
 *
 * @generated from message api.SimpleFilter
 */
export class SimpleFilter extends Message<SimpleFilter> {
  /**
   * Filter path
   *
   * @generated from field: string Attribute = 1;
   */
  Attribute = "";

  /**
   * Use this parameter if only one value
   *
   * @generated from field: string Value = 2;
   */
  Value = "";

  /**
   * Use this parameter if more than one value
   *
   * @generated from field: repeated string Values = 3;
   */
  Values: string[] = [];

  /**
   * \" EQUAL: 'EQUAL',  DIFF: 'DIFF',  START_BY: 'START_BY',  NOT_START_BY: 'NOT_START_BY',  FINISH_BY: 'FINISH_BY',  NOT_FINISH_BY: 'NOT_FINISH_BY',  CONTAINS: 'CONTAINS',  NOT_CONTAINS: 'NOT_CONTAINS'\"
   *
   * @generated from field: string Operator = 4;
   */
  Operator = "";

  /**
   * metadata's key
   *
   * @generated from field: string CombinedID = 5;
   */
  CombinedID = "";

  constructor(data?: PartialMessage<SimpleFilter>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.SimpleFilter";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Attribute", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "Value", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "Values", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 4, name: "Operator", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "CombinedID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SimpleFilter {
    return new SimpleFilter().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SimpleFilter {
    return new SimpleFilter().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SimpleFilter {
    return new SimpleFilter().fromJsonString(jsonString, options);
  }

  static equals(a: SimpleFilter | PlainMessage<SimpleFilter> | undefined, b: SimpleFilter | PlainMessage<SimpleFilter> | undefined): boolean {
    return proto3.util.equals(SimpleFilter, a, b);
  }
}

/**
 *
 * Combined filter structure for Find query
 *
 * @generated from message api.CombinedFilter
 */
export class CombinedFilter extends Message<CombinedFilter> {
  /**
   * @generated from field: string Path = 1;
   */
  Path = "";

  /**
   * Simple filter structure for Find query
   *
   * @generated from field: repeated api.SimpleFilter simpleFilters = 2;
   */
  simpleFilters: SimpleFilter[] = [];

  /**
   * Range filter structure for Find query
   *
   * @generated from field: repeated api.RangeFilter rangeFilters = 3;
   */
  rangeFilters: RangeFilter[] = [];

  /**
   * @generated from field: string CombinedID = 4;
   */
  CombinedID = "";

  constructor(data?: PartialMessage<CombinedFilter>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.CombinedFilter";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Path", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "simpleFilters", kind: "message", T: SimpleFilter, repeated: true },
    { no: 3, name: "rangeFilters", kind: "message", T: RangeFilter, repeated: true },
    { no: 4, name: "CombinedID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CombinedFilter {
    return new CombinedFilter().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CombinedFilter {
    return new CombinedFilter().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CombinedFilter {
    return new CombinedFilter().fromJsonString(jsonString, options);
  }

  static equals(a: CombinedFilter | PlainMessage<CombinedFilter> | undefined, b: CombinedFilter | PlainMessage<CombinedFilter> | undefined): boolean {
    return proto3.util.equals(CombinedFilter, a, b);
  }
}

/**
 * Filter between two values
 *
 * @generated from message api.RangeFilter
 */
export class RangeFilter extends Message<RangeFilter> {
  /**
   * Filter path
   *
   * @generated from field: string Attribute = 1;
   */
  Attribute = "";

  /**
   * Maximum value
   *
   * @generated from field: string valueLt = 2;
   */
  valueLt = "";

  /**
   * Minimum value
   *
   * @generated from field: string valueGt = 3;
   */
  valueGt = "";

  /**
   * Metadata's key
   *
   * @generated from field: string CombinedID = 4;
   */
  CombinedID = "";

  constructor(data?: PartialMessage<RangeFilter>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.RangeFilter";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Attribute", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "valueLt", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "valueGt", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "CombinedID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RangeFilter {
    return new RangeFilter().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RangeFilter {
    return new RangeFilter().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RangeFilter {
    return new RangeFilter().fromJsonString(jsonString, options);
  }

  static equals(a: RangeFilter | PlainMessage<RangeFilter> | undefined, b: RangeFilter | PlainMessage<RangeFilter> | undefined): boolean {
    return proto3.util.equals(RangeFilter, a, b);
  }
}

/**
 *
 * Block filter structure for Find query, each element (SimpleFilter, RangeFilter & BlockFilter) is an "AND" part of the query
 *
 * @generated from message api.BlockFilter
 */
export class BlockFilter extends Message<BlockFilter> {
  /**
   * Simple filter structure for Find query
   *
   * @generated from field: repeated api.SimpleFilter simpleFilters = 1;
   */
  simpleFilters: SimpleFilter[] = [];

  /**
   * Range filter structure for Find query
   *
   * @generated from field: repeated api.RangeFilter rangeFilters = 2;
   */
  rangeFilters: RangeFilter[] = [];

  /**
   * block filter structure for Find query
   *
   * @generated from field: repeated api.BlockFilter BlockFilters = 3;
   */
  BlockFilters: BlockFilter[] = [];

  constructor(data?: PartialMessage<BlockFilter>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.BlockFilter";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "simpleFilters", kind: "message", T: SimpleFilter, repeated: true },
    { no: 2, name: "rangeFilters", kind: "message", T: RangeFilter, repeated: true },
    { no: 3, name: "BlockFilters", kind: "message", T: BlockFilter, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BlockFilter {
    return new BlockFilter().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BlockFilter {
    return new BlockFilter().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BlockFilter {
    return new BlockFilter().fromJsonString(jsonString, options);
  }

  static equals(a: BlockFilter | PlainMessage<BlockFilter> | undefined, b: BlockFilter | PlainMessage<BlockFilter> | undefined): boolean {
    return proto3.util.equals(BlockFilter, a, b);
  }
}

/**
 *
 * MatchField structure, for FindMatching query
 *
 * @generated from message api.MatchField
 */
export class MatchField extends Message<MatchField> {
  /**
   * @generated from field: string Attribute = 1;
   */
  Attribute = "";

  /**
   * @generated from field: string AttributeCombined = 2;
   */
  AttributeCombined = "";

  /**
   * @generated from field: string CombinedID = 3;
   */
  CombinedID = "";

  constructor(data?: PartialMessage<MatchField>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.MatchField";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Attribute", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "AttributeCombined", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "CombinedID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MatchField {
    return new MatchField().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MatchField {
    return new MatchField().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MatchField {
    return new MatchField().fromJsonString(jsonString, options);
  }

  static equals(a: MatchField | PlainMessage<MatchField> | undefined, b: MatchField | PlainMessage<MatchField> | undefined): boolean {
    return proto3.util.equals(MatchField, a, b);
  }
}

/**
 *
 * structure containing error key & value
 *
 * @generated from message api.ErrorDetail
 */
export class ErrorDetail extends Message<ErrorDetail> {
  /**
   * @generated from field: string Key = 1;
   */
  Key = "";

  /**
   * @generated from field: string Value = 2;
   */
  Value = "";

  constructor(data?: PartialMessage<ErrorDetail>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ErrorDetail";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Key", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "Value", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ErrorDetail {
    return new ErrorDetail().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ErrorDetail {
    return new ErrorDetail().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ErrorDetail {
    return new ErrorDetail().fromJsonString(jsonString, options);
  }

  static equals(a: ErrorDetail | PlainMessage<ErrorDetail> | undefined, b: ErrorDetail | PlainMessage<ErrorDetail> | undefined): boolean {
    return proto3.util.equals(ErrorDetail, a, b);
  }
}

/**
 *
 * Error message to be found in all rpc responses
 *
 * @generated from message api.Errors
 */
export class Errors extends Message<Errors> {
  /**
   * n1error code (xxyyzzzz)
   *
   * @generated from field: string ErrorCode = 1;
   */
  ErrorCode = "";

  /**
   * generated error code, for debugging purposes(in logs)
   *
   * @generated from field: string ErrorTrace = 2;
   */
  ErrorTrace = "";

  /**
   * @generated from field: repeated api.ErrorDetail ErrorDetails = 3;
   */
  ErrorDetails: ErrorDetail[] = [];

  /**
   * Entity
   *
   * @generated from field: string ContextType = 4;
   */
  ContextType = "";

  /**
   * Method grpc
   *
   * @generated from field: string ContextProcess = 5;
   */
  ContextProcess = "";

  /**
   * Payload request
   *
   * @generated from field: string ContextPayload = 6;
   */
  ContextPayload = "";

  constructor(data?: PartialMessage<Errors>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.Errors";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "ErrorCode", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "ErrorTrace", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "ErrorDetails", kind: "message", T: ErrorDetail, repeated: true },
    { no: 4, name: "ContextType", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "ContextProcess", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 6, name: "ContextPayload", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Errors {
    return new Errors().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Errors {
    return new Errors().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Errors {
    return new Errors().fromJsonString(jsonString, options);
  }

  static equals(a: Errors | PlainMessage<Errors> | undefined, b: Errors | PlainMessage<Errors> | undefined): boolean {
    return proto3.util.equals(Errors, a, b);
  }
}

/**
 *
 * structure containing error key & value
 *
 * @generated from message api.ParamElement
 */
export class ParamElement extends Message<ParamElement> {
  /**
   * @generated from field: string Key = 1;
   */
  Key = "";

  /**
   * string Value = 2;
   *
   * @generated from field: api.ValueType Value = 3;
   */
  Value?: ValueType;

  constructor(data?: PartialMessage<ParamElement>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ParamElement";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Key", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "Value", kind: "message", T: ValueType },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ParamElement {
    return new ParamElement().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ParamElement {
    return new ParamElement().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ParamElement {
    return new ParamElement().fromJsonString(jsonString, options);
  }

  static equals(a: ParamElement | PlainMessage<ParamElement> | undefined, b: ParamElement | PlainMessage<ParamElement> | undefined): boolean {
    return proto3.util.equals(ParamElement, a, b);
  }
}

/**
 * @generated from message api.LabelStructure
 */
export class LabelStructure extends Message<LabelStructure> {
  /**
   * @generated from field: string Code = 1;
   */
  Code = "";

  /**
   * @generated from field: string Label = 2;
   */
  Label = "";

  /**
   * map of parameter to be put/replaced in the error label
   *
   * @generated from field: repeated api.ParamElement Params = 3;
   */
  Params: ParamElement[] = [];

  constructor(data?: PartialMessage<LabelStructure>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.LabelStructure";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Code", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "Label", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "Params", kind: "message", T: ParamElement, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LabelStructure {
    return new LabelStructure().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LabelStructure {
    return new LabelStructure().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LabelStructure {
    return new LabelStructure().fromJsonString(jsonString, options);
  }

  static equals(a: LabelStructure | PlainMessage<LabelStructure> | undefined, b: LabelStructure | PlainMessage<LabelStructure> | undefined): boolean {
    return proto3.util.equals(LabelStructure, a, b);
  }
}

/**
 * @generated from message api.Credentials
 */
export class Credentials extends Message<Credentials> {
  /**
   * @generated from field: string Jwt = 1;
   */
  Jwt = "";

  /**
   * @generated from field: string Seed = 2;
   */
  Seed = "";

  constructor(data?: PartialMessage<Credentials>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.Credentials";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Jwt", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "Seed", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Credentials {
    return new Credentials().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Credentials {
    return new Credentials().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Credentials {
    return new Credentials().fromJsonString(jsonString, options);
  }

  static equals(a: Credentials | PlainMessage<Credentials> | undefined, b: Credentials | PlainMessage<Credentials> | undefined): boolean {
    return proto3.util.equals(Credentials, a, b);
  }
}

/**
 * @generated from message api.Int32Object
 */
export class Int32Object extends Message<Int32Object> {
  /**
   * @generated from field: int32 Int32 = 1;
   */
  Int32 = 0;

  constructor(data?: PartialMessage<Int32Object>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.Int32Object";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Int32", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Int32Object {
    return new Int32Object().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Int32Object {
    return new Int32Object().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Int32Object {
    return new Int32Object().fromJsonString(jsonString, options);
  }

  static equals(a: Int32Object | PlainMessage<Int32Object> | undefined, b: Int32Object | PlainMessage<Int32Object> | undefined): boolean {
    return proto3.util.equals(Int32Object, a, b);
  }
}

/**
 * @generated from message api.BoolObject
 */
export class BoolObject extends Message<BoolObject> {
  /**
   * @generated from field: bool Bool = 1;
   */
  Bool = false;

  constructor(data?: PartialMessage<BoolObject>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.BoolObject";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Bool", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BoolObject {
    return new BoolObject().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BoolObject {
    return new BoolObject().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BoolObject {
    return new BoolObject().fromJsonString(jsonString, options);
  }

  static equals(a: BoolObject | PlainMessage<BoolObject> | undefined, b: BoolObject | PlainMessage<BoolObject> | undefined): boolean {
    return proto3.util.equals(BoolObject, a, b);
  }
}

/**
 * @generated from message api.StringObject
 */
export class StringObject extends Message<StringObject> {
  /**
   * @generated from field: string String = 1;
   */
  String = "";

  constructor(data?: PartialMessage<StringObject>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.StringObject";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "String", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StringObject {
    return new StringObject().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StringObject {
    return new StringObject().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StringObject {
    return new StringObject().fromJsonString(jsonString, options);
  }

  static equals(a: StringObject | PlainMessage<StringObject> | undefined, b: StringObject | PlainMessage<StringObject> | undefined): boolean {
    return proto3.util.equals(StringObject, a, b);
  }
}

/**
 * @generated from message api.StringDateObject
 */
export class StringDateObject extends Message<StringDateObject> {
  /**
   * UTC date/time in ISO 8601 format with time zone (accepted tzd formats: [+01:00, -01:00, Z])
   *
   * @generated from field: string DateTime = 10;
   */
  DateTime = "";

  constructor(data?: PartialMessage<StringDateObject>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.StringDateObject";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 10, name: "DateTime", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StringDateObject {
    return new StringDateObject().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StringDateObject {
    return new StringDateObject().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StringDateObject {
    return new StringDateObject().fromJsonString(jsonString, options);
  }

  static equals(a: StringDateObject | PlainMessage<StringDateObject> | undefined, b: StringDateObject | PlainMessage<StringDateObject> | undefined): boolean {
    return proto3.util.equals(StringDateObject, a, b);
  }
}